Linux:python面向对象以及三个特点

面向对象和面向过程

面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了；
面向对象是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。

一·面向对象的基本语法

1、简单的动物特性的面向对象编程

# _*_ coding:utf-8 _*_
"""
file: 面向对象_3.py
date: 2018-07-23 18:29
author: jiong
desc:
类的设计：
在程序中,要设计一个类,通常需要满足以下三个需求:
1.类名 这类事物的名字,满足大驼峰命名法
2.属性 这类事物具有什么样的特征
3.方法 这类事物具有什么样的行为

面向对象的基础语法：
定义简单的类：
定义只包含方法的类：
class 类名：
    def 方法1(self,参数列表)：
        pass
    def 方法2(self,参数列表)：
        pass

当一个类定义完成之后,要使用这个类来创建对象,语法格式如下:
对象变量 = 类名()
需求
    小狗爱吃肉，小狗爱玩耍
"""
# 定义一个类，但是只有一个类是无法输出的
class Dog():
    def eat(self):
        print '小狗爱吃肉'
    def play(self):
        print '小狗爱玩耍'
# 将类转换到对象
dou = Dog()
dou.eat()
dou.play()

2、一个类可以创建多个对象

# _*_ coding:utf-8 _*_
"""
file: 面向对象_1.py
date: 2018-07-23 13:40
author: jiong
desc:

需求：
    小猫爱吃鱼,小猫爱喝水

"""
class Cat():
    # 哪一个对象调用的方法,self就是哪一个对象的引用
    def eat(self):
        print '%s like eating fish' % self.name
    def drink(self):
        print '小猫爱喝水'

# 创建猫对象
dudu = Cat()
dudu.name = 'dudu'   #给猫一个名字
dudu.eat()
dudu.drink()
print dudu
#addr = id(dudu)
# %x:打印格式为十六进制的内存地址
#print '%x' % addr
# %x:打印格式为十进制的内存地址
#print '%d' % addr

# 再创建一个猫对象(内存地址与dudu的不同)
lazy_cat = Cat()
lazy_cat.name = 'bobo'
lazy_cat.eat()
lazy_cat.drink()
print lazy_cat

lazy_cat2 = lazy_cat
print lazy_cat2  #内存地址与lazy_cat相同

3、在类的外部给对象增加属性会报错：（还是刚才的脚本做了点修改）

# _*_ coding:utf-8 _*_
"""
file: 面向对象_2.py
date: 2018-07-23 16:15
author: jiong
desc:

需求:小狗爱吃骨头,小狗喜欢汪汪叫
"""
class Dog():
    # self:哪一个对象调用的方法,self就是哪一个对象的引用
    def eat(self):
        print '%s love a bone'  % self.name
    def shout(self):
        print '小狗喜欢汪汪叫'

# 创建狗对象
shoutao = Dog()
shoutao.name = 'shoutao'
shoutao.eat()
shoutao.shout()
print shoutao
addr = id(shoutao)
# %x:打印格式为十六进制
print '%x' % addr
# %d:打印格式为十进制
print '%d' % addr

# 再创建一个狗对象
Dog_1 = Dog()
Dog_1.eat()
Dog_1.shout()

Dog_2 = Dog_1
print Dog_2

二·初始化方法

# _*_ coding:utf-8 _*_
"""
file: 面向对象_4.py
date: 2018-07-23 22:52
author: jiong
desc:
初始化方法
我们现在已经知道了使用 类名() 就可以创建一个对象
当使用类名()创建对象时,python的解释器就会自动执行以下操作：
    1.为对象在内存中分配空间--创建对象
    2.调用初始化方法为对象的属性设置初始值--初始化方法(__init__)
这个初始化方法就是__init__方法,__init__时对象的内置方法
__init__方法是专门用来定义一个类具有那些属性的方法

"""


class Cat():
    def __init__(self):
        print '这是一个初始化方法'
        # self.属性名 = 属性的初始值
        self.name = 'dudu'


# 使用 类名() 创建对象的时候,会自动调用初始化方法_init_
dudu = Cat()
print dudu.name


