Fundamentos da programação orientada a objetos: análise abrangente de encapsulamento, herança, polimorfismo e abstração

Três características principais da orientação a objetos

A programação orientada a objetos possui três características principais: encapsulamento, herança e polimorfismo.

• Encapsulamento: O encapsulamento garante a segurança dos dados em um objeto, encapsulando dados e métodos de operação de dados em um objeto para evitar acesso externo direto aos dados do objeto.
• Herança: A herança garante a escalabilidade dos objetos.As subclasses podem herdar os atributos e métodos da classe pai e podem ser estendidas com base nisso.
• Polimorfismo: O polimorfismo garante a flexibilidade do programa e permite que objetos de diferentes tipos respondam de maneira diferente à mesma mensagem.

Noções básicas de programação orientada a objetos, como classes e objetos

Na programação orientada a objetos, geralmente definimos classes e objetos. Uma classe é uma descrição abstrata de uma classe de objetos semelhantes, enquanto os objetos são instâncias concretas. Vamos dar uma olhada nos conceitos de classes e objetos e no relacionamento entre eles.

definir uma classe

class A(object):

    # 类属性
    count = 0

    def __init__(self):
        # 实例属性
        self.name = '孙悟空'

    def test(self):
        # 实例方法
        print('这是test方法~~~', self)

    @classmethod            
    def test_2(cls):
        # 类方法
        print('这是test_2方法，他是一个类方法~~~', cls)
        print(cls.count)

    @staticmethod
    def test_3():
        # 静态方法
        print('test_3执行了~~~')

No código acima, definimos uma classe A. em:

• countÉ um atributo de classe que pode ser acessado por meio de uma classe ou instância e só pode ser modificado por meio de um objeto de classe.
• __init__()É um método construtor usado para inicializar as propriedades da instância e é chamado automaticamente ao criar um objeto.
• test()É um método de instância que toma selfcomo primeiro parâmetro e opera as propriedades da instância.
• test_2()É um método de classe que toma clscomo primeiro parâmetro e opera atributos de classe.
• test_3()É um método estático, não precisa especificar parâmetros padrão e não tem nada a ver com a classe atual.

Crie objetos e chame métodos

a = A()

a.test()

A.test_2()

A.test_3()

No código acima, criamos um objeto ae então chamamos o método de instância por meio da instância object test(). A seguir, chamamos métodos de classe test_2()e métodos estáticos por meio da classe object test_3().

Este é o conceito básico e o uso de classes e objetos. A seguir, continuaremos a explorar outros recursos da programação orientada a objetos.

Noções básicas de programação orientada a objetos: herança e polimorfismo

Na programação orientada a objetos, herança e polimorfismo são dois conceitos importantes que podem melhorar a reutilização e flexibilidade do código. Vamos aprender juntos o uso e as características da herança e do polimorfismo.

herdar

Herança é um mecanismo de programação orientada a objetos que nos permite criar uma nova classe que herda de uma ou mais classes existentes. A classe herdada é chamada de classe pai (ou classe base), e a classe recém-criada é chamada de subclasse (ou classe derivada). As subclasses herdam as propriedades e métodos da classe pai e podem ser estendidas e modificadas com base nisso.

# 定义一个父类
class Parent(object):
    def __init__(self):
        self.parent_attr = '父类属性'

    def parent_method(self):
        print('这是父类方法')

# 定义一个子类，继承父类
class Child(Parent):
    def __init__(self):
        # 调用父类的构造方法
        super().__init__()
        self.child_attr = '子类属性'

    def child_method(self):
        print('这是子类方法')

No código acima, definimos uma classe pai Parente uma classe filha Child. A subclasse Childherda a classe pai Parente super().__init__obtém as propriedades e métodos da classe pai chamando o construtor da classe pai. As subclasses podem adicionar suas próprias propriedades e métodos além disso.

Polimorfismo

O polimorfismo é um recurso muito poderoso na programação orientada a objetos. Isso nos permite usar a referência da classe pai para apontar para o objeto da subclasse, obtendo assim um design de código flexível. O polimorfismo nos permite lidar com objetos de diferentes subclasses de maneira unificada.

# 使用多态调用父类方法
def invoke_method(obj):
    obj.parent_method()

# 创建父类和子类对象
parent = Parent()
child = Child()

# 调用父类方法
invoke_method(parent)
invoke_method(child)

No código acima, definimos uma invoke_methodfunção que aceita um objeto da classe pai como parâmetro e chama o método da classe pai. Em seguida, criamos um objeto de classe pai parente um objeto de classe filho childe os passamos para invoke_methoda função para chamada, respectivamente. Devido às características do polimorfismo, seja um objeto de classe pai ou um objeto de subclasse, os métodos da classe pai podem ser chamados normalmente.

