Día 15: Orientado a Objetos

En primer lugar, orientado a objetos

proceso de programación orientado a objetos más énfasis en
tres propiedades orientadas a objetos: encapsulación, herencia, polimorfismo
py en todas las clases con una clase herede de padres

1, clase con clase

#class 类
class Person:
   pass

Se añadió a la clase de atributos:
# Atributo
name = "JS"
Edad = 18 es
pelo = "Negro"
a la clase de Incorporación:
DEF Tell (Ser)

#class 类
class Person:
    #属性
    name = "js"
    age = 18
    hair = "black"
    
    #方法 self：谁调用就是谁
    def tell(self):
        print("my name is %s,age %s,hair is %s"%(self.name,self.age,self.hair))
    pass

2, el objeto es instanciado

Usando el nombre de la clase () muestra un ejemplo de un objeto

p = Person()
print(p.name)
p.tell()

3, utilizando el constructor

El método puede ser configurado para inicializar ejemplo instanciación

#class 类
class Person:
    #属性
    name = "js"
    age = 18
    hair = "black"
    #构造方法：在实例化的时候自动调用
    #如果定义了构造器则没有默认的缺省的构造器了
    def __init__(self,name,age):
        self.name = name
        self.age = age
    #方法 self：谁调用就是谁
    def tell(self):
        print("my name is %s,age %s,hair is %s"%(self.name,self.age,self.hair))
    pass
#类名() 表示实例化一个对象
p = Person("js",18)
p.tell()
p1 = Person("LY",14)
p1.tell()

4, el acceso a la propiedad original

Se puede acceder por persona.

#访问原来属性：
print(Person.name)
print(Person.age)
Person.tell(p1) #self可以传入实例

Nota:
Se puede observar, los atributos de instancia de clase son diferentes.
Cuando no hay ningún parámetro atributos de la llamada entrante, la llamada a atributos de clase

5, destructor

Cuando una instancia se recupera invoca automáticamente

class Person:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    #析构函数，当实例被回收时自动调用
    def __del__(self):
        print("析构函数调用")
    def tell(self):
        print("mtname is %s,age %s"%(self.name,self.age))

p = Person("sj",18)
p.tell()
"""
当程序结束时，析构函数就会调用
"""

6, el uso de la propiedad privada, los métodos privados

__ puede ser proporcionada por atributos y métodos privados particulares: por ejemplo,
__name__
DEF __setName (Ser, nombre):

Después de configurar privada y sólo puede ser llamado por el público

class Person:
    def __init__(self,name,age):
        #加两个下划线表示私有属性，不能直接被外部访问
        self.__name = name
        self.__age = age
    def getAge(self):
        return  self.__age
    def setAge(self,age):
        self.__age = age
    #可以设置私有方法，同理，只能通过公用方法调用
    def __setName(self,name):
        self.__name = name
    def setNamePass(self):
        pwd = 123
        res = int(input("请输入密码："))
        if res == pwd:
            self.__setName("haha修改成功")
        else:
            print("pass word error")
    def tell(self):
        print("mtname is %s,age %s"%(self.__name,self.__age))

p = Person("sj",18)
p.tell()
print(p.getAge())
p.setAge(10)
p.tell() #可以看出修改成功

p.setNamePass()
p.tell()

7, la herencia, reescritura, expanda

La herencia, la clase padre para llenar los soportes, para que pueda tener las propiedades del método de la clase padre, reducir la duplicación de esfuerzos

#继承，括号内填写父类,如
class MtList(list):
    pass

En la sucesión, la cita a menudo en otra clase de archivos
por IF nombre '== principal ' función se puede importar sólo cuando la herencia es muy común

Un pequeño ejercicio de la siguiente manera:

from day15.面向对象 import Person
#通过 if __name__ == '__main__' 可以只导入功能，
p = Person("LS",18)
p.tell()

class Basterd(Person):
    #方法拓展，在保留父类方法时拓展
    def __init__(self,name,age,badhobby):
        super().__init__(name,age)
        self.badhobby = badhobby
    #方法重写，完全覆盖父类方法
    def tell(self):
        print("我叫%s，age %s，我爱%s"%(self.name,self.age,self.badhobby))
"""
建立一个坏弹类，
坏蛋是一个人，
坏蛋有他特殊的属性与发方法
"""
if __name__ == '__main__':
    p = Basterd("ly",18,"打架")
    p.tell()

En donde, el init () Los usos se expanden,
Tell () está cubierto directamente

8, la práctica pequeña

class Clip:
    def __init__(self,bullet):
        self.bullet = bullet

class Gun:
    def __init__(self,clip):
        self.clip = clip
    def fier(self,n):
        if self.clip.bullet > n:
            self.clip.bullet -= n
            print("开枪；还剩%s发子弹"%(self.clip.bullet))
            for i in range(n):
                print("tu~")
        else:
            print("子弹不够啦，上子弹啊！")

class Person:
    def __init__(self,gun):
        self.gun = gun
    def fill(self,n):
        self.gun.clip.bullet += n
        print("上弹成功，还有%s发"%(self.gun.clip.bullet))

from day15.clip import *
from day15.gun import *
from day15.Person import *

c = Clip(10)
g = Gun(c)
p = Person(g)
for i in range(4):
    p.gun.fier(3)
p.fill(5)
for i in range(4):
    p.gun.fier(3)
"""
运行效果
开枪；还剩7发子弹
tu~
tu~
tu~
开枪；还剩4发子弹
tu~
tu~
tu~
开枪；还剩1发子弹
"""