Java学习笔记—

子类对象实例化过程

1.从结果上看，（继承性）
子类继承父类以后，就获取了父类中声明的属性或者方法
创建子类的对象，在堆空间中，就会加载所有父类中声明的属性
2.从过程上看，
当我们通过子类的构造器创建子类对象时，我们一定会直接或间接的调用其父类的构造器，进而调用父类的父类的构造器，直到调用了java.lang.Object类中空参的构造器为止，正是因为加载过所有的父类的结构，所以才可以看到内存中有父类中的结构，子类对象才可以考虑进行调用。
明确。虽然创建子类对象时，调用了父类的构造器，但是自始自终就创建过一个对象，即为new的子类对象。

多态性

1.对象的多态性，父类的引用指向子类的对象

Person p1 = new Man();
Person P2 = new Woman();

左边是父类的声明，右边new一个子类的对象
当P1调用Person和Man同名同参数的方法时，实际调用的是子类（Man）重写的方法！
2.多态性的使用，虚拟方法使用
有了多态性以后，我们在编译期间，只能调用父类中声明的方法，但是在运行期间，我们实际执行的是子类重写父类的方法
总结：编译看左边，运行看右边
3.多态性的使用前提
①类的继承关系
②方法重写
4.对象的多态性，只适用于方法，不适用于属性
5.对象的多态性，只适用于方法，不适用于属性（编译和运行都看左边）
因此多态性是运行时行为
6.多态性下不能调用子类所特有的方法、属性，编译时实例化的对象是父类类型：有了对象的多态性以后，内存中实际上是加载了子类特有的属性和方法，但是由于变量声明为父类类型，导致编译时，只能调用父类中声明的属性和方法，子类特有的属性和方法不能调用。
如何才能调用子类特有的属性和方法？向下转型、使用强制类型转换符

向下转型/向上转型（多态）

为了避免出现ClassCastException的异常，引入关键字：instanceof
instanceof的使用：
a instanceof A:判断对象a是否是类A的实例，如果是，返回true，如果不是，则返回false
使用情景，为了避免在向下转型出现ClassCastException的异常，我们在向下转型之前，先进行instanceof的判断，一旦返回true，就进行向下转型，如果返回false，不进行向下转型

final、finally、finalize 其中前两个是关键字，在对象被回收前调用finalize方法

== 和equals()的区别

==，运算符
1.可以使用在基本数据类型变量和引用数据类型变量中
2.如果比较的是基本数据类型变量，比较两个变量保存的数据是否相等。（不一定类型要相同）
如果比较的是引用数据类型变量，则比较两个地址值是否相等，即两个引用是否指向同一个对象实体
equals（）方法的使用
1.是一个方法而非运算符
2.只能适用于引用数据类型
3.Object类中equals（）的定义：

public boolean equals(Object obj){return (this == obj);
}

说明：Object类中定义的equals()和==的作用是相同的，比较两个对象的地址值是都相同，即两个引用是否指向同一个对象
4.像String、Data、File、包装类等都重写了Object类中的equals（）方法。重写以后，比较的不是两个引用的地址是否相同，而是比较两个对象”实体内容“是都相同。
5.通常情况下，我们自定义的类如果使用equals（）方法的话，也通常是比较两个对象的”实体内容"是是否相同，那么我们需要重写了Object类中的equals（）方法。

toString

1.当我们输出一个对象的引用时，实际上就是调用当前对象的toString（）
2.Object类中toString（）的定义

    public String toString() {return getClass().getName() + "@" + Integer.toHexString(hashCode());}

3.像String、Data、File、包装类等都重写了Object类中的toString（）方法。重写以后，使得调用toString方法时，返回“实体内容”信息。

包装类（Wrapper）

1.基本数据类——>包装类：调用包装类的构造器

int num = 10;
Interger in1 = new Interger(num);
Interger in2 = new Interger("34455");

2.包装类——>基本数据类型：调用包装类的xxxValue()方法

Interger in1 = new Interger("34455");
int i1 = in1.intValue();

