Java基础：接口、多态

￡神魔★判官ぃ 2024-03-31 14:42 64阅读 0赞

## **第一章 接口** ##

### **1.1概述** ###

接口，是Java语言中一种引用类型，是方法的集合，如果说类的内部封装了成员变量、构造方法和成员方法，那么 接口的内部主要就是**封装了方法**，包含抽象方法（`JDK 7`及以前），默认方法和静态方法（`JDK 8`），私有方法（`JDK 9`）。

接口的定义，它与定义类方式相似，但是使用 `interface`关键字。它也会被编译成`.class`文件，但一定要明确它并不是类，而是另外一种引用数据类型。

引用数据类型：数组，类，接口。

接口的使用，它不能创建对象，但是可以被实现（`interface`，类似于被继承）。一个实现接口的类（可以看做是接口的子类），需要实现接口中所有的抽象方法，创建该类对象，就可以调用方法了，否则它必须是一个抽象类。

### **1.2 定义格式** ###

public interface 接口名称 {
         
        // 抽象方法 
        // 默认方法 
        // 静态方法 
        // 私有方法 
    }

#### 含有抽象方法 ####

抽象方法：

使用代码如下：

public interface InterFaceName {
         
        public abstract void method();
    }

#### **含有默认方法和静态方法** ####

默认方法：使用`default`修饰，不可省略，供子类调用或者子类重写。

静态方法：使用`static`修饰，供接口直接调用。

代码如下：

public interface InterFaceName {
         
        public default void method() {
         
            // 执行语句 
        }
        public static void method2() {
         
            // 执行语句 
        } 
    }

#### **含有私有方法和私有静态方法** ####

私有方法：使用`private`修饰，供接口中的默认方法或者静态方法调用。

代码如下：

public interface InterFaceName {
         
        private void method() {
         
            // 执行语句 
        } 
    }

### **1.3 基本的实现** ###

#### **实现的概述** ####

类与接口的关系为实现关系，即类实现接口，该类可以称为接口的实现类，也可以称为接口的子类。实现的动作类似继承，格式相仿，只是关键字不同，实现使用`implements`关键字。

非抽象子类实现接口：

*  必须重写接口中所有抽象方法。
 *  继承了接口的默认方法，即可以直接调用，也可以重写。

实现格式：

class 类名 implements 接口名 {
         
        // 重写接口中抽象方法【必须】 
        // 重写接口中默认方法【可选】 
    }

#### **抽象方法的使用** ####

必须全部实现，代码如下：

定义接口：

public interface LiveAble {
        
        // 定义抽象方法 
        public abstract void eat(); 
        public abstract void sleep(); 
    }

定义实现类：

public class Animal implements LiveAble {
         
        @Override 
        public void eat() {
         
            System.out.println("吃东西"); 
        }
        @Override 
        public void sleep() {
         
            System.out.println("晚上睡"); 
        } 
    }

定义测试类：

public class Interface_Demo {
         
        public static void main(String[] args) {
         
            // 创建子类对象 
            Animal animal = new Animal(); 
            // 调用实现后的方法 
            animal.eat(); 
            animal.sleep(); 
        } 
    }

![在这里插入图片描述][42611495163d4441b10918d67623818a.png_pic_center]

#### **默认方法的使用** ####

可以继承，可以重写，二选一，但是只能通过实现类的对象来调用。

*  继承默认方法，代码如下：

定义接口：

public interface LiveAble {
         
        public default void fly(){
         
            System.out.println("天上飞"); 
        } 
    }

定义实现类：

public class Animal implements LiveAble {
         
        // 继承，什么都不用写，直接调用 
    }

定义测试类：

public class Interface_Demo {
         
        public static void main(String[] args) {
         
            // 创建子类对象 
            Animal animal = new Animal(); 
            // 调用默认方法 
            animal.fly(); 
        } 
    }

![在这里插入图片描述][955845fd9a6a4d2583c971671441873c.png_pic_center]

*  定重写默认方法，代码如下：

定义接口：

public interface LiveAble {
         
        public default void fly(){
         
            System.out.println("天上飞"); 
        } 
    }

定义实现类：

public class Animal implements LiveAble {
         
        @Override 
        public void fly() {
         
            System.out.println("自由自在的飞"); 
        } 
    }

定义测试类：

public class Interface_Demo {
         
        public static void main(String[] args) {
         
            // 创建子类对象 
            Animal animal = new Animal(); 
            // 调用重写方法 
            animal.fly(); 
        } 
    }

![在这里插入图片描述][5d627759f24a4d78ae8f4f6b626a8bbc.png_pic_center]

#### **静态方法的使用** ####

