多态抽象接口

Xiakeyi165

已于 2024-04-06 20:32:16 修改

阅读量716

点赞数 29

文章标签： java 开发语言

于 2024-04-03 23:15:37 首次发布

本文链接：https://blog.csdn.net/Xiakeyi/article/details/137359901

版权

一、多态

1.1 多态概述

多态是在继承、实现情况下的一种现象，表现为：对象多态、行为多态

比如：Teacher和Student都是People的子类，代码可以写成下面的样子

1.2 多态的好处

在多态形式下，右边的代码是解耦合的，更便于扩展和维护。

怎么理解这句话呢？比如刚开始p1指向Student对象，run方法执行的就是Student对象的业务；假如p1指向Student对象，run方法执行的自然是Student对象的业务。

定义方法时，使用父类类型作为形参，可以接收一切子类对象，扩展行更强，更便利。

1.3 类型转换

虽然多态形式下有一些好处，但是也有一些弊端。在多态形式下，不能调用子类特有的方法，比如在Teacher类中多了一个teach方法，在Student类中多了一个study方法，这两个方法在多态形式下是不能直接调用的。

多态形式下不能直接调用子类特有方法，但是转型后是可以调用的。这里所说的转型就是把父类变量转换为子类类型。格式如下：

//如果p接收的是子类对象
if(父类变量 instance 子类){
    //则可以将p转换为子类类型
    子类 变量名 = (子类)父类变量;
}

如果类型转换错了，就会出现类型转换异常ClassCastException，比如把Teacher类型转换成了Student类型.

关于多态转型问题，我们最终记住一句话：原本是什么类型，才能还原成什么类型

二、final关键字

2.1 final修饰符的特点

final关键字是最终的意思，可以修饰类、修饰方法、修饰变量。

final修饰类：该类称为最终类，特点是不能被继承
final修饰方法：该方法称之为最终方法，特点是不能被重写。
final修饰变量：该变量只能被赋值一次。

2.2 常量

被 static final 修饰的成员变量，称之为常量。

通常用于记录系统的配置信息

三、抽象

3.1 认识抽象类

在Java中有一个关键字叫abstract，它就是抽象的意思，它可以修饰类也可以修饰方法

被abstract修饰的类，就是抽象类
被abstract修饰的方法，就是抽象方法（不允许有方法体）

//abstract修饰类，这个类就是抽象类
public abstract class A{
    //abstract修饰方法，这个方法就是抽象方法
    public abstract void test();
}


// 抽象类
public abstract class A {
    //成员变量
    private String name;
    static String schoolName;

    //构造方法
    public A(){

    }

    //抽象方法
    public abstract void test();

    //实例方法
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

抽象类是不能创建对象的，如果抽象类的对象就会报错
抽象类虽然不能创建对象，但是它可以作为父类让子类继承。而且子类继承父类必须重写父类的所有抽象方法。
子类继承父类如果不复写父类的抽象方法，要想不出错，这个子类也必须是抽象类

3.2 抽象类的好处

1.用抽象类可以把父类中相同的代码，包括方法声明都抽取到父类，这样能更好的支持多态，一提高代码的灵活性。

2.反过来用，我们不知道系统未来具体的业务实现时，我们可以先定义抽象类，将来让子类去实现，以方便系统的扩展。

3.3 模板方法模式

先解释下一什么是设计模式？设计模式是解决某一类问题的最优方案。

设计模式在一些源码中经常会出现，还有以后面试的时候偶尔也会被问到。

那模板方法设计模式解决什么问题呢？模板方法模式主要解决方法中存在重复代码的问题

比如A类和B类都有sing()方法，sing()方法的开头和结尾都是一样的，只是中间一段内容不一样。此时A类和B类的sing()方法中就存在一些相同的代码。

怎么解决上面的重复代码问题呢？我们可以写一个抽象类C类，在C类中写一个doSing()的抽象方法。再写一个sing()方法，代码如下：

// 模板方法设计模式
public abstract class C {
    // 模板方法
    public final void sing(){
        System.out.println("唱一首你喜欢的歌：");

        doSing();

        System.out.println("唱完了!");
    }

