Python3 面向对象进阶

1. Introduction

Python is a popular high-level programming language used for a wide range of applications. One of the most significant benefits of Python is its strong support for object-oriented programming (OOP). This allows programmers to easily create complex, modular applications that can be easily scaled and maintained.

This article will cover some of the more advanced aspects of Python3's OOP capabilities. We will explore some of the key concepts of OOP in Python, including inheritance, polymorphism, and encapsulation. We will also dive into some practical examples of how to use these techniques in real-world scenarios.

2. Inheritance

Inheritance is a key feature of OOP, which allows developers to define a new class based on an existing class. The new class, known as the derived or child class, inherits all the properties and methods of the parent class, known as the base or super class. This enables developers to reuse code and create hierarchies of classes with varying levels of complexity.

2.1 Basic Inheritance

Let's start with a simple example. We will create a class called `Person` that contains the basic information of a person:

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

Now, let's create a new class called `Student` that inherits from `Person` and adds new properties and methods specific to a student:

class Student(Person):
    def __init__(self, name, age, major):
        super().__init__(name, age)
        self.major = major
    def get_major(self):
        return self.major

In this example, `Student` is derived from `Person`. The `super()` function is used to call the constructor of the `Person` class, which sets the `name` and `age` properties of the student. We then add a new property for `major`, specific to the student class, and a method to get the major.

2.2 Method Overriding

Method overriding is another important feature of inheritance. It allows a child class to override a method of its parent class with its own implementation.

For example, let's modify our `Person` class to include a `greeting` method:

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def greeting(self):
        print("Hello, my name is", self.name, "and I am", self.age, "years old.")

Now, let's create a new class called `Teacher` that overrides the `greeting` method with its own implementation:

class Teacher(Person):
    def __init__(self, name, age, department):
        super().__init__(name, age)
        self.department = department
    def greeting(self):
        print("Hello, my name is", self.name, "and I teach", self.department, "at this school.")

In this example, the `Teacher` class overrides the `greeting` method with a new implementation that is specific to a teacher. When we call the `greeting` method on an instance of `Teacher`, it will print out the teacher's name and department instead of their age.

3. Polymorphism

Polymorphism is another key feature of OOP, which allows objects of different classes to be treated as if they are of the same class. This is achieved through the use of inheritance and the ability to override methods.

For example, let's create a new class called `Animal`:

class Animal:
    def __init__(self, name):
        self.name = name
    def make_sound(self):
        pass

This class defines a basic animal with a name and a method for making a sound. However, since this class does not provide an implementation for the `make_sound` method, we cannot create an instance of this class directly.

We will create a new class called `Dog` that inherits from `Animal` and provides its own implementation for the `make_sound` method:

class Dog(Animal):
    def make_sound(self):
        return "Woof"

And a new class called `Cat` that does the same thing:

class Cat(Animal):
    def make_sound(self):
        return "Meow"

Now, we can create instances of both `Dog` and `Cat` and call the `make_sound` method on them:

dog = Dog("Rufus")
cat = Cat("Mittens")
print(dog.make_sound()) # Output: Woof
print(cat.make_sound()) # Output: Meow

In this example, we have two instances of two different classes, but because they both inherit from `Animal` and override the `make_sound` method, we can treat them as if they are the same class and call the same method on them.

4. Encapsulation

Encapsulation is the practice of hiding the internal workings of an object and only exposing a public interface. This helps prevent external code from modifying the internal state of an object in unexpected ways. In Python, encapsulation can be achieved through the use of private variables and methods.

Private variables are defined by prefixing the variable name with two underscores "__". This makes the variable inaccessible from outside the class.

For example, let's modify our `Student` class to include a private property for GPA:

class Student(Person):
    def __init__(self, name, age, major):
        super().__init__(name, age)
        self.major = major
        self.__gpa = 0.0
    def get_major(self):
        return self.major
    def set_gpa(self, gpa):
        if gpa >= 0.0 and gpa <= 4.0:
            self.__gpa = gpa
    def get_gpa(self):
        return self.__gpa

In this example, we have defined a private property for GPA and exposed a public method to access it. This ensures that the GPA can only be set and accessed through the public interface provided by the class.

5. Conclusion

Python's support for OOP makes it an excellent language for building complex, modular applications. In this article, we covered some of the more advanced aspects of Python3's OOP capabilities, including inheritance, polymorphism, and encapsulation. By mastering these concepts, you can create robust, scalable applications with ease.