Polymorphism

博客展示了Java中类的多态性相关代码。定义了类A,包含成员变量和方法,类B继承自A并进行了变量隐藏和方法重写,类Z也继承自A。通过这些代码体现了类在继承关系中的多态特性。

l          Polymorphism

 

1.  class A{

2.    int x = 1;

3.    int y = 2;

4.    int f() { return x; }

5.    static char sf() { return ‘A’; }

6.  }

7.  class B extend A{

8.    int x = 3;  // shadowing

9.    int z = 4;

10.   int f() { return x; } // overriding

11.   static char sf() { return ‘B’;} //shadowing

12.   int g(){ int x = 1;  return (x+this.x); }

13. }

14. class Z extend A{ }

15. public class SCJP {

16.   pubilc static void main(String[] args){

17.     A a = new B();

18.     B b = new B();

19.     B bb = new Z();               //error

20.     System.out.println(a.f());     // 3

21.     System.out.println(a.g());    // error

22.     System.out.println(a.z);      // error

23.     System.out.println(a.x);      // 1

24.     System.out.println(a.y);      // 2

25.     System.out.println(a.sf());    // ‘A’

26.     System.out.println(b.x);      // 3

27.     System.out.println(b.sf());    // ‘B’
28. } }

Assignment

  意思是superclassreference var可以refer to所有subclassinstance(指的是reference variable不是object,只要是subtype就可以)

  如第17行。第19行會產生compile error,因class Z不是class Bsubclass

Method Invocation

  virtual mehhod invocation,建立在method overridingpolymorphic assignment上。

  如第20行。第17行宣告一個class Areference var “a”refer to subclass B

Compile-time and Run-time Type

  compile-time typereference vartyperun-time typeobjecttype

  17行,compile-timeaA typerunt-timeaB type

  21compile err因為此時aA type,需轉型為 ((B)a).g() 才可以被執行。

Overriding and Shadowing

  instance method只能被overridden,而class methodfield只能被shadowed

  overriding instance method才有所謂的compile time typerun time type

  shadowing class method / field 永遠只有一種type,就是reference vartype

  23x和第25sf()shadowing。要看reference vartype (A)

  27行最好改為標準呼叫方式B.sf()


