面向对象--接口、多态（OOP--面向对象编程）

🕗 发布于 2024-10-17 13:01 java 开发语言

一、接口

使用interface关键字，且它也会被编译成.class文件，但他不是类而是一种引用数据类型

接口的特点

不能实例化
没有构造方法
方法默认public abstract修饰
变量默认public static final修饰
没有静态代码块

抽象类特点

继承了抽象类的子类，要么对父类的抽象方法进行重写，要么自己也是抽象类
抽象类也可以拥有普通方法
抽象类不能创建对象
抽象类也有构造方法，但是是为了子类创建对象使用

定义格式：

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

接口包含方法分类:

JDK7 ：只能定义抽象方法

JDK8 : 默认方法、静态方法

JDK9 : 私有方法、私有静态方法

接口中定义变量(常量):

接口中只能定义常量

含有抽象方法

抽象方法：使用 abstract 关键字修饰，可以省略，没有方法体。该方法供子类实现使用。

代码如下：

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() {
// 执行语句
}
}

接口实现：

实现类，也就是接口的子类使用implements关键字

非抽象子类实现接口：

1.必须重写接口中所有抽象方法。

2.继承了接口的默认方法，即可以直接调用，也可以重写。

例：

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 InterfaceDemo {
public static void main(String[] args) {
// 创建子类对象
Animal a = new Animal();
// 调用实现后的方法
a.eat();
a.sleep();
}
}
输出结果：
吃东西
晚上睡

默认方法的使用

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

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

定义接口：

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

定义实现类：

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

定义测试类

public class InterfaceDemo {
public static void main(String[] args) {
// 创建子类对象
Animal a = new Animal();
// 调用默认方法
a.fly();
}
}
输出结果：
天上飞

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

定义接口

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

定义实现类

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

定义测试类

public class InterfaceDemo {
public static void main(String[] args) {
// 创建子类对象
Animal a = new Animal();
// 调用重写方法
a.fly();
}
}
输出结果：
自由自在的飞

静态方法的使用

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

定义接口：

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

定义实现类：

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

定义测试类

public class InterfaceDemo {
public static void main(String[] args) {
// Cat.run(); // 【错误】无法继承方法,也无法调用
Animal.run(); //
}
}
输出结果：
跑起来~~~

私有方法的使用

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

如果一个接口中有多个默认方法，并且方法中有重复的内容，那么可以抽取出来，封装到私有方法中，供默认方法去调用。从设计的角度讲，私有的方法是对默认方法和静态方法的辅助。同学们在已学技术的基础上，可以自行测试。

定义接口：

public interface Animal{
default void func(){
func1();
func2();
}
private void func1(){
System.out.println("跑起来~~~");
}
private void func2(){
System.out.println("跑起来~~~");
}
}

接口的多实现

一个接口可以有多个实现类
一个类可以有多个子类
总: 一个类只能继承一个父类，可以实现多个接口
实现格式：

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

抽象方法

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

定义多个接口：

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");
}
}

默认方法

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

定义多个接口

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");
}
}

静态方法

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

优先级的问题

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

定义接口：

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

定义父类

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

定义子类

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

定义测试类：

public class Test {
public static void main(String[] args) {
C c = new C();
c.methodA();
}
}
输出结果:
DDDDDDDDDDDD

注：

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

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

二、多态

概念：

指同一种行为，具有多种不同表现形式

格式：

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

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

例：

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

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

代码如下：

定义父类：

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 a1 = new Cat();
// 调用的是 Cat 的 eat
a1.eat();
// 多态形式，创建对象
Animal a2 = new Dog();
// 调用的是 Dog 的 eat
a2.eat();
}
}

优点 : 增加代码的灵活性

引用类型转换

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

向上转型

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

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

使用格式：

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

向下转型

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

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

使用格式：

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

为什么要转型

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

转型演示，代码如下：

定义类：

/**
 * @Author chen
 * @Version 1.0
 * @Date 2024/10/17
 * @Description 定义类
 */
public abstract class Pet {
    int a=50;
    public abstract void name();
}

public class Cat extends Pet{
     int a=10;
    public void name(){
        System.out.println("小黑");
    }
    public void fight(){
        System.out.println("小黑在打架");
    }
}

