python3 面向对象（二）

面向对象的程序设计

1、面向对象的程序设计怎么来的

（面向对象的程序设计）

1. 什么是，什么要有
2. 以对象为中心，对象相互交互
3. 对象是特征与技能的结合体
4. 对象优点：解决程序的扩展性，对一个对象单独修改，会反应到整个体系中
5. 对象缺点：可控性差

2、类和对象 从一组对象中提取相似的部分就是 类 类也是特征与技能的结合体（数据和函数的结合体） 实例化过程中，把实例当作第一个参数传给init本身

• 类的实例化

g = Game('lol','hehe') # Game.__init__(g,'lol','hehe')

• 属性引用，包含数据属性和函数属性

pirnt(Game.member)
print(Game.__init__)
print(Game.attack)

• 对于一个实力来说，只有一种功能：属性引用

print(g.nickname)
print(g.aggrv)
print(g.life_value)

* 类的数据属性

print(g.camp) print(g.attack)

• g. 是在调用自己的属性 也是在调用自己的类

继承

• 单继承与多继承

class P1 # 父类1
    pass
class P2 # 父类2
    pass
Class Sub1(P1) # 子类1，单继承
    pass
Class Sub2(P1,P2) # 子类1,多继承
    pass

• 继承顺序

1. 深度优先

2. 广度优先

• 绑定方法

静态方法

class Foo:
    @staticmethod
    def sayhi(x,y,z):
        print(x,y,z)
        
>> Foo.sayhi(1,2,3)

import time
class Date:
    def __init__(self,year,mon,day):
        self.year = year
        self.mon = mon
        self.day = day
        
    @staticmethod
    def now():
    t = time.localtime()
    return Date(t.tm_year,t.tm_mon,t.tm_mday)
    
d = Date(1999,1,1)
d1=Date.now()

类方法

class A:
    x = 1
    @classmethod
    def test(cls):
        print(cls,cls.x)
        
A.test()

类方法的应用场景

class A:
    def __init__(self,name):
        self.name = name
        
    def __str__(self):
        return '%s' % self.name
        
a = A('alex')
print(a)

# 使用静态方法，无法调用B 中的 __str__方法
# 使用类方法，cls是谁调用，cls就等于那个类名，如下，cls=B
import time
class A:
    def __init__(self,name,age,gender):
        self.name = name
        self.age = age
        self.gender = gender

    @staticmethod
    def now():
        t = time.localtime()
        return A(t.tm_year,t.tm_mon,t.tm_mday)
    '''打印 A object'''
    @classmethod
    def now(cls):
        print('time'.center(30,'-'))
        t = time.localtime()
        return cls(t.tm_year, t.tm_mon, t.tm_mday)
    '''打印 2017-3-4'''
class B(A):
    def __str__(self):
        return '%s-%s-%s' % (self.name,self.age,self.gender)
b1 = B.now()
print(b1)

• 继承用来解决重用性

class Animal:
    start = 'earth'

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

    def talk(self):
        print('in talk')

    def run(self):
        print('running')

class Person(Animal):
    def baojian(self):
        print('%s like dabaojian'%self.name)
    pass

class Pig(Animal):
    pass

class Dog(Animal):
    pass

p1 = Person('alex',1000,'female')
pig1 = Pig('bajie',30,'xiong')

print(p1.start)
pig1.run()
p1.baojian()

• 组合

class People:
    def __init__(self,name,birth,course):
        self.name = name
        self.birth = birth # Date(1999,1,1)
        self.course = course #Course('python',1000,'3mon')
class Course:
    def __init__(self,name,price,period):
        self.name = name
        self.price = price
        self.period = period

class Date:
    def __init__(self,year,mon,day):
        self.year = year
        self.mon = mon
        self.day = day
        # print('birthday is %s-%s-%s'%(year,mon,day))

p3 = People('alex',Date(1999,1,1),Course('python',1000,'3mon'))
print(p3.birth.year)
print(p3.course.name)

• 接口与归一化设计

父类只写名字，不写动作 动作写在子类

• 多态与多态性

1. 多态：同一种事物的不同形态，如序列类型包含字符串、元祖、列表

s='xxxx'
l=[1,2,3]
t=(4,5,6)

2. 多态性

增加了程序的灵活性 增加了程序的可扩展性

def func(obj):
    print(obj.__len__())
func(s)
func(l)
func(t)

封装

• 封装数据：保护隐私
• 封装方法：隔离复杂度

分为两个层面：

class Foo:
    x = 1
    def __init__(self,name,money):
        self.name = name
        self.__money = money # _Foo__money

    def get_money(self):
        print(self.__money)

f = Foo('alex',1000000)
# print(f.__money) # 隐私属性不能直接调用
# 可以通过__dict__看到
print(f.__dict__)
# 输出 {'name': 'alex', '_Foo__money': 1000000}
f.get_money() # 可以多写个功能用来调用

---