来自:【 Garfield 的 SCJP 閱讀筆記 】
<think>好的,用户现在想了解Python中的多态性(Polymorphism)。首先,我需要回忆一下多态性的基本概念,然后结合用户提供的引用内容来构建回答。用户之前的问题是关于链表remove_first方法的实现,但现在转向了面向对象编程中的多态,这需要我调整思路。 用户提供的引用中,引用[1]提到了animal_sound函数可以接受任何有speak方法的对象,这展示了多态性。引用[3]提到了类的抽象和封装,这可能与多态的实现有关。需要将这些内容整合到回答中,但用户也提到这些引用仅供参考,需要更多参考之前的对话。 在之前的对话中,用户的问题是关于链表操作的实现,其中提到了类的方法和异常处理。这可能与多态中的方法重写有关联,比如不同子类实现相同方法。现在需要将多态的概念与Python的具体实现结合起来,比如使用继承和方法重写。 用户可能需要一个清晰的解释,包括定义、示例代码以及实际应用场景。考虑到用户之前的问题中有代码示例,最好在回答中也提供类似的代码,比如Dog和Cat类继承自Animal,并重写speak方法,然后通过一个函数调用展示多态。 同时,需要解释多态的优点,比如代码的灵活性和可扩展性,引用用户提到的引用内容中的“代码更灵活,适应不同对象”。还要提到鸭子类型,这是Python中多态的重要方面,即关注对象的行为而非类型,比如只要对象有speak方法,就可以调用,而不必强制继承。 可能还需要区分编译型语言的多态和Python的动态多态,强调Python的灵活性。此外,结合引用[3]中的封装和抽象,说明多态如何帮助隐藏实现细节,让用户关注接口而非具体实现。 用户可能想知道如何在实践中应用多态,比如在函数设计时接受接口而非具体类,提高代码的可维护性。此外,可能涉及相关的问题,比如多态与继承的关系,或者多态在设计模式中的应用,比如策略模式。 需要检查是否有遗漏点,比如多态的不同形式(如函数重载和重写),但Python中主要通过重写和鸭子类型实现。确保回答结构清晰,分点解释,有示例代码和相关问题,符合用户之前要求的格式。</think>### Python多态性(Polymorphism)详解 多态性是面向对象编程的三大核心特性之一(封装、继承、多态)。在Python中,多态允许**不同类的对象对同一方法名表现出不同的行为**,且无需在调用时显式检查对象类型。其核心原理是**“接口重用,实现分离”**,通过统一接口调用不同对象的方法,提升代码的灵活性和可扩展性。 --- #### 1. **多态的核心逻辑** - **定义**:多态(Polymorphism)源自希腊语“多种形态”,指**同一操作作用于不同对象时,产生不同的行为结果**。 - **实现基础**: - **继承**:子类继承父类并重写方法。 - **鸭子类型(Duck Typing)**:Python特有的动态类型机制,关注对象的行为(是否具有特定方法),而非对象的类型[^1]。 --- #### 2. **多态的实现示例** 以下通过动物叫声的经典案例演示多态: ```python class Animal: def speak(self): raise NotImplementedError("子类必须实现此方法") class Dog(Animal): def speak(self): # 方法重写 return "Woof!" class Cat(Animal): def speak(self): # 方法重写 return "Meow!" def animal_sound(animal_obj): print(animal_obj.speak()) # 统一调用接口,实际行为由对象类型决定 # 测试多态行为 dog = Dog() cat = Cat() animal_sound(dog) # 输出: Woof! animal_sound(cat) # 输出: Meow! ``` **关键点**: - `animal_sound`函数无需知道具体对象类型,只需确保传入对象有`speak()`方法。 - 通过继承和方法重写,不同子类对同一方法`speak()`表现出不同行为。 --- #### 3. **Python多态的特殊性:鸭子类型** Python的多态不依赖严格的继承关系,而是基于**“如果它走起来像鸭子,叫起来像鸭子,那么它就是鸭子”**的理念: ```python class Car: def speak(self): # 非Animal子类,但实现相同方法 return "Vroom!" car = Car() animal_sound(car) # 输出: Vroom! (仍可调用) ``` 此时`Car`类未继承`Animal`,但因实现了`speak()`方法,仍可被`animal_sound`正确处理[^2]。 --- #### 4. **多态的优势** | **优势** | **说明** | |------------------|-------------------------------------------------------------------------| | **代码解耦** | 调用方与具体实现分离,新增子类无需修改调用逻辑。 | | **扩展性** | 添加新类型只需实现相同接口,无需修改已有代码(开闭原则)。 | | **灵活性** | 通过鸭子类型支持非继承关系的对象协作。 | --- #### 5. **多态与抽象类的结合** 通过抽象基类(Abstract Base Class, ABC)强制接口定义,确保多态的安全性: ```python from abc import ABC, abstractmethod class Shape(ABC): @abstractmethod def area(self): pass class Circle(Shape): def __init__(self, radius): self.radius = radius def area(self): return 3.14 * self.radius ** 2 class Square(Shape): def __init__(self, side): self.side = side def area(self): return self.side ** 2 def print_area(shape_obj): print(f"Area: {shape_obj.area()}") # 使用示例 circle = Circle(5) square = Square(4) print_area(circle) # 输出: Area: 78.5 print_area(square) # 输出: Area: 16 ``` 通过`ABC`强制子类实现`area()`方法,避免因方法缺失导致的运行时错误[^3]。 --- ### 相关问题 1. **多态与重载(Overloading)有何区别?为什么Python不支持函数重载?** 2. **如何利用多态实现策略模式(Strategy Pattern)?** 3. **在Python中,如何通过`isinstance`检查破坏多态性?应如何避免?** [^1]: 鸭子类型通过行为而非类型实现多态,是Python动态特性的核心体现。 [^2]: 类的封装性隐藏了实现细节,使多态调用仅依赖公共接口。 [^3]: 抽象基类通过`@abstractmethod`强制接口实现,增强多态的安全性。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值