《JAVA SE》面向对象编程（中篇）

迈不过友情╰ 2023-09-29 13:58 1阅读 0赞

## 前言 ##

`上一篇已经讲过包、继承和多态，链接如下：`

[《JAVA SE》面向对象编程（上篇）][JAVA SE]

下面会给各位老铁总结面向对象编程的最后两个知识点： **抽象类**和**接口**。

--------------------

## 一、（补充）在构造方法中调用重写的方法（坑） ##

一段有坑的代码. 我们创建两个类, B 是父类, D 是子类. D 中重写 func 方法. 并且在 B 的构造方法中调用 func。

class B {
        
        public B() {
        
            // do nothing
            func();
        }
    
        public void func() {
        
            System.out.println("B.func()");
        }
    }
    
    class D extends B {
        
        private int num = 1;
    
        @Override
        public void func() {
        
            System.out.println("D.func() " + num);
        }
    }
    
    public class Test {
        
        public static void main(String[] args) {
        
            D d = new D();
        }
    }

程序执行结果如下：  
![在这里插入图片描述][e8b0bb3ed1f049018f9ca80fe18ca0b3.png]  
✦ 构造 D 对象的同时, 会调用 B 的构造方法.  
✦ B 的构造方法中调用了 func 方法, 此时会触发动态绑定, 会调用到 D 中的 func().  
✦ 此时 D 对象自身还没有构造, 此时 num 处在未初始化的状态, 值为 0.

> **结论**: “用尽量简单的方式使对象进入可工作状态”, 尽量不要在构造器中调用方法(如果这个方法被子类重写, 就会触发**动态绑定**, 但是此时子类对象还没构造完成), 可能会出现一些隐藏的但是又极难发现的问题。

## 二、抽象类 ##

### 2.1 语法规则 ###

在上篇打印图形例子中, 我们发现, 父类 Shape 中的 draw 方法好像并没有什么实际工作, 主要的绘制图形都是由Shape 的各种子类的 draw 方法来完成的. 像这种没有实际工作的方法, 我们可以把它设计成一个抽象方法(abstract method), 包含抽象方法的类我们称为 抽象类(abstract class).

abstract class Shape {
         
     abstract public void draw(); 
    }

★ 在 draw 方法前加上 abstract 关键字, 表示这是一个抽象方法. 同时抽象方法没有方法体(**没有 \{ \}**, 不能执行具体代码).

★ 对于包含抽象方法的类, 必须加上 abstract 关键字表示这是一个抽象类（抽象方法指的是**只有函数声明，没有函数实现**的方法，如上代码）

### 2.2 注意事项 ###

1.  抽象类**不能直接实例化**，哪怕该类中一个抽象方法都没有。

Shape shape = new Shape(); 
    // 编译出错
    Error:(30, 23) java: Shape是抽象的; 无法实例化

1.  抽象方法**不能是 private** 的，因为子类无法重写。

abstract class Shape {
         
     abstract private void draw(); 
    } 
    // 编译出错
    Error:(4, 27) java: 非法的修饰符组合: abstract和private

1.  抽象类中可以包含其他的**非抽象方法**, 也可以包含**字段**. 这个非抽象方法和普通方法的规则都是一样的, 可以被重写,也可以被子类直接调用

abstract class Shape {
         
     abstract public void draw(); 
     void func() {
         
     System.out.println("func"); 
     } 
    } 
    class Rect extends Shape {
         
     ... 
    } 
    public class Test {
         
     public static void main(String[] args) {
         
     Shape shape = new Rect(); 
     shape.func(); 
     } 
    } 
    // 执行结果
    func

1.  抽象方法所在的类必须是抽象类，子类若继承了抽象类，**必须覆写所有的抽象方法**（子类是普通类的情况下），抽象类也可以被抽象类继承，此时可以留给这个抽象类的子类去覆写。
2.  题目：JAVA中没有方法体的方法就是抽象方法（✘）  
    ![在这里插入图片描述][073d26ed1ad8453abb58c8523f1ff881.png]本地方法也没有方法体，但它不是抽象方法。
3.  抽象类是普通类的超集（普通类有的内容，抽象类都有），只是比普通类多了一些抽象方法而已，抽象类虽然没法直接实例对象，但是也可以存在构造方法，**子类在实例化时，仍然遵从继承原则，先调用父类（抽象类）的构造方法，而后调用子类的构造方法！！！**

