python_04_面向对象

1.面向对象

1）定义
面向对象
是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。
面向过程：
就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。
2）面向对象的基础语法
定义简单的类;
定义只包含方法的类;

定义只包含方法的类;
class 类名():
	def 方法1(self, 参数列表) ;
		pass
	def 方法2(self, 参数列表) :
		pass

当一个类定义完成之后，要使用这个类来创建对象，语法格式如下

对象变量=类名()

例如：小狗爱玩球，小狗爱吃肉

# 定义一个‘狗’类
class Dog():
    def play(self):
        print '小狗爱玩球'
    def eat(self):
        print '小狗爱吃肉'
# 创建一个‘狗’对象
dog = Dog()
dog.eat()
dog.play()

执行如下：

self的用法：

class Dog():
    # 哪个对象调用的方法，self就是哪个的引用
    def play(self):
        print '%s 爱玩球' % self.name
    def eat(self):
        print '小狗爱吃肉'
# 创建一个狗对象
xixi = Dog()
xixi.name = 'xixi'
xixi.play()
xixi.eat()
# 创建一个狗对象
haha = Dog()
haha.name = 'haha'
haha.play()
haha.eat()

执行如下：

3）初始化方法
初始化方法
使用类名（）创建对象时，python的解释器会自动执行以下操作：
1.为对象再内存中分配空间–创建对象
2.调用初始化方法为对象的属性设置初始值–初始化方法__init__
这个初始化方法就是__init__方法，__init__是对象的内置方法
__init__方法是专门用来定义一个类具有那些属性的方法
示例：

class Dog():
    def __init__(self,dog_name):
        self.name = dog_name
        # 在类中，任何方法都可以使用self.name
    def swim(self):
        print '%s 爱游泳' % self.name

# 使用类名()创建对象的时候，会自动调用初始化方法__init__
xixi = Dog('xixi')
xixi.swim()

haha = Dog('haha')
haha.swim()

执行结果：

2.内置方法

1）__del__方法
在python中，当使用类名()创建对象时，为对象分配完空间后，自动调用__init__
当一个对象被从内存中销毁前，会自动调用__del__方法
例：

class Dog():
    def __init__(self,dog_name):
        self.name = dog_name
        print '%s来了' % self.name
    def __del__(self):
        print '%s走了' % self.name

xixi = Dog('xixi')
print xixi.name

del xixi
print '*' * 50

执行如下：
销毁前自己调用

我们手动调用了之后就销毁了，最后不再自动调用

2）__str__方法
在python中，使用python输出对象变量
默认情况下，会输出这个变量引用的对象是由哪一个类创建的以及在内存中的地址(十六进制表示)
如果在开发中，希望使用print输出对象变量时，能够打印自定义的内容，就可以利用__str__ 这个内置方法了
例：

class Dog():
    def __init__(self,dog_name):
        self.name = dog_name

    def __str__(self):
        # 必须返回一个字符串
        return '我是%s' % self.name

xixi = Dog('xixi')
print xixi

执行结果：

3.面向对象的三大特征

1.封装

1）定义
封装是面向对象编程的一大特点
面向对象编程的第一步将属性和方法封装到一个抽象的类中
外界使用类创建对象，然后让对象调用方法
对象方法的细节都被封装在类的内部
根据职责把属性和方法封装在一个抽象的类中，定义类的准则

例1：xx爱跑步，体重是XX，每次跑步减轻0.5kg，每次吃东西增重1kg

class Person():
    def __init__(self,name,weight):
        self.name = name
        self.weight = weight
    def __str__(self):
        return '体重是%.2f'% self.weight
    def run(self):
        print '%s爱跑步' % self.name
        self.weight -= 0.5
    def eat(self):
        print '%s吃东西' % self.name
        self.weight += 1

lin = Person('llj',45.0)
lin.run()
lin.eat()
print lin

执行结果：
跑步，吃东西

吃东西

跑步

