Python之面向对象

一、面向对象

面向对象三大特征:
1.封装：根据职责将属性和方法封装到一个抽象的类中
2.继承：实现代码的重用，相同的代码不需要重复的编写
3.多态:(以封装和继承为前提)，不同的子类对象调用相同的方法，产生不同的执行结果

1、面向过程：—侧重于怎么做？

1.把完成某一个需求的 所有步骤 从头到尾 逐步实现
2.根据开发要求，将某些功能独立的代码封装成一个又一个函数
3.最后完成的代码，就是顺序的调用不同的函数

特点：

1.注重步骤与过程，不注重职责分工
2.如果需求复杂，代码会变得很复杂
3.开发复杂项目，没有固定的套路，开发难度很大

2、面向对象：–谁来做?

相比较函数，面向对象是更大的封装，根据职责在一个对象中封装多个方法
1.在完成某一个需求前，首先确定职责–要做的事(方法)
2.根据职责确定不同的对象，在对象内部封装不同的方法(多个)
3.最后完成代码，就是顺序的让不同的对象调用不同的方法

特点：

1.注重对象和职责，不同的对象承担不同的职责
2.更加适合对复杂的需求变化，是专门应对复杂项目的开发，提供的固定套路
3.需要在面向过程的基础上，再学习一些面向对象的语法

3、熟悉面向对象编程： python java c++

面向过程和面向对象，是两种不同的编程方式

类的设计
1.类名 这类事物的名字，满足大驼峰命名法
    大驼峰命名法
        每一个单词的首字母大写
        单词与单词只见没有下划线
2.属性 这个类创建出的对象有什么样的特征
3.方法 这个类创建出的对象有什么样的行为

二、类的基础知识

1、self用法

self:哪一个对象调用的方法，self就是哪一个对象的引用
在方法内部：可以通过self.访问对象的属性
在方法内部：可以通过self.调用其他的对象方法

class Cat:
    def eat(self):
        print '%s爱吃鱼' %self.name
    def drink(self):
        print '小猫要喝水'


# 创建猫对象
tom = Cat()
# 可以使用 .属性名 利用赋值语句就可以了
#tom.name = 'Tom'
tom.eat()
tom.name = 'Tom'
tom.drink()
print tom

2、初始化方法

初始化方法:init 是python对象的内置方法
__init__方法是专门用来定义一个类具有哪些属性和方法的

class Cat:
    def __init__(self,new_name): # 与函数一样
        print '这是一个初始化方法'
        # self.属性名= 属性的初始值
        #self.name = 'Tom'
        self.name = new_name
    # 在类中 任何方法都可以使用这个self.name
    def eat(self):
        print '%s 爱吃鱼' %self.name
# 并没有调用__init__方法
# 使用类名()创建对象的时候，会自动调用初始化方法__init__
tom = Cat('Tom')
# 在__init__方法的内部使用 self.属性名= 属性的初始值 定义对象的属性
# 定义属性之后，再使用Cat类创建对象，都会拥有该属性
print tom.name
tom.eat()

lazy_cat=Cat('Lazy_cat')
lazy_cat.eat()

3、内置方法

__del__方法：对象被从内存中销毁前，会自动调用
__str__方法：返回对象的描述信息 print 对象

__del__方法：

在python中，当一个对象被从内存中销毁前(把这个对象从内存中删除掉)，会自动调用__del__方法
应用场景：
__del__如果希望在对象被销毁前，再做一些事情，可以考虑一下__del__方法