![在这里插入图片描述][b7d331ca3eaa4a38b0f47f167937a408.png]![在这里插入图片描述][7374120de23b4a47a6d9d0874152e2e1.png]  
输出num=0是因为print语句是在父类构造方法中完成的，此时还没进到子类的构造方法中，num还未初始化，默认值为0。

### 2.3 抽象类的作用 ###

✦抽象类存在的最大意义就是为了**被继承**.  
✦抽象类本身不能被实例化, 要想使用, 只能创建该抽象类的子类. 然后让子类重写抽象类中的抽象方法。

✦使用抽象类相当于**多了一重编译器的校验**。  
✦使用抽象类的场景就如上面的代码, 实际工作不应该由父类完成, 而应由子类完成. 那么此时如果不小心误用成父类了,使用普通类编译器是不会报错的.但是父类是抽象类就会在实例化的时候提示错误, 让我们尽早发现问题

> ✦很多语法存在的意义都是为了 “预防出错”, 例如 final 关键字也是类似. 创建的变量用户不去修改, 不就相当于常量嘛? 但是加上 final 能够在不小心误修改的时候, 让编译器及时提醒我们.  
> ✦充分利用编译器的校验, 在实际开发中是非常有意义的.

## 三、接口 ##

接口是抽象类的更进一步. 抽象类中还可以包含非抽象方法, 和字段. 而接口中包含的方法都是**抽象方法**, 字段只能包含**静态常量**。

### 3.1 语法规则 ###

在刚才的打印图形的示例中, 我们的父类 Shape 并没有包含别的非抽象方法, 也可以设计成一个接口：

interface IShape {
        
        void draw();
    }
    class Cycle implements IShape {
        
        @Override
        public void draw() {
        
            System.out.println("○");
        }
    }
    public class Test {
        
        public static void main(String[] args) {
        
            IShape shape = new Cycle();
            shape.draw();
        }
    }

✦使用 **interface** 定义一个接口

✦接口中的方法一定是抽象方法, 因此**可以省略 abstract**

✦接口中的方法一定是 public, 因此**可以省略 public**

✦Cycle 使用 **implements 继承接口**. 此时表达的含义不再是 “扩展”, 而是 “实现”

✦在调用的时候同样可以创建一个接口的引用, 对应到一个子类的实例.

✦接口**不能**单独被实例化.

✦接口允许**多实现**

> **扩展(extends) vs 实现(implements)**  
> 扩展指的是当前已经有一定的功能了, 进一步扩充功能.  
> 实现指的是当前啥都没有, 需要从头构造出来

接口中只能包含抽象方法. 对于字段来说, 接口中只能包含静态常量(final static).

interface IShape {
        
        void draw();
    
        public static final int num = 10;
    }

其中的 public, static, final 的关键字都可以省略. 省略后的 num 仍然表示 public 的静态常量:

interface IShape {
        
        void draw();
    
        int num = 10;
    }

**注意事项：**

1.  我们创建接口的时候, 接口的命名**一般以大写字母 I 开头**.
2.  接口的命名一般使用 **“形容词” 词性**的单词.
3.  阿里编码规范中约定, 接口中的方法和属性**不要加任何修饰符号**, 保持代码的简洁性，只保留**方法返回值，方法参数列表，名称**即可
4.  子类实现一个接口的时候，命名以相对应的接口开头，以impl结尾。  
    eg：如果是IRun的子类，则建议命名为RunImpl（也不是强制要求）  
    如果子类实现多个父接口，不需要使用此规范命名。

> 提示, IDEA 中使用 ctrl + i 快速实现接口

### 3.2 实现多个接口（可看可不看） ###

有的时候我们需要让一个类同时继承自多个父类. 这件事情在有些编程语言通过 **多继承** 的方式来实现的.

然而 Java 中只支持单继承, 一个类只能 extends 一个父类. 但是可以同时实现多个接口, 也能达到多继承类似的效果.

现在我们通过类来表示一组动物：

class Animal {
        
        protected String name;
    
        public Animal(String name) {
        
            this.name = name;
        }
    }

