JAVA 接口分发设计

转载

数据大侠客 2025-01-04 22:03:16

文章标签 JAVA 接口分发设计接口抽象 java 案例 文章分类 Java 后端开发

🔴 抽象类

🔵 语法规则

🔵 抽象类的作用

🔴 接口

🔵 语法规则

🔵 实现多个接口

🔴 抽象类

🔵 语法规则

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

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

在 draw 方法前加上 abstract 关键字, 表示这是一个抽象方法. 同时抽象方法没有方法体(没有 { }, 不能执行具体代码).
对于包含抽象方法的类, 必须加上 abstract

🔻注意

🍈 抽象类不能直接实例化

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

🍈 抽象方法不能是 private 的

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

🍈 抽象方法不能是 private 的

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

🍈 抽象继承抽象，直到遇到子类，方法将要全部重写(欠债还钱)

abstract class A {
    int a;
    abstract void show1();
}

abstract class B extends A {
    abstract void show2();
}


class C extends B {
    @Override
    void show1() {
        System.out.println(a);
    }

    @Override
    void show2() {

    }
}

🔵 抽象类的作用

🔸 抽象类存在的最大意义就是为了被继承.

🔸 抽象类本身不能被实例化, 要想使用, 只能创建该抽象类的子类. 然后让子类重写抽象类中的抽象方法

🔸 有些同学可能会说了, 普通的类也可以被继承呀, 普通的方法也可以被重写呀, 为啥非得用抽象类和抽象方法呢? 确实如此. 但是使用抽象类相当于多了一重编译器的校验

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

🔷 很多语法存在的意义都是为了 "预防出错", 例如我们曾经用过的 final 也是类似. 创建的变量用户不去修改, 不就相当于常量嘛? 但是加上 final 能够在不小心误修改的时候, 让编译器及时提醒我们

🔷 充分利用编译器的校验, 在实际开发中是非常有意义的

JAVA 接口分发设计_案例

🔴 接口

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

🔵 语法规则

🔷在上一篇打印图形的示例中, 我们的父类 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 Rect();
        shape.draw();
    }
}

❌ 一个错误的代码

public class Demo {
    public static void main(String[] args) {

    }
}
interface IShape {
    abstract void draw() ; // 即便不写public，也是public 
}
class Rect implements IShape {
    void draw() {
        System.out.println("□") ; //权限更加严格了，所以无法覆写。
    }
}

🔵 实现多个接口

🔶 有的时候我们需要让一个类同时继承自多个父类. 这件事情在有些编程语言通过 多继承 的方式来实现的. 然而 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 面向对象编程中最常见的用法: 一个类继承一个父类, 同时实现多种接口

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

📝 例如, 现在实现一个方法, 叫 "散步"

public class Demo {
    public static void walk(IRunning running) {
        System.out.println("我带着伙伴去散步");
        running.run();
    }
    public static void main(String[] args) {

        walk(new Cat("小猫"));
        walk(new Duck("小鹅"));
        walk(new Frog("小青蛙"));
    }
}

🔶 甚至参数可以不是 "动物", 只要会跑

class Robot implements IRunning {
    private String name;
    public Robot(String name) {
        this.name = name;
    }
    @Override
    public void run() {
        System.out.println(this.name + "正在用轮子跑");
    }
}

🔶 游泳和飞行同理，一以下展示上面的全部代码

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 Robot implements IRunning {
    private String name;
    public Robot(String name) {
        this.name = name;
    }
    @Override
    public void run() {
        System.out.println(this.name + "正在用轮子跑");
    }
}

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 + "正在漂在水上");
    }
}
public class Demo {
    public static void walk(IRunning running) {
        System.out.println("我带着伙伴去散步");
        running.run();
    }
    public static void main(String[] args) {

        walk(new Cat("小猫"));
        walk(new Duck("小鹅"));
        walk(new Frog("小青蛙"));
        walk(new Robot("机器人"));
        System.out.println("==============华丽的分割线============");
    }
}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。