__str__方法：
在python中，使用python输出对象变量，默认情况下，会输出这个变量引用的对象是由哪>一个类创建的对象，以及在内存中的地址(十六进制表示)
如果在开发中，希望使用print输出对象变量时，能够打印自定义的内容，就可以利用__str__这个内置方法了
"""
class Cat:
    def __init__(self,new_name):
        self.name = new_name
        print '%s 来了' %self.name
    def __del__(self):
        print '%s 走了' %self.name
    def __str__(self):
        # 必须返回一个字符串
        return '我是 %s' %self.name

# tom是一个全局变量
# 所以当我们的代码全部执行完之后，系统才会把tom这个对象进行回收
tom = Cat('Tom')
print tom
# print tom.name
# # del关键字，可以从内存中删除一个对象，del关键字自己调用了__del__方法
# del tom
# print '*' * 50

4、私有属性和私有方法

应用场景及定义方式
应用场景
	在实际开发中，对象的某些属性或方法可能只希望在对象的内部使用，而不希望在外部被访问到
	私有属性 就是 对象 不希望公开的 属性
	私有方法 就是 方法 不希望公开的 方法
定义方法
	在定义属性或方法时，在属性名或者方法名前增加两个下划线，定义的就是私有属性或方法

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')
print lily.name
# 私有属性，外界不能直接访问
#print lily.age
# 私有方法，外界不能直接调用
lily.secret()

三、封装（面向对象三大特征之一）

封装

1.封装是面向对象编程的一大特点
2.面向对象编程的第一步 将属性和方法封装到一个抽象的类中(为什么说是抽象的，因为类不能直接使用)
3.外界使用类创建对象，然后让对象调用方法
4.对象方法的细节都被封装在类的内部

1、案例一

需求
1.小明体重75.0公斤
2.每次跑步会减肥0.5公斤
3每次吃东西体重会增加1公斤
4.小美的体重是45.0公斤
"""
class Person:
    def __init__(self,name,weight):
        # 初始化方法中增加两个参数由外界传递
        # self.属性 = 形参
        self.name = name
        self.weight = weight
    def __str__(self):
        return '我的名字叫 %s 体重是 %.2f' %(self.name,self.weight)
    def run(self):
        print '%s 爱跑步' %self.name
        # 在对象方法的内部，是可以直接访问对象的属性
        self.weight -= 0.5
    def eat(self):
        print '%s 吃东西' %self.name
        self.weight += 1

xx = Person('小明',75.0)
xx.run()
xx.eat()
print xx

# 同一个类创建出来的多个对象之间，属性互不干扰
xm = Person('小美',45.0)
xm.run()
xm.eat()
print xm
print xx

2、案例2：摆放家具

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

被使用的类应该先开发
"""


class HouseItem:
    # 初始化方法
    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.item_list = []

    def __str__(self):
        return '户型:%s\n总面积:%.2f[剩余:%.2f]\n家具:%s' \
               % (self.house_type, self.area, self.free_area, self.item_list)

    def add_item(self, item):
        print '要添加 %s' % item
        """
        1.判断家具的面积是否超过房子的面积，如果超过了，提示不能添加这个家具
        2.将 家具的名称 追加到 家具名称列表中去
        3.用 房子的剩余面积 - 家具的面积
        """
        if item.area > self.free_area:
            print '%s 的面积太大了，无法添加' %item.name
            # 如果不满足，下方的代码就不执行
            return
        # 将家具的名称添加到列表中
        self.item_list.append(item.name)
        # 计算剩余面积
        self.free_area -= item.area

# 1.创建家具
bed = HouseItem('bed', 400)
print bed
chest = HouseItem('chest', 2)
print chest
table = HouseItem('table', 1.5)
print table

#2.创建房子对象
my_home = House('两室一厅',60)
# 添加家具到房子里面去
my_home.add_item(bed)
my_home.add_item(chest)
my_home.add_item(table)
print my_home

3、案例3：

"""
需求：
1.士兵瑞恩有一把AK47
2.士兵可以开火(士兵开火扣动的是扳机)
3.枪 能够 发射子弹(把子弹发射出去)
4.枪 能够 装填子弹 --增加子弹的数量
"""

Soldier                     Gun
-------------               -----------------
name                        model
gun                         bullet_count #子弹数量足够多才能完成射击的动作
-------------               -----------------
__init__(self):		    __init__(self):
fire(self):                 add_bullet(self,count):#装填子弹的方法
			    shoot(self):

#练习重点：一个对象的属性可以是另外一个类创建的对象
"""