3.自动装修和自动拆箱
4.基本数据类型、包装类——>String：调用String重载的valueOf（xxx xxx)
①连接运算

int num = 10;
String s1 = num + "";

②valueOf（xxx xxx)

float f1 = 10.0f;
String s2 = String.valueOf(f1);

5.String——>基本数据类型、包装类：调用包装类的parseXxx（）

String str = "123";
int num = Interger.parseInt(str);

static关键字

属性，按是否使用static修饰，又分为静态属性和非静态属性（实例变量）
实例变量，我们创建了类的多个对象，每个对象都独立的拥有一套类中的非静态属性。
静态变量：创建的类的多个对象共享一个静态变量。
static修饰的属性的说明
①静态变量随着类的加载而加载，因此可以通过类.静态变量的方式进行调用
②静态变量的加载要早于对象的创建
静态属性举例：System.out；Math.PI
同样的，静态方法也是随着类的加载而加载，可以通过类.静态方法的方式进行调用
①静态方法中，只能调用静态的方法或属性（他们的生命周期是一致的）
②在非静态方法中，既可以调用非静态方法，也可以调用静态方法
③静态方法中，不能使用this、super等关键字

单例设计模式（Singleton）

饿汉式：一次性造好
好处：线程是安全的
坏处：对象加载时间过长
1.私有化类的构造器
2.内部创建类的对象，必须是静态对象
3.提供公共的静态方法，返回类的对象

public class SingletonTest {public static void main(String[] args) {Bank b1 = Bank.getInstance();Bank b2 = Bank.getInstance();System.out.println(b1 == b2);//b1\b2是同一个实例}
}
class Bank{//1.私有化类的构造器private Bank() {}//2.内部创建类的对象，必须是静态对象，因为静态方法只能调用静态属性private static Bank instance = new Bank();//3.提供公共的静态方法，返回类的对象，因为Bank类的构造器是私有的，//不能通过构造实例来调用，因此声明为staticpublic static Bank getInstance() {return instance;}
}

懒汉式：啥时候用啥时候造
好处：延迟对象的创建
坏处：线程不安全

public class SingletonTest2 {public static void main(String[] args) {Order b1 = Order.getInstance();Order b2 = Order.getInstance();System.out.println(b1 == b2);}
}
class Order{//1.私有化类的构造器private Order() {}//2.声明当前类的对象，也是必须为static,没有初始化private static Order instance = null;//3.声明public、static的返回当前类对象的方法public static Order getInstance() {if(instance == null){instance = new Order();}return instance;}
}

main方法

1.main（）作为程序入口
2.main（）也是一个静态方法

代码块（Block）

静态代码块
随着类的加载而执行，而且只执行一次
作用、初始化类的属性
如果一个类中定义了多个静态代码块，则按照声明的先后顺序执行
静态代码块的执行要先于非静态代码块的执行
静态代码块中只能调用静态属性、方法，不能调用非静态的结构
非静态代码块
随着对象的创建而执行
每创建一个对象，就执行一次非静态代码块
作用、可以在创建对象时，对对象的属性进行初始化
如果一个类中定义了多个非静态代码块，则按照声明的先后顺序执行

属性赋值的先后顺序

对属性可以赋值的位置
①默认初始化（默认初始值，如 int型默认是0）
②显式初始化（显式赋值，如：int i = 1;)\⑤在代码块中初始化
③在构造器中初始化
④有了对象以后，可以通过“类.属性”或“对象.方法”的方式进行赋值

执行的先后顺序：① - ②\⑤ - ③ - ④

final关键字

final类：表示类不能被继承，不能拥有子类；如：String、System、StringBuffer类
final方法：表示方法不能被重写；如：Object类中的getClass();
final变量：此时的变量就称为常量；
final修饰属性，可以考虑赋值的位置有：显式初始化、代码块中初始话、构造器中初始化
final修饰局部变量，
尤其是final修饰形参是，表示此形参是一个常量。当我们调用此方法时，给常量形参赋一个实参，一旦赋值以后，就只能在方法体内使用此形参，但是不能进行重新赋值。

static final 用来修饰属性：全局常量