Java基础|1-05-接口与多态 @面向对象篇

写在前面：
此系列文是笔者在学习Java系列课程的过程中，参考相关课件、视频讲解、课程代码，并结合一些文档、思维导图及个人理解，对所学内容做的阶段性梳理与总结。

  • 写于：2021年1月27日、29日
  • 内容：Java后端系列笔记005（Java基础-接口与多态）
  • 全文：10989字；读完需要：20分钟

一、接口

1. 1 概述

生活中的接口

  • 接口就是多个类的公共规范
  • 接口是一种引用数据类型，最重要的内容就是其中的：抽象方法

1. 2 接口的定义与实现

定义接口的格式

public interface 接口名称 {
   
	// 接口内容
}
  • 备注：换成了关键字interface之后，编译生成的字节码文件仍然是：.java --> .class

接口中的内容

  • 如果是Java 7，那么接口中可以包含的内容有：
    • ① 常量
    • ② 抽象方法
  • 如果是Java 8，还可以额外包含有：
    • ③ 默认方法
    • ④ 静态方法
  • 如果是Java 9，还可以额外包含有：
    • ⑤ 私有方法

实现接口的格式

  • 类与接口的关系为实现关系，即类实现接口，该类可以称为接口的实现类，也可以称为接口的子类 
class 类名 implements 接口名 {
   
	// 重写接口中抽象方法【必须】
	// 重写接口中默认方法【可选】
}

接口的抽象方法

定义：

  • 在任何版本的Java中，接口都能定义抽象方法
  • 格式：public abstract 返回值类型 方法名称(参数列表);
  • 注意事项：
    • 接口当中的抽象方法，修饰符必须是两个固定的关键字：public abstract
    • 这两个关键字修饰符，可以选择性地省略（对于初学者，不推荐）
    • 方法的三要素，可以随意定义 
//接口
public interface MyInterfaceAbstract {
   
    // 这是一个抽象方法
    public abstract void methodAbs1();

    // 这也是抽象方法
    abstract void methodAbs2();

    // 这也是抽象方法
    public void methodAbs3();

    // 这也是抽象方法
    void methodAbs4();
}

使用：

  1. 接口不能直接使用，必须有一个“实现类”来“实现”该接口
    ★ 格式：public class 实现类名称 implements 接口名称 { /*...*/ }
  2. 接口的实现类必须覆盖重写（实现）接口中所有的抽象方法
    ★ 实现：去掉abstract关键字，加上方法体大括号 
//实现类
public class MyInterfaceAbstractImpl implements MyInterfaceAbstract {
   
//把鼠标放在红线处：快捷键Alt+Enter → implement methods → 默认选中所有抽象方法 
// → OK 即可生成覆盖重写的代码 → 自己填写里面的方法体
    @Override
    public void methodAbs1() {
   
        System.out.println("这是第一个方法！");
    }

    @Override
    public void methodAbs2() {
   
        System.out.println("这是第二个方法！");
    }

    @Override
    public void methodAbs3() {
   
        System.out.println("这是第三个方法！");
    }

    @Override
    public void methodAbs4() {
   
        System.out.println("这是第四个方法！");
    }
}
  1. 创建实现类的对象，进行使用 
//测试类
public class Demo01Interface {
   
    public static void main(String[] args) {
   
        // 错误写法！不能直接new接口对象使用
// MyInterfaceAbstract inter = new MyInterfaceAbstract();

        // 创建实现类的对象使用
        MyInterfaceAbstractImpl impl = new MyInterfaceAbstractImpl();
        impl.methodAbs1();
        impl.methodAbs2();
    }

}

/* 输出结果： 这是第一个方法！ 这是第二个方法！ */

注意事项：
如果实现类并没有覆盖重写接口中所有的抽象方法，那么这个实现类自己就必须是抽象类。

接口的默认方法

定义：

  • 从Java 8开始，接口里允许定义默认方法
  • 格式：public default 返回值类型 方法名称(参数列表) { 方法体 }
  • 备注：接口当中的默认方法，可以解决接口升级的问题

