day4 java笔记

==继承==

1.格式

• public class Employee（父类）

• public class Teacher ==extends== Employee（子类）

2.子类会继承父类的变量和方法

3.当子类和父类的变量重名时，直接调用子类变量（teacher.num）结果是子类中的值，若使用==父类==的方法调用，则使用父类中的值

4.当子类中定义方法

public class fu {

int num = 10;

}

public class zi extends fu{

int num = 20;

public void a(){

int num = 30;

System.out.println(num);/方法中定义的num

System.out.println(this.num);//子类中的num

System.out.println(super.num);//父类中的num

}

}

5.当父子方法重名，使用子类的方法，当二者名字，参数完全相同，就叫做方法的覆盖重构（可在子类方法定义前加@override,可检查方法覆盖重构是否成功）

6.super关键字

• super();代表直接调用父类的构造方法

• 也可以super.变量名或super.方法名，访问父类变量和方法

7.this关键字

• this();代表直接调用本类的构造方法

• 也可以this.变量名或this.方法名，访问类变量和方法

8.父子间的构造方法

• 子类的构造方法必须包含父类的构造方法===，并且将父类构造方法写在第一行，如果没写，编译器会赠送一个super();在第一行；

• 子类构造方法也可以将调用父类构造方法改为调用本类的另外一个调用方法(this()).也必须写在第一行

• super()和this()同时只能调用一个，且每种也只能有一个。

==抽象==

1.在定义抽象类时，加上abstract关键字，定义抽象类

2.在抽象类中可以定义抽象方法

3.不能直接new和使用抽象类（但可以有构造方法），需要让一个非抽象类继承

4.继承的类中必须覆盖重构抽象类中的所有抽象方法

##==接口==

1.接口的定义public interface myinter

2.接口中可以定义抽象方法前缀是public abstract

3.也可以定义默认方法(实现类无需重构就可以使用)public default void method

4.接口要创建实现类，实现类再创建对象才可以使用

5.也可以定义静态方法，但是无法通过实现类调用，只能使用接口名.静态方法名调用

6.可以在接口中定义私有方法，只有接口中可以调用私有方法,把public 改为 private

7.接口中只能定义常量public static final int NUM_MYINTER = 10;常量必须赋值，之后不可以再改变

8.一个实现类可以有多个接口，当多个接口的抽象方法冲突，只用重写一次或让实现类设为抽象类，当多个接口的默认方法冲突，一定要覆盖重写

9.一个类如果继承了一个父类又有一个接口，当有方法冲突时，优先用父类的方法

10.接口可以继承，一个接口可以继承一个或多个接口，多个接口抽象方法冲突没问题，但默认方法冲突就必须重构

==多态==

1.Fu one = new Zi(); 代表创建一个子类对象，当作父类看待，创建处理的对象无法使用子类特有的方法。

2.对于上面的定义：==成员变量：编译看左边，运行还看左边；成员方法：编译看左边，运行看右边==

3.Zi two = (Zi)one;代表将将创建的one向下转型

==final关键字==

1.当用来修饰一个类，这个类不能有任何子类。

2.当用来修饰一个方法，这个类不能再被覆盖重构。（不能与abstract一起写，矛盾）

3.当用来修饰一局部变量，这个变量不能被再次改变，只能赋值一次。==对于基本类型来说，指的是变量数值不能变，对于引用类型来说，指的是地址不能变，但是地址所指向的位置的内容可以改变==

4.当修饰成员变量，也只能赋值一次，只能在定义时手动赋值，或者在构造方法中赋值

==权限修饰符==

1.public > protected > (default) > private.

==内部类==

1.就是在一个类中第一另外一个类

2.内部类可以直接使用外部类的变量和方法，外部无法直接使用

3.想要调用内部类信息有两种方法

• 间接调用：在外部类中的方法中创建内部对像，再调用内部信息

• 直接调用：直接创建内部对象，格式：外部类名.内部类名 对象名 = new外部类名().new内部类名();

public class Body {
    int a = 30;
    public class Heart{
        int a = 20;
        public void beat() {
            int a = 10;
            System.out.println("xztd");
            System.out.println(a);//10
            System.out.println(this.a);//20
            System.out.println(Body.this.a);//30
        }
    }
}

==匿名内部类==

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello world!");
        inter in1 = new interl();
        in1.method();
        //--------------------------------------------------------------
        inter in2 = new inter() {
            @Override
            public void method() {
                System.out.println("类名的匿名，只能创建一个对象");
            }
        };
        in2.method();
        //--------------------------------------------------------------
        new inter(){
            @Override
            public void method() {
                System.out.println("啥都匿名的匿名，只能使用一次");
            }
        }.method();
    }
}