数据类型、常量、对象和类、Java 修饰符、位运算符
命名规则
包:com.trvqd(域名倒过来,所有字母小写)
类或接口:HelloWorld(驼峰,首字母大写)
方法和变量:helloWorld(驼峰,首字母小写)
常量:NAME 、 GET_PLAYER(大写,多个单词下划线分隔)
数据类型
-
基本数据类型
Java语言基本类型分为数值型(整数类型:byte,short,int,long; 浮点类型:float,double),字符型(char),布尔型(boolean)。
byte:
- byte 数据类型是8位(bit)、1字节、有符号的,以二进制补码表示的整数;
- 最小值是 -128(-2^7);
- 最大值是 127(2^7-1);
- 默认值是 0;
- byte 类型用在大型数组中节约空间,主要代替整数;
- 例子:byte a = 100,byte b = -50。
short:
- short 数据类型是 16 位(bit)、2字节、有符号的以二进制补码表示的整数
- 最小值是 -32768(-2^15);
- 最大值是 32767(2^15 - 1);
- 默认值是 0;
- Short 数据类型也可以像 byte 那样节省空间;
- 例子:short s = 1000,short r = -20000。
int:
- int 数据类型是32位(bit)、4字节、有符号的以二进制补码表示的整数;
- 最小值是 -2,147,483,648(-2^31);
- 最大值是 2,147,483,647(2^31 - 1);
- 默认值是 0 ;
- 一般地整型变量默认为 int 类型;
- 例子:int a = 100000, int b = -200000。
long:
- long 数据类型是 64 位(bit)、8字节、有符号的以二进制补码表示的整数;
- 最小值是 -9,223,372,036,854,775,808(-2^63);
- 最大值是 9,223,372,036,854,775,807(2^63 -1);
- 默认值是 0L;
- 这种类型主要使用在需要比较大整数的系统上;
- 例子: long a = 100000L,Long b = -200000L。
float:
- float 数据类型是单精度、32位、符合IEEE 754标准的浮点数;
- float 在储存大型浮点数组的时候可节省内存空间;
- 默认值是 0.0f;
- 浮点数不能用来表示精确的值,如货币;
- 例子:float f1 = 234.5f。
double:
- double 数据类型是双精度、64 位、符合IEEE 754标准的浮点数;
- 浮点数的默认类型为double类型;
- double类型同样不能表示精确的值,如货币;
- 默认值是 0.0d;
- 例子:double d1 = 123.4。
boolean:
- boolean数据类型表示一位的信息;
- 只有两个取值:true 和 false;
- 这种类型只作为一种标志来记录 true/false 情况;
- 默认值是 false;
- 例子:boolean one = true。
char:
- char类型是一个单一的 16 位 Unicode 字符;
- 最小值是 \u0000(即为0);
- 最大值是 \uffff(即为65,535);
- char 数据类型可以储存任何字符;
- 例子:char letter = 'A';。
整型、实型(常量)、字符型数据可以混合运算。运算中,不同类型的数据先转化为同一类型,然后进行运算。
转换从低级到高级。
低 --------------------------------------------> 高
byte,short,char—> int —> long—> float —> double
-
引用数据类型
类(class),接口(interface),数组([])
常量
常量在程序运行时是不能被修改的。
在 Java 中使用 final 关键字来修饰常量。
final double PI = 3.1415927;
对象和类
一个类中可以包含以下类型变量:
局部变量:在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中,方法结束后,变量就会自动销毁。
成员变量(实例变量):成员变量是定义在类中,独立于方法之外的变量,没有 static 修饰。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
类变量(静态变量):独立于方法之外的变量,用 static 修饰。
public class Variable{
static int allClicks=0; // 类变量
String str="hello world"; // 实例变量
public void method(){
int i =0; // 局部变量
}
}
成员变量和类变量的区别:
1、两个变量的生命周期不同
成员变量随着对象的创建而存在,随着对象的回收而释放。
静态变量随着类的加载而存在,随着类的消失而消失。
2、调用方式不同
成员变量只能被对象调用。
静态变量可以被对象调用,还可以被类名调用。
3、数据存储位置不同
成员变量存在于堆内存中。
静态变量存在于方法区中。
-
构造方法
每个类都有构造方法。如果没有显式地为类定义构造方法,Java编译器将会为该类提供一个默认构造方法。
在创建一个对象的时候,至少要调用一个构造方法。构造方法的名称必须与类同名,一个类可以有多个构造方法。
public class Puppy{
public Puppy(){
}
public Puppy(String name){
// 这个构造器仅有一个参数:name
}
}
注:1、如果一个类中没有定义构造方法,系统会默认提供一个空参的构造方法;
2、如果一个类中定义了有参的构造方法,系统不会再提供空参的构造方法,需要手动定义;
-
创建对象
对象是根据类创建的。在Java中,使用关键字new来创建一个新的对象。创建对象需要以下三步:
声明:声明一个对象,包括对象名称和对象类型。
实例化:使用关键字new来创建一个对象。
初始化:使用new创建对象时,会调用构造方法初始化对象。
public class Puppy{
public Puppy(String name){
//这个构造器仅有一个参数:name
System.out.println("小狗的名字是 : " + name );
}
public static void main(String []args){
// 下面的语句将创建一个Puppy对象
Puppy myPuppy = new Puppy( "tommy" );
}
}
Java 修饰符
修饰符用来定义类、方法或者变量,通常放在语句的最前端。
-
访问控制修饰符
访问控制
Java中,可以使用访问控制符来保护对类、变量、方法和构造方法的访问。
default (即缺省,什么也不写): 在同一包内可见,不使用任何修饰符。使用对象:类、接口、变量、方法。
private : 在同一类内可见。使用对象:变量、方法。 注意:不能修饰类(外部类)
public : 对所有类可见。使用对象:类、接口、变量、方法
protected: 对同一包内的类和所有子类可见。使用对象:变量、方法。 注意:不能修饰类(外部类)。
-
访问控制和继承
请注意以下方法继承的规则:
1.父类中声明为 public 的方法在子类中也必须为 public。
2.父类中声明为 protected 的方法在子类中要么声明为 protected,要么声明为 public,不能声明为 private。
3.父类中声明为 private 的方法,不能够被继承。 -
非访问修饰符
static关键字
static关键字特点:
a. 随着类的加载而加载;
b. 优先于对象存在;
c. 被类的所有对象共享;
d. 可以通过类名调用;
static的注意事项:
1)在静态方法中没有this关键字
静态是随着类的加载而加载,this是随着对象的创建而存在;
2)非静态的成员方法可以访问静态成员变量,静态方法不能访问非静态的成员变量(静态只能访问静态);
3)静态对象和静态方法可以通过对象调用,也可以使用类名调用,推荐使用类名调用;
final 修饰符
1.final 变量
final 变量能被显式地初始化并且只能初始化一次。被声明为 final 的对象的引用不能指向不同的对象。但是 final 对象里的数据可以被改变。也就是说 final 对象的引用不能改变,但是里面的值可以改变。
final 修饰符通常和 static 修饰符一起使用来创建类常量。
2.final 方法
类中的 final 方法可以被子类继承,但是不能被子类修改。
声明 final 方法的主要目的是防止该方法的内容被修改。
3.final 类
final 类不能被继承,没有类能够继承 final 类的任何特性。
abstract 修饰符
1.抽象类
抽象类不能用来实例化对象,声明抽象类的唯一目的是为了将来对该类进行扩充。
2.抽象方法
抽象方法是一种没有任何实现的方法,该方法的的具体实现由子类提供。
任何继承抽象类的子类必须实现父类的所有抽象方法,除非该子类也是抽象类。
如果一个类包含若干个抽象方法,那么该类必须声明为抽象类。抽象类可以不包含抽象方法。
synchronized 修饰符
synchronized 关键字声明的方法同一时间只能被一个线程访问。
transient 修饰符
序列化的对象包含被 transient 修饰的实例变量时,java 虚拟机(JVM)跳过该特定的变量。
该修饰符包含在定义变量的语句中,用来预处理类和变量的数据类型。
public transient int limit = 55; // 不会持久化
public int b; // 持久化
volatile 修饰符
volatile 修饰的成员变量在每次被线程访问时,都强制从共享内存中重新读取该成员变量的值。而且,当成员变量发生变化时,会强制线程将变化值回写到共享内存。这样在任何时刻,两个不同的线程总是看到某个成员变量的同一个值。
一个 volatile 对象引用可能是 null。
位运算符
<<n 向左移n次,相当于乘以2的n次方
>>n 向右移n次,相当于除以2的n次方
>>> 无符号右移和>> 有符号右移区别:
>>>:无论高位是0还是1,移动后都用0补位
>>:高位是0就补0,高位是1就补1
public class Test {
public static void main(String[] args) {
int a = 60; /* 60 = 0011 1100 */
int b = 13; /* 13 = 0000 1101 */
int c = 0;
c = a & b; /* 12 = 0000 1100 */
System.out.println("a & b = " + c );
c = a | b; /* 61 = 0011 1101 */
System.out.println("a | b = " + c );
c = a ^ b; /* 49 = 0011 0001 */
System.out.println("a ^ b = " + c );
c = ~a; /*-61 = 1100 0011 */
System.out.println("~a = " + c );
c = a << 2; /* 240 = 1111 0000 */
System.out.println("a << 2 = " + c );
c = a >> 2; /* 15 = 1111 */
System.out.println("a >> 2 = " + c );
c = a >>> 2; /* 15 = 0000 1111 */
System.out.println("a >>> 2 = " + c );
}
}
网友评论