1.一个类的构成

一个类{
静态属性
普通属性
静态方法（）
普通方法（）
构造方法（）
静态代码块{}
构造代码块{}
}

2.有关类加载

类加载的时机：
1.创建他的对象
2.访问他的静态变量或方法
3.反射
4.初始化他的子类时
5.虚拟机启动（如果他定义了main方法）
类对象创建的时机:
1.经典创建:调用new 类名();
2.Class类反射创建:
1>(类名)Class.forName(“类全限定名”).newInstance();
2>类名.class.newInstance();
3.Constructor类反射创建:
Constructor constructor = 类名.class.getConstructor(参数类名.class);
类名 a = (类名) constructor.newInstance(参数);
4.通过克隆:
类名 a = new 类名();
类名 b = (类名)a.clone;
5.反序列化:不好讲,再说吧

当类加载时,
1.子类准备静态属性
2.父类准备静态属性
3.父父…类准备静态属性

4.父父…类执行静态代码块，给静态属性赋值(按代码实际顺序执行)
5.父类执行静态代码块,给静态属性赋值
6.子类执行静态代码块,给静态属性赋值
当创建类对象时,
1.子类准备普通属性
2.父类准备普通属性
3.父父…类准备普通属性

4.父父…类执行构造代码块,给普通属性赋值
5.父父…类执行无参构造方法
6.父类执行构造代码块,给普通属性赋值
7.父类执行无参构造方法
8.子类执行构造代码块,给普通属性赋值
9.子类执行正确参构造方法

3.反序列化例子

反序列化例子:
public class Student implements Cloneable, Serializable {
private int id;
public Student(Integer id) {
this.id = id;
}
@Override
public String toString() {
return “Student [id=” + id + “]”;
}
public static void main(String[] args) throws Exception {
Constructor constructor = Student.class
.getConstructor(Integer.class);
Student stu3 = constructor.newInstance(123);
// 写对象
ObjectOutputStream output = new ObjectOutputStream(
new FileOutputStream(“student.bin”));
output.writeObject(stu3);
output.close();
// 读对象
ObjectInputStream input = new ObjectInputStream(new FileInputStream(
“student.bin”));
Student stu5 = (Student) input.readObject();
System.out.println(stu5);
}
}