class Gun:
    def __init__(self, model):
        # 枪的型号
        self.model = model
        # 子弹的数量(调用装填子弹的方法来增加子弹的数量)
        self.bullet_count = 0

    def add_bullet(self, count):
        self.bullet_count += count

    def shoot(self):
        # 1.判断子弹的数量
        if self.bullet_count <= 0:
            print '[%s] 没有子弹了...' % self.model
            return
            # 2.发射子弹，子弹的数量-1
        self.bullet_count -= 1
        # 3.提示发射信息
        print '[%s] 突突突...[%d]' %(self.model,self.bullet_count)


class Soldier:
    def __init__(self,name):
        self.name = name
        """
        在定义属性的时候，如果不知道设置什么初始值，可以设置为None
        None表示什么都没有
        表示一个空对象，没有方法和属性，是一个特殊的常量
        可以将None赋值给任何一个变量
        """
        self.gun = None
    def fire(self):
        # 1.判断士兵是否有枪
        if self.gun == None:
            print '[%s] 还没有枪' %self.name
            return
        print 'go!!! [%s]' %self.name
        # 士兵让枪装填子弹
        self.gun.add_bullet(50)
        # 士兵让枪发射子弹
        self.gun.shoot()


# 1.创建枪对象
ak47 = Gun('AK47')
# ak47.add_bullet(50)
# ak47.shoot()

# 2.创建士兵对象
ryan = Soldier('Ryan')
ryan.gun = ak47
ryan.fire()
#print ryan.gun

四、封装（面向对象三大特征之二）

继承:实现代码的重用，相同的代码不需要重复的写

继承的概念:子类拥有父类的所有属性和方法

class 类名(父类)：
def 子类特有的方法

Cat类是Animal类的子类，Animal类是Cat类的父类，Cat从Animal类继承
Cat类是Animal类的派生类，Animal类是Cat类的基类，Cat类从Animal类派生

1、单继承

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

class Cat(Animal):
    # 子类拥有父类的所有属性和方法
    def call(self):
        print '喵喵'
class Dog(Animal):
    def bark(self):
        print '旺旺'
class Hellokitty(Cat):
    def speak(self):
        print '我可以说日语'

# 创建一个猫对象
fentiao = Cat()
fentiao.eat()
fentiao.drink()
fentiao.run()
fentiao.sleep()
fentiao.call()

# 创建一个hellokitty对象
# kt = Hellokitty()
# kt.speak()
# kt.call()

# 继承的传递行，子类拥有父类的父类的属性和方法
"""
继承的传递性：（爷爷 父亲 儿子）
1.C类从B类继承，B类又从A类继承
2.那么C类就具有B类和A类的所有属性和方法
子类拥有父类以及父类的父类中封装的所有属性和方法
"""
kt.eat()
kt.drink()
kt.run()
kt.sleep()

# 子类继承自父类，可以直接享受父类中已经封装好的方法
# 子类中应该根据自己的职责，封装子类特有的属性和方法

重写父类

重写父类方法
    1.覆盖父类的方法
    2.扩展父类的方法
