Python autodidata - três características de orientação a objetos: encapsulamento, herança, polimorfismo

Um, embalagem

1. Como o nome indica, o conteúdo é encapsulado em algum lugar e, em seguida, o conteúdo encapsulado em algum lugar será chamado posteriormente.
2. A privatização de atributos não pode ser acessada diretamente externamente, mas pode ser acessada indiretamente (por meio de métodos).
Portanto, ao usar o recurso de encapsulamento orientado a objetos, você precisa:
·
encapsular o conteúdo de algum lugar · chamar o conteúdo encapsulado de algum lugar

Encapsulamento

#隐藏属性,在外部不可以对属性直接访问,可以间接访问,提供属性值的安全性。
#1.顾名思义就是将内容封装到某个地方,以后再去调用被封装在某处的内容。
#第一步:将内容封装到某处
class People():
	  def __init__(self,name,age):
	        self.name = name
	        self.age = age
	    def show(self):
	        print(self.name,self.age)
	        
p1 = People('张三',22)
p1.show()
p2 = People('张三2',12)
p2.show()	 
#把数据张三,22,张三2,12分别封装到p1,p2 中	 
#从某处调用被封装的内容
#调用被封装的内容时,有两种情况:
#通过对象直接调用
print(p1.name)
#通过self间接调用
def show(self):
    print(self.name,self.age) 
#面向对象的封装来说,其实就是使用构造方法将内容封装到 对象中,然后通过对象直接或者self间接获取被封装的内容

#2.对属性私有化 ,在外部不能直接访问,可以间接访问(通过方法)
__xx(左边只有两个下划线):类的私有变量,只能是允许这个类本身进行访问了,连子类也不可以
class people():
    def __init__(self):
        self.age = 2  # 实例属性(对象)
        self.__name=""

    def showinfo(self):
        print("名字:",self.__name)
        print("年龄:",self.age)

    #设置值
    def set_name(self,name):
        self.__name=name

    #获取值
    def get_name(self):
        return self.__name
        
#创建对象
p=people()
p.set_name("aa")
print(p.get_name())  

Em segundo lugar, herança

1. Herança, a herança orientada a objetos é igual à herança na vida real, ou seja, o filho pode herdar o conteúdo do pai.
2. Função: É um dos meios importantes para realizar a reutilização de código em linguagem orientada a objetos, o que é conveniente para expansão. Java suporta apenas herança de raiz única, ou seja, uma classe pode ter apenas uma classe pai direta e python pode ter herança múltipla.

Por exemplo: os
  gatos podem: miar, comer, beber, puxar e espalhar Os
cães podem: latir, comer, beber, puxar, espalhar

Se quisermos criar uma classe para cães e gatos, precisamos implementar todas as suas funções para cães e gatos, conforme mostrado abaixo:

class 猫:

    def 喵喵叫(self):
        print '喵喵叫'
 
    def 吃(self):
        # do something

    def 喝(self):
        # do something
 
    def 拉(self):
        # do something
 
    def 撒(self):
        # do something

class 狗:
 
    def 汪汪叫(self):
        print '汪汪叫'
 
    def 吃(self):
        # do something
 
    def 喝(self):
        # do something
 
    def 拉(self):
        # do something
 
    def 撒(self):
        # do something

O código acima não é difícil de perceber que comer, beber, puxar e espalhar são funções que cães e gatos têm, mas nós os escrevemos duas vezes nas classes de cães e gatos, respectivamente. Se você usar a ideia de herança, a implementação é a seguinte:
   Animais: comem, bebem, puxam e espalham (classe pai, classe base)
   gato: miau (o gato herda a função de animais)
   cachorro: latindo (o cachorro herda a função dos animais) O
código é o seguinte:

#继承
#作用重用代码,扩展代码
#语法
#class a(父类):
#只要不是私有的属性和方法,都可以继承
class animal():

    def eat(self):
        print("动物在吃。。。")

    def sleep(self):
        print("动物在睡觉。。。")

class dog(animal):

    def dog_say(self):
        print("狗在叫。。。汪汪。。。")

class cat(animal):

    def cat_say(self):
        print("猫在叫。。。喵喵。。。")


d = dog()
d.sleep()#父类继承的方法(重用)
d.dog_say()#扩展
c = cat()
c.sleep()#父类继承的方法(重用)
c.cat_say()#扩展

