Java基础05——抽象类、接口和多态

最新推荐文章于 2021-11-01 16:26:00 发布

原创最新推荐文章于 2021-11-01 16:26:00 发布 · 821 阅读

20 ·

CC 4.0 BY-SA版权

Java基础专栏收录该内容

11 篇文章

订阅专栏

本文深入探讨了Java中的抽象类、接口和多态概念。解释了抽象类的特性，如不可实例化和抽象方法的存在。详细阐述了接口作为抽象类的一种特殊形式，以及如何通过接口实现多继承。最后，介绍了多态的概念，包括虚方法调用、形参多态和返回值多态，展示了如何利用多态增强代码的灵活性。

1.抽象类（abstract）

（1）关键字abstract：可以用abstract来修饰一个类或方法。用abstract修饰的类表示这个类是一个抽象类，用abstract修饰的方法表示这个方法是一个抽象方法。

（2）抽象类不能被实例化。抽象方法只有方法声明，而没有方法的实现。

（3）抽象是将一类对象的共同特征总结出来构造类的过程，包括数据抽象和行为抽象两方面。抽象只关注对象有哪些属性和行为，并不关注这些行为的细节如何。

（4）具有下列情况之一，类必须被定义为抽象类：

a.类中至少有一个抽象方法

b.类继承了父类的抽象方法，如果至少有一个抽象方法在子类中没有被实现，该类必须是抽象类，实现类可以为抽象类的子类。

c.类实现了某个接口，但没有实现接口中的全部方法。

抽象类实例：

public abstract class Car {
    public abstract  int getR();

    public abstract  int getN();
    public double comSpeed(){
        return getR()*2*Math.PI*getN();
    }
}
public class BMW extends Car {
    @Override
    public int getR() {
        return 1;
    }

    @Override
    public int getN() {
        return 2;
    }
}
public class Benz extends Car {
    @Override
    public int getR() {
        return 2;
    }

    @Override
    public int getN() {
        return 3;
    }
}
public class TestCar {
    public static void main(String[] args) {
        BMW b=new BMW();
        System.out.println(b.comSpeed());

        Benz b1=new Benz();
        System.out.println(b1.comSpeed());

    }
}

2.接口（interface）

（1）接口是抽象方法和常量值的定义集合。

（2）接口是一种特殊的抽象类，这种抽象类只包含常量和抽象方法的定义，而没有变量和一般方法的实现。

（3）关键词implements（实现）：多个类可以实现同一个接口，一个类可以实现多个接口。java中可以通过接口来模拟“多继承”机制。

（4）接口的继承：接口与类类似，可以从一个父接口中派生，接口的继承也使用extends关键字完成。

与类不同的是，一个接口可以继承多个父接口。（接口和接口是继承关系）

（5）接口和抽象类的区别：

a.接口中的方法都是抽象的、公共的；而抽象类中的方法可以有一般方法，并且访问作用域可以是四种修饰符。

b.接口中没有变量，都是常量，而抽象类中有变量和常量。

c.类和接口的关系是implements（实现），类和抽象类的关系是extends（继承/拓展）。

d.类可以实现多个接口，而类只能继承一个抽象类。

e.接口可以多继承，抽象类只能有一个父类。

（6）对于一个既有继承又有实现的类，先继承再实现。

3.多态（polymorphism）

（1）在java中，对象变量如果是多态的，一个类型为Aclass的变量既可以指向类型为Aclass的对象，又可以指向Aclass的任何子类的对象。

（2）以多态的形式来传递参数，增强了参数类型的灵活性。

（3）Java引用变量有两个类型，一个是编译时的类型，一个是运行时的类型，编译时的类型由声明该变量时使用的类型决定，运行时的类型由实际赋给该变量的对象决定，如果两者类型不一致，就会出现多态。

1.虚方法调用：应用在实例化期间，仅有子类重写父类的方法

2.形参多态：一个接口有多个实现，形参不用写每个实现，直接写接口名即可代表所有的实现

3.返回值多态：一个有返回值的函数返回接口的实现的数据类型时直接写接口名代表返回值

//多态(polymorphism)：一个类型为Aclass的对象，既可以代表其本身，也可以代表其子类
interface IA{
    void go();
}
class A1 implements IA{

    @Override
    public void go() {
        System.out.println("a1_go");
    }
}
class A2 implements IA{

    @Override
    public void go() {
        System.out.println("a2_go");
    }
}
class A3 implements IA{

    @Override
    public void go() {
        System.out.println("a3_go");
    }
}

class B implements IA{//implements 实现

    @Override
    public void go() {

    }

    void ok(){//专有的方法
        System.out.println("ok!");
    }
}
public class A {
    /*
    //重载方法：麻烦，不用
    void ok(A1 a1){}
    void ok(A2 a1){}
    void ok(A3 a1){}
    */


    //【2】形参多态
    void ok(IA a)
    {
        a.go();
    }
    //【3】返回值多态
    public IA ok(int i){
        if(i==1)
            return new A1();
        else
            return new A2();
    }


    public static void main(String[] args) {
/*
        //【1】虚方法调用，仅有子类重写父类的方法【实例化期间用】
        IA b=new B();//上转型（B implements IA) 看堆（new B（））中是否有该方法
        ((B) b).ok();//强转，“.”的优先级高于强转
*/
        A1 a1=new A1();
        A2 a2=new A2();
        A3 a3=new A3();

        new A().ok(a1);//【2】Output: a1_go

        new A().ok(1).go();//【3】走return new A1();



    }
}