Java基础

1. Java基本数据类型

Java是一种强类型语言，有8种基本数据类型，分为4种整型、2种浮点类型、1种布尔类型和1种字符类型。

类型	字节	取值范围
byte	1字节	- 128 ~ 127
short	2字节	- 32 768 ~ 32 767
int	4字节	- 2 147 483 648 ~ 2 147 483 647（正好超20亿）
long	8字节	- 9.2*1018 ~ 9.2*1018
float	4字节	有效位数 6~7 位
double	8字节	有效位数 15 位
boolean		true / false
char	2个字节	Unicode编码字符

特殊字符的转义序列符：
\b 退格 ? ? \t 制表 ? ? \n 换行 ? ? \r 回车 ? ? \" 双引号 ? ? \’ 单引号 ? ? \\ 反斜杠

2. 包装类

基本类型与它们对应的包装类之间能够 自动装箱 和 自动拆箱 。

Byte、Short、Integer、Long、Float、Double、Boolean、Character

包装类（Integer）API：

int intValue()  以 int 类型返回 Integer 对象的值。
static String toString(int i)  以一个新 String 对象的形式返回给定数值 i 的十进制表示。
static int parselnt(String s)  返回字符串 s 表示的整型数值，给定字符串表示的是十进制的整数。
static Integer valueOf(String s)  返回用 s 表示的整型数值进行初始化后的一个新 Integer 对象，给定字符串表示的是十进制的整数。

3. 常量

关键字 final 修饰的变量，只能被赋值一次，一旦赋值就不能再更改。

4. 类型转换

4.1 数值之间的自动类型转换

两个数值进行二元操作时：

• 如果两个操作数中有一个是 double 类型，另一个操作数就会转换为 double 类型。
• 否则，如果其中一个操作数是 float 类型，另一个操作数将会转换为 float 类型。
• 否则，如果其中一个操作数是 long 类型，另一个操作数将会转换为 long 类型。
• 否则，两个操作数都将被转换为int 类型。
  
  说明：下图中实心箭头表示无信息丢失的转换，虚箭头表示可能有精度损失的转换。

4.2 强制类型转换

强制类型转换通过截断小数部分将浮点值转换为整型。

double d = 9.99;
int i = (int)d; // i = 9

4.3 隐式强制转换

“隐式强制转换”前提：

• 转换的值(编译时)是常量表达式，并且值"适合"目标类型而不会被截断。
• 值类型为 byte、char、short、int。
• 目标类型为 byte、char、short 或 Byte、Short、Character。

// 10 是一个 int 常量，赋值给 byte 变量时，会进行“隐式强制转换”。
byte b = 10; // 正确
byte y = b; // 正确
byte t = b + y; // 编译错误，b + y 的结果在运行时才能确定，所以在编译时不是常量表达式。
byte e = 128; // 编译错误，128超过byte的取值范围，必须进行显示强制转换。

5. 逻辑运算符

&&（逻辑“与”运算符），||（逻辑“或”运算符），!（逻辑“非”运算符）

注意: && 和 || 运算符按照“短路”方式求值。

6. 移位运算符：

<<（左移）: 右边用0填充。
>>（右移）: 左边用最高位相同的值填充。
>>>（逻辑右移）: 左边用0填充。

7. 按位运算符

& (按位与) ?? | (按位或) ? ? ~ (按位非) ?? ^ (按位异或)

数1	数2	&	|	^
0	0	0	0	0
0	1	0	1	1
1	1	1	1	0

8. 访问修饰符

访问修饰符	同类	同包	子类（同包）	子类（不同包）	不同包
public	√	√	√	√	√
protected	√	√	√	√	–
默认	√	√	√	–	–
private	√	–	–	–	–
注：
类的访问修饰符：public、默认
内部类的访问修饰符：public、protected、默认、private

9. 接口（interface）

• 接口中的成员变量都会被自动设置为 public static final。
• 接口中的所有方法都会被自动设置为 public abstract（Java8新增的静态方法和默认方法只会默认设置为 public）。

public interface Shape{
    // 自动设置为 public static final int DI = 2;
    int DI = 2;
    // 自动设置为 public abstract void fun();
    void fun();
    // 接口的静态方法，用 static 修饰。自动设置为 public static void fun2(){ }
    static void fun2(){ }
    // 接口的默认方法，必须用 default 修饰符修饰。自动设置为 public default void fun3(){ }
    default void fun3(){ }
}

10. 抽象类

• 抽象类是用 abstract 关键字修饰的类，不能被实例化。
• 抽象方法是用 abstract 修饰的方法，它没有具体的实现。
• 子类继承抽象类必须实现所有的抽象方法(除非子类也为抽象类)。
• 抽象类中也可以有非抽象方法。

public abstract class Shape{
	public abstract void contains(int x,int y);
}

11. 类（class）

11.1 类的三大特性

类的三大特性：继承、封装、多态。

11.2 类的构造方法

作用：初始化成员变量。
注意：子类的构造方法一定调用父类的构造方法，这是为了保证子类中从父类继承的成员被妥善的初始化。