使用：（两种方式）

  1. 接口的默认方法，可以通过接口实现类对象，直接调用（继承）
  2. 接口的默认方法，也可以被接口实现类进行覆盖重写（重写）

代码演示：

  • 定义接口 
public interface MyInterfaceDefault {
   

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

    // 新添加了一个抽象方法
// public abstract void methodAbs2(); //接口的实现类必须覆盖重写所有抽象方法，新添加抽象方***影响实现类

    // 新添加的方法，改成默认方法
    public default void methodDefault() {
   
        System.out.println("这是新添加的默认方法");
    }

}
  • 定义实现类 
public class MyInterfaceDefaultA implements MyInterfaceDefault {
   
    @Override
    public void methodAbs() {
   
        System.out.println("实现了抽象方法，AAA");
    }
	// 继承默认方法(什么都不写，直接调用)
}

public class MyInterfaceDefaultB implements MyInterfaceDefault {
   
    @Override
    public void methodAbs() {
   
        System.out.println("实现了抽象方法，BBB");
    }

    @Override  //重写默认方法
    public void methodDefault() {
   
        System.out.println("实现类B覆盖重写了接口的默认方法");
    }
}
  • 定义测试类 
public class Demo02Interface {
   
    public static void main(String[] args) {
   
        // 创建了实现类对象
        MyInterfaceDefaultA a = new MyInterfaceDefaultA();
        a.methodAbs(); // 调用抽象方法，实际运行的是右侧实现类

        // 调用默认方法，如果实现类当中没有，会向上找接口
        a.methodDefault(); // 这是新添加的默认方法
        System.out.println("==========");

        MyInterfaceDefaultB b = new MyInterfaceDefaultB();
        b.methodAbs();
        b.methodDefault(); // 实现类B覆盖重写了接口的默认方法
    }
}
/* 执行结果： 实现了抽象方法，AAA 这是新添加的默认方法 ========== 实现了抽象方法，BBB 实现类B覆盖重写了接口的默认方法 */

接口的静态方法

定义：

  • 从Java 8开始，接口当中允许定义静态方法
  • 格式：public static 返回值类型 方法名称(参数列表) { 方法体 }
  • 提示：就是将abstract或者default换成static即可，带上方法体

使用：

  • 注意事项：不能通过接口实现类的对象来调用接口当中的静态方法
  • 正确用法：通过接口名称，直接调用其中的静态方法
  • 格式：接口名称.静态方法名(参数);

代码演示：

  • 定义接口 
public interface MyInterfaceStatic {
   

    public static void methodStatic() {
   
        System.out.println("这是接口的静态方法！");
    }
    
}
  • 定义实现类 
public class MyInterfaceStaticImpl implements MyInterfaceStatic {
   
	// 无法重写静态方法
}
  • 定义测试类 
public class Demo03Interface {
   
    public static void main(String[] args) {
   
        // 创建了实现类对象
        MyInterfaceStaticImpl impl = new MyInterfaceStaticImpl();
        // 错误写法！（无法继承方法,也无法调用）
// impl.methodStatic();

        // 直接通过接口名称调用静态方法
        MyInterfaceStatic.methodStatic();
    }
}
/* 执行结果： 这是接口的静态方法！ */

接口的私有方法

问题描述：

  • 我们需要抽取一个共有方法，用来解决两个默认方法之间重复代码的问题
  • 但是这个共有方法不应该让实现类使用，应该是私有化的

解决方案：从Java 9开始，接口当中允许定义私有方法

  • 普通私有方法，解决多个默认方法之间重复代码问题
    ★ 格式：private 返回值类型 方法名称(参数列表) { 方法体 }
  • 静态私有方法，解决多个静态方法之间重复代码问题
    ★ 格式：private static 返回值类型 方法名称(参数列表) { 方法体 }

