1、继承关系中，父子类构造方法的访问特点

1、子类构造方法当中有一个默认隐含的”super()“调用，所以一定是先调用的父类构造，后执行的子类构造。
2、子类构造可以通过super关键字来调用父类重载构造。
3、super的父类构造调用，必须是子类构造方法的第一个语句。不能一个子类构造调用多次super构造。

2、super关键字用来访问父类的内容，而this关键字用来访问本类内容。用法也有三种

1、在本类的成员方法中，访问本类的成员变量
2、在本类的成员方法中，访问本类的另一个成员方法
3、在本类的构造方法中，访问本类的另一个构造方法
this(...)调用也必须是构造方法的第一个语句，唯一一个
super和this两种构造调用，不能同时使用

// Fu
public class Fu {
    int num = 20;
}
// Zi
public class Zi extends  Fu{
    int num = 20;

    public Zi() {
        this(123); // 本类的无参构造，调用本类的有参构造
    }

    public Zi(int n) {
    }
    public void showNum() {
        int num = 10;
        System.out.println(num); // 10
        System.out.println(this.num); // 20
        System.out.println(super.num); // 30
    }

    public void methodA() {
        System.out.println("AAA");
    }

    public void methodB() {
        this.methodA();
        System.out.println("BBB");
    }
}

3、抽象类

1、抽象类不能够创建对象，如果创建，编译无法通过而报错。
2、抽象类中可以有构造方法，是供子类创建对象时，初始化父类成员使用。
3、抽象类中，不一定包含抽象方法，但是抽象方法的类必定是抽象类。
4、抽象类的子类，必须重写抽象父类中的抽象方法，否则，编译无法通过而报错。

4、Interface

在任何版本的Java中，接口都能定义抽象方法。
格式：
public abstract 返回值类型 方法名称(参数列表)
注意事项：
1、接口当中的抽象方法，修饰符必须是两个固定的关键字：public abstract
2、这两个关键字可以选择性的省略

public interface MyInterfaceAbstract {
    // 下面都是抽象方法
    public abstract  void method1();
    abstract  void method2();
    public  void method3();
    void method4();
}

3、接口的默认方法，可以通过接口实现类对象，直接调用
4、接口的默认方法，也可被接口实现类覆盖重写。

public interface MyInterfaceAbstract {
    public default void method1() {
        System.out.println("我是一个默认方法");
    };
}

5、从java8开始接口中允许定义静态方法
调用方式：接口名称.静态方法名(参数)
6、从java9开始，接口当中允许定义私有方法。
普通私有方法：解决多个默认方法之间重复代码问题。
静态私有方法：解决多个静态方法之间重复代码问题。

public interface MyInterfacePrivate {
    public static void method1() {
        System.out.println("静态方法1");
        methodCommon();
    }
    public static void method2() {
        System.out.println("静态方法2");
        methodCommon();
    }

    private static void methodCommon() {
        System.out.println("AAA");
        System.out.println("BBB");
    }
}

7、一个类实现多个接口的方法
注意点：
1）、如果实现类所实现的多个接口当中，存在重复的抽象方法，那么只需要覆盖重写一次即可。
2）、如果实现类没有覆盖重写所有接口当中的所有抽象方法，那么实现类一定要对冲突的默认方法进行覆盖重写。
3）、一个类如果直接父类当中的方法，和接口当中的默认方法产生了冲突，优先用父类当中的方法。
4）、多个父类接口当中的默认方法如果重复，那么子接口必须进行默认方法的覆盖重写，【而且带着default关键字】。

5、final

可以修饰一个类、方法、局部变量、成员变量
由于成员变量具有默认值，所以用了final之后必须手动赋值，不会在给默认值了。
对于final成员变量，要么直接赋值，要么通过构造方法赋值。
必须保证类中的所有重载的构造方法，都最终会对final成员变量赋值。

6、访问权限

权限	public	protected	(default)	private
同一个类	YES	YES	YES	YES
同一个包	YES	YES	YES	NO
不同包子类	YES	YES	NO	NO
不同包非子类	YES	NO	NO	NO

注：(default)代表不写

7、内部类

1、成员内部类
2、局部内部类（包含匿名内部类）
1、间接方式：在外部类的方法当中，使用内部类：然后main只是调用外部类的方法。
2、直接方法，公式：类名称 对象名 = new 类名称()
外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();

// Hear class
// ========
public class Body {
    public class Heart {
        // 内部类的方法
        public void beat() {
            System.out.println("心脏跳动");
            System.out.println("我叫：" + name);
        }
    }
    private String name = "外部类成员";
    public void  methodBody() {
        System.out.println("外部类方法");
        new Heart().beat(); // 间接调用
    }
}
// main class
// ========
public class Demo01HeartClass {
    public static void main(String[] args) {
        // 间接调用
        Body body = new Body();
        body.methodBody();
        // 直接调用
        Body.Heart heart = new Body().new Heart();
        heart.beat();
    }
}

3、如果出现了重名现象：外部类名称.this.外部类成员变量名

public class Outer {
    int num = 10;
    public class Inner {
        int num = 20;
        public void methodInner() {
            int num = 30;
            System.out.println(num); // 局部变量就近原则
            System.out.println(this.num); // 内部类的成员变量
            System.out.println(Outer.this.num); // 外部类的成员变量
        }
    }
}

4、从java8开始，只要局部变量事实不变，那么final关键字可以省略

public class Outer {
    public void methodOuter() {
        int num = 10; // 所在方法的局部变量
        class MyInner {
            public void methodInner() {
                System.out.println(num);
            }
        }
    }
}

5、匿名内部类
如果接口实现类，只需要使用唯一一次
那么这种情况下就可以省略掉该类的定义，而改为使用【匿名内部类】。

// MyInterface
// =========
public interface MyInterface {
    public void method();
}
// ========
MyInterface obj = new MyInterface() {
    @Override
    public void method() {
        System.out.println("匿名内部类");
    }
};
obj.method();