"""
class Animal:
    def eat(self):
        print '吃'
    def drink(self):
        print '喝'
    def run(self):
        print '跑'
    def sleep(self):
        print '睡'


class Cat(Animal):
    # 子类拥有父类的所有属性和方法
    def call(self):
        print '喵喵'

class Hellokitty(Cat):
    def speak(self):
        print '我可以说日语'
    def call(self):
        # 针对子类特有的需求，编写代码
        print '欧哈有～空你起哇'
        # 调用原本在父类中封装的代码
        Cat.call(self)
        # 增加其他的子类代码
        print '#!@$@!#!#'
kt = Hellokitty()
# 如果子类中，重写了父类的方法
# 在运行中，只会调用在子类中重写的父类的方法而不会调用父类的方法
kt.call()

class Bird:
    def __init__(self):
        self.hungry = True
    # 鸟吃过了以后就不饿了
    def eat(self):
        if self.hungry:
            print 'Aaaaahhh...'
            self.hungry = False
        else:
            print 'No thanks'

class SongBird(Bird):
    def __init__(self):
        self.sound = 'Squawk!'
        Bird.__init__(self)
    def sing(self):
        print self.sound

littlebird = SongBird()
littlebird.eat()
littlebird.sing()

2、多继承

class A:
    def test(self):
        print 'A-----test 方法'
    def demo(self):
        print 'A-----demo 方法'
class B:
    def test(self):
        print 'B------test 方法'
    def demo(self):
        print 'B-------demo方法'
class C(B,A):
    """多继承可以让子类对象，同时具有多个父类的属性和方法"""
    pass

# 创建子类对象
c = C()
c.test()
c.demo()

4、图书管理系统

"""
 图书管理系统
   图书管理系统
                    1. 查询
                    2. 增加
                    3. 借阅
                    4. 归还
                    5. 退出
"""
class Book(object):
    def __init__(self, name, author, state, bookIndex):
        self.name = name
        self.author = author
        # 0:借出 1：未借出
        self.state = state
        self.bookIndex = bookIndex

    # 打印对象时自动调用;str(对象)
    def __str__(self):
        return "书名:<%s> 状态:<%s>" % (self.name, self.state)


class BookManage(object):
    books = []

    def start(self):
        """图书管理初始化"""
        b1 = Book('python', 'Guido', 1, "INS888")
        self.books.append(b1)
        self.books.append(Book('java', 'hello', 1, "IGS888"))
        self.books.append(Book('c', 'westos', 1, "INS880"))

    def Menu(self):
        self.start()
        while True:
            print("""
                        图书管理系统
                    1. 查询
                    2. 增加
                    3. 借阅
                    4. 归还
                    5. 退出

             """)

            choice = input("Choice:")
            if choice == "1":
                pass
            elif choice == '2':
                self.addBook()
            elif choice == '3':
                self.borrowBook()
            else:
                print("清输入正确的选择!")

    def addBook(self):
        name = input("书名：")
        self.books.append(Book(name, input("作者:"), 1, input("书籍位置:")))
        print("添加图书%s成功!" % (name))

    def borrowBook(self):
        name = input("借阅书籍名称:")
        ret = self.checkBook(name)
        if ret != None:
            if ret.state == 0:
                print("书籍《%s》已经借出" % (name))
            else:
                ret.state = 0
                print("借阅%s成功" % (name))
        else:
            print("书籍《%s》不存在!" % (name))

    def checkBook(self, name):
        """查找书籍是否存在"""
        for book in self.books:
            # book: Book类创建的对象
            # book.name;
            if book.name == name:
                # 返回book对象
                return book
        else:
            return None

bookManage = BookManage()
bookManage.Menu()

五、多态（面向对象三大特征之三）

1、多态概念：

(以封装和继承为前提)，不同的子类对象调用相同的方法，产生不同的执行结果

2、案例：

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

    def game(self):
        print '%s 蹦蹦跳跳的玩..' % self.name


class Xiaotiandog(Dog):
    # 父类方法不能满足子类的方法，重写game方法
    def game(self):
        # 在使用继承时，子类拥有父类的所有属性和方法
        print '%s 飞到天上玩...' % self.name


class Person(object):
    def __init__(self, name):
        self.name = name

    def game_with_dog(self, dog):
        print '%s 和 %s 快乐的玩耍' % (self.name, dog.name)
        # 让狗玩耍
        dog.game()

# 1.创建一个狗对象
#wangcai = Dog('旺财')
wangcai = Xiaotiandog('旺财')
# 2.创建一个小明对象(小明是一个人)
xiaoming=Person('小明')
# 3.让小明调用和狗玩的方法(把之前创建的狗对象传递进去)
xiaoming.game_with_dog(wangcai)
"""
案例小结：
Person类中只需要让狗对象调用game方法(这是子类的父类中封装的方法)，而不关心具体是什么狗
	game方法是在Dog父类中定义的