例2：摆放家具
摆放家具需求:
1.房子有户型，总面积和家具名称列表
新房子没有任何的家具
2.家具有名字和战地面积，其中
床：占4平米衣柜:占2平面餐
桌：占1.5平米
3.将以上三件家具添加到房子中
4.打印房子时,要求输出:户型，总面积，剩余面积，家具名称列表

# 定义家具类
class Furniture():
    def __init__(self,name,area):
        self.name = name
        self.area = area
    def __str__(self):
        return '%s占地%.2f平米' % (self.name,self.area)

# 定义房类
class House():
    def __init__(self,house_type,area):
        self.house_type = house_type
        self.area = area
        self.free_area = area
        self.list = []
    def __str__(self):
        return '户型：%s，总面积是%.2f，剩余面积：%.2f，家具列表：%s' % (self.house_type,self.area,self.free_area,self.list)
    def add(self,furniture):
        print '添加%s' % furniture
        # 判断家具面积
        if furniture.area > self.free_area:
            print '%s面积太大，不能添加' % furniture.name
            return
        # 添加家具
        self.list.append(furniture.name)
        # 计算剩余面积
        self.free_area -= furniture.area
# 创建家具对象
bed = Furniture('bed',4)
chest = Furniture('chest',2)
table = Furniture('table',110)


# 创建房对象
house = House('两室一厅',100)
house.add(bed)
house.add(chest)
house.add(table)
print house

执行结果：

如果家具面积太大，会提示：

例3：士兵开枪

# 定义枪类
class Gun():
    def __init__(self,model):
        # 枪的类型
        self.modle = model
        # 子弹数量
        self.bullet_count = 0
    # 添加子弹
    def add_bullet(self,count):
        self.bullet_count += count
    def shoot(self):
        if self.bullet_count <= 0:
            print '%s没有子弹了' % self.modle
            return
        # 发射子弹
        self.bullet_count -= 1
        # 提示发射信息
        print '%s 突突突 %d'% (self.modle,self.bullet_count)
# 定义士兵类
class Soldier():
    def __init__(self,name):
        self.name = name
        self.gun = None
    def fire(self):
        # 检查士兵是否有枪
        if self.gun == None:
            print '%s还没有枪' % self.name
            return
        # 喊口号
        print 'Go!!! %s' % self.name
        # 给枪装子弹
        self.gun.add_bullet(50)
        # 让枪发射子弹
        self.gun.shoot()

# 创建枪
gun = Gun('AK47')
# 创建士兵
alen = Soldier('Alen')
alen.gun = gun
alen.fire()

不装子弹执行结果：

装子弹执行结果：

2）私有属性和私有方法
私有属性，私有方法是对象的隐私，不能对外公开，外界不能直接访问和调用

class Women():
    # 在初始化方法中定义一个公有属性和私有属性
    def __init__(self,name):
        self.name = name
        self.__age = 18
    # 定义一个私有方法
    def __secret(self):
        print '%s的年龄是%d' % (self.name,self.__age)
# 在外界不能直接访问私有属性/调用私有方法
lily = Women('Lily')
lily.__secret()

执行结果：

定义一个公有方法，调用私有方法

class Women():
    def __init__(self,name):
        self.name = name
        self.__age = 18
    def __secret(self):
        print '%s的年龄是%d' % (self.name,self.__age)
    # 定义一个公有方法，调用私有方法
    def pub(self):
        self.__secret()
lily = Women('Lily')
lily.pub()

执行结果：

2.继承

1）单继承
一个子类只拥有一个父类，实现代码的重用，相同的代码不需要重复编写，子类继承父类的所有属性和方法，子类根据需要，封装自己特有的属性和方法
例：

# 创建动物类
class Animal():
    def eat(self):
        print '吃'
    def drink(self):
        print '喝'
    def sleep(self):
        print '睡'
    def run(self):
        print '跑'
# 创建狗类，继承动物类所有属性和方法
class Dog(Animal):
    # 定义它特有的方法
    def call(self):
        print '汪汪叫'