public class Dog extends Pet{
    int a=100;
    public void name(){
        System.out.println("大黄");
    }
    public void sleep(){
        System.out.println("大黄在睡觉");
    }
}

定义测试类

/**
 * @Author chen
 * @Version 1.0
 * @Date 2024/10/17
 * @Description 测试类
 */
public class TestPet {
    public static void main(String[] args) {
        // 向上转型
        Pet pet=new Cat();
        pet.name();// 调用的是 Cat 的name
        System.out.println(pet.a);//调用的是Pet的a
        // 向下转型
        Cat cat = (Cat) pet;
        cat.fight();// 调用的是 Cat 的fight
        System.out.println(cat.a);//调用的是Cat的a
    }
}

转型的异常

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

public class Test {
public static void main(String[] args) {
// 向上转型
Pet pet=new Cat();
pet.name(); // 调用的是 Cat 的 name
// 向下转型
Dog dog = (Dog)pet;
dog.sleep(); // 调用的是 Dog 的 sleep() 【运行报错】
}
}

这段代码可以通过编译，但是运行时，却报出了 ClassCastException ，类型转换异常！这是因为，明明创建了Cat类型对象，运行时，当然不能转换成Dog对象的。这两个类型并没有任何继承关系，不符合类型转换的定义。

为了避免ClassCastException的发生，Java提供了 instanceof 关键字，给引用变量做类型的校验，格式如下：

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

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

public class Test {
public static void main(String[] args) {
// 向上转型
Pet pet=new Cat();
pet.name(); // 调用的是 Cat 的 name
// 向下转型
if (a instanceof Cat){
Cat cat = (Cat) pet; cat.fight();// 调用的是 Cat 的fight

                System.out.println(cat.a);//调用的是Cat的a
} else if (a instanceof Dog){
Dog dog = (Dog)pet;
        dog.sleep(); // 调用的是 Dog 的 sleep()

                System.out.println(dog.a);//调用的是Cat的a
}
}
}

设计模式:

原则 : 开闭原则(对扩展开发、对修改进行关闭)

装饰模式：

在某些情况下，我们需要在不修改现有对象结构的情况下，动态地添加功能或责任

add(){
...
}

①、继承

add(){
// 扩展能力
super.add();
// 扩展能力
}

②、装饰模式

③、代理设计模式

角色:

组件（Component）：定义了一个抽象的接口，可以是具体对象或装饰器所共有的接口。
具体组件（Concrete Component）：实现了组件接口，是被装饰的原始对象。

装饰器（Decorator）：持有一个指向组件对象的引用，并实现了组件的接口。它可以包含额外的功能，也可以将请求传递给组件对象。
具体装饰器（Concrete Decorator）：扩展了装饰器类，通过添加额外的功能来装饰具体组件。

以coffee为例：

首先创建一个coffee的接口作为组件：


/**
 * @Author JY
 * @Version 1.0
 * @Date 2024/10/15
 * @Description 咖啡接口
 */
public interface Coffee {
    /**
     *  成本
     * @return
     */
    double cost();

    /**
     *  咖啡 描述 (普通 + 牛奶 + 糖)
     * @return
     */
    String description();

}

其次弄一个coffeeDecorator具体组件

public  class CoffeeDecorator implements Coffee{

    /**
     *  持有具体对象引用
     */
    private Coffee simpleCoffee ;


    public CoffeeDecorator(Coffee simpleCoffee) {
        this.simpleCoffee = simpleCoffee;
    }

    @Override
    public double cost() {
        return simpleCoffee.cost();
    }

    @Override
    public String description() {
        return simpleCoffee.description();
    }
}

然后写一个coffee修饰器

public class SimpleCoffee implements Coffee{
    @Override
    public double cost() {
        return 1.0;
    }

    @Override
    public String description() {
        return "Simple Coffee";
    }
}

最后再写一个具体装饰器

public class MilkDecorator extends CoffeeDecorator {

    public MilkDecorator(Coffee simpleCoffee) {
        super(simpleCoffee);
    }

    @Override
    public double cost() {
        return super.cost() + 3.0;
    }


    @Override
    public String description() {
        return super.description() + "、" + addMilk();
    }


    private String addMilk() {
        return "添加牛奶";
    }
}