小提示：

  • 私有方法：使用 private 修饰，供接口中的默认方法或者静态方法调用
    • 普通私有方法：只有默认方法可以调用
    • 静态私有方法：默认方法和静态方法可以调用
  • 从设计的角度讲，私有的方法是对默认方法和静态方法的辅助

代码演示：

  • 定义接口 
// 默认方法
public interface MyInterfacePrivateA {
   
    public default void methodDefault1() {
   
        System.out.println("默认方法1");
        methodCommon();
    }

    public default void methodDefault2() {
   
        System.out.println("默认方法2");
        methodCommon();
    }

    private void methodCommon() {
   
        System.out.println("AAA");
        System.out.println("BBB");
        System.out.println("CCC");
    }
}

// 静态方法
public interface MyInterfacePrivateB {
   
    public static void methodStatic1() {
   
        System.out.println("静态方法1");
        methodStaticCommon();
    }

    public static void methodStatic2() {
   
        System.out.println("静态方法2");
        methodStaticCommon();
    }

    private static void methodStaticCommon() {
   
        System.out.println("AAA");
        System.out.println("BBB");
        System.out.println("CCC");
    }
}
  • 定义测试类（使用） 
public class Demo04Interface {
   

    public static void main(String[] args) {
   
     	MyInterfacePrivateB.methodStatic1();//直接调用
        MyInterfacePrivateB.methodStatic2();
        // 错误写法！不可调用里面的私有方法
// MyInterfacePrivateB.methodStaticCommon();
    }

}

接口的常量

定义：

  • 接口当中也可以定义“成员变量”，但是必须使用public static final三个关键字进行修饰
    • 从效果上看，这其实就是接口的【常量】
  • 格式：public static final 数据类型 常量名称 = 数据值;
  • 备注：一旦使用final关键字进行修饰，说明不可改变

注意事项：

  • 接口当中的常量，可以省略public static final，注意：不写也照样是这样
  • 接口当中的常量，必须进行赋值；不能不赋值
  • 接口中常量的名称，使用完全大写的字母，用下划线进行分隔（推荐命名规则）

代码演示：

// 接口中定义常量
public interface MyInterfaceConst {
   

    // 这其实就是一个常量，一旦赋值，不可以修改
    public static final int NUM_OF_MY_CLASS = 12;

}

// 访问常量
public class Demo05Interface {
   
    public static void main(String[] args) {
   
        // 访问接口当中的常量（接口名.常量名）
        System.out.println(MyInterfaceConst.NUM_OF_MY_CLASS);
    }
}

小结 [ 导图 ]

1. 3 接口的多实现

使用接口的时候，需要注意：

  1. 接口是没有静态代码块或者构造方法的 
public interface MyInterfaceA {
   
    // 错误写法！接口不能有静态代码块
// static {
   
//
// }

    // 错误写法！接口不能有构造方法
// public MyInterfaceA() {
   
//
// }
}
  1. 一个类的直接父类是唯一的，但是一个类可以同时实现多个接口（接口的多实现）
    ★ 格式： 
public class 类名 [extends 父类名] implements 接口名1,接口名2,接口名3... {
   
	// 重写接口中所有抽象方法【必须】
	// 重写接口中默认方法【不重名时可选】
}
// [ ]：表示可选操作
  1. 如果实现类所实现的多个接口当中，存在重复的抽象方法，那么只需要覆盖重写一次即可 
// 定义多个接口
interface A {
   
	public abstract void showA();
	public abstract void show();
}
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");
	}
}
  1. 如果实现类没有覆盖重写所有接口当中的所有抽象方法，那么实现类就必须是一个抽象类
    ★ 格式： 
public abstract class 类名 implements 接口名1,接口名2,... {
   
    // 未重写接口中所有抽象方法
}
  1. 如果实现类所实现的多个接口当中，存在重复的默认方法，那么实现类一定要对冲突的默认方法进行覆盖重写 
