python ----面向对象

一、面向对象两个核心概念：

1.     类：是一群具有相同特征或形为的事物的一个统称，类是抽象的，不能直接使用
2.     对象：由类创造出来的具体存在
3.     在开发中，应该先有类，再有对象

类和对象的关系：

1.     类是模板，对象是根据这个模板创建出来的
2.     类只需要有一个，对象可以有多个（一张图纸可以造多个飞机）
3.     类：属性（信息）和方法（你能完成的事）

•     类名 ：这类事物的名字，满足大驼峰命名法
•     属性：这个类创建出的对象有什么特征#3.方法
•     方法：这个类创建出的对象有什么行为

例子：

class Cat():
    def eat(self):      #self:哪一个对象调用的方法，self就是哪一个对象的引用
        print('%s爱吃鱼' %self.name)
    def drink(self):     ##定义方法喝
        print('小猫要喝水')

tom = Cat()     ##利用Cat类，创建一个对象tom
tom.name = 'Tom'   #可以使用 .属性名 利用赋值语句就可以在类的外部
print(tom)     ##打印出tom是一个对象
tom.eat()       ##调用方法
tom.drink()

hello_kitty = Cat()
hello_kitty.name = 'hello_kitty'
hello_kitty.eat()
hello_kitty.drink()

结果：
<__main__.Cat object at 0x7f05ecc8b588>
Tom爱吃鱼
小猫要喝水
hello_kitty爱吃鱼
小猫要喝水

二、面向对象中常用内置方法

一、初始化方法

1. init()方法 当使用类名（）创建对象时，Python解释器会自动执行以下操作：

• 为对象在内存中分配空间———创建对象
• 调用初始化方法为对象的属性设置初始值——初始化方法（init）
• 这个初始化方法是对象的内置方法，是专门用来定义一个类具有哪些属性的方法

class Cat():
    def __init__(self,name):
        print('这是一个初始化方法')
        self.name = name

    def eat(self):
        print('%s爱吃鱼' %self.name)

cat = Cat('tom')     ##使用类名（）创建对象时，会自动调用初始化方法
print(cat.name)

hello_kitty = Cat('HK')
print(hello_kitty.name)
hello_kitty.eat()

结果：
这是一个初始化方法
tom
这是一个初始化方法
HK
HK爱吃鱼

二、 __str__方法：

• str ( ) 在Python中，如果直接输出创建的对象，会输出这个变量引用的对象是由哪一个,类创建的对象以及在内存中的地址（十六进制）
• 如果希望使用print输出对象变量，能够打印自定义的内容，就可以利用str内置方法

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

结果：
我是粉条 

三、python——面向对象——实现栈

• 入栈
• 出栈
• 查看栈顶元素
• 查看栈长度
• 查看栈元素

class Stack():

    def __init__(self):
        self.stack = []

    def push(self,value):
        self.stack.append(value)
        return True

    def pop(self):
        #先判断栈是否为空
        if self.stack:
            item = self.stack.pop()
            return item
        else:
            return False

    def top(self):
        if self.stack:
            return self.stack[-1]
        else:
            return False

    def length(self):
        return len(self.stack)

    def view(self):
        return ','.join(self.stack)


s = Stack()
s.push('1')
s.push('2')
item = s.pop()
print(item)
print(s.view())

结果：
2
1

四、python——面向对象的三大特性：封装，继承，多态

一、封装：

• 面向对象第一步 ： 将属性和方法封装到一个抽象的类中
• 外界使用类创建对象，然后让对象调用方法
• 对象方法的细节都封装在类的内部

例子：

需求
1.小明体重75.0公斤
2.小明每次跑步会减肥0.5公斤
3.小明每次吃东西会增重1攻击

需求
1.小明和小美都爱跑步
2.小美体重45.0公斤
3.小明体重75.0公斤
4.每次跑步会减肥0.5公斤
5.每次吃东西会增重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):
        print('%s爱跑步' %self.name)
        self.weight -= 0.5

    def eat(self):
        print('%s吃东西' %self.name)
        self.weight += 1

xiaoming = Person('小明',76.0)
print(xiaoming)
xiaoming.run()
print(xiaoming)
xiaoming.eat()
print(xiaoming)

结果：
我的名字叫小明 体重是76.00
小明爱跑步
我的名字叫小明 体重是75.50
小明吃东西
我的名字叫小明 体重是76.50

练习题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)

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


##定义房子类
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):
        #1.判断家具的面积
        if item.area > self.free_area:
            print('%s的面积太大，无法添加' %item.name)

        #2.将家具的名称添加到列表中
        self.item_list.append(item.name)
        #3.计算剩余面积
        self.free_area -= item.area

#1.创建家具对象
bed = HouseItem('bed',4)
# print(bed)
chest = HouseItem('chest',2)
# print(yg)
table = HouseItem('table',1.5)
# print(table)

#2.创建房子对象
my_house = House('两室一厅',100)
#3.添加家具
my_house.add_item(bed)
my_house.add_item(chest)
my_house.add_item(table)
print(my_house)

结果：
户型:两室一厅
总面积:100.00[剩余:92.50]
家具:['bed', 'chest', 'table']

练习题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     ##子弹的数量一开始为0

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

    def shoot(self):
        if self.bullet_count <=0:
            print('%s没有子弹了...' %self.model)

        self.bullet_count -= 1
        print('%s~~~~~%s' %(self.model,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)

        self.gun.add_bullet(10)
        self.gun.shoot()

##定义枪对象
ak47 = Gun('ak47')
ak47.add_bullet(50)
ak47.shoot()

##定义士兵对象
ryan = Soldier('Ryan')
ryan.gun = ak47
ryan.fire()

结果：
ak47~~~~~49
ak47~~~~~58

二、继承：

• 继承：实现代码的重用，相同的代码不需要重复写
• 子类继承自父类，可以直接享受父类中已经封装好的方法
• 子类重应该根据职责，封装子类特有的属性和方法

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.run()
fentiao.call()

结果：
吃~~~~~
跑
喵～

• 子类可以继承父类的所有属性和方法
• 继承具有传递性，子类拥有父类的父类的属性和方法

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('我能说英语')

class Dog(Animal):
    def bark(self):
        print('汪～')

kt = HelloKitty()
kt.eat()
kt.speak()

结果:
吃~~~~~
我能说英语

• 如果子类重写了父类的方法
• 在运行中，只会调用在子类中重写的方法而不会调用父类方法

class Cat():
    def call(self):
        print('喵～')

class HelloKitty(Cat):
    def speak(self):
        print('我能说英语')
    def call(self):
        print('@#@$@$@#@!#')

kt = HelloKitty()
kt.call()

结果：
@#@$@$@#@!#

• 如果子类重写父类的方法后，还想调用父类的方法：

class Cat():
    def call(self):
        print('喵～')

class HelloKitty(Cat):
    def speak(self):
        print('我能说英语')
    def call(self):
        #1.针对子类特有的需求，编写代码
        print('@#@$@$@#@!#')
        #2.调用原本在父类中封装的方法
        # Cat.call(self)    ##两种方法选一种
        super().call()

kt = HelloKitty()
kt.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(A,B):
    ##当父类的方法或属性同名时，按括号中的父类先后顺序执行
    pass

c = C()
c.test()
c.demo()

结果:
A---->test方法
A---->demo方法