# 创建狗类对象，可调用动物类的方法
dog = Dog()
dog.call()
dog.drink()
dog.eat()
dog.run()
dog.sleep()

执行结果：

继承还有连续继承，A继承B，B继承C
例：

# 创建动物类
class Animal():
    def eat(self):
        print '吃'
    def drink(self):
        print '喝'
    def sleep(self):
        print '睡'
    def run(self):
        print '跑'
# 创建猪类，继承动物类
class Pig(Animal):
    # 定义它特有的方法
    def call(self):
        print '哼哼叫'
# 创建佩奇猪类，继承猪类
class pegga(Pig):
    # 定义它特有的方法
    def speak(self):
        print '说英语，hello'
# 创建佩奇类对象小猪佩奇
pig = pegga()
pig.speak()
pig.eat()
pig.call()

执行结果：

3）父类重写
覆盖：子类根据自己特有的需求，编写特定的代码
定义与父类相同的方法名称，然后重新编写代码

扩展：如果在开发中，子类的方法实现包含有父类的方法实现(父类原本封装的方法实现是子类方法的一部分就可以使用扩展方法)
先在子类中重写父类的方法
然后在需要的位置使用父类名方法(self)来调用父类方法的执行(使用父类名称调用父类方法)
代码其他的位置针对子类的需求，编写子类特有的代码实现
例1：覆盖

class Animal():
    def eat(self):
        print '吃'
    def drink(self):
        print '喝'
    def sleep(self):
        print '睡'
    def run(self):
        print '跑'

class Pig(Animal):
    def call(self):
        print 'hhhhh'

class pegga(Pig):
    def speak(self):
        print '说英语'
    # 定义与父类相同的方法名称，然后重新编写代码
    def call(self):
        print 'hello'
# 如果子类覆盖了父类的方法
# 调用时只调用子类重写的方法，不会调用父类的方法
pig = pegga()
pig.call()

执行结果：

例2：扩展

class Animal():
    def eat(self):
        print '吃'
    def drink(self):
        print '喝'
    def sleep(self):
        print '睡'
    def run(self):
        print '跑'

class Pig(Animal):
    def call(self):
        print 'hhhhh'

class pegga(Pig):
    def speak(self):
        print '说英语'
    def call(self):
        # 对父类方法进行重写
        print 'hello'
        # 调用父类方法
        Pig.call(self)
        print 'George'
pig = pegga()
pig.call()

执行结果：

4）多继承
子类可以拥有多个父类，并继承所有属性和方法
例子：

class A():
    def test(self):
        print 'A---test方法'

class B():
    def demo(self):
        print 'B---demo方法'
# 多继承可以让子类同时拥有多个父类的属性和方法
class C(A,B):
    def ccc(self):
        print 'ccccc'

class D(C):
    pass
d = D()
d.demo()
d.test()

当两个父类有相同的方法名，谁写在前面就调用谁

class A():
    def test(self):
        print 'A---test方法'
    def demo(self):
        print 'A---demo方法'

class B():
    def demo(self):
        print 'B---demo方法'
# 将A写在B前，同一方法名，会调用A类的方法
class C(A,B):
    def ccc(self):
        print 'ccccc'

class D(C):
    pass
d = D()
d.demo()
d.test()

执行结果：

5）父类的私有方法和私有属性
子类对象不能在自己方法内部，直接访问父类私有属性和私有方法
子类对象可以通过父类的公有方法间接访问到父类的私有属性和私有方法
私有属性，私有方法是对象的隐私，不能对外公开，外界以及子类都不能直接访问和调用
例：

class A(object):
    def __init__(self):
        # 在初始化方法中定义一个公有属性和私有属性
        self.num1 = 100
        self.__num2 = 200
    # 定义一个私有方法
    def __secret(self):
        print '%d 和 %d' % (self.num1,self.__num2)