// 定义多个接口
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");
	}
}
  1. 优先级问题：一个类如果直接父类当中的方法，和接口当中的默认方法产生了冲突，优先用父类当中的方法 
// 定义接口
public interface MyInterface {
   
    public default void method() {
   
        System.out.println("接口的默认方法");
    }
}

// 定义父类
public class Fu {
   
    public void method() {
   
        System.out.println("父类方法");
    }
}

// 定义子类
public class Zi extends Fu implements MyInterface {
   
	// 未重写method方法
}

// 定义测试类
public class Demo01Interface {
   
    public static void main(String[] args) {
   
        Zi zi = new Zi();
        zi.method();
    }
}
/* 输出结果： 父类方法 */

1. 4 接口的多继承

概念：

  • 一个接口能继承另一个或者多个接口，这和类之间的继承比较相似
  • 接口的继承使用 extends 关键字，子接口继承父接口的方法

区别：

  1. 类与类之间是单继承的，直接父类只有一个
  2. 类与接口之间是多实现的，一个类可以实现多个接口
  3. 接口与接口之间是多继承的

注意事项：

  1. 多个父接口当中的抽象方法如果重复，没关系 
// 定义父接口
interface MyInterfaceA {
   
    public abstract void methodA();
    public abstract void methodCommon();
}

interface MyInterfaceB {
   
    public abstract void methodB();
    public abstract void methodCommon();
}

// 定义子接口
public interface MyInterface extends MyInterfaceA, MyInterfaceB {
   
    public abstract void method();
}

/* 这个子接口当中有几个方法？答：4个 methodA 来源于接口A methodB 来源于接口B methodCommon 同时来源于接口A和B method 来源于我自己 */
  1. 多个父接口当中的默认方法如果重复，那么子接口必须进行默认方法的覆盖重写，而且带着default关键字 
// 定义父接口
interface A {
   
	public default void method(){
   
		System.out.println("AAAAAA");
	}
}
interface B {
   
	public default void method(){
   
		System.out.println("BBBBBB");
	}
}

// 定义子接口
interface D extends A,B{
   
	@Override
	public default void method() {
   
		System.out.println("DDDDDD");
	}
}

小贴士：

子接口重写默认方法时，default关键字可以保留；

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

二、多态

2. 1 概述

  • 多态性是继封装、继承之后，面向对象的第三大特性
  • 定义：多态是指同一行为，具有多个不同表现形式
  • 前提（多态存在的三个必要条件）
    • ① 继承或者实现（二选一）
    • ② 方法的重写（意义体现：不重写，无意义）
    • ③ 父类引用指向子类对象（格式体现）
      • 如：Parent p = new Child();

2. 2 多态的体现

多态的格式和使用：

  • 代码当中体现多态性，其实就是一句话：父类引用指向子类对象
  • 格式： 
父类名称 对象名 = new 子类名称();
或者：
接口名称 对象名 = new 实现类名称();
  • 代码示例： 
// 左侧父类的引用，指向了右侧子类的对象
Fu obj = new Zi();  // 使用多态的写法
obj.method();

多态的中成员变量的使用特点：

  1. 访问方式1：直接通过 对象名称 访问成员变量：看等号左边是谁，优先用谁，没有则向上找
  2. 访问方式2：间接通过 成员方法 访问成员变量：看该方法属于谁，优先用谁，没有则向上找

多态的中成员方法的使用特点：

  • 访问规则：看new的是谁，就优先用谁，没有则向上找
  • 口诀：编译看左边，运行看右边

对比：
成员变量：编译看左边，运行还看左边；
成员方法：编译看左边，运行看右边。

代码演示：

  • 定义父类 
public class Fu /*extends Object*/ {
   

    int num = 10;

    public void showNum() {
   
        System.out.println(num);
    }

    public void method() {
   
        System.out.println("父类方法");
    }

    public void methodFu() {
   
        System.out.println("父类特有方法");
    }

}
  • 定义子类 
public class Zi extends Fu {
   

    int num = 20;
    int age = 16;

