接口和多态

接口

如果一个抽象类中的所有方法都是抽象的,则可以将这个类用另一种方式来定义,即接口。在定义接口时,需要使用interface关键字来声明。

接口特点:

  1. 接口中的方法都是抽象的,不能实例化对象。
  2. 当一个类实现接口时,如果这个类是抽象类,则实事接口中的部分方法即可,否则需要实现接口中的所有方法。
  3. 一个类通过 implements关键字实现接口时,可以实现多个接口,被实现的多个接口之间要用逗号隔开。
  4. 一个接口可通过extends关键字继承多个接口,接口之间用逗号隔开。
  5. 一个类在继承另一个类的同时还可以实现接口,此时 ,Extends关键字必须位于implements关键字之前

多态

所谓多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定,而是在程序运行期间才确定,即一个引用变量倒底会指向哪个类的实例对象,该引用变量发出的方法调用到底是哪个类中实现的方法,必须在由程序运行期间才能决定。因为在程序运行时才确定具体的类,这样,不用修改源程序代码,就可以让引用变量绑定到各种不同的类实现上,从而导致该引用调用的具体方法随之改变,即不修改程序代码就可以改变程序运行时所绑定的具体代码,让程序可以选择多个运行状态,这就是多态性。

比如你是一个酒神,对酒情有独钟。某日回家发现桌上有几个杯子里面都装了白酒,从外面看我们是不可能知道这是些什么酒,只有喝了之后才能够猜出来是何种酒。你一喝,这是剑南春、再喝这是五粮液、再喝这是酒鬼酒….在这里我们可以描述成如下:

      酒 a = 剑南春

      酒 b = 五粮液

      酒 c = 酒鬼酒

多态我们可以总结如下

指向子类的父类引用由于向上转型了,它只能访问父类中拥有的方法和属性,而对于子类中存在而父类中不存在的方法,该引用是不能使用的,尽管是重载该方法。若子类重写了父类中的某些方法,在调用该些方法的时候,必定是使用子类中定义的这些方法(动态连接、动态调用)。

多态实现条件

Java实现多态有三个必要条件:继承、重写、向上转型。

         继承:在多态中必须存在有继承关系的子类和父类。

         重写:子类对父类中某些方法进行重新定义,在调用这些方法时就会调用子类的方法。

         向上转型:在多态中需要将子类的引用赋给父类对象,只有这样该引用才能够具备技能调用父类的方法和子类的方法。

    1. 只有满足了上述三个条件,我们才能够在同一个继承结构中使用统一的逻辑实现代码处理不同的对象,从而达到执行不同的行为。
    2. 对于Java而言,它多态的实现机制遵循一个原则:当超类对象引用变量引用子类对象时,被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法,但是这个被调用的方法必须是在超类中定义过的,也就是说被子类覆盖的方法。

实现形式

在Java中有两种形式可以实现多态。继承和接口。

所以基于继承实现的多态可以总结如下:对于引用子类的父类类型,在处理该引用时,它适用于继承该父类的所有子类,子类对象的不同,对方法的实现也就不同,执行相同动作产生的行为也就不同。

经典实例

package org.zl.Test;

 

public class A {

    public String show(D obj) {

        return ("A and D");

    }

 

    public String show(A obj) {

        return ("A and A");

    }

 

}

 

class B extends A{

    public String show(B obj){

        return ("B and B");

    }

   

    public String show(A obj){

        return ("B and A");

    }

}

class C extends B{

 

}

class D extends B{

 

}

 

class Test {

    public static void main(String[] args) {

        A a1 = new A();

        A a2 = new B();

        B b = new B();

        C c = new C();

        D d = new D();

       

        System.out.println("1--" + a1.show(b));

        System.out.println("2--" + a1.show(c));

        System.out.println("3--" + a1.show(d));

       

        System.out.println("4--" + a2.show(b));

        System.out.println("5--" + a2.show(c));

        System.out.println("6--" + a2.show(d));

       

        System.out.println("7--" + b.show(b));

        System.out.println("8--" + b.show(c));

        System.out.println("9--" + b.show(d));     

    }

}

运行结果:
 

1--A and A

2--A and A

3--A and D

4--B and A

5--B and A

6--A and D

7--B and B

8--B and B

9--A and D