在程序执行时，传入不同的狗对象的实参，就会产生不同的执行效果
"""

六、类属性

一切皆对象
类是一个特殊的对象---类对象
在程序运行的时候，类对象(创建实例对象的模板)在内存中只有
一份，通过它可以创建出和很多个对象实例
除了封装实例的属性和方法外，类对象还可以拥有自己的==属性==和==方法==

通过 类名. 的方式可以直接访问类的属性

类属性：使用赋值语句在class关键字下可以定义类属性
类属性用于记录与这个类相关的特性

class Tool(object):
    # 1.使用赋值语句定义类属性，记录所有工具的数量
    count = 0

    def __init__(self, name):
        self.name = name
        # 让类属性+1
        Tool.count += 1
# 创建工具对象
tool1 = Tool('斧头')
tool2 = Tool('榔头')

# 输出工具对象的总数
# 使用 类名.属性名 来获取
print Tool.count

七、类方法

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

class Toy(object):
    # 使用赋值语句定义类属性，记录所有玩具的数量
    count = 0

    @classmethod
    def show_toy_count(cls):
        # cls.count 在类方法内部，访问当前的类属性
        print '玩具对象的数量 %d' % cls.count

    def __init__(self, name):
        self.name = name
        # 让类属性+1
        Toy.count += 1

#创建玩具对象
toy1 = Toy('乐高')
toy2 = Toy('玩具熊')

#调用类方法
Toy.show_toy_count()

八、静态方法

静态方法
在开发的时候，如果需要在类中封装一个方法，这个方法
即不需要访问实例属性或者调用实例方法
也不需要访问类属性或者调用类方法
这个时候，我们就可以把这个方法封装成一个静态方法

class Cat(object):
    # 不访问实例属性/类属性
    @staticmethod
    def call():
        print '喵喵～'
# 通过 类名. 调用静态方法
Cat.call()
# 不需要创建对象，直接就可以使用

练习：

1.设计一个Game类
2.属性
	定义一个类属性top_score记录游戏的历史最高分(与这个游戏有关，每次游戏的时候与游戏最高分无关)
	定义一个实例属性player_name记录当前游戏玩家的玩家姓名
3.方法：
	静态方法show_help显示游戏帮助信息(即不需要访问类属性，也不需要访问实例熟悉)
	类方法show_top_score显示历史最高分(访问类属性)
	实例方法start_game开始当前玩家的游戏

1.查看帮助信息
2.查看历史最高分
3.创建游戏对象，开始游戏
"""


class Game(object):
    # 1.历史最高分
    top_score = 0

    # 实例属性在初始化方法内部定义
    def __init__(self, player_name):
        self.player_name = player_name

    @staticmethod
    def show_help():
        print '帮助信息：$@$@$@#$@'

    @classmethod
    def show_top_score(cls):
        print '历史记录 %d' % cls.top_score

    def start_game(self):
        print '%s 开始游戏啦' % self.player_name

# 1.查看帮助信息
Game.show_help()
# 2.查看历史最高分
Game.show_top_score()
# 3.创建游戏对象，开始游戏
game = Game('小明')
game.start_game()

"""
案例小结：
1.实例方法--方法内部需要访问实例属性
	实例方法内部可以使用 类名. 访问类属性
2.类方法：方法内部“只”需要访问类属性
3.静态方法：方法内部，不需要访问实例属性和类属性

提问：
如果方法内部 即需要访问实例属性，又需要访问类属性，应该定义什么方法?
答案：
应该定义实例方法
因为，类只有一个，在实例方法内部可以使用类名，访问类属性
"""