class Cat():
    def __init__(self, new_name):
        self.name = new_name
        # 在类中,任何方法都可以使用self.name

    def eat(self):
        print '%s like eating fish' % self.name


dudu = Cat('dudu')
print dudu.name
dudu.eat()

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

1、直接调用初始化不加入形参

# _*_ coding:utf-8 _*_
"""
file: 面向对象_5.py
date: 2018-07-23 22:59
author: jiong
desc:


"""
class Cat():
    def __init__(self):
        self.name = 'Tom'
        # 在类中，任何方法都可以使用self.name
    def eat(self):
        print '%s 爱吃鱼' % self.name
tom = Cat()
print tom.name
tom.eat()
# 重新定义一个猫输出还是Tom,显然不合理
lazy_cat = Cat()
lazy_cat.eat()

2、调用初始化加入形参

扫描二维码关注公众号，回复： 2469662 查看本文章

# _*_ coding:utf-8 _*_
"""
file: 面向对象_6.py
date: 2018-07-23 23:01
author: jiong
desc:


"""
class Cat():
    def __init__(self,new_name):  # new_name为形参
        # 在类中，任何方法都可以使用self.name
        self.name = new_name
    def eat(self):
        print '%s 爱吃鱼' % self.name
tom = Cat('tom')    # 必须给传递实际的参数不然会报错
print tom.name
tom.eat()
lazy_cat = Cat('lazy_cat')   # 必须给传递实际的参数不然会报错
lazy_cat.eat()

三·面向对象编程的三大特点

1.封装：根据职责将属性和方法封装到一个抽象的类中
定义类的准则
2.继承：实现代码的重用，相同的代码不需要重复的编写
设计类的技巧
子类针对自己特有的需求，编写特定的代码
3.多态：
不同的子类对象调用相同的方法，产生不同的执行结果

1、封装

# _*_ coding:utf-8 _*_
"""
file: 封装_1.py
date: 2018-07-23 23:05
author: jiong
desc:
封装：
1.封装是面向对象编程的一大特点
2.面向对象编程的第一步 将属性和方法封装到一个抽象的类中
3.外界使用类创建对象,然后让对象调用方法
4.对象方法的细节都被封装在类的内部

需求：
1.xx爱跑步
2.xx体重50公斤
3.xx每次跑步会减肥0.5公斤
4.xx每次吃东西体重会增加1公斤

"""
class Person():
    def __init__(self,new_name,weight):
        self.name = new_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

name = Person('jiong',52.0)
#name.run()
name.eat()
print name

1、士兵开枪案例：

# _*_ coding:utf-8 _*_
"""
file:士兵开枪.py
date:2018-07-21 7:21 AM
author:Jiong
desc:


"""
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.发射子弹
        self.bullet_count -= 1
        # 3。提示发射信息
        print '%s 突突突 %d' %(self.model,self.bullet_count)

class Soldier():
    def __init__(self,name):
        self.name = name
        self.gun = None
    def fire(self):
        # 1.判断士兵没有枪
        if self.gun == None:
            print '%s 需要一把枪' %self.name
            return
        # 2.高喊口号
        print 'go!!! %s' % self.name
        # 3.让枪装填
        self.gun.add_bullet(50)
        # 4.让枪发子弹
        self.gun.shoot()

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

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

2、摆放家具（没有完成添加家具）

# _*_ coding:utf-8 _*_
"""
file:摆放家具1.py
date:2018-07-21 5:44 AM
author:Jiong
desc:
1.房子有户型,总面积和家具名称列表
  新房子没有任何家具
2.家具有名字和占地面积,其中
    床：占4平米
    衣柜：占2平米
    餐桌：占2平米
3.将以上三件家具添加到房子中
4.打印房子时,要求输出：户型,总面积,剩余面积,家具名称列表

小结：
1.创建了一个房子类,使用__init__和__str__两个内置的方法
2.准备了一个add_item方法 准备添加家具
3.使用 房子类 创建了一个房子对象
4.让 房子对象 调用三次add_item方式,将三件家具以实参的形式传递到add_item

"""
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.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.判断家具的面积
            if item.area > self.free_area:
                print '%s 的面积太大了,无法添加' % item.name
                # 如果不满足,下方的代码就不执行
                return
            # 2.将家具的名称添加到列表中
            self.item_list.append(item.name)
            # 3.计算剩余面积
            self.free_area -= item.area