另外我们再提供一组接口, 分别表示 “会飞的”, “会跑的”, “会游泳的”

interface IFlying {
        
        void fly();
    }
    interface IRunning {
        
        void run();
    }
    interface ISwimming {
        
        void swim();
    }

接下来我们创建几个具体的动物  
猫, 是会跑的

class Cat extends Animal implements IRunning {
        
        public Cat(String name) {
        
            super(name);
        }
        @Override
        public void run() {
        
            System.out.println(this.name + "正在用四条腿跑");
        }
    }

鱼, 是会游的

class Fish extends Animal implements ISwimming {
        
        public Fish(String name) {
        
            super(name);
        }
        @Override
        public void swim() {
        
            System.out.println(this.name + "正在用尾巴游泳");
        }
    }

青蛙, 既能跑, 又能游(两栖动物)

class Frog extends Animal implements IRunning, ISwimming {
        
        public Frog(String name) {
        
            super(name);
        }
        @Override
        public void run() {
        
            System.out.println(this.name + "正在往前跳");
        }
        @Override
        public void swim() {
        
            System.out.println(this.name + "正在蹬腿游泳");
        }
    }

还有一种神奇的动物, 水陆空三栖, 叫做 “鸭子”

class Duck extends Animal implements IRunning, ISwimming, IFlying {
        
        public Duck(String name) {
        
            super(name);
        }
        @Override
        public void fly() {
        
            System.out.println(this.name + "正在用翅膀飞");
        }
        @Override
        public void run() {
        
            System.out.println(this.name + "正在用两条腿跑");
        }
        @Override
        public void swim() {
        
            System.out.println(this.name + "正在漂在水上");
        }
    }

上面的代码展示了 Java 面向对象编程中最常见的用法: 一个类继承一个父类, 同时实现多种接口.

继承表达的含义是 is - a 语义, 而接口表达的含义是 具有 xxx 特性

> 猫是一种动物, 具有会跑的特性.  
> 青蛙也是一种动物, 既能跑, 也能游泳  
> 鸭子也是一种动物, 既能跑, 也能游, 还能飞

这样设计有什么好处呢? 时刻牢记多态的好处, 让程序猿忘记类型. 有了接口之后, 类的使用者就不必关注具体类型, 而只关注某个类是否具备某种能力.

例如, 现在实现一个方法, 叫 “散步”

public static void walk(IRunning running) {
        
        System.out.println("我带着伙伴去散步");
        running.run();
    }

在这个 walk 方法内部, 我们并不关注到底是哪种动物, 只要参数是会跑的, 就行

Cat cat = new Cat("小猫"); 
    walk(cat); 
    Frog frog = new Frog("小青蛙"); 
    walk(frog); 
    // 执行结果
    我带着伙伴去散步
    小猫正在用四条腿跑
    我带着伙伴去散步
    小青蛙正在往前跳

甚至参数可以不是 “动物”, 只要会跑!

class Robot implements IRunning {
        
        private String name;
    
        public Robot(String name) {
        
            this.name = name;
        }
    
        @Override
        public void run() {
        
            System.out.println(this.name + "正在用轮子跑");
        }
    }
        Robot robot = new Robot("机器人");
    
        walk(robot);
    // 执行结果
    机器人正在用轮子跑

## 总结 ##

以上给大家介绍了抽象类以及接口的定义和语法规则，关于常用的接口以及实例，我们会在下篇讲解，未完待续~

[JAVA SE]: https://blog.csdn.net/qq_43575801/article/details/124555803?spm=1001.2014.3001.5501
[e8b0bb3ed1f049018f9ca80fe18ca0b3.png]: https://img-blog.csdnimg.cn/e8b0bb3ed1f049018f9ca80fe18ca0b3.png
[073d26ed1ad8453abb58c8523f1ff881.png]: https://img-blog.csdnimg.cn/073d26ed1ad8453abb58c8523f1ff881.png
[b7d331ca3eaa4a38b0f47f167937a408.png]: https://img-blog.csdnimg.cn/b7d331ca3eaa4a38b0f47f167937a408.png
[7374120de23b4a47a6d9d0874152e2e1.png]: https://img-blog.csdnimg.cn/7374120de23b4a47a6d9d0874152e2e1.png