多态与接口

2024.7.29

1、快速重写：

当已经在一个父类中写下一个方法，比如在shape中写下draw方法，可以在shape的子类中，用draw加回车快速重写draw方法。

2、多态：

当我们引用的对象不一样，调用同一个重写的方法，表现得行为不一样，这种思想叫做多态。

3、多态的好处：

A、能够降低代码的“圈复杂度”，避免使用大量的if-else

不使用多态输出多个子类中的方法：

String[] strings = {"cycle","rect","cycle","rect","flower"};
for (String s: strings) {
    if(s.equals("cycle")){
        cycle.draw();
    }else if(s.equals("rect")){
        rect.draw();
    }else{
        flower.draw();
    }
}

使用多态：

Shape[] shapes = {cycle,rect,cycle,rect,flower};//发生了向上转型
for(Shape shape:shapes){
    shape.draw();

B、可扩展能力更强

想要扩展，直接写一个子类，然后new一个出来，将这个刚new出来的加入到shapes中，即可完成。

4、多态的缺陷：代码的运行效率降低

A、属性没有多态性（当父类和子类都有同名属性的时候，通过父类引用，只能引用父类自己的成员属性）

B、构造方法没有多态性

5、抽象类概念：如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

6、抽象类语法：一个类如果被abstract修饰称为抽象类，抽象类中被abstract修饰的方法称为抽象方法，抽象方法不用给出具体的实现体。（就是连花括号都不用了，因为子类会重写这个方法）

抽象类是不可以被实例化的

要抽象类就是为了被继承

当一个普通类继承了这个抽象类之后，这个普通类一定要重写这个抽象类当中所有的抽象方法

抽象方法不能被private、static、final修饰

当一个抽象类A不想被一个普通类B继承，此时可以把B这个类变成抽象类，那么当一个普通类C继承这个抽象类B之后，C要重写A和B中所有抽象方法

Final和abstract是不能够同时存在的

//new Rect() ->匿名对象（没有名字的对象）匿名对象的缺点是每次使用都得重新实例化，也就是再new一次。

比如同样调用两次draw方法，匿不匿名的差异：

不匿名：

Rect rect = new Rect();

Rect.draw();

Rect.draw();

匿名：

new Rect().draw();

new Rect().draw();

接口

概念：接口就是公共的行为规范，大家在实现时，只要符合规范标准，就可以通用。

再Java中，接口可以看成是：多个类的公共规范，是一种引用数据类型。

接口当中的成员变量默认都是public static final的

接口当中的成员方法默认都是public abstract，一般情况下我们不写

接口当中不可以有普通的方法

Java8开始，允许在接口当中定义一个default方法，可以有具体的实现

接口当中的方法，如果是static修饰的方法，那么是可以有具体的实现的

接口不能通过new关键字进行实例化

类和接口之间可以通过关键字implements来实现接口

接口也可以发生向上转型以及动态绑定

接口特性：

1. 接口类型是一种引用类型，但是不能直接new接口的对象
2. 接口中每一个方法都是public的抽象方法，即接口中的方法会被隐式的指定为public abstract(也只能是public abstract,其他修饰符会报错)
3. 接口中的方法是不能在接口中实现的，只能由接口的类来实现。
4. 重写接口中方法时，不能使用默认权限。
5. 接口中可以含有变量，但是接口中的变量会被隐式的指定为public static final变量。
6. 接口中不能有静态代码块和构造方法
7. 接口虽然不是类，但是接口编译完成后字节码文件的后缀格式也是.class
8. 如果类没有实现接口中的所有抽象方法，则类必须设置为抽象类
9. Jdk8中，接口中还可以包含default方法。

今日份部分代码：

class Animal{
    public String name;
    public int age;
    public Animal(String name,int age){
        this.name = name;
        this.age = age;
    }

    public void eat(){
        System.out.println(name + "正在吃！");
    }

    @Override
    public String toString() {
        return "Animal{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

class Dog extends Animal{
    public Dog(String name,int age){
        super(name,age);
    }

    public void wangWang(){
        System.out.println(name + "正在汪汪");
    }
    public void eat(){
        System.out.println(name + "吃狗粮！");
    }
}

class Bird extends Animal{
    public Bird(String name,int age){
        super(name,age);
    }

    public void fly(){
        System.out.println(name + "正在飞！");
    }
}
public class Test {
    public static void main(String[] args) {
        Animal animal1 = new Dog("小狗",10);
        animal1.eat();
    }
   /* public static void main1(String[] args) {
        *//*Dog dog = new Dog("小狗",10);
        dog.eat();
        dog.wangWang();
        System.out.println("===");
        Animal animal = new Animal("animal"，10);
        animal.eat();*//*
        Animal animal1 = new Dog("小狗",10);//父类引用引用了子类对象
        Animal animal2 = new Bird("小鸟",10);
        Dog dog = new Dog("小狗",10);
        //理解多态：1、向上转型。2、重写方法。3、通过父类引用，调用这个子类对象重写的方法
        //向上转型三种方法：1、直接赋值。2、方法传参的方式。3、返回值
        func1(dog);
    }*/
    /*public static Animal func2(){

    }
    public static void func1(Animal animal){

    }*/
}

class Shape{
    public void draw(){
        System.out.println("画图形！");
    }
}

class Rect extends Shape{
    @Override
    public void draw() {
        System.out.println("矩形");
    }
}
class Cycle extends Shape{
    @Override
    public void draw() {
        System.out.println("圆");
    }
}
class Flower extends Shape{
    @Override
    public void draw() {
        System.out.println("花");
    }
}
class Triangle extends Shape{
    @Override
    public void draw() {
        System.out.println("三角形");
    }
}
public class Shape1 {
    public static void drawMap(Shape shape){
        shape.draw();
    }
    public static void drawMaps(){
        Cycle cycle = new Cycle();
        Rect rect = new Rect();
        Flower flower = new Flower();
        Triangle triangle = new Triangle();
        /*String[] strings = {"cycle","rect","cycle","rect","flower"};
        for (String s: strings) {
            if(s.equals("cycle")){
                cycle.draw();
            }else if(s.equals("rect")){
                rect.draw();
            }else{
                flower.draw();
            }
        }*/

        //多态做法
        Shape[] shapes = {cycle,rect,cycle,rect,flower,triangle};//发生了向上转型
        for(Shape shape:shapes){
            shape.draw();
        }
    }
    public static void main(String[] args) {
        drawMaps();
        Cycle cycle = new Cycle();
        Rect rect = new Rect();
        Flower flower = new Flower();


        drawMap(cycle);
        drawMap(rect);
        drawMap(flower);
    }
}