Python5(面向对象)

1,面向对象的基本概念
我们之前学习的编程方式就是面向过程的
面向过程和面向对象，是两种不同的编程方式
对比面向过程的特点，可以更好的了解什么是面向对象

过程和函数(都是对一段功能的代码进行封装)
过程：是早期的一个编程概念
过程类似于函数，只能执行，但是没有返回值
函数：不仅能执行，还可以返回结果(return)

面向对象的两个核心概念

类：是对一群具有相同特征或行为的事物的一个统称，是抽象的，不能直接使用(就好比，飞机图纸不能直接飞上天)
特征:被称为属性
行为:被称为方法
类 就相当于制造飞机时的图纸，是一个模板，是负责创建对象的

对象：是由类创建出来的一个具体的存在，可以直接使用(图纸创造出来的飞机，可以飞上天)
由哪一个类创建出来的对象，就拥有哪一个类种法定义的属性和方法
“对象就相当于用图纸创造出来的飞机”

在程序开发中，应该先有类，再有对象

类和对象的关系
类是模板，对象是根据类这个模板创建出来的，应该先有类，再有对象
类只需要有一个 而对象可以有很多个（一张图纸可以造出很多架飞机）
不同对象之前属性可以不相同(比如飞机的颜色 等等。。)
类中定义了什么属性和方法，使用这个类创建出来的对象中就有什么属性和方法，不可能多也不可能少。
1.类名：满足这类事物的名字(大驼峰命名法)
大驼峰命名法：
1.每个单词的首字母大写
2.单词与单词之间没有下划线
2.属性:这个类创建出来的对象有什么样的特征
3.方法：这个类创建出来的对象有什么样的行为
类名的确定：
名词提炼法:分析整个业务流程，出现的名词，通常就是找到的类名
2. 类和对象的基本语法
面向对象的基本语法：
定义一个只包含方法的类

class 类名：
    def 方法1(self,参数列表):
        pass
    def 方法2(self,参数列表):
        pass

方法的定义格式和之前学的函数几乎一样
区别在于第一个参数必须是self
1)例如：小猫爱吃鱼，小猫要喝水
创建类和方法

class Cat:
    def eat(self):
        print '小猫爱吃鱼'
    def drink(self):
        print '小猫爱喝水'

创建对象
当一个类定义完成之后，要使用这个类来创建对象
对象变量 = 类名()

tom = Cat()
tom.drink()
tom.eat()

在面向对象开发中，引用的概念是同样适用的
tom = Cat():在等号右侧我们使用cat类创建了一个猫对象，在等号左侧使用tom这个变量接收了这个猫对象
python解释器在执行到此句代码的时候，在内存中为这个猫对象分配了一个内存空间，然后再让tom这个变量记录了猫对象在内存中的地址
在python中使用类创建对象之后，tom变量中仍然记录的是对象在内存中的地址
也就是tom变量引用了新建的猫对象
使用print输出对象变量，默认情况下，是能够输出这个变量引用的对象是由哪一个类创建的象，以及在内存中的地址(十六进制表示)
提示：在计算机中，通常使用十六进制表示内存地址

tom = Cat()
tom.eat()
tom.drink()
print tom
addr = id(tom)
print addr
# %x:打印格式为十六进制
print '%x' %addr
# %d:打印格式为十进制
print '%d' %addr

lazy_cat = Cat()
lazy_cat.drink()
lazy_cat.eat()
print lazy_cat
# 两个对象的内存地址不一样，
# 我们就断定这两只猫是不同的猫

3.self的内存地址和tom/lazy_cat这个对象的内存地址是一样
哪一个对象调用的方法，self就是哪一个对象的引用
self:
在调用方法的时候，程序员不需要传递self参数(但是定义的时候，第一个参数必须是self)
在方法内部：可以通过self.访问对象的属性
1)例如:

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

# tom = Cat()
# # 给tom对象添加一个属性
# tom.name = 'Tom'
# tom.eat()
# tom.drink()
# print tom
#
# lazy_cat = Cat()
# # 给lazy_cat对象添加一个属性
# lazy_cat.name = 'lazy'
# lazy_cat.eat()
# lazy_cat.drink()
# print lazy_cat

