第五篇：面向对象设计

三大编程范式：面向过程、函数式和面向对象
面向对象的核心在对象，即将一类具体事物的动作和特征结合在一起。
类：把一类事物的特征和动作整合在一起，是一个抽象的概念。
对象：有类实例化而来，类实例的结果称为一个实例或对象

1、类和对象的相关知识
类的属性：数据属性和函数属性
实例的属性：只有数据属性
注意：类和对象都是通过点(.)访问自己的属性
class Chinese():
    '我们都是中国人'
    dang = '民主党派'
    def __init__(self,name):
        self.name = name
    def tu_tan(self):
        print('朝着墙上吐痰')
    def cha_dui(self):
        print('他插队了')
print(Chinese.__name__)						类的名字
print(Chinese.__doc__)						类的文档字符创
print(Chinese.__module__)					类定义所在的模块
print(Chinese.__dict__)						类的属性字典
类中必须有初始化函数，函数中必须有self+数据属性
实例化的过程可以理解为执行初始化函数的过程，实例本身会当做参数传递给self
p1 = Chinese('yuan')
print(p1.__dict__)
print(Chinese.__dict__)
print(p1.tu_tan())							p1会自动填充到函数中
print(Chinese.tu_tan(p1))					p1不会自动填充，需要手动填充

2、类属性的增删改查
class Chinese():
    country = 'China'
    def __init__(self,name):
        self.name = name
    def play_ball(self,ball):
        print('%s正在打%s'%(self.name,ball))
类数据属性
p1 = Chinese('alex')
增加
Chinese.dang = '无党派'
print(p1.__dict__)
print(Chinese.__dict__)
删除
del Chinese.dang
print(Chinese.__dict__)
修改
Chinese.country = 'Janpan'
print(Chinese.country)
print(p1.__dict__)
print(Chinese.__dict__)
查看
print(Chinese.country)
类函数属性
class Chinese():
    country = 'China'
    def __init__(self,name):
        self.name = name
    def play_ball(self,ball):
        print('%s正在打%s'%(self.name,ball))
增加
def eat_food(self,food):
    print('%s正在吃%s'%(self.name,food))
p1 = Chinese('alex')
Chinese.eat = eat_food
print(Chinese.__dict__)
Chinese.eat(p1,'水果')
p1.eat('水果')
删除
del Chinese.eat
print(Chinese.__dict__)
修改
def test(self):
    print('%s正在test'%self.name)
Chinese.play_ball=test
Chinese.play_ball(p1)

3、实例属性(只有数据属性)的增删改查
class Chinese():
    country = 'China'
    def __init__(self,name):
        self.name = name
    def play_ball(self,ball):
        print('%s正在打%s'%(self.name,ball))

p1 = Chinese('alex')
增加
p1.age = 18
print(p1.__dict__)
print(p1.age)
删除
del p1.age
print(p1.__dict__)
修改
p1.name = 'yuan'
print(p1.__dict__)
查看
print(p1.name)
print(p1.country)
p1.play_ball('篮球')

4、对象与实例属性
country = '中国'
class Chinese():
    country = 'china'
    def __init__(self,name):
        self.name = name
        print('--->',country)
    def play_ball(self,ball):
        print('%s正在打%s'%(self.name,ball))
print(Chinese.country)
p1 = Chinese('alex')
注：数据属性和变量的区别
class Chinese():
    country = 'china'
    l = [1,2]
    def __init__(self,name):
        self.name = name
    def play_ball(self,ball):
        print('%s正在打%s'%(self.name,ball))
p1 = Chinese('alex')
print(p1.l)
两种方式的区别
p1.l = [1,2,3]							给p1增加数据属性
print(Chinese.l)
print(p1.l)

p1.l.append('c')						p1中没有l，会往类中找，因此此时修改的是类的
print(p1.l)
print(Chinese.l)


4、静态属性和静态方法
静态数据就是数据属性
class Room():
    tag = 1
    def __init__(self,name,leng,wid,hing):
        self.name =  name
        self.leng = leng
        self.wid = wid
        self.hing = hing
    def tel(self):
        print('%s正在测量的尺寸分别是%s %s %s'%(self.name,self.leng,self.wid,self.hing))
    @property					#封装操作，实例能够按照调用属性的方式执行函数(针对实例)
    def cal_area(self):
        print('%s 你好'%self.name)
    @classmethod				#使用类调用类方法，使类和实例分开，且只能类调用	
    def tel_info(cls,X):
        print(cls,X)
    @staticmethod				#类的工具包，不能使用类变量和实例变量
    def wah_boy(a,b,c):
        print(a,b,c)

p1 = Room('alex',10,20,30)
p1.cal_area

Room.tel_info(10)

p1.wah_boy(1,2,3)
Room.wah_boy(1,2,3)
Room.tel(p1)