静态与`.class`文件相关，只能使用接口名调用，不可以通过实现类的类名或者实现类的对象调用，代码如下：

定义接口：

public interface LiveAble {
         
        public static void run(){
         
            System.out.println("跑起来~~~"); 
        } 
    }

定义实现类：

public class Animal implements LiveAble {
         
        // 无法重写静态方法 
    }

定义测试类：

public class Interface_Demo {
         
        public static void main(String[] args) {
         
            // Animal.run(); // 【错误】无法继承方法,也无法调用 
            LiveAble.run();  
        } 
    }

![在这里插入图片描述][172a6dc7ff804fce9ef88f8d3eae92a5.png_pic_center]

#### **私有方法的使用** ####

*  私有方法：只有默认方法可以调用。
 *  私有静态方法：默认方法和静态方法可以调用。

如果一个接口中有多个默认方法，并且方法中有重复的内容，那么可以抽取出来，封装到私有方法中，供默认方法去调用。从设计的角度讲，私有的方法是对默认方法和静态方法的辅助。

定义接口：

public interface LiveAble { 
        default void func(){ 
            fly01();
            fly02();
        }
    
        private void  fly01(){
            System.out.println("fly01  飞起来~~~~");
        }
        private void  fly02(){
            System.out.println("fly02  飞起来~~~~");
        }
    }

定义测试类：

public class Interface_Demo {
        
        public static void main(String[] args) {
        
            // 创建子类对象
            Animal animal = new Animal();
    
            // 调用默认方法
            animal.fly();
        }
    }

![在这里插入图片描述][52339f7449834c98b3142f740073e814.png_pic_center]

### **1.4 接口的多实现** ###

在继承体系中，一个类只能继承一个父类。而对于接口而言，一个类是可以实现多个接口的，这叫做接口的多实现。并且，一个类能继承一个父类，同时实现多个接口。

实现格式：

class 类名 [extends 父类名] implements 接口名1,接口名2,接口名3... {
         
        // 重写接口中抽象方法【必须】 // 重写接口中默认方法【不重名时可选】 
    }

*  \[ \]： 表示可选操作。

#### **抽象方法** ####

接口中，有多个抽象方法时，实现类必须重写所有抽象方法。如果抽象方法有重名的，只需要重写一次。代码如下：

定义多个接口：

public interface A {
         
        public abstract void showA();
        public abstract void show(); 
    }
    public interface B {
         
        public abstract void showB(); 
        public abstract void show(); 
    }

定义实现类：

public class C implements A,B{
        
        @Override 
        public void showA() {
         
            System.out.println("showA"); 
        }
        @Override 
        public void showB() {
         
            System.out.println("showB"); 
        }
        @Override 
        public void show() {
         
            System.out.println("show"); 
        } 
    }

#### **默认方法** ####

接口中，有多个默认方法时，实现类都可继承使用。**如果默认方法有重名的，必须重写一次。** 代码如下：

定义多个接口：

interface A {
         
        public default void methodA(){
        } 
        public default void method(){
        } 
    }
    interface B {
         
        public default void methodB(){
        } 
        public default void method(){
        } 
    }

定义实现类：

public class C implements A,B{
         
        @Override
        public void method() {
         
            System.out.println("method"); 
        } 
    }

#### **静态方法** ####

接口中，存在同名的静态方法并不会冲突，原因是只能通过各自接口名访问静态方法。

#### **优先级的问题** ####

当一个类，既继承一个父类，又实现若干个接口时，父类中的成员方法与接口中的默认方法重名，子类就近选择执行父类的成员方法。代码如下：

定义接口：

public interface A {
         
        public default void methodA(){
         
        System.out.println("AAAAAAAAAAAA"); 
        } 
    }

定义父类：

public class D {
        
        public void methodA(){
        
            System.out.println("DDDDDDDDDDDD");
        }
    }

定义子类：

public class C extends D implements A {
         
        // 未重写methodA方法 
    }

定义测试类：

public class Interface_Demo2 {
        
        public static void main(String[] args) {
        
            C c = new C();
            c.methodA();
        }
    }

![在这里插入图片描述][60c937acb7fe4a08a5d26f66b94178a9.png_pic_center]

### **1.5 接口的多继承【了解】** ###

一个接口能继承另一个或者多个接口，这和类之间的继承比较相似。接口的继承使用`extends`关键字，子接口继承父接口的方法。\*\*如果父接口中的默认方法有重名的，那么子接口需要重写一次。\*\*代码如下：

定义父接口：

public interface A {
         
         public default void method(){
                     
             System.out.println("AAAAAAAAAAAAAAAAAAA"); 
        } 
    }
    public interface B {
        
        public default void method(){
         
            System.out.println("BBBBBBBBBBBBBBBBBBB"); 
        } 
    }