class B(A):
    def test(self):
        # 在子类方法中，不能访问父类的私有属性
        print '访问父类私有属性%d' % self.__num2
        # 在子类方法中，不能调用父类的私有方法
        self.__secret()
        pass
b = B()
print b.num1
# 在外界不能直接访问父类的私有属性/调用私有方法
print b.__num2
b.__secret

执行结果：

定义共有方法，间接调用私有方法

class A(object):
    def __init__(self):
        # 在初始化方法中定义一个公有属性和私有属性
        self.num1 = 100
        self.__num2 = 200
    # 定义一个私有方法
    def __secret(self):
        print '%d 和 %d' % (self.num1,self.__num2)
    # 定义一个公有方法，调用私有方法
    def pub(self):
        print self.__num2
        self.__secret()
class B(A):
    def test(self):
        # 在子类方法中，调用公有方法，间接调用私有方法
        self.pub()
        pass
b = B()
print b.num1
# 在外界可以调用公有方法，间接调用私有方法
b.test()

执行结果：

3.多态

多态：不同的子类，对象调用相同的方法，产生不同的执行结果
在这里先将一个新式类和经典类的区别

新式类：class A() #新式类以object作为基类

经典类：class B()

多态例子：

class Cat(object):
    def __init__(self,name):
        self.name = name
    def play(self):
        print '%s在玩小皮球'% self.name

class Jiqimao(Cat):
    def play(self):
        print '%s带着竹蜻蜓飞'%self.name

class Person(object):
    def __init__(self,name):
        self.name = name
    def play_with_dog(self,cat):
        print '%s和%s快乐的玩'% (self.name,cat.name)
        cat.play()
# 创建一个猫对象
cat1 = Cat('小花生')
cat2 = Jiqimao('蓝胖子')
# 创建一个人对象
daxiong = Person('大雄')
# 人和猫玩
daxiong.play_with_dog(cat1)

cat1调用方法

cat2调用方法

4.类的结构

实例：
1.使用面向对象开发，第一步是设计类
2.使用 类名()创建对象，创建对象的步骤有两步
1）在内存中为对象分配空间
2）调用初始化方法__init__(self)为对象初始化
3.对象创建后，内存中就有了一个对象实实在在的存在

因此
创建出来的对象叫做类的实例
创建对象的动作叫实例化
对象的属性叫做实例属性
对象调用的方法叫做实例方法

在程序执行时：
1.对象各自拥有自己的实例属性
2.调用的方法，可以通过self访问自己的属性调用自己的方法
结论：
1.每一个对象都有自己独立的内存空间，保存各自不同的属性
2.多个对象的方法，在内存中之有一份，在调用方法时， 需要把对象的引用传递到方法内部

5.类属性和类方法

类是一个特殊的对象
Python中- -切皆对象
class AAA:定义的类属性属于类对象
obj1 =AAA:属于实例对象
在运行程序时，类同样会被加载到内存
在python中，类是一个特殊的对象–类对象
除了封装实例(对象)的属性和方法外，类对象还可以有自己的属性和左
通过类名，的方式可以直接访问类的属性或者调用类的方法
1）类属性： 就是针对类对象定义的属性
使用赋值语句在class关键字下方可以定义类属性类属性用于记录于这个类相关的特性

例：类属性

class Tool(object):
    # 使用赋值语句定义类属性
    count = 0
    def __init__(self,name):
        self.name = name
        # 让类属性的值加1
        Tool.count += 1
# 创建工具对象，会自动调用初始化方法
tool1 = Tool('铲子')
tool2 = Tool('斧头')
tool3 = Tool('钳子')
# 输出工具总数量，使用类名.属性名来获取
print Tool.count

执行结果：

2）类方法： 就是针对类对象定义的方法，在类方法内部就可以直接访问类属性或者调用其他类方法
语法如下：

class A():
    @classmethod
    def 类方法(cls):
        pass

例：类方法

class Toy(object):
    count = 0
    @classmethod
    def toy_count(cls):
        # 在类方法内部，访问当前的类属性
        print '玩具的数量是%d'% cls.count
    def __init__(self,name):
        self.name = name
        Toy.count += 1