public class SugarDecorator extends CoffeeDecorator {
    public SugarDecorator(Coffee simpleCoffee) {
        super(simpleCoffee);
    }

    @Override
    public double cost() {
        return super.cost() + 1.0;
    }

    @Override
    public String description() {
        return super.description() + "、" + addSugar();
    }

    private String addSugar() {
        return "加糖";
    }
}

接下来就可以调用测试类进行测试了

public class TestCoffee {

    public static void main(String[] args) {

        // 基本咖啡
        Coffee coffee = new SimpleCoffee();
        coffee =  new SugarDecorator(coffee);
        coffee = new MilkDecorator(coffee);
        System.out.println(coffee.cost());
        System.out.println(coffee.description());
       /* Coffee coffee = new MilkDecorator(new SugarDecorator(new SimpleCoffee()));*/
        // 调用能力
    }
}

原文地址：https://blog.csdn.net/m0_69307756/article/details/142991251

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：设计模式——建造者模式（5）
下一篇：【硬件问题】——显示器黑屏且只显示鼠标

Vue是一套构建用户界面的渐进式框架，常用于构建单页面应用
组件（Component）是Vue最强大的功能之一，它扩展了HTML元素，封装了可重用的代码。组件系统使得开发者可以用独立可复用的小组件来构建大型应用，几乎任意类型的应用的界面都可以抽象为一个组件树。
阅读更多2024-10-17
好用的python相关的AI工具Bito介绍
step 1:点插件step 2：搜索bito并安装step3 ：需要登录，要有真实邮箱，按步骤走就行，完后就可以使用。
阅读更多2024-10-17
408算法题leetcode--第36天
408算法题leetcode--第36天
阅读更多2024-10-17
【实战经验】IPv6部署实战：Panabit AX40与锐捷交换机的无缝对接（一）
我们详细探讨了如何将Panabit的AX40和锐捷的NBS5100-24GT4SFP三层交换机进行对接，以实现内网获取IPv6地址的功能。通过一系列的配置步骤和注意事项，我们确保了网络的平滑过渡和高效
阅读更多2024-10-17
【redis】数据过期清除策略、缓存淘汰策略
Redis 所有的数据结构都可以设置过期时间，时间一到，就会自动删除。可以想象里面有一个专门删除过期数据的线程，数据已过期就立马删除。这个时候可以思考一下，会不会因为同一时间太多的 key 过期，以至
阅读更多2024-10-17
【建议收藏】如何设置你的提词器，一文帮你轻松拿捏提词悬浮窗的大小、速度、颜色设置
好的攻略，还需要好的提词器搭配，提词宝就是一块好的提词器！一站式适配你的各种提词场景！通过设置合适的距离、字体大小、滚动速度、单位速度、字体颜色等，可以有效改善提词器使用体验，在不同场景下表现更专业、
阅读更多2024-10-17
unity 音频和文字转换工具分享
在C#中实现离线语音转文字（Speech to Text），可以使用一些本地库，如Microsoft的`System.Speech`，或集成其他第三方的本地库，如Vosk或CMU Sphinx。- 下
阅读更多2024-10-17
AirServer免费终身版本Win5.6.3+Mac7.2.7
别再等待啦！赶紧入手这款AirServer手机投屏软件，让你的生活更加便捷和有趣吧！❤️无论是娱乐、工作还是学习，它都能成为你得力的助手。快来体验一下“无线”的自由吧！
阅读更多2024-10-17
python从0快速上手（二）IDE选择
在这个代码横飞的世界里，选择一个合适的Python IDE就好比是选择一把顺手的武器。今天，就让我来带你一探究竟，看看市面上有哪些让人眼花缭乱的Python IDE，并一较高下。
阅读更多2024-10-17
禅道8.2 - 9.2.1前台Getshell-poc
直接通过fuzz的方式遍历默认路径，写入文件，当然了，要是存在phpinfo界面的话，获取到服务路径，直接写入即可。发送该报错poc时候，通过报错获取服务路径，然后在对应目录下写入文件，如果遇到无回显
阅读更多2024-10-17

面向对象--接口、多态（OOP--面向对象编程）

一、接口

接口的多实现

二、多态

引用类型转换

相关文章