# 创建家具
bed = Furniture('bed',4)
print bed
chest = Furniture('chest',2)
print chest
table = Furniture('table',2)
print table


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

2、继承

1、单继承

# _*_ coding:utf-8 _*_
"""
file:继承_1.py
date:2018-07-21 8:15 AM
author:Jiong
desc:
单继承
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 '喵喵喵'

mm = Cat()
mm.eat()
mm.drink()
mm.run()
mm.sleep()
mm.call()

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

2、继承的传递性

# _*_ coding:utf-8 _*_
"""
file:继承_2.py
date:2018-07-21 8:44 AM
author:Jiong
desc:
继承的传递性：（爷爷,父亲,儿子）
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.run()
kt.sleep()

3、重写父类

# _*_ coding:utf-8 _*_
"""
file:继承_3.py
date:2018-07-21 8:49 AM
author:Jiong
desc:
重写父类方法有两种情况:
1.覆盖父类的方法
2.对父类方法进行扩展

1.覆盖父类的方法
如果在开发中,父类的方法的实现和子类方法的实现,
完全不同,就可以使用覆盖的方法,
在子类中重新编写父类的方法

具体实现方法,就相当于在子类中定义了
一个和父类同名的方法并且实现
重写之后,在运行时,只会调用子类的重写方法
而不会再调用父类封装的方法

"""
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 '偶哈呦 空你起哇'

kt = Hellokitty()
# 如果子类中,重写了父类的方法
# 在运行中,只会调用子类中重写的方法,不会调用父类的方法
kt.call()

4、对父类的方法进行扩展

# _*_ coding:utf-8 _*_
"""
file:继承_4.py
date:2018-07-21 9:02 AM
author:Jiong
desc:
对父类的方法进行扩展：
如果在开发中,子类的方法实现包含有父类的方法实现
(父类原本封装的方法实现是子类方法的一部分就可以使用扩展方法)
1.在子类中重写父类的方法
2.在需要的位置使用 父类名.方法(self)来调用父类方法的执行
（使用父类名称调用父类方法）
3.代码其他的位置针对子类的需求,编写子类特有的代码实现

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

kt = Hellokitty()
kt.call()

5、多继承

# _*_ coding:utf-8 _*_
"""
file:多继承.py
date:2018-07-22 1:13 AM
author:Jiong
desc:
多继承：
子类拥有一个父类叫做单继承
子类可以拥有多个父类,并且具有所有父类的属性和方法
例如：孩子会继承自己父亲和母亲的特性

"""
class A(object):
    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():
    def teat(self):
        print 'C----test 方法'
    def demo(self):
        print 'C----demo 方法'
class D(A,B,C):
    # 多继承可以让子类对象,同时具有多个父类的属性和方法
    pass

d = D()
d.test()
d.demo()

3、多态

# _*_ coding:utf-8 _*_
"""
file:多态.py
date:2018-07-22 2:40 AM
author:Jiong
desc:
多态
不同的子类（这是之前提到的继承的知识）
对象调用相同的方法,产生不同的执行结果

"""
class Cat(object):
    def __init__(self,name):
        self.name = name
    def play(self):
        print '%s 喜欢玩毛球' % self.name

class HelloKetty(Cat):
    def play(self):
        print '%s 会说日语' % self.name


class Person(object):
    def __init__(self,name):
        self.name = name
    def play_with_cat(self,a):
        print '%s 和 %s 玩耍' % (self.name,a.name)
        a.play()
# 创建一个猫对象
maiomiao = Cat('喵喵')
# maiomiao.play()
# 创建一个人对象
xiaoming = Person('小明')
# 让小明和猫玩耍
xiaoming.play_with_cat(maiomiao)