    public abstract void doSing();
}

然后，写一个A类继承C类，复写doSing()方法，代码如下

public class A extends C{
    @Override
    public void doSing() {
        System.out.println("我是一只小小小小鸟，想要飞就能飞的高~~~");
    }
}

接着，再写一个B类继承C类，也复写doSing()方法，代码如下

public class B extends C{
    @Override
    public void doSing() {
        System.out.println("我们一起学猫叫，喵喵喵喵喵喵喵~~");
    }
}

综上所述：模板方法模式解决了多个子类中有相同代码的问题。具体实现步骤如下

第1步：定义一个抽象类，把子类中相同的代码写成一个模板方法。
第2步：把模板方法中不能确定的代码写成抽象方法，并在模板方法中调用。
第3步：子类继承抽象类，只需要父类抽象方法就可以了。

四、接口

4.1 认识接口

Java提供了一个关键字interface，用这个关键字来定义接口这种特殊结构。格式如下：

public interface 接口名{
    //成员变量（常量）
    //成员方法（抽象方法）
}

public interface A{
    //这里public static final可以加，可以不加。
    public static final String SCHOOL_NAME = "黑马程序员";
    
    //这里的public abstract可以加，可以不加。
    public abstract void test();
}

public class Test{
    public static void main(String[] args){
        //打印A接口中的常量
        System.out.println(A.SCHOOL_NAME);
        
        //接口是不能创建对象的
        A a = new A();
    }
}

我们发现定义好接口之后，是不能创建对象的。那接口到底什么使用呢？需要我注意下面两点

接口是用来被类实现（implements）的，我们称之为实现类。

一个类是可以实现多个接口的（接口可以理解成干爹），类实现接口必须重写所有接口的全部抽象方法，否则这个类也必须是抽象类

4.2 接口的好处

主要有下面的两点

弥补了类单继承的不足，一个类同时可以实现多个接口。

让程序可以面向接口编程，这样程序员可以灵活方便的切换各种业务实现。

4.3 接口JDK8的新特性

从JDK8开始，接口中新增的三种方法形式。我们看一下这三种方法分别有什么特点？

public interface A {
    /**
     * 1、默认方法：必须使用default修饰，默认会被public修饰
     * 实例方法：对象的方法，必须使用实现类的对象来访问。
     */
    default void test1(){
        System.out.println("===默认方法==");
        test2();
    }

    /**
     * 2、私有方法：必须使用private修饰。(JDK 9开始才支持的)
     *   实例方法：对象的方法。
     */
    private void test2(){
        System.out.println("===私有方法==");
    }

    /**
     * 3、静态方法：必须使用static修饰，默认会被public修饰
     */
     static void test3(){
        System.out.println("==静态方法==");
     }

     void test4();
     void test5();
     default void test6(){

     }
}
public class B implements A{
    @Override
    public void test4() {

    }

    @Override
    public void test5() {

    }
}
public class Test {
    public static void main(String[] args) {
        // 目标：掌握接口新增的三种方法形式
        B b = new B();
        b.test1();	//默认方法使用对象调用
        // b.test2();	//A接口中的私有方法，B类调用不了
        A.test3();	//静态方法，使用接口名调用
    }
}

综上所述：JDK8对接口新增的特性，有利于对程序进行扩展。

4.4 接口的其他细节

一个接口可以继承多个接口

public class Test {
    public static void main(String[] args) {
        // 目标：理解接口的多继承。
    }
}

interface A{
    void test1();
}
interface B{
    void test2();
}
interface C{}

//比如：D接口继承C、B、A
interface D extends C, B, A{

}

//E类在实现D接口时，必须重写D接口、以及其父类中的所有抽象方法。
class E implements D{
    @Override
    public void test1() {

    }

    @Override
    public void test2() {

    }
}

接口除了上面的多继承特点之外，在多实现、继承和实现并存时，有可能出现方法名冲突的问题，需要了解怎么解决（仅仅只是了解一下，实际上工作中几乎不会出现这种情况）

1.一个接口继承多个接口，如果多个接口中存在相同的方法声明，则此时不支持多继承
2.一个类实现多个接口，如果多个接口中存在相同的方法声明，则此时不支持多实现
3.一个类继承了父类，又同时实现了接口，父类中和接口中有同名的默认方法，实现类会有限使用父类的方法
4.一个类实现类多个接口，多个接口中有同名的默认方法，则这个类必须重写该方法。

综上所述：一个接口可以继承多个接口，接口同时也可以被类实现。