java面向对象理解-2021-11-19

基本用法：extends

public class Parents01 {
    public static int a = 9;
    private int b = 3;
    protected int c = 6;
}

public class Son01 extends Parents01{
    public int a = 5;

    public static void main(String[] args) {
        Son01 son = new Son01();
        System.out.println(Parents01.a);
        System.out.println(son.a);   //会覆盖
//        System.out.println(son.b);  私有变量与方法不被继承
        System.out.println(son.c);

//        9
//        5
//        6
    }
}

可以看到继承后可以通过子类去调用父类的变量，私有属性不被继承，final修饰的不能继承

构造方法：
子类继承父类会先执行父类的构造方法
若子类没有定义构造方法，默认调用父类的构造方法
子类调用父类的变量和方法，用super.变量或方法

public class Son01 extends Parents01{
    public int a = 5;
    public Son01(){
        System.out.println("gg");
//        super();
    }


    public static void main(String[] args) {
        Son01 son = new Son01();
//        i like （这里父类的构造方法）
//        gg

子类和父类关系：创建子类会自动执行父类的构造器

没啥可讲

多态：指程序中定义的引用变量所指向的具体类型和方法调用在编程时并不确定，而是在程序运行期间才确定（父类型引用指向子类型对象）
发生在继承类接口之间
向上转型：子->父
向下转型：父->子

public class Animal {
    public void eat(){
        System.out.println("eat");
    }
}

public class Dog extends Animal{

    public void eat() {
        System.out.println("dog eat a");
        drink();
    }

    public void drink() {
        System.out.println("dog drink water");
    }

}

public class Main {
    public static void main(String[] args) {
        Animal ag = new Dog();
//        ag.drink();  报错,ag是Animal没有drink方法
        ag.eat();

    }
}

ag在编译时候认为是Animal类，堆中存的是一个Dog对象，Animal中没有drink()方法，所以报错，
编译和运行两个状态，编译是Animal，运行是Dog

public class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("吃鱼");
    }

    public void drink(){
        System.out.println("小猫喝水");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal ag = new Dog();
//        ag.drink();  报错,ag是Animal没有drink方法
        ag.eat();
        ((Dog) ag).drink();
        

       if(ag instanceof Dog){
           ((Dog) ag).drink();
       }

       Cat cat =  ((Cat) ag);   //ClassCastException  编译通过运行不通过，这个时候就是instanceOf
       cat.drink();
    }
}

向下转型要判断是不是对应的子类，不是的话语法上不错，运行报强转错误

在类和类的基础上再抽象得到一个特征类；所以没有实例对象，只能被继承，final修饰不了

abstract class AbtractKL {
    private int a;
    public void a(){
        System.out.println("3");
    }

    public abstract void al();
}

1、有构造方法
2、可以有抽象方法

一种特殊的抽象类，没有构造方法，只有全局变量和抽象方法

public interface Example {
    public static int a=3;
    public int b =0;
    public final int c =6;
    public void k();
}

接口与抽象类异同点：
抽象类是一个类，只不过是类的抽象，他与普通类区别：不能被继承，里面可能拥有抽象方法abstract修饰的方法。
接口：更关注功能的实现，他不是一个类，是方法的集合，里面完全是抽象方法和全局变量（static，final，public修饰），没有抽象方法，可以多实现。