Herança e polimorfismo são conceitos e técnicas muito importantes na programação orientada a objetos, que podem melhorar muito a capacidade de manutenção e escalabilidade do código.

O polimorfismo é uma das três principais características da orientação a objetos.

O polimorfismo é um recurso importante na programação orientada a objetos, que permite que objetos de diferentes tipos respondam de maneira diferente à mesma mensagem. No conceito de polimorfismo, um objeto pode ser apresentado de múltiplas formas.

Defina duas classes

Primeiro, definimos duas classes A e B e adicionamos alguns métodos e propriedades a elas. Essas duas classes representam diferentes tipos de objetos, respectivamente.

class A:
    def __init__(self, name):
        self._name = name

    @property
    def name(self):
        return self._name
        
    @name.setter
    def name(self, name):
        self._name = name   

class B:
    def __init__(self, name):
        self._name = name

    def __len__(self):
        return 10

    @property
    def name(self):
        return self._name
        
    @name.setter
    def name(self, name):
        self._name = name   

class C:
    pass

a = A('孙悟空')
b = B('猪八戒')
c = C()

definir uma função

A seguir, definimos uma função say_hello(obj)que aceita um parâmetro obj. Esta função não considera o tipo específico do objeto. Desde que o objeto contenha nameatributos, ele pode ser passado para a função como parâmetro.

def say_hello(obj):
    print('你好 %s' % obj.name)

Neste ponto, podemos chamar say_helloa função e passar objetos de diferentes tipos como parâmetros, e a função imprimirá a saudação correspondente com base nas propriedades do objeto.

say_hello(a)  # 输出：你好 孙悟空
say_hello(b)  # 输出：你好 猪八戒

tipo pato

Na programação orientada a objetos, a digitação duck é um conceito de digitação dinâmica. Baseia a adequação dos objetos nos métodos e propriedades que possuem, e não através de relacionamentos de herança ou implementação de interfaces específicas.

Tomemos len()funções como exemplo: desde que um objeto tenha __len__um método especial, você pode len()obter seu comprimento.

l = [1, 2, 3]
s = 'hello'

print(len(l))  # 输出：3
print(len(s))  # 输出：5
print(len(b))  # 输出：10
print(len(c))  # 报错：AttributeError: 'C' object has no attribute '__len__'

No código acima, podemos ver que por meio len()da função é possível obter o comprimento da lista le da string s, mas Co comprimento da classe não pode ser obtido. Isso ocorre porque as classes Bdefinem __len__métodos, enquanto as classes Cnão.

Encapsulamento e abstração baseado em programação orientada a objetos

Na programação orientada a objetos, encapsulamento e abstração são dois conceitos importantes que nos ajudam a organizar e gerenciar melhor o código. Vamos aprender o uso e as características do encapsulamento e da abstração.

encapsulamento

Encapsulamento é um mecanismo de programação orientada a objetos que encapsula dados e métodos de operação de dados em uma unidade e oculta detalhes específicos de implementação de fora. Através do encapsulamento, podemos organizar dados e métodos em um todo lógico, melhorando a legibilidade e a manutenção do código.

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

    def get_name(self):
        return self.name

    def set_name(self, name):
        self.name = name

    def get_age(self):
        return self.age

    def set_age(self, age):
        self.age = age

student = Student('张三', 18)
print(student.get_name())  # 输出：张三
print(student.get_age())   # 输出：18

student.set_name('李四')
student.set_age(20)
print(student.get_name())  # 输出：李四
print(student.get_age())   # 输出：20

No código acima, definimos uma Studentclasse que encapsula os atributos de nome e idade do aluno e fornece métodos para obter e definir valores de atributos. Desta forma, podemos controlar as permissões de acesso dos atributos, bem como realizar verificação e processamento razoáveis ​​dos atributos.

abstrato

A abstração é um princípio importante na programação orientada a objetos, que abstrai propriedades e métodos comuns em uma classe ou interface abstrata. As classes abstratas não podem ser instanciadas e só podem servir como classes pai para outras classes. As subclasses devem implementar todos os métodos abstratos definidos na classe abstrata.

from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod
    def make_sound(self):
        pass

class Dog(Animal):
    def make_sound(self):
        print('汪汪汪')

class Cat(Animal):
    def make_sound(self):
        print('喵喵喵')

#animal = Animal()  # 错误，抽象类不能被实例化

dog = Dog()
dog.make_sound()  # 输出：汪汪汪

cat = Cat()
cat.make_sound()  # 输出：喵喵喵