    @Override
    public void showNum() {
   
        System.out.println(num);
    }

    @Override
    public void method() {
   
        System.out.println("子类方法");
    }

    public void methodZi() {
   
        System.out.println("子类特有方法");
    }
}
  • 定义测试类 
public class Demo01 {
   

    public static void main(String[] args) {
   
        // 使用多态的写法，父类引用指向子类对象
        Fu obj = new Zi();
        
        /*成员变量： 编译看左边，运行还看左边 */
        System.out.println(obj.num); // 父：10 （通过对象名称访问成员变量）
// System.out.println(obj.age); // 错误写法！

        // 子类没有覆盖重写，就是父：10
        // 子类如果覆盖重写，就是子：20
        obj.showNum();// 子：20 （通过成员方法访问成员变量）
        System.out.println("=============");
        
        
		/* 成员方法： 编译看左边，运行看右边 */
		obj.method(); // 父子都有，优先用子
        obj.methodFu(); // 子类没有，父类有，向上找到父类

        // 编译看左边，左边是Fu，Fu当中没有methodZi方法，所以编译报错。
// obj.methodZi(); // 错误写法！
    } 
}

小贴士：当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，执行的是子类重写（“编译看左，运行看右”的体现）

2. 3 多态的好处

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

代码演示：

  • 定义父类 
public abstract class Animal {
   
	public abstract void eat();
}
  • 定义子类 
class Cat extends Animal {
   
	public void eat() {
   
		System.out.println("吃鱼");
	}
}

class Dog extends Animal {
   
	public void eat() {
   
		System.out.println("吃骨头");
	}
}
  • 定义测试类 
public class Test {
   
	public static void main(String[] args) {
   
		// 多态形式，创建对象
		Animal c = new Cat();
		Animal 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();
	}
}

分析：


2. 4 引用类型转换

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

向上转型（默认）

// 格式
父类类型 变量名 = new 子类类型();
如：Animal a = new Cat(); // 父类引用指向一个子类对象
  • 向上转型一定是安全的，没有问题的，正确的
  • 但也有一个弊端：对象一旦向上转型为父类，那么就无法调用子类原本特有的内容
  • 解决方案：用对象的向下转型（还原）

向下转型（强制）

// 格式
子类类型 变量名 = (子类类型) 父类变量名;
如:Cat c =(Cat) a; // 父类类型向子类类型向下转换

小贴士：

  1. 向上转型：多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的
  2. 向下转型：父类类型向子类类型向下转换的过程，这个过程是强制的

为什么要转型

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

转型代码演示：

  • 定义类 
abstract class Animal {
   
	abstract void eat();
}

class Cat extends Animal {
   
    @Override
	public void eat() {
   
		System.out.println("猫吃鱼");
	}
	// 子类特有方法
	public void catchMouse() {
   
		System.out.println("猫抓老鼠");
	}
}

class Dog extends Animal {
   
	@Override
	public void eat() {
   
		System.out.println("狗吃骨头");
	}
	public void watchHouse() {
   
		System.out.println("狗看家");
	}
}
  • 定义测试类 
public class Demo01Main {
   

    public static void main(String[] args) {
   
        // 对象的向上转型，就是：父类引用指向之类对象。
        Animal animal = new Cat(); // 本来创建的时候是一只猫
        animal.eat(); // 猫吃鱼

// animal.catchMouse(); // 错误写法！

        // 向下转型，进行“还原”动作
        Cat cat = (Cat) animal;
        cat.catchMouse(); // 猫抓老鼠
    }
}

转型的异常

java.lang.ClassCastException

// 示例：
Animal animal = new Cat(); 

 /* 下面是错误的向下转型： 本来new的时候是一只猫，现在非要当做狗。 错误写法！编译不会报错，但是运行会出现异常： java.lang.ClassCastException，类转换异常 */
 Dog dog = (Dog) animal;

