20200930—多态抽象类和接口

今日学习

今天把IDEA的

Generate可以快速生成get和set方法、构造函数、override等。

队列的实际应用

1.12306买票和卖票

​

买票请求发出后，消息放在队列里，卖票的处理不过来（卖票的过程比较繁琐，还要排位置，算钱啥的），就按照队列，先进先出，先进队列的请求先处理，请求处理完之后扔掉，接着处理下一个，这就是一个消息队列。

2.银行取号

取号机里生成5个号：1，2，3，4，5。1号先出，然后去办事，办完后2号办，1号办完之后再进队列，等5号被取走之后接着取一号

栈的实际应用

栈就像一个羽毛球桶，只有一头是开的，先放进去的羽毛球是最后取出的，最后放进去的羽毛球是最先被取出的。

多态

存在的前提：

注意：用父类引用指向子类对象，该对象只能调用父类和子类共有的方法，子类的特殊方法不能调用。

​ 把dog当成animal，此时只能用animal有的方法，如果该方法被子类重写了，那么调用的是被子类重写的方法而不是父类方法。

​ 涉及动态绑定。

那么什么是多态：都是父类引用指向了不同的子类对象，调用了相同方法，产生不同的结果，这就是多态。

测试：

package com.sunjie.polymorphism;

/**
 * @author SJ
 * @date 2020/9/30
 */
public class Animal {
    private String type;

    public Animal() {

    }

    //get和set方法是public的，所以能够传给子类
    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public Animal(String type) {
        this.type = type;
    }

    public void eat() {
        System.out.println("[" + this.type + "]在吃食物！");
    }


}

package com.sunjie.polymorphism;

/**
 * @author SJ
 * @date 2020/9/30
 */
public class Cat extends Animal  {

    public Cat(String type) {
        super(type);
    }

    public Cat() {
        super();
    }


    @Override
    public void eat() {
        System.out.println(this.getType()+"在吃鱼！");
    }
}

package com.sunjie.polymorphism;

/**
 * @author SJ
 * @date 2020/9/30
 */
public class Dog extends Animal {


    public Dog(String type) {
        super(type);
    }


    @Override
    public void eat() {
        System.out.println(this.getType() + "在吃肉！");
    }
    public void shake(){
        System.out.println(this.getType()+"摇尾巴");
    }
}

package com.sunjie.polymorphism;

/**
 * @author SJ
 * @date 2020/9/30
 */
public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog("小狗");
        System.out.println(dog.getType());
        dog.eat();

        Cat cat = new Cat("小猫");
        System.out.println(cat.getType());
        cat.eat();

        //父类引用指向子类对象
        Animal animal = new Dog("小狗狗");
        animal.eat();
        Animal animal1 = new Cat("小猫咪");
        animal1.eat();


    }
}

结果：

"C:\Program Files\Java\jdk1.8.0_131\bin\java.exe" ...
小狗
小狗在吃肉！
小猫
小猫在吃鱼！
小狗狗在吃肉！
小猫咪在吃鱼！

Process finished with exit code 0

多态的实际应用：

我们需要连接数据库，但是数据库有好多种，每种的连接方式也不咋一样。

然后java写了个接口（父类)，这个接口里有所有的方法。

我们可以随便调，但是我们不知道实例是啥，只有真正连数据库的时候，我们才会去看看到底是要连oracle还是mysql还是其他的。

注册驱动就是因为java里有个父类，父类有方法叫.connect( )

调用时就会根据实际传过来的这个实例(注册在内存里的驱动)，调用不同的连接方法。这就是多态。

行参是父类，传进去的实参就可以是所有的子类。

此时，便于扩展，可以随时增加子类，而不动那个形参是父类是方法。

抽象类

既然某些方法是一定会被重写的，如果不重写就不适合放在子类里用，那么父类就没必要给出该方法的实现。

例如：上面例子里Animal的eat( )方法

 public abstract void eat();

此时，我们可以将Animal类里的eat方法改成抽象方法，相应的，有抽象方法的类叫做抽象类。

public abstract class Animal {...

抽象方法规定子类一定要重写，父类不做实现。

变成抽象类之后，Animal就不能直接new了，因为某些方法没有方法体，这些方法就是用来重写的，就是定义了子类必须有这些方法。

抽象类必须被继承才能用。

如果一个类继承了抽象类，

要么，把自己申明成一个抽象类

要么，实现抽象类的所有方法

接口

接口里只能有抽象方法(没有实现的空方法)和静态常量，不能有实例变量。

接口里的所有方法都必须被实现。接口的存在就是为了约定子类里必须有这些方法。

接口使用的关键字是 interface 和 implements

Java 里只能由一个父类，单继承；但是一个类可以实现多个接口，同时该类也必须实现接口们所有的方法。

package com.sunjie.polymorphism;

/**
 * @author SJ
 * @date 2020/9/30
 */
public interface Car {
    public static int num = 1;

    public void run();

    public void ride();
}

package com.sunjie.polymorphism;

/**
 * @author SJ
 * @date 2020/9/30
 */
public class Benz implements Car {

    @Override
    public void run() {
        System.out.println("benz快跑");

    }

    @Override
    public void ride() {
        System.out.println("benz坐5人");

    }
}

package com.sunjie.polymorphism;

/**
 * @author SJ
 * @date 2020/9/30
 */
public class Test2 {
    public static void main(String[] args) {
        System.out.println(Car.num);

        Benz benz = new Benz();
        benz.ride();
        Car benz2 = new Benz();
        benz2.run();

    }
}

结果：

"C:\Program Files\Java\jdk1.8.0_131\bin\java.exe"...
1
benz坐5人
benz快跑

Process finished with exit code 0