11.3 类的成员

• 成员变量：实例变量、类变量（用static修饰）
• 方法：构造方法、实例方法、类方法（用static修饰）
• 内部类
• 静态代码块

11.4 局部变量、类的成员变量

11.4.1 局部变量

• 方法的参数和方法里的变量。使用前必须初始化，否则会编译错误。

11.4.2 类的成员变量

• Java虚拟机会在实例化类时自动进行初始化。如果给出了初始值，则初始化为该初始值。如果没有给出，则把它初始化为该类型变量的默认初始值（默认初始值： 数值为0、布尔值为false、对象引用为null）。
• final修饰的成员变量必须给出初始值，否则就会报编译错误。final修饰的变量(值类型和引用类型)其值不能改变(引用类型是引用的值不变，而不是引用的对象不变)。
• static修饰的成员变量存储在Java堆中（Java8），初始化发生在类被类加载器（ClassLoader）加载的时候，系统会对没有初始化的静态成员变量在静态区进行默认赋值。

11.5 类之间的关系

• 依赖（“ uses-a”）：如果一个类的方法操纵另一个类的对象， 我们就说一个类依赖于另一个类。
• 聚合/关联（“ has-a”）：聚合关系意味着类A 的对象包含类B 的对象。
• 继承（“ is-a”）

注：依赖优于关联，关联优于继承。

// 依赖关系      	
public class A {		
   public void fun1(B b) {  }		
   public B fun2() {  }
}

public class B {  }

// 聚合/关联关系 
public class A {
    private B b;
}

public class B {  }      

类之间关系的标准UML符号：

12. 内部类、静态内部类、匿名内部类、局部内部类

class Square{
    // 内部类
    class InnerClass{

    }
    // 静态内部类
    static class StaticClass{

    }
    public void kind() {
        // 匿名内部类
        Runnable run = new Runnable(){
            @Override
            public void run() { }
        };
        // 局部内部类
        // 局部内部类不能用 public、protected、private 访问修饰符进行声明。它的作用域被限定在声明这个局部类的块中。
        class PartClass {
            
        }
    }
}

13. Object

Object 类是Java 中所有类的始祖， 在Java 中每个类都是由它扩展而来的。

13.1 equals方法 和 hashCode方法

子类如果重写 equals 方法，就必须重写 hashCode 方法。
原因：比如 HashSet 类型，判断两个对象元素相等的标准就是：两个对象通过 equals() 方法比较相等，并且两个对象的 hashCode() 方法返回值也相等。

14. 方法的重载和重写

public class MyTest {

    public static void main(String[] args) {
        // 注意：子类如果有与父类同名的方法，不是重载就是重写，不然就报错。

        // 一、方法的重载规则
        // 方法名相同，参数列表不同。与返回值类型无关。

        // 二、方法的重写规则
        // 方法名、返回值类型和参数列表相同。
        // 注：
        // 1.等大：访问修饰符的限制一定要大于或等于被重写方法的访问修饰符（public > protected > default > private）。
        // 2.等子：重写方法的返回值类型可以是被重写方法返回值类型的子类。
        // 3.等小：重写方法一定不能抛出新的检查异常或者比被重写方法申明更加宽泛的检查型异常。

        // 1.父类变量 引用 父类对象，这没啥说的
        // 2.父类变量 引用 子类对象
        ParentClass parent = new ChildClass();
        System.out.println(parent.name); // Parent 成员变量不具有多态性
        System.out.println(parent.getValue()); // Child 重写的方法具有多态性
        parent.getParentName(); // Parent
        parent.getParentThisName(); // Parent

        // parent.getChildName(); // 编译失败；编译时是根据变量的类型进行判断，运行时是根据实际的对象运行。
        // parent.getChildThisName(); // 编译失败；编译时是根据变量的类型进行判断，运行时是根据实际的对象运行。

        System.out.println("----------------");

        // 3.子类变量 引用 子类对象
        ChildClass child = new ChildClass();
        System.out.println(child.name); // Child 成员变量不具有多态性
        System.out.println(child.getValue()); // Child 重写的方法具有多态性
        child.getParentName(); // Parent
        child.getParentThisName(); // Parent
        child.getChildName(); // Child
        child.getChildThisName(); // Child

        // 4.转型
        ParentClass parentObj = new ChildClass();
        ChildClass childObj = (ChildClass)parentObj; // 正确
        parentObj = childObj; //  正确

        // 父类对象不能强转为子类
        ChildClass cc = (ChildClass)new ParentClass(); // 编译通过，运行时报 ClassCastException 异常
    }
}

class ParentClass {
    public String name  = "Parent";
    public Object getValue() {
        return "Parent";
    }
    public void getParentName(){
        System.out.println(name);
    }
    public void getParentThisName(){
        System.out.println(this.name);
    }
}

class ChildClass extends ParentClass {
    public String name  = "Child";
    // 重写父类方法
    public String getValue() {
        return "Child";
    }
    public void getChildName(){
        System.out.println(name);
    }
    public void getChildThisName(){
        System.out.println(this.name);
    }
}