数据类型、常量、对象和类、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 );
}
}