在日常开发中，不推荐在类的外部给对象增加属性,如果在运行的时候，没有找到属性，程序就报错,对象应该包含有哪些属性，应该封装在类的内部

tom = Cat()
tom.eat()
tom.drink()
##此时没有定义name的属性,程序就会报错

4,初始化方法
初始化方法：
类名() 就可以创建一个对象
当使用类名()创建对象的时候，python解释器会自动执行以下操作
1.为对象在内存中分配空间 —创建对象
2.调用初始化方法

class Cat:
    def __init__(self):
        print '这是一个初始化方法!'
#使用类名创建对象的时候,会自动调用初始化方法__inin__(self)
tom=Cat()

改造初始化方法–初始化的同时设置初始值：
在开发中，如果希望在创建对象的同时，就设置对象的属性，可以对init方法进行改造
1.把希望设置的属性值，定义成init方法的参数
2.在方法内部使用self.属性名 = 形参 接收外部传递的参数
3.在创建对象时，使用类名(属性1，属性2..)调用

class Cat:
    def __init__(self,name):
        self.name=name
    def eat(self):
        print '%s爱吃鱼'%self.name
#在类的任何方法中都可以使用self.name
tom=Cat('tom')
print tom.name
tom.eat()

5.内置方法和属性
del方法：对象被从内存中销毁前，会被自动调用
str方法：如果在开发中，希望使用print输出对象变量时
能够自定义打印的内容

class Cat(object):
    def __init__(self,name):
        self.name=name
        print '欢迎%s光临'%self.name
    def __del__(self):
        print '欢迎%s下次再来'%self.name
tom=Cat('tom')
del tom 
print '*****'

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

str方法:

class Cat:
    def __init__(self,name):
        self.name=name
    def __str__(self):
        return '我的名字是%s' %self.name
        ### 必须返回一个字符串
tom=Cat('tom')
print tom

del方法：对象被从内存中销毁前，会被自动调用
str方法：返回对象的描述信息，print函数输出使用

del方法：
在python中
当使用类名()创建对象时，为对象分配完空间后，自动调用init方法
当一个对象被从内存中销毁前(把这个对象从内存中删除掉)，会自动调用del方法
应用场景
init改造初始化方法，可以让创建对象更加灵活
del如果希望在对象被销毁前，再做一些事情，可以考虑一下del方法

生命周期(出生到死亡)
一个对象从调用类名()创建，生命周期开始
一个对象的del方法一但被调用，生命周期结束
在对象的生命周期内，可以访问对象属性，或者让对象调用方法

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

6.私有属性和方法
应用场景
在实际开发中，对象的某些属性或方法可能只希望在对象的内部使用，而不希望在外部被访问到
私有属性 就是 对象 不希望公开的 属性
私有方法 就是 对象 不希望公开的 方法

class Women:
    def __init__(self,name):
        self.name=name
        self.__age=18
        ##定义私有属性
    def __secret(self):
        ##定义私有方法
        print '%s的年龄是%d'%(self.name,self.__age)

tom=Women('tom')
##此时在外部无法访问私有属性和方法

7.封装
1).封装是面向对象编程的一大特点
2).面向对象编程的第一步，将属性和方法封装到一个抽象的类中
3).外界使用类创建对象，然后让对象调用方法
4).对象方法的细节都被封装在类的内部
例1:
小明和小美爱跑步
1.小明体重75.0公斤
小美体重45.0公斤
2.小明每次跑步会减肥0.5公斤
3.小明每次吃东西体重会增加1公斤

class Person:
    def __init__(self,name,weight):
        self.name=name
        self.weight=weight
    def __str__(self):
        return '%s的体重是%.2f'%(self.name,self.weight)
    def run(self):
        self.weight-=0.5
    def eat(self):
        self.weight+=1
xiaoming=Person('小明',75.0)
xiaoming.eat()
xiaoming.run()
print xiaoming

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

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

剩余面积：
1.在创建房子对象的时候，定义一个剩余面积的属性，初始值和总面积相等
2.在调用添加家具的方法时，让 剩余面积 -= 家具的面积

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, housetype, area):
        self.housetype = housetype
        self.area = area
        self.free_area = area
        self.item_list = []

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


desk = HouseItem('desk', 20)
print desk
chair = HouseItem('chair', 10)
print chair

house = House('两室一厅', 100)
house.add_item(desk)
house.add_item(chair)
print house