定义子接口：

public interface D extends A,B{
         
        @Override 
        public default void method() {
         
            System.out.println("DDDDDDDDDDDDDD"); 
        } 
    }

**小贴士：**

*  子接口重写默认方法时，`default`关键字可以保留。
 *  子类重写默认方法时，`default`关键字不可以保留。

### **1.6 其他成员特点** ###

*  接口中，无法定义成员变量，但是可以定义常量，其值不可以改变，默认使用`public static final`修饰。
 *  接口中，没有构造方法，不能创建对象。
 *  接口中，没有静态代码块。

## **第二章 多态** ##

### **2.1 概述** ###

#### **引入** ####

多态是继封装、继承之后，面向对象的第三大特性。

生活中，比如跑的动作，小猫、小狗和大象，跑起来是不一样的。再比如飞的动作，昆虫、鸟类和飞机，飞起来也是不一样的。可见，同一行为，通过不同的事物，可以体现出来的不同的形态。多态，描述的就是这样的状态。

#### **定义** ####

**多态**：是指同一行为，具有多个不同表现形式。

### **2.2 多态的体现** ###

多态体现的格式：

父类类型 变量名 = new 子类对象； 
    变量名.方法名();

*  父类类型：指子类对象继承的父类类型，或者实现的父接口类型。

代码如下：

Fu f = new Zi(); 
    f.method();

**当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，执行的是子类重写后方法。**

代码如下：

定义父类：

public abstract class Animal {
         
        public abstract void eat(); 
    }

定义子类：

public class Cat extends Animal{
        
        @Override
        public void eat() {
        
            System.out.println("吃鱼");
        }
    }

public class Dog extends Animal{
        
        @Override
        public void eat() {
        
            System.out.println("吃骨头");
        }
    }

定义测试类：

public class Test {
        
        public static void main(String[] args) {
        
            // 多态形式，创建对象
            Animal cat = new Cat();
            // 调用的是 Cat 的 eat
            cat.eat();
    
            // 多态形式，创建对象
            Animal dog = new Dog();
            // 调用的是 Dog 的 eat 
            dog.eat();
        }
    }

![在这里插入图片描述][4d47c87c8151442bb42c70302c747691.png_pic_center]

### **2.3 多态的好处** ###

实际开发的过程中，父类类型作为方法形式参数，传递子类对象给方法，进行方法的调用，更能体现出多态的扩展性与便利。代码如下：

定义父类：

public abstract class Animal {
         
        public abstract void eat(); 
    }

定义子类：

public class Cat extends Animal{
        
        @Override
        public void eat() {
        
            System.out.println("吃鱼");
        }
    }

public class Dog extends Animal{
        
        @Override
        public void eat() {
        
            System.out.println("吃骨头");
        }
    }

定义测试类：

public class Test02 {
        
        public static void main(String[] args) {
        
            // 多态形式，创建对象
            Cat c = new Cat();
            Dog d = new Dog();
            // 调用showCatEat
            showCatEat(c);
            // 调用showDogEat
            showDogEat(d);
            /*以上两个方法, 均可以被showAnimalEat(Animal a)方法所替代 而执行效果一致 */
            showAnimalEat(c);
            showAnimalEat(d);
        }
        public static void showCatEat (Cat c){
        
            c.eat();
        }
        public static void showDogEat (Dog d){
        
            d.eat();
        }
        public static void showAnimalEat (Animal a){
        
            a.eat();
        }
    }

![在这里插入图片描述][4f5783f980984d038962982693b30bbe.png_pic_center]

由于多态特性的支持，`showAnimalEat`方法的`Animal`类型，是`Cat`和`Dog`的父类类型，父类类型接收子类对象，当然可以把`Cat`对象和`Dog`对象，传递给方法。

当`eat`方法执行时，多态规定，执行的是子类重写的方法，那么效果自然与`showCatEat`、`showDogEat`方法一致，所以`showAnimalEat`完全可以替代以上两方法。

不仅仅是替代，在扩展性方面，无论之后再多的子类出现，我们都不需要编写`showXxxEat`方法了，直接使用`showAnimalEat`都可以完成。

所以，多态的好处，体现在，可以使程序编写的更简单，并有良好的扩展。

### **2.4 引用类型转换** ###

多态的转型分为向上转型与向下转型两种：

#### **向上转型** ####

*  **向上转型**：多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的。

当父类引用指向一个子类对象时，便是向上转型。

使用格式：

父类类型 变量名 = new 子类类型(); 
    如：Animal a = new Cat();

#### **向下转型** ####

*  **向下转型**：父类类型向子类类型向下转换的过程，这个过程是强制的。

