Linux---python中的封装（内置方法，初始化方法），继承

 

面向对象中：哪一个对象调用的方法，self就是哪一个对象的引用

在类封装的方法内部，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.drink()

 

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

__del__方法：

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

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

class Cat:
    def __init__(self,new_name):   ##__init__ 是python对象的内置方法
        self.name = new_name
        print '%s 来了' %self.name
    def __del__(self):
        print '%s 走了' %self.name
    def __str__(self):   ##返回对象的描述信息 print 对象
        # 必须返回一个字符串
        return '我是 %s' %self.name

# tom是一个全局变量
# 所以当我们的代码全部执行完之后，系统才会把tom这个对象进行回收
tom = Cat('Tom')
print tom
# print tom.name

# # del关键字，可以从内存中删除一个对象，del关键字自己调用了__del__方法
# del tom
# print '*' * 50

"""
生命周期
一个对象从调用类名()创建，声明周期开始
一个对象的__del__方法一旦被调用，生命周期就结束
在对象的生命周期内，可以访问对象的属性，调用对象的方法
"""

 

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

初始化方法
我们现在已经知道了使用 类名() 就可以创建一个对象
当使用类名()创建对象时，python的解释器会自动执行以下操作：
    1.为对象在内存中分配空间--创建对象
    2.调用初始化方法为对象的属性设置初始值--初始化方法(__init__)
这个初始化方法就是__init__方法，__init__是对象的内置方法
__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()

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

###########################################

封装
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：摆放家具
需求：
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：

需求：
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.C类从B类继承，B类又从A类继承
2.那么C类就具有B类和A类的所有属性和方法
子类拥有父类以及父类的父类中封装的所有属性和方法
##
kt.eat()
kt.drink()
kt.run()
kt.sleep()

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

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 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.覆盖父类的方法
    2.扩展父类的方法

class Animal:
    def eat(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()

 

###多继承###

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

注意：当多继承时，子类括号中谁在前面就调用谁的方法

###新式类和旧式类###
新式类和旧式(经典)类：
object是Python为所有对象提供的基类，提供有一些内置的属性和方法，可以使用dir函数查看
新式类：以object为基类的类，推荐使用
经典类：不以object为基类的类，不推荐使用
在python3.X中定义的类时，如果没有指定父类，会默认使用object作为基类--python3.x中定义的类都是新式类
在python2.x中定义类时，如果没有指定父类，则不会以object作为基类
####推荐使用新式类#############

新式类和旧式类在多继承时---会影响到方法的搜索顺序

为保证编写的代码能够同时在python2.x和python3.x运行
今后在定义类时，如果没有父类，建议统一继承自object

 

###继承（私有属性和私有方法）###
 类的私有属性和私有方法
1.子类对象不能在自己的方法内部，直接访问父类的私有属性和私有方法
2.子类对象可以通过父类的公有方法间接访问到私有属性或私有方法
私有属性，私有方法是对象的隐私，不对外公开，外界以及子类都不能直接访问
私有属性，私有方法常用做一些内部的事情

class A:
    def __init__(self):
        # 在初始化方法中定义两个属性，一个公有属性一个私有属性
        self.num1 = 100
        self.__num2 = 200

    def __test(self):
        print '私有方法 %d %d' % (self.num1, self.__num2)

    def test(self):
        print '父类的共有方法 %d' % self.__num2
        self.__test()

class B(A):
    def demo(self):
        # # 在子类的对象方法中，不能访问父类的私有属性
        # print '访问父亲的私有属性 %d' % self.__num2
        # # 在子类对象的方法中，不能调用父类的私有方法
        # self.__test()
        #调用父类的共有方法
        self.test()

# 创建一个子类对象
b = B()
b.demo()
# b.test()
# 在外界不能直接访问对象的私有属性/调用私有方法
# print b.__num2
# b.__test()

###在此可以看出，要显示访问对象的私有方法或属性时，可以建立共有方法后，将私有方法添加进去，最后直接调用共有方法即可###

###综合练习（ 图书管理系统）###
 图书管理系统功能：
                    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()