【day12】面向对象编程进阶（接口与多态）

程序员波特

发布于 2024-12-23 08:10:17

15500

代码可运行

文章被收录于专栏：魔法书魔法书

运行总次数：0

代码可运行

【day11】回顾

在深入本模块之前，让我们回顾一下【day11】中的关键内容：

继承：子类继承父类，可以直接使用父类中非私有成员，避免代码重复。
关键字：extends用于实现类继承。
成员访问特点：
- 成员变量：取决于等号左边的对象。
- 成员方法：取决于new的对象。
方法重写：子类中定义与父类方法名和参数列表相同的方法。
继承中构造的特点：创建子类对象时，先初始化父类。
super：代表父类引用，用于调用父类构造、成员变量和成员方法。
this：代表当前对象，用于区分重名的成员变量和局部变量。
继承的特点：
- 只支持单继承，不支持多继承。
- 支持多层继承。
- 一个父类可以拥有多个子类。

模块十二重点

本模块我们将探索接口和多态的概念，包括：

定义接口。
在接口中定义抽象方法、默认方法、静态方法和成员变量。
调用接口中的成员。
理解多态的前提。
利用多态的方式创建对象。
了解使用多态的好处。
在多态的前提下进行向下转型。
利用instanceof判断类型。

第一章：接口

1. 接口的介绍

接口是Java中一种定义标准和规则的方式，它允许类实现一个或多个接口，从而确保类遵循特定的规范。

2. 接口的定义及使用

接口：是一个引用数据类型，是一种标准，规则

jdk7以及之前:
- 抽象方法: public abstract -> 即使不写public abstract, 默认也有
- 成员变量: public static final 数据类型变量名 = 值-> 即使不写public static final,默认也有
- final是最终的,被final修饰的变量不能二次赋值,所以我们一般将final修饰的变量视为常量
jdk8:
- 默认方法:public default 返回值类型方法名(形参){}
- 静态方法:public static 返回值类型方法名(形参){}
jdk9开始:
- 私有方法: private的方法

定义接口

public interface 接口名 {
    // 抽象方法、默认方法、静态方法、成员变量
}

实现接口

public class 实现类名 implements 接口名 {
    // 实现接口中的抽象方法
}

使用接口

public interface USB {
    public abstract void open();
    public abstract void close();
}

public class Mouse implements USB {
    @Override
    public void open() {
        System.out.println("鼠标打开");
    }

    @Override
    public void close() {
        System.out.println("鼠标关闭");
    }
}

public class Test01 {
    public static void main(String[] args) {
        Mouse mouse = new Mouse();
        mouse.open();
        mouse.close();
    }
}

3. 接口中的成员

抽象方法

public interface USB {
    public abstract void open();
}

默认方法

格式:

  public default 返回值类型 方法名(形参){
      方法体
      return 结果
  }

使用:
- 定义实现类,实现接口
- 默认方法可重写,可不重写
- 创建实现类对象,调用默认方法

public interface USB {
    public default void methodDef() {
        System.out.println("我是默认方法");
    }
}

public class Mouse implements USB {
    @Override
    public void methodDef(){
        System.out.println("我是重写接口中的默认方法");
    }
}

public class Test01 {
    public static void main(String[] args) {
        Mouse mouse = new Mouse();
        mouse.methodDef();
    }
}

静态方法

定义格式:

public static 返回值类型 方法名(形参){
     方法体
     return 结果
 }

使用: 接口名直接调用

public interface USB {
    public static void methodSta() {
        System.out.println("我是接口中的静态方法");
    }
}

成员变量

public interface USB {
    public static final int NUM1 = 100;
}

4. 接口的特点

接口可以多继承，一个接口可以继承多个接口。
一个实现类可以实现一个或多个接口。
一个子类可以继承一个父类的同时实现一个或多个接口。

当一个类实现多个接口时,如果接口中的抽象方法有重名且参数一样的,只需要重写一次

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

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

public class InterfaceImpl implements InterfaceA,InterfaceB{
	@Override
	public void method() {
    	System.out.println("重写的method方法");
	}
}

当一个类实现多个接口时,如果多个接口中默认方法有重名的,且参数一样的,必须重写一次默认方法

public interface InterfaceA {
	public abstract void method();

	public default void methodDef(){
    	System.out.println("我是接口A中的默认方法");
	}
}

public interface InterfaceB {
	public abstract void method();

 	/*    public default void methodDef(){
         	System.out.println("我是接口B中的默认方法");
     }*/
 	public default void methodDef(int a) {
     	System.out.println("我是接口B中的默认方法");
 	}
}

public class InterfaceImpl implements InterfaceA,InterfaceB{
 	@Override
 	public void method() {
     	System.out.println("重写的method方法");
 	}