Portanto, para a herança orientada a objetos, é na verdade extrair os métodos compartilhados por várias classes na classe pai, e a subclasse só precisa herdar a classe pai sem ter que implementar cada método um por um.

Herança múltipla:

Class A ():
      Def a():
          Print(“a”)
 
Calss B():
   
   Def b():
       Print(“b”)
 
Class C (A,B):
  
   Def c():
      Print(“c”)
      
C =C()
C.a()
C.b()
C.c()
 
显示结果 a b  c

Reescrever:

子类不想原封不动地继承父类的方法,而是想作一定的修改,这就需要采用方法的重写。方法重写又称方法覆盖。
	#方法重写
	#子类不想原封不动地继承父类的方法,而是想作一定的修改,这就需要采用方法的重写。方法重写又称方法覆盖。
	#参数和方法名都不能改,只改方法体
	
class animal():

    def eat(self):
        print("动物在吃。。。")	
        
class dog(animal):

    def eat(self):
        print("狗吃骨头。。。")
        
class cat(animal):

    def eat(self):
        print("猫吃鱼。。。")
d = dog()
d.eat()

super:

#super 调用父类方法
#调用父类中的方法或者属性
#super 调用父类方法
#调用父类中的方法或者属性

class animal():

    def __init__(self,name,color=""):
        self.name=name
        self.color=color

    def sleep(self):
        print(self.name,"动物在睡觉。。。")

    def eat(self):
        print("动物在吃。。。")

class dog(animal):

    def __init__(self,number,name,color):
        # 调用父类的构造方法
        super(dog, self).__init__(name)
        self.number=number#扩展的属性

    def eat(self):
        print(self.name,self.color,self.number,"狗吃骨头。。。")

class cat(animal):

    def eat(self):
        print("猫吃鱼。。。")

d = dog("小白","白色",2)
d.eat()

função dir ():

 #获得一个对象的所有属性和方法,可以使用 dir() 函数,它返回一个包含字符串的 list。
 #私有变量和方法  在其他地方不可以访问,不是绝对的,可以通过 dir()查看私有属性,直接访问。

class people():

    def __init__(self,name):
        self.__name=name
        self.age=0

p=people("a")
#print(dir(p))
print(p._people__name)
p.address="北京市"
print(p.address)

classe raiz do objeto
A classe base de todas as classes em Python é Object

#object 根类
#__new__ 执行在__init__之前
#如果__new__ 没有返回新的对象,则不会执行__init__返回
#在 __new__方法中返回的return  object.__new__(cls)对象,实际就是__init__中self对象
#__str__ 把当前对象转换成str,在打印对象时,默认调用
#__xx__(两边两个下划线):是特列方法像__init__之类的,是python的内嵌的方法在特定的时候会被自动调用

class Monkey(object):

    def speak(self):
        print("咿咿呀呀......")

class people(Monkey):

    #Create and return a new object创建并返回新的对象

    def __new__(cls, *args, **kwargs):
        print("__new__")
        return  object.__new__(cls)

    #构造方法
    def __init__(self, name):
        print("__init__")
        self.name = name

    def speak(self):
        print("小样的,不错嘛!会说话了!")

    def think(self):
        print("别说话!认真思考!")

    def __str__(self):
        return "重写的str方法"+self.name

    def __del__(self):
        print("删除对象")

p = people("a")

#判断对象是否是那种数据类型
#print(isinstance(p,object))

#type()  查看

#打印对象时,默认调用__str__()
#print(p)
del p

Três, polimorfismo

Um tipo tem várias formas.
Função: modificar frequentemente o código, você pode usar polimorfismo para resolver a expansão, manutenção

class cat():
    def __init__(self,name):
        self.name=name

    def say(self):
        print("喵喵。。。")


class dog():
    def __init__(self,name):
        self.name=name

    def say(self):
        print("汪汪。。。")

class people():

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

    #养宠物
    def set_pet(self,pet):
        self.pet=pet

    #让宠物叫
    def show_pet(self):
        print(self.name,"让宠物叫")
        self.pet.say()

g = dog("小黄")
c = cat("小花")
p = people("jack")
#养宠物
p.set_pet(g)
#让宠物叫
p.show_pet()

Acho que você gosta

Origin blog.csdn.net/weixin_47580822/article/details/113726983
Recomendado
Clasificación