# 创建玩具对象
toy1 = Toy('玩具熊')
toy2 = Toy('玩具车')
toy3 = Toy('遥控飞机')
# 调用类方法
Toy.toy_count()

执行结果：

6.静态方法

静态方法
在开发时，如果需要在类中封装一个方法，这个方法：
既不需要访问实例属性或调用实例方法
也不需要访问类属性或者调用类方法
则可以把它封装成一个静态方法

语法如下：

@staticmethod
def 静态方法():
    pass

静态方法需要通过修饰器@staticmethod来标示，
告诉解释器这是一个静态方法
通过类名，调用静态方法
例：

class Cat(object):
    # 用@staticmethod来告诉解释器这是一个静态方法
    @staticmethod
    def call():
        print '小猫喵喵叫'
# 不需要创建对象，直接调用
Cat.call()

执行结果：

7.综合应用

1.设计一个Game类
2.属性
记录游戏的历史最高分市记录当前游戏玩家的玩家姓名
3.方法
方法show_help显示游戏帮助信息
方法show_top_ score显示历史最高分方法start_game开始当前玩家的游戏
4.主程序步骤
1.查看帮助信息2.查看历史最高分
3.创建游戏对象，开始游戏

class Game(object):
    score = 10
    # 初始化方法
    def __init__(self, name):
        self.name = name

    # 创建一个静态方法
    @staticmethod
    def show_help():
        print '游戏帮助信息'

    # 创建一个类方法
    @classmethod
    def show_top_score(cls):
        print '最高记录为%d' % cls.score

    def start_game(self):
        print '玩家%s 开始游戏'%self.name

# 查看帮助
Game.show_help()
# 历史最高
Game.show_top_score()
# 创建玩家，开始游戏
person = Game('小明')
person.start_game()

执行结果：

案例小结;
1.实例方法:方法内部需要访问实例属性
2.类方法:方法内部只需要访问类属性
3.静态方法:方法内部不需要访问实例属性和类属性
提问:如果方法内部，既需要访问实例属性，又需要访问类属性，应该定义什么方法了

8.单例设计模式

1）
使用类名()创建对象时，python的解释器首先会调用
__new__方法为对象分配空间
__new__是一个由object 基类提供的内置的静态方法，主要有两个作用:
在内存中为对象分配空间
返回对象的引用
python的解释器获得对象的引用后，
将引用作为第一个参数，传递给__ init__方法
__new__ 负责给对象分配空间
__init__ ( 初始化方法)负责给对象初始化）

class MusicPlayer(object):
    def __new__(cls, *args, **kwargs):
    # 第一个参数cls：哪个类调用，就传递哪个类
    # 第二个参数*args:多值参数
    # 第三个参数**kwargs:多值的字典参数
    # 创建对象的时候，new方法会被自动调用
        print '创建对象 分配空间'
        instense = object.__new__(cls)
        return instense
    def __init__(self):
        print '播放器初始化'

player1 = MusicPlayer()
print player1

player2 = MusicPlayer()
print player2

执行结果：返回不同的内存地址

2）
只执行一次初始化工作
在每次使用类名()创建对象时，python的解释器都会自动调用两个方法
__new__分配空间
__init__对象初始化
但在上一小结中
new 方法改造之后，每次都会得到第一 次被创建对象的引用
但是:初始化方法还会被再次掉用
需求，让初始化方法只执行一次
例：

class MusicPlayer(object):
    instense = None
    music_flag = False
    def __new__(cls, *args, **kwargs):
        if cls.instense == None:
            cls.instense = object.__new__(cls)
        return cls.instense
    def __init__(self):
        if MusicPlayer.music_flag:
            return
        print '播放器初始化'
        MusicPlayer.music_flag = True
player1 = MusicPlayer()
print player1

player2 = MusicPlayer()
print player2

执行结果：返回相同的内存地址