一个已经向上转型的子类对象，将父类引用转为子类引用，可以使用强制类型转换的格式，便是向下转型。

使用格式：

子类类型 变量名 = (子类类型) 父类变量名; 
    如:Cat c =(Cat) a;

#### **为什么要转型** ####

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误。也就是说，**不能调用**子类拥有，而父类没有的方法。编译都错误，更别说运行了。这也是多态给我们带来的一点"小麻烦"。所以，想要调用子类特有的方法，必须做向下转型。

转型演示，代码如下：

定义类：

public abstract class Animal {
        
        public abstract void eat();
    }

public class Cat extends Animal{
        
        @Override
        public void eat() {
        
            System.out.println("吃鱼");
        }
    
        public void catchMouse() {
        
            System.out.println("抓老鼠");
        }
    }

public class Dog extends Animal{
        
        @Override
        public void eat() {
        
            System.out.println("吃骨头");
        }
    
        public void watchHouse() {
        
            System.out.println("看家");
        }
    }

定义测试类：

public class Test03 {
        
        public static void main(String[] args) {
        
            // 向上转型 
            Animal animal = new Cat();
            animal.eat();  // 调用的是 Cat 的 eat
    
            // 向下转型
            Cat cat = (Cat)animal;
            cat.catchMouse();  // 调用的是 Cat 的 catchMouse
        }
    }

![在这里插入图片描述][06eaee326cbe428eb04a42ff54b5d8d5.png_pic_center]

#### **转型的异常** ####

转型的过程中，一不小心就会遇到这样的问题，请看如下代码：

public class Test04 {
        public static void main(String[] args) {
            // 向上转型
            Animal animal = new Cat();
            animal.eat(); // 调用的是 Cat 的 eat
            // 向下转型
            Dog dog = (Dog) animal;
            dog.watchHouse(); // 调用的是 Dog 的 watchHouse 【运行报错】
        }
    }

![在这里插入图片描述][d02c4872d4854d0fba16d8d362d23043.png_pic_center]

这段代码可以通过编译，但是运行时，却报出了`ClassCastException`，类型转换异常！这是因为，明明创建了`Cat`类型对象，运行时，当然不能转换成`Dog`对象的。这两个类型并没有任何继承关系，不符合类型转换的定义。为了避免`ClassCastException`的发生，`Java`提供了`instanceof`关键字，给引用变量做类型的校验，格式如下：

变量名 instanceof 数据类型 
    如果变量属于该数据类型，返回true。 
    如果变量不属于该数据类型，返回false。

所以，转换前，我们最好先做一个判断，代码如下：

public class Test04 {
        
        public static void main(String[] args) {
        
            // 向上转型
            Animal animal = new Cat();
            animal.eat(); // 调用的是 Cat 的 eat
            // 向下转型
            //Dog dog = (Dog) animal;
            //dog.watchHouse(); // 调用的是 Dog 的 watchHouse 【运行报错】
            if (animal instanceof Cat) {
        
                Cat cat = (Cat) animal;
                cat.catchMouse(); // 调用的是 Cat 的 catchMouse
            } else if (animal instanceof Dog) {
        
                Dog dog = (Dog) animal;
                dog.watchHouse(); // 调用的是 Dog 的 watchHouse
            }
        }
    }

![在这里插入图片描述][0ce520eaa52f4711a9ecbfaf3b07cd67.png_pic_center]

[42611495163d4441b10918d67623818a.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/037ee19398fe4eaa92c38734fb4612ee.png
[955845fd9a6a4d2583c971671441873c.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/0212f1d3eff943a7a7f2ab1a203b3cec.png
[5d627759f24a4d78ae8f4f6b626a8bbc.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/cfcd0a328389402e815c204fe7fd1261.png
[172a6dc7ff804fce9ef88f8d3eae92a5.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/951cd99395444ab5a45ec0f0ff6441ac.png
[52339f7449834c98b3142f740073e814.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/5eb9768356094fe5934e63127239056c.png
[60c937acb7fe4a08a5d26f66b94178a9.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/4c682dda77cf4ee4af68b46c7b3e17c8.png
[4d47c87c8151442bb42c70302c747691.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/be96f63a96d0444f85922bd53bbd28f2.png
[4f5783f980984d038962982693b30bbe.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/67b95db87fe04af99c5ef99b60e1122e.png
[06eaee326cbe428eb04a42ff54b5d8d5.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/cb89a31de2614dc4869b7c9a4ec13a69.png
[d02c4872d4854d0fba16d8d362d23043.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/ba1952a8d4f04a42b8f8b9793cefdeba.png
[0ce520eaa52f4711a9ecbfaf3b07cd67.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/1e929a0df3664c40a730d200105847e1.png