	/*    @Override
 	public void methodDef() {
     	System.out.println("重写后的默认方法");
 	}*/
}


public class Test01 {
 	public static void main(String[] args) {
     	InterfaceImpl anInterface = new InterfaceImpl();
     	anInterface.methodDef();
     	anInterface.methodDef(10);
 	}
}

5. 接口和抽象类的区别

抽象类可以有成员变量、构造方法、成员方法和抽象方法。
接口成员单一，一般用于抽取方法，视为功能的集合。
类不能多继承，但接口可以。

第二章：多态

面向对象三大特征: 封装、继承、多态

1. 多态的介绍

多态是面向对象编程的三大特征之一，它允许父类引用指向子类对象，从而在运行时动态决定调用哪个类的方法。

多态的前提

必须存在子父类继承或接口实现关系。
必须存在方法重写。
使用父类引用指向子类对象。

多态的基本使用

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

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

    //特有方法
    public void lookDoor(){
        System.out.println("狗会看门");
    }
}

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

    //特有方法
    public void catchMouse(){
        System.out.println("猫会捉老鼠");
    }
}

public class Test01 {
    public static void main(String[] args) {
        //原始方式
        Dog dog = new Dog();
        dog.eat();//重写的
        dog.lookDoor();//特有的

        Cat cat = new Cat();
        cat.eat();//重写的
        cat.catchMouse();//特有的

        System.out.println("==================");
        //多态形式new对象
        Animal animal = new Dog();//相当于double b = 10
        animal.eat();//重写的 animal接收的是dog对象,所以调用的是dog中的eat
//      animal.lookDoor();   多态前提下,不能直接调用子类特有成员

        Animal animal1 = new Cat();
        animal1.eat();//cat重写的


    }
}

2. 多态的条件下成员的访问特点

成员变量：取决于等号左边的对象。
成员方法：取决于new的对象。

3. 多态的好处

多态提高了程序的扩展性和灵活性。通过多态，我们可以编写出更通用、更灵活的代码，使得代码更容易维护和扩展。

4. 多态中的转型

向上转型

Animal animal = new Dog();

向下转型

Dog dog = (Dog) animal;

5. 转型可能会出现的问题

向下转型可能会抛出ClassCastException，因此在向下转型之前，我们可以使用instanceof进行类型检查。

if (animal instanceof Dog) {
    Dog dog = (Dog) animal;
}

6. 综合练习

定义笔记本类，具备开机，关机和使用USB设备的功能。具体是什么USB设备，笔记本并不关心，只要符合USB规格的设备都可以。鼠标和键盘要想能在电脑上使用，那么鼠标和键盘也必须遵守USB规范，不然鼠标和键盘的生产出来无法使用; 进行描述笔记本类，实现笔记本使用USB鼠标、USB键盘

USB接口，包含开启功能、关闭功能
笔记本类，包含运行功能、关机功能、使用USB设备功能
鼠标类，要符合USB接口
键盘类，要符合USB接口

public interface USB {
    void open();
    void close();
}

public class Mouse implements USB {
    @Override
    public void open() {
        System.out.println("鼠标开启");
    }

    @Override
    public void close() {
        System.out.println("鼠标关闭");
    }

 	//特有方法
    public void click() {
        System.out.println("点击鼠标");
    }
}

public class KeyBoard implements USB {
    @Override
    public void open() {
        System.out.println("键盘开启");
    }

    @Override
    public void close() {
        System.out.println("键盘关闭");
    }

    public void input() {
        System.out.println("敲击键盘");
    }
}

public class NoteBook {
    //开机
    public void start(){
        System.out.println("开机");
    }

    //使用USB
    /*
       USB usb = mouse  多态
       USB usb = keyBoard 多态
     */
    public void useUSB(USB usb){
        if (usb instanceof Mouse){
            Mouse mouse = (Mouse) usb;
            mouse.open();
            mouse.click();
            mouse.close();
        }else{
            KeyBoard keyBoard = (KeyBoard) usb;
            keyBoard.open();
            keyBoard.input();
            keyBoard.close();
        }
        //usb.open();
        //usb.close();
    }

    //关机
    public void stop(){
        System.out.println("关机");
    }
}

public class Test01 {
    public static void main(String[] args) {
        NoteBook noteBook = new NoteBook();
        Mouse mouse = new Mouse();
        noteBook.start();
        noteBook.useUSB(mouse);
        noteBook.stop();

        System.out.println("===========");
        KeyBoard keyBoard = new KeyBoard();
        noteBook.start();
        noteBook.useUSB(keyBoard);
        noteBook.stop();
    }
}

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2024-12-22，如有侵权请联系 cloudcommunity@tencent.com 删除

面向对象编程