1. 代码块
本类中用static修饰的代码块，会被自动加载，没有用static修饰的构造代码块只有在创建该类对象的时候才会被加载。非本类中的static代码块需要在进入main方法后，创建该类对象时加载，而且无论创建多少个对象都只执行一次，而该类中非static代码块会在每次创建类对象时加载。
1）局部代码块：
{
}
2）静态代码块：
static{
}
举例：
package smallprogrames;
public class Constructor {
private String name;
private String age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAge() {
return age;
}
public void setAge(String age) {
this.age = age;
}
public Constructor() {
return;
}
public Constructor(String name, String age) {
//super();
this.name = name;
this.age = age;
}
public void Work(){
System.out.println("姓名:"+name+"年龄："+age+"在工作。。。");
}
{
System.out.println("这是构造代码块1。");
}
static{
System.out.println("这是一个Constructor中的静态代码块。");
}
{
System.out.println("这是构造代码块2。");
}
public static void People(){
System.out.println("人类。。。。。。");
}
}
package smallprogrames;
public class Test0 {
static{
System.out.println("Test0中的静态代码块");
}
{
System.out.println("Test0中的构造代码块");
}
public static void main(String[] args){
System.out.println("进入main方法");
{
int a = 100;
System.out.println("这是Test0中的局部代码块。");
}
Constructor con = new Constructor();
con.setName("kathy");
con.setAge("34");
Constructor con0 = new Constructor("Mark","40");
con.Work();
con0.Work();
Constructor.People();
con.People();
//Test0 ts = new Test0();
}
}
运行结果：
Test0中的静态代码块
进入main方法
这是Test0中的局部代码块。
这是一个Constructor中的静态代码块。
这是构造代码块1。
这是构造代码块2。
这是构造代码块1。
这是构造代码块2。
姓名:kathy年龄：34在工作。。。
姓名:Mark年龄：40在工作。。。
人类。。。。。。
人类。。。。。。
注：
1.局部代码块：用于限定变量的周期，及早释放，提高内存利用率
2.构造代码块：多个构造方法中相同的代码可以放到这里，每个构造方法执行前，首先执行构造代码块。
3. 静态代码块：可以用于对类的数据进行初始化，仅仅执行一次。
2. 继承
把多个类中相同的成员提取出来定义到一个独立的类中，然后让这多个类和该独立的类建立联系，让这多个类具备该独立类的内容。
格式： class 子类名 extends 父类名{
}
java 中继承的特点：只能单继承，但是可以多层继承。
注意：
a.子类不能继承父类的私有成员
b.子类不能继承父类的构造方法但可以通过super访问
c.父类的初始化在子类初始化之前
3. this 和 super
this：代表当前类的引用。
super:代表父类存储空间的标识。可理解为父类的引用。
| this.成员变量 | 调用本类的成员变量 |
|---|---|
| this(…) | 调用本类的构造方法 |
| this.成员方法 | 调用本类的成员方法 |
| super.成员变量 | 调用父类的成员变量 |
| super（） | 调用父类的午餐构造方法 |
| super（…） | 调用父类的构造方法 |
| super.成员方法 | 调用父类的成员方法 |
注：
a.子类的所有构造方法默认都会先访问父类中的无参构造方法。
b.子类构造方法中加不加super()；,都会访问父类的无参构造。
c.如果父类中没有无参构造，那么会报错，那么可以在子类构造加上super(参数）；,或者子类中的一个构造使用super(…);，子类中的其他构造方法通过加上this（参数）或者this（）来访问使用了super(…)的本类构造方法。
d.this（…）或super(…)必须出现在第一条语句上。如果不在第一条语句那么就有可能对父类进行了多次初始化。
举例：
父类
package smallprogrames;
public class Father {
public String name = "Jack";
public int age = 40;
public Father(String name,int age){
this.age = age;
this.name = name;
System.out.println("父类 有参构造");
}
public Father(){
System.out.println("父类无参构造");
}
public void hobby(){
System.out.println("My name is "+name+". I'm now "+age +" years old.");
}
}
子类
package smallprogrames;
public class Son extends Father{
public String name;
public int age;
public Son(String name,int age){
super(name,age);
//this.name = name;
//this.age = age;
}
public void hobby(){
super.hobby();
//System.out.println("My name is "+name+". I'm now "+age +" years old.");
}
public static void main(String[] args){
Son s =new Son("Mark",12);
s.hobby();
}
}
输出结果：
父类 有参构造
My name is Mark. I'm now 12 years old.
4. override 和overload
区别：
override：重写-- 子类中出现和父类中方法声明一模一样的方法。如果子类的要实现的功能除了父类同名方法中提供的另外还有的话，那么可以在子类同名方法中方法体的第一行写上super.方法名（参数）来继承父类的功能。返回值类型不能改变。
overload：重载–本类中出现的方法名一样，参数列表不同，与返回值无关。返回值类型可以改变。
注：
a.父类中的私有方法不能被重写。
b.子类方法重写父类方法时，子类方法的访问权限不能比父类方法的访问权限低。
c.子类重写父类方法时，声明最好一模一样。
5.继承中代码块的执行顺序
父类静态代码块–子类静态代码块–父类构造代码块–父类构造方法–子类构造代码块–子类构造方法
注：子父类之间是分层初始化
6. final
就是最终的意思，可以修饰类，方法，变量。
特点：
1）它修饰的类，不能被继承。
2）它修饰的方法，不能被重写。
3）它修饰的变量，是一个常量。
注：
1）修饰基本类型是，值不能被改变；
2）修饰引用类型时，地址值不能被改变。
3）被final修饰的变量只能赋值一次。
4）被修饰的非静态常量，在构造方法完毕前完成初始化。
7. 多态
同一个对象，在不同时刻体现出来的不同状态。
分类：
1）具体类多态—父类名 f = new 子类名（）
2）抽象类多态—抽象父类名 f = new 子类名（）
3）接口多态— 接口父类名 f = new 子类名（）
多态的前提：
1）要有继承关系。
2）要有方法重写。
3）要有父类或者父接口引用指向子类对象。父类名 f = new 子类名（）
多态中的成员访问特点：
1）成员变量–编译看左边，运行看左边。（如果父类有，就加载父类的内容，如果没有就会报错！）
2）构造方法–创建子类对象时，访问父类的构造方法，对父类的数据进行初始化。
3）成员方法–编译看左边，运行看右边（如果父类有这个方法就再看子类有没有重写这个方法，如果子类有重写这个方法就执行子类的方法，如果子类没有这个方法就执行父类的方法。如果父类没有这个方法，那么编译的时候会报错。也就是不能使用父类中没有的，子类中独有的方法。）
4）静态方法—编译看左边，运行看左边。静态和类相关，方法是否重写并不影响，所以访问的还是左边的。
多态的方式调用子类独有的方法：
父类名 f = new 子类名（）；（向上转型）
子类名 z=(子类名）f;（向下转型）
将多态中父类的引用强制转换为子类的引用。（这种方法叫向下转型，相比再创建子类对象调用来说，节省了空间。）
多态的好处：
1）提高代码维护性
2）提高代码扩展性
8. 抽象类
特点：
1）抽象类和抽象方法必须用关键字abstract修饰。
2）抽象类中不一定有抽象方法，但是有抽象方法的类一定是抽象类。
3）抽象类不能实例化
4）抽象类的子类(有两种情况：1.是一个抽象类。2.是一个具体类里面重写了抽象类中的所有抽象方法。）
抽象类的成员特点：
a.成员变量–有变量，有常量
b.构造方法–有构造方法
c.成员方法–有抽象方法，有非抽象方法
注：
a.抽象类的构造方法，不能实例化，目的是为了子类访问父类数据的初始化。
b.如果一个类不想被创建对象，那么可以将它定义为抽象方法。
c.abstract 不能和final（因为用final修饰的类不能被继承，用final修饰的成员方法不能被重写），private（因为用private 修饰的类不能被继承，用private修饰的成员方法不能被重写），static（因为static修饰的方法，可以用类名直接访问方法，但是抽象方法时没有方法体的，所以加了也没有意义） 。
8. 接口
特点：
1）接口用关键字interface表示。interface Aaaa{}
2）类实现接口用implements. class Xxx implements Aaaa{}
3）接口不能实例化。因为没有构造方法，只能使用多态的方式实例化。
4）接口中的方法全部是抽象方法，默认用public abstract修饰。具体类在实现的时候里面所有的方法必须要重写。
5）接口中的成员变量默认是常量不能被重新赋值，并且默认都是静态修饰的。（如果写完整了应该是这种格式：public static final int/String/etc;）
注：java中所有的类默认继承自Object（class InterImpl extends Obeject implements Inter {}）, 所有实现的类中应该是初始化的Object里面的构造方法。
9. 类，接口之间的关系
1）类–类：单继承，可以多层继承。
2）类-- 接口：实现关系，可以单实现，也可以多实现。
并且还可以在继承一个类的同时实现多个接口（比如 class Son extends Object implements Father, Mother{}）
3) 接口–接口：继承关系，并且可以多继承。（interface Sister extends Father,Mother{}）
10. 抽象类和接口的区别：
1）抽象类中定义的是共性功能，接口中定义的是扩展功能。
2）抽象类的成员变量可以是变量也可以是常量，接口中的成员变量只能是常量。
3）抽象类中必须有抽象方法和也可以有非抽象方法，接口中全部都是抽象方法。
4）类只可以继承一个抽象类，但是却可以实现多个接口。
5）抽象类中有构造方法，接口中没有构造方法。抽象类通过子类实例化，接口通过实现的具体类实例化。
