1.类的信息加载完成后，会自动调用静态代码块，可以完成静态属性的初始化功能

对象准备创建时，也会自动调用代码块，但不是静态的；

public class java_3_24
{public static void main(String[] args) {new User08();}}
class User08{static {System.out.println("静态代码块执行1");}static {System.out.println("静态代码块执行2");}static void test(){System.out.println("test...");}{System.out.println("代码块执行");}static {System.out.println("静态代码块执行3");}
}

注意：先调用静态代码块，再调用了代码块，这是准备创建的情况，既会调用代码块，也会调用静态代码块；

public class java_3_24
{public static void main(String[] args) {User08.test();   //因为test是静态方法，所以可以通过类名直接调用；}}
class User08{static {System.out.println("静态代码块执行1");}static {System.out.println("静态代码块执行2");}static void test(){System.out.println("test...");   }{System.out.println("代码块执行");}static {System.out.println("静态代码块执行3");}
}

这是信息加载的情况，只会调用静态代码块；

2.包：package;

在包之中容纳类，调用包中的类：

java.lang.Object;

主要目的是分类管理；类可以没有包；

包的声明语句只能在一个源码文件中使用一次；

包名一般都是小写；

3.一般情况下，使用类时，都会使用类的全名：包名+类，但有例外：

（1）使用的类就在本包中，无需全名；

（2）java.lang中的类，无需全名;

（3）事先import一个类，也无需全名；

例如：

import java.util.Date;
public class java_3_24
{public static void main(String[] args) {Date d = new Date();}}

但import在使用时有需要注意的地方：

（1）import语句只能用于package后，class前；

（2）import可以多次使用，导入多个类；

如果要导入多个类，可以使用通配符*来操作：

import java.util.*;
public class java_3_24
{public static void main(String[] args) {Date d = new Date();}}

4.构建对象：

构造方法：在一个类中如果没有自己设置创建方法，那么JVM会自动添加一个公共的，无参的构造方法，方便使用；

（1）构造方法也是方法，但没void关键字；

（2）方法名和类名完全相同；

（3）构造方法可以传递参数，但是一般传递参数的目的是用于对象属性的赋值；

例如：

public class java_3_24
{public static void main(String[] args) {System.out.println("before");User11 user = new User11();System.out.println("after");user.test();}}
class User11{User11(){System.out.println("user...");}void test(){System.out.println("test...");}
}

在定义构造方法的同时，打印一个user；

例如:

public class java_3_24
{public static void main(String[] args) {User11 user = new User11("zhangsan");System.out.println(user.username);}}
class User11{String username;User11(String name){username = name;}}

打印结果为zhangsan；

5.面向对象编程中有3个非常重要的特征：继承，封装，多态；

下面介绍继承：

（1）类存在父子关系：子类可以直接获取到父类的成员属性和成员方法。

（2）类的继承只能单继承一个父类；

（3）一个父类可以有多个子类；

例如：

import java.util.concurrent.Callable;public class java_3_24
{public static void main(String[] args) {Child c = new Child();System.out.println(c.name);c.test();};}class Parent{String name = "zhangsan";void test(){System.out.println("test...");}
}
class Child extends Parent{}

6.如果父类和子类含有相同的属性，那么可以采用特殊的关键字来区分：

super & this. 例如：

import java.util.concurrent.Callable;public class java_3_24
{public static void main(String[] args) {Child c = new Child();c.test();};}class Parent{String name = "zhangsan";}
class Child extends Parent{String name = "lisi";void test(){System.out.println(super.name);System.out.println(this.name);}
}

父子类中的构造方法:

父类对象是在子类对象创建前创建完成，创建子类对象前，会调用父类的构造方法完成父类的创建

默认情况下，子类对象创建时，会默认调用父类的构造方法完成父类对象的创建，使用的是super方法；

例如：

import java.util.concurrent.Callable;public class java_3_24
{public static void main(String[] args) {Child c = new Child();};}class Parent{Parent(String name){System.out.println("parent...");}}
class Child extends Parent{Child() {super("zhangsan");System.out.println("child...");}
}

父类要求传参才能构建，所以这时省略super方法就行不通了，所以要手动的进行传参，注意super方法时在子类的构建方法中调用的；

7.多态：

所谓的多态，其实就是一个对象在不同场景下表现出来的不同状态和形态；

多态语法其实就是对对象的使用场景进行了约束；

import java.util.concurrent.Callable;public class java_3_24
{public static void main(String[] args) {Person p = new Person();p.testperson();Person p1 = new Boy();p1.testperson();p1.testboy();   //会报错Person p2 = new Girl();p2.testgirl();  //会报错};}
class Person{void testperson(){System.out.println("testperson");}
}
class Boy extends Person{void testboy(){System.out.println("testboy");}}
class Girl extends Person{void testgirl(){System.out.println("testgirl");}
}

一个对象可以使用的功能取决于引用变量的类型；上面的p1和p2都是person类型，所以可以引用person的功能；

8.一个类中，不能重复声明相同的方法（方法名、参数列表，但是和返回值类型无关），也不能声明相同的属性；

如果方法名相同，但参数列表不同，会被认为是不同的方法，只不过名称一样，这个操作在java中称之为方法的重载；

例如：

import java.util.concurrent.Callable;public class java_3_24
{public static void main(String[] args) {User14 user = new User14();user.login(12321);user.login("nima", "cnm");user.login("123123");}}
class User14{void login(String account, String password){System.out.println("账号密码登录");}void login(int tel){System.out.println("手机号登录");}void login(String vx){System.out.println("weixin登录");}}

三个方法名字相同，执行不同功能；

9.方法的重载：

import java.util.concurrent.Callable;public class java_3_24
{public static void main(String[] args) {User12 user = new User12();}}
class User12{User12(){this("zhangsan");}User12(String name){this(name, "男");}User12(String name, String sex){System.out.println(name + "," + sex);}
}

当调用无参构造方法时，用this来调用自身的构造方法，并传入参数，再调再传，然后执行打印操作；

10.匹配方法时的精度扩大：

import java.util.concurrent.Callable;public class java_3_24
{public static void main(String[] args) {byte b = 10;test(b);}static void test(byte b){System.out.println("bbb");}static void test(short s){System.out.println("sss");}static void test(char c){System.out.println("ccc");}static void rest(int i){System.out.println("iii");}
}

此时打印bbb没毛病，但当我去掉test（byte b）这个方法时，就会打印sss，这是因为byte类型扩大精度优先转换为容易转换的类型；

注意：byte类型无法和char类型转换，因为byte类型有负数，而char类型没有负数；

11.重载和多态的综合:

import java.util.concurrent.Callable;public class java_3_24
{public static void main(String[] args) {AAA aaa = new AAA();BBB bbb = new BBB();test(bbb);}static void test(AAA aaa){System.out.println("aaa");}}
class AAA{}
class BBB extends AAA{}

打印结果为aaa，因为当前test方法应该接受AAA类型，但传入BBB类型，就会发生类似于基本类型的精度提升，只不过这里是从子向父提升；

12.方法的重写：父类对象的方法其实主要体现通用性，无法在特殊的场合下使用；

如果子类对象需要在特殊场合使用，那么需要重写方法的逻辑，这个操作在java中称为方法的重写；（并不影响父类的方法，使用super类型还是可以访问）；

重写方法：子类的方法和父类的方法，方法名相同，返回值类型相同，参数列表要相同；

总结：（1）一个对象使用什么方法，取决于引用变量的类型；

（2）一个对象能使用什么属性，取决于引用变量的类型；

（3）一个对象的方法具体的使用是需要看具体的对象的；

（4）一个对象的属性具体的使用是不需要看具体的对象的，属性在哪里声明就在哪里使用；

例如：

import java.util.concurrent.Callable;public class java_3_24
{public static void main(String[] args) {CCC ddd = new DDD();System.out.println(ddd.sum());}}
class CCC{int i = 10;int sum(){return i + 10;}
}
class DDD extends CCC{int i = 20;int sum(){return i + 20;}
}
ddd是CCC类型，所以应该看CCC中有没有sum方法，有，那么能使用，但具体的实现过程是依靠DDD中的sum方法，所以输出结果为40；

import java.util.concurrent.Callable;public class java_3_24
{public static void main(String[] args) {CCC ddd = new DDD();System.out.println(ddd.sum());}}
class CCC{int i = 10;int sum(){return i + 10;}
}
class DDD extends CCC{int i = 20;}

当把子类中的sum类型去掉后，方法具体的实现在子类中没有，那么去父类中寻找，父类的sum实现时，默认使用的是this属性，也就是父类中的属性，所以结果为20；

再看：

import java.util.concurrent.Callable;public class java_3_24
{public static void main(String[] args) {CCC ddd = new DDD();System.out.println(ddd.sum());}}
class CCC {int i = 10;int geti() {return i;}int sum() {return geti() + 10;}}class DDD extends CCC {int i = 20;int geti() {return i;}}

这串代码中，首先运行sum，在子类中没办法实现，最终要落回父类，再执行geti方法，这个需要子类中的方法进行实现，所以最终打印30；

13.访问权限：

public:公共的，访问权限修饰符，java源码中，公共类只能有一个，而且必须和源码文件名相同；

（1）private：私有的，同一个类中可以使用；

（2）（default）：默认权限，不设定时默认设定，同类同包可用；

（3）protected：受保护的：同包，同类，子类可用；

（4）public：公共的，任意使用；

14.Java中不允许外部类使用private，protected修饰；

所谓外部类，就是在源码中直接声明的类；

所谓的内部类，就是类中声明的类；

注意：内部类就当成外部类的属性使用即可，因为内部类可以看做内部类的属性，所以需要构造外部类对象才可以使用；

例如：内部类的创建过程：

import java.util.concurrent.Callable;public class java_3_24
{public static void main(String[] args) {OuterClass outer = new OuterClass();OuterClass.InnerClass innerClass = outer.new InnerClass();}}
class OuterClass{public class InnerClass{}
}

15.类的单一创建：单例模式：

由于类的创建过程复杂，如果在外部直接创建类的对象，可能会丢失一些结构，使对象使用出现问题；

还有就是类占用内存较大，我们尽可能少创建类的对象，所以我们可以把类的构建方法进行private修饰，那么就只能在类中构建了；同时再加上if语句做判断，那么就保证了一个类只会产生一个对象；

例如：

import java.util.concurrent.Callable;public class java_3_24
{public static void main(String[] args) {User19 instance = User19.getInstance();}}
class User19{private static User19 user19 = null;private User19(){}public static User19 getInstance(){if(user19 == null){user19 = new User19();}return user19;}
}
在这串代码中，创建了一个user19作为属性，然后设计getinstance方法，实现了在类的内部创建对象；

其中，由于静态方法只能访问静态属性，非静态方法既可以访问静态也可以访问非静态属性，那么就需要给属性前加上static；

16.Java中提供了一种语法，可以在数据初始化后不被修改，使用关键字final；

final可以修饰变量；变量的值一旦初始化后无法修改。

例如：

import java.util.concurrent.Callable;public class java_3_24
{public static void main(String[] args) {final String name = "zhangsan";name = "lisi";}}

会发生报错；

（1）final可以修饰变量：变量的值一旦初始化后无法修改；

（2）final可以修饰属性：那么JvM无法自动进行初始化，需要自己进行初始化，属性值不能发生变化；

（3）final可以修饰方法，这个方法不能被子类重写；

（4）final可以修饰类，这样的类就没有子类了；

（5）final不可以修饰构造方法

（6）final可以修饰方法的参数，一旦修饰，参数就无法修改了；