01-Java基础-类与对象&数据类型&运算符

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