小结：
1.主程序只负责创建房子对象和家具对象
2.让 房子 对象调用add_item 方法 将家具添加到房子中
3.面积计算，剩余面积，家具列表 等处理都被封装到房子类的内部
例3
一个对象的属性可以是另外一个类创建的对象
示例:士兵射击
需求：
1.士兵瑞恩有一把AK47
2.士兵可以开火(士兵开火扣动的是扳机)
3.枪 能够 发射子弹(把子弹发射出去)
4.枪 能够 装填子弹 –增加子弹的数量

class Gun:
    def __init__(self, type):
        self.type = type
        self.bullet_count = 0
     # 子弹的数量
    def add_bullet(self, count):
        self.bullet_count += count
# 只要子弹的数量足够，就能发射，所以shoot方法不需要传递参数
    def shoot(self):
        if self.bullet_count <= 0:
            print '没有子弹了!' % self.type
            return
        self.bullet_count -= 1
        print '%s突突突...剩余[%d]' % (self.type, self.bullet_count)


class Soldier:
    def __init__(self, name):
        self.name = name
        self.gun = None
# 定义属性的时候，如果不知道设置什么初始值，可以设置为None
# None关键字表示什么都没有，表示一个空对象，没有方法和属性
# 是一个特殊的常量，可以将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()


ak = Gun('AK47')
ryan = Soldier('Ryan')
ryan.gun =ak
ryan.fire()
print ryan.gun

8.继承
继承：实现代码的重用，相同的代码不需要重复的写
单继承
1.继承的概念：子类拥有父类的所有属性和方法(子类只需要封装自己特有的方法)
2.语法

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

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 '喵喵～'

fentiao = Cat()
fentiao.eat()
fentiao.drink()
fentiao.run()
fentiao.sleep()
fentiao.call()
# 子类继承自父类，可以直接享受父类中已经封装好的方法

多继承
子类拥有一个父类叫作单继承
子类可以拥有多个父类，并且具有所有父类的属性和方法
例如:孩子会继承自己父亲和母亲的特征

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

继承的传递性(爷爷 爸爸 儿子)
1.C 类从B类继承 ，B类又从A类继承
2.那么C类就具有B类和A类的所有属性和方法

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 '我可以说日语'

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

# 继承的传递性 子类拥有父类的父类的属性和方法
kt.eat()
kt.drink()
kt.sleep()
kt.run()

方法的重写
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):
        # 1.针对子类特有的需求，编写代码
        print '欧哈呦～空你起哇'
        # 2.调用原本子阿父类中封装的方法
        Cat.call(self)
        #3.增加其他子类代码
        print '@$@!$#@!$!#'
kt =Hellokitty()
# 如果子类中，重写了父类的方法
# 在运行中，只会调用在子类中重写的方法而不会调用父类的方法
kt.call()

继承的完整性

class Bird:
    def __init__(self):
        self.hungry=True
    def eat(self):
        if self.hungry:
            print '饿了....'
            self.hungry=False
        else:
            print '我不饿...'
class SongBird(Bird):
    def __init__(self):
        self.sound='Squake!'
        Bird.__init__(self)
       ## 不调用会出现找不到对象的错误
    def sing(self):
        print self.sound
bird=Bird()
bird.eat()

bird2=SongBird()
bird2.eat()
bird2.sing()

9.私有属性和私有方法

class A(object):
    def __init__(self):
        self.num1 = 100
        # 定义私有属性
        self.__num2 = 200
    def __text(self):
        print '私有方法 %d %d' %(self.num1,self.__num2)
    def test(self):
        print '父类的私有方法 %d' %self.__num2
        self.__text()

class B(A):
    def demo(self):
        # 在子类的对象方法中，不能访问父类的私有属性
        #print '访问父类的私有属性 %d' %self.__num2
        # 在子类的对象方法中，不能调用父类的私有方法
        #self.__test()
        print '子类方法 %d' %self.num1
        self.test()
# 创建一个子类对象
b = B()
print b
# 在子类方法的内部能访问父类的公有属性和调用父类的公有方法
b.demo()
# 在外界访问父类的公有属性和调用公有方法
print b.num1
# 在外界不能直接访问对象的私有属性/调用私有方法
# print b.__num2
# b.__test()