No código acima, definimos uma classe abstrata Animal, que contém um método abstrato make_sound(). Este método abstrato não tem implementação específica, mas é deixado para as subclasses implementarem. Em seguida, criamos Dogduas Catsubclasses e implementamos métodos abstratos respectivamente. Através do uso de classes abstratas, podemos garantir que métodos específicos serão implementados em subclasses.

Encapsulamento e abstração são conceitos e técnicas muito importantes na programação orientada a objetos, que podem nos ajudar a construir código mais confiável e escalável.

Noções básicas de programação orientada a objetos: composição e interfaces

Na programação orientada a objetos, além de herança e polimorfismo, existem dois conceitos importantes: composição e interfaces. Vamos aprender o uso e as características das combinações e interfaces.

combinação

Composição refere-se à combinação de diferentes classes para formar uma classe maior. Através da composição, podemos referenciar objetos de outras classes em uma classe como suas propriedades para construir estruturas de objetos mais complexas.

class Engine:
    def start(self):
        print("引擎启动")

    def stop(self):
        print("引擎停止")

class Car:
    def __init__(self):
        self.engine = Engine()

    def drive(self):
        self.engine.start()
        print("汽车行驶中")
        self.engine.stop()

car = Car()
car.drive()

No código acima, definimos uma Carclasse e uma Engineclasse. As classes implementam a combinação de motores Carusando objetos como atributos. EngineDesta forma, podemos Carchamar Engineo método do objeto na classe para implementar as funções de partida e parada do carro.

interface

Uma interface é uma convenção que especifica quais propriedades e métodos uma classe deve ter. Na programação orientada a objetos, uma interface descreve um conjunto de operações relacionadas, mas não possui implementação específica. Através de interfaces, podemos definir um conjunto comum de padrões comportamentais para obter flexibilidade e substituibilidade de código.

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

    @abstractmethod
    def perimeter(self):
        pass

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def area(self):
        return self.width * self.height

    def perimeter(self):
        return 2 * (self.width + self.height)

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14 * self.radius * self.radius

    def perimeter(self):
        return 2 * 3.14 * self.radius

rectangle = Rectangle(5, 3)
print(rectangle.area())       # 输出：15
print(rectangle.perimeter())  # 输出：16

circle = Circle(4)
print(circle.area())          # 输出：50.24
print(circle.perimeter())     # 输出：25.12

No código acima, definimos uma Shapeinterface, que contém dois métodos abstratos area()e perimeter(). Em seguida, criamos duas Shapesubclasses que implementam a interface: Rectanglee Circle. Através do uso de interfaces, podemos garantir que todas as classes que implementam Shapea interface tenham os mesmos métodos, conseguindo assim um processamento unificado de código.

Composição e interfaces são conceitos e técnicas muito importantes na programação orientada a objetos, que podem nos ajudar a construir códigos mais flexíveis e extensíveis.

Resumir

A Programação Orientada a Objetos (OOP, abreviadamente) é um paradigma de programação para organizar e gerenciar código. Baseia-se no conceito de objetos, encapsulando dados e operações em uma entidade independente e alcançando flexibilidade, legibilidade e manutenção do código por meio de interações entre classes.

A programação orientada a objetos possui as seguintes características básicas:

Encapsulamento: Encapsule dados e operações em dados em uma entidade, oculte detalhes internos de implementação por meio de controle de acesso e melhore a segurança e a modularidade do código.

Herança: por meio do mecanismo de herança, uma classe pode ser derivada de outra classe, herdar os atributos e métodos da classe pai e estendê-la ou modificá-la com base nisso para obter a reutilização de código e o design hierárquico.

Polimorfismo: O mesmo método pode produzir comportamentos diferentes quando chamado em objetos diferentes. Através do polimorfismo, uma interface unificada pode ser usada para lidar com diferentes tipos de objetos, melhorando a flexibilidade e escalabilidade do código.

Abstração: Defina especificações e restrições por meio de classes ou interfaces abstratas, oculte detalhes de implementação, enfatize a lógica de alto nível e a arquitetura geral do código e melhore a modularidade e a capacidade de manutenção do código.

Na programação orientada a objetos, podemos criar objetos definindo classes e chamar métodos de objetos para obter funções específicas. Ao combinar vários objetos, podemos construir sistemas e estruturas de dados mais complexos.

Além disso, a programação orientada a objetos também introduz alguns princípios e padrões de design, como o princípio de responsabilidade única, o princípio aberto-fechado e padrões de design, etc., para nos ajudar a projetar códigos com alta coesão, baixo acoplamento, escalabilidade e fácil manutenção. .

Ao aprender os fundamentos da programação orientada a objetos, podemos compreender e aplicar melhor esse paradigma de programação e melhorar nossas capacidades de desenvolvimento de software.