### Python 中接口多态的实现方式及使用方法 #### 1. 多态的基础原理 在 Python 中,多态的核心理念基于动态类型系统鸭子类型[^1]。这意味着只要一个对象能够响应所需的方法调用,无论它的具体类型是什么,都可以认为它是有效的。这种灵活的设计使得 Python 的多态性更加直观且易于实现。 --- #### 2. 使用继承实现多态 通过继承机制,子类可以覆盖父类中的方法以提供特定的功能实现。当通过父类引用访问这些方法时,实际执行的是子类中定义的行为。 ```python # 定义一个基类 class Animal: def talk(self): raise NotImplementedError("Subclasses must implement this method") # 子类覆写talk方法 class Dog(Animal): def talk(self): return 'Woof!' class Cat(Animal): def talk(self): return 'Meow!' # 测试多态行为 def animal_speak(animal: Animal): print(animal.talk()) dog = Dog() cat = Cat() animal_speak(dog) # 输出 Woof! animal_speak(cat) # 输出 Meow! ``` 在这里,`Animal` 类作为一个抽象基类提供了统一的接口 `talk()`,而具体的实现则由各个子类负责完成。这种方式体现了典型的多态特征[^3]。 --- #### 3. 利用鸭子类型简化设计 由于 Python 支持鸭子类型,因此并不严格要求显式的继承关系也能达到类似的多态效果。只要有相同名称的方法就可以正常工作。 ```python class Laptop: def charge(self): return "Charging laptop..." class Phone: def charge(self): return "Charging phone..." def device_charge(device): return device.charge() laptop = Laptop() phone = Phone() print(device_charge(laptop)) # 输出 Charging laptop... print(device_charge(phone)) # 输出 Charging phone... ``` 此例说明即便 `Laptop` `Phone` 没有任何关联,但因为两者都有名为 `charge` 的方法,所以仍然可以通过通用函数 `device_charge` 来操作它们。 --- #### 4. 接口的隐式表达 Python 并不像一些静态语言那样拥有正式的接口关键字,但是可以通过 ABCs(Abstract Base Classes) 或协议(protocol) 来模拟接口的概念。ABCs 可用于强制某些类必须实现特定的方法才能实例化。 ```python from abc import ABC, abstractmethod class DeviceInterface(ABC): @abstractmethod def connect(self): pass @abstractmethod def disconnect(self): pass class BluetoothDevice(DeviceInterface): def connect(self): return "Bluetooth connected." def disconnect(self): return "Bluetooth disconnected." bluetooth_device = BluetoothDevice() print(bluetooth_device.connect()) # 输出 Bluetooth connected. print(bluetooth_device.disconnect()) # 输出 Bluetooth disconnected. try: interface_instance = DeviceInterface() # 尝试直接实例化会抛出异常 TypeError except Exception as e: print(e) # 输出 Can't instantiate abstract class ... ``` 这里展示了一个简单的设备连接断开的例子,其中 `DeviceInterface` 是一个抽象基类,只有在其所有抽象方法都被具体实现在子类之后才可以正常使用[^4]。 --- #### 5. 协议与数据类的应用 从 Python 3.8 开始引入的数据类(data classes),配合协议的支持,可以让开发者更方便地构建具有固定属性集合的对象,并自动获得诸如比较、字符串表示等功能。同时结合 typing 模块中的 Protocol ,可以进一步强化类型提示的同时保留灵活性。 ```python from dataclasses import dataclass from typing import Protocol class SpeakerProtocol(Protocol): volume_level: int def adjust_volume(self, level_change: int) -> None: ... @dataclass class Radio(SpeakerProtocol): volume_level: int def adjust_volume(self, level_change: int): self.volume_level += level_change print(f'Radio Volume adjusted to {self.volume_level}') radio = Radio(volume_level=50) radio.adjust_volume(-10) # 输出 Radio Volume adjusted to 40 ``` 这段代码片段演示了如何利用协议来描述期望的行为模式而不必关心确切的继承链路[^2]。 --- ### 总结 综上所述,Python 提供了多种途径来达成多态的目标,既可以依赖传统的继承结构也可以充分利用其独特的动态特性如鸭子类型等手段。无论是简单应用还是复杂架构下都能找到适合自己的解决方案。
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值