5、组合
组合即拼接，定义一个人的类，人有头、脚、身体和躯干等部分，
这些部分之间没有相似关系共同构成一个人的类，这就是组合。
用途：做关联；小的组成大的。
class School():
    def __init__(self,name,addr):
        self.name = name
        self.addr = addr
    def zhao_sheng(self):
        print('%s正在招生'%self.name)

class Course():
    def __init__(self,name,price,period,school):
        self.name = name
        self.price =price
        self.period = period
        self.school = school
    def tell_info(self):
        print('%s 开设的课程名字为%s,周期%s,价格为%s'%(self.school.name,self.name,self.period,self.price))

p1 = School('老男孩','上海校区')
p2 = School('老男孩','北京校区')

c1 = Course('python',100,20,p1)
# print(c1.__dict__)
c1.tell_info()

6、面向对象的三大特性(继承、多态和封装)
继承是一种创建新类的方式，可以单继承一个或者多继承(用逗号分隔开)
父类又可称为基类或超类，新建的类称为派生类或子类
子类继承父类的所有属性，子类如果新增的属性和父类重名，那么调用新增的属性时，以自己为准。
class File():
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def run(self):
        print('%s跑了'%self.name)
class Ten(File):
    def __init__(self,name):
        self.name = name

    def run(self):
        print('%s不跑了'%self.name)
t1 = Ten('alex')
print(t1.run())
使用方式：
当类之间有显著不同时，并且较小的类是较大类所需要的组件时，用组合较好；
当类之间有很多相同的功能，提取这些共同的功能做成基类，用继承较好。

接口继承：声明某个子类兼容基类，定义一个接口，子类继承接口类，并且实现接口定义的方法。
归一化：
规定一个兼容接口，使得调用者无需关系具体的细节，可一视同仁的处理实现了特定接口的对象
import abc
class All_file(metaclass=abc.ABCMeta):
	@abc.abstractmethod
	def read(self)
		pass
	@abc.abstractmethod
	def write(self):
		pass
class Disk(All_file):
	def read(self):
		print('read')
	def write(self):
		print('write')
通过abc模块，父类对子类限定，父类只定义可不做具体的实现方法，但是子类只要继承，
就必须实现父类所规定的方法。
继承的顺序广度优先(F-->D-->B-->E-->C-->A)
依据准则：子类会先于父类被检查；多个父类会按照在解析顺序列表顺序被检查；
如果对下一个类存在两个合法的选择，选择左边(D)的 class F(D,E)

class Vehile():
    country = 'China'
    def __init__(self,name,speed,power):
        self.name = name
        self.speed = speed
        self.power = power
    def run(self):
        print('跑了')
class Subway(Vehile):
    def __init__(self,name,speed,power,line):
        super().__init__(name,speed,power)
        #super(Subway,self).__init__(name,speed,power)
        self.line = line

    def run(self):
        super().run()
        #super(Subway, self).run()
        print('跑的跟快了')
s1 = Subway('上海地铁',1000,'电',13)
# print(s1.__dict__)
s1.run()

7、多态 
多态指出对象通过他们共同的属性和动作来操作和访问，不需考虑他们具体的类
多态的继承有两种含义：改变和扩展
多态就是类的这两层意义的一个具体实现机制，即调用不同的类实例化对象下的相同方法，
实现的过程不一样。
class H20():
    def __init__(self,name,temperate):
        self.name = name
        self.temperate = temperate
    def turn_ice(self):
        if self.temperate < 0:
            print('%s温度太低结冰了'%self.name)
        if self.temperate > 0:
            print("%s液化成水了"%self.name)
        if self.temperate > 100:
            print('%s温度太高成水蒸气了'%self.name)
class Water(H20):
    pass
class Ice(H20):
    pass
class Steam(H20):
    pass
w1 = Water('水',25)
i1 = Ice('冰',-20)
s1 = Steam('蒸气',150)
w1.turn_ice()
i1.turn_ice()
s1.turn_ice()

8、封装
第一层面的封装：类就是一个麻袋，这本身就是一种封装；
第二层面的封装：类中定义私有的，只在类的内部使用，外部无法访问；
约定一：任何单下划线开头的名字都应该是内部的私有的，外部无法直接访问
约定二：双下划线开头的名字不应该被访问
第三层面的封装：明确区分内外，内部的实现逻辑，外部无法知晓，并且为封装到内部的逻辑提供
一个访问接口给外部使用。
class People():
    # star = 'earth'
    _star = 'earth'
    # __star = 'earth'
    def __init__(self,id,name,salary):
        self.name = name
        self.id = id
        self.salary = salary
    def get_id(self):
        print('我是私有的方法，找到我的id是[%s]'%self.id)
    def get_star(self):
        print(self.__star)

p1 = People(123,'alex',1000)
# p1.get_id()
# p1.get_star()
# p1.star
# print(People._star)
# print(p1._star)
# print(People.__star)