如何才能知道一个父类引用的对象，本来是什么子类？

  • 为了避免ClassCastException的发生，Java提供了 instanceof 关键字，给引用变量做类型的校验
  • 格式：对象 instanceof 类名称
  • 这将会得到一个boolean值结果，也就是判断前面的对象能不能当做后面类型的实例 
public class Demo02Instanceof {
   

    public static void main(String[] args) {
   
        Animal animal = new Dog(); // 本来是一只狗
        animal.eat(); // 狗吃骨头

        // 如果希望调用子类特有方法，需要向下转型
        // 判断一下父类引用animal本来是不是Dog
        if (animal instanceof Dog) {
   
            Dog dog = (Dog) animal;
            dog.watchHouse();// 调用的是 Dog 的 watchHouse
        }
        // 判断一下animal本来是不是Cat
        if (animal instanceof Cat) {
   
            Cat cat = (Cat) animal;
            cat.catchMouse();// 调用的是 Cat 的 catchMouse
        }
    }
}
全部评论

相关推荐

头像
愣着干嘛
05-27 20:48
TP-LINK_运营管理_HR
点赞 评论 收藏
转发
头像
moyuhuashui
今天 12:25
已编辑
门头沟学院 计算机类
点赞 评论 收藏
转发
头像
可否毕业前给个offer
04-24 14:41
广州软件学院 计算机类
点赞 评论 收藏
转发
头像
wjh6
昨天 16:04
腾讯云智研发_智子研发中心_客户端开发(实习员工)
点赞 评论 收藏
转发
头像
Sorhic
05-22 16:53
天津理工大学 电子信息类
数字绿土C++一面凉经
 岗位/笔试时间：数字绿土C++开发 ，BOSS投完简历直接给笔试，笔试后一天就面试。面试：C++11的特性：语言特性，标准库特性，改进和增强，其他C++11的类型推导：auto和decltype什么时候不能进行类型推导C++11中的array什么时候用array，什么时候用vector虚析构函数的作用虚继承.so文件是什么动态库如何进行编程可能因为会议室太大了，所以千万记得把声音调大一点。问得不是特别难，本人太菜了。好多东西都是听过但是没有用过，所以答得不是很好。而且因为摄像头可能太高了，所以看得我头一直是低的，所以感觉像是在查资料🤦‍♂️🤦‍♂️，希望后续的人引以为戒。
数字绿土一面1人在聊 查看6道真题和解析
点赞 评论 收藏
转发
点赞 收藏 评论
分享

全站热榜

正在热议
# 和牛牛一起刷题打卡 #
4525次浏览 428人参与
# 机械制造薪资爆料 #
340920次浏览 4044人参与
# 牛客帮帮团来啦！有问必答 #
983266次浏览 15247人参与
# 通信硬件薪资爆料 #
242003次浏览 2282人参与
# 腾讯工作体验 #
146356次浏览 1405人参与
# 如何写一份好简历 #
300774次浏览 4324人参与
# 实习必须要去大厂吗？ #
18076次浏览 265人参与
# 你的简历改到第几版了 #
323179次浏览 4856人参与
# 晒一晒我的offer #
3650850次浏览 56923人参与
# 2022毕业生求职现身说法 #
20430次浏览 310人参与
# 毕业租房也有小确幸 #
31954次浏览 1834人参与
# 产品人专业大盘点 #
15082次浏览 120人参与
# 浅聊一下我实习的辛苦费 #
93348次浏览 916人参与
# 为什么国企只招应届生 #
56071次浏览 411人参与
# 视觉/交互/设计岗位评价 #
3356次浏览 59人参与
# 双非本科求职如何逆袭 #
224686次浏览 3291人参与
# 你觉得机械有必要实习吗 #
10111次浏览 132人参与
# 为什么那么多公司毁约 #
54859次浏览 485人参与
# 在国企工作的人，躺平了吗？ #
105418次浏览 1335人参与
# 来选选带哪个offer回家过年 #
185309次浏览 1773人参与
牛客网
牛客企业服务