day15：面向对象

一、面向对象

面向对象，更加注重过程的编程方法
面向对象三大特性：封装，继承，多态
py中所有的类都继承与一个父类

1、使用class建立类

#class 类
class Person:
   pass

给类加入属性：
#属性
name = “js”
age = 18
hair = “black”
给类加入方法：
def tell(self)

#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、实例化对象

使用 类名() 表示实例化一个对象

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

3、使用构造方法

构造方法能够在实例化时就初始化实例

#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、访问原来的属性

可以通过Person.来进行访问

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

注意：
可以看出，类中与实例中属性不同。
当调用传入参数中没有的属性时，对调用类属性

5、析构函数

当实例被回收时自动调用

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、使用私有属性、私有方法

通过__ 就可以设置私有属性和私有方法：例如
__name
def __setName(self,name):

设置了私有之后，只能通过公有来调用

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、继承、重写、拓展

继承，括号内填写父类,这样就能够拥有父类的方法属性，减少重复工作

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

在继承中，经常引用其他文件中的类
通过 if name == ‘main’ 可以只导入功能，在继承时十分常用

一个小练习如下：

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()

其中，init()用到了拓展，
tell()则是直接覆盖了

8、小练习

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发子弹
"""