第8章 面向对象编程

本章知识点：

1、类和对象；

2、属性和方法；

3、继承和组合；

4、类的多态性；

5、类的访问权限；

6、设计模式的应用；

内容：

8.1 面向对象的概念

1、用例图
2、活动图
3、状态图
4、类图
5、序列图和协助图
6、组建图和部署图

8.2 类和对象

8.2.1 类和对象的区别

8.2.2 类的定义

## 继承自object
class Class_name(object):
    ...
## 不显式继承object
class Class_name:
    ...

## 类的创建
class Fruit:
    def __init__(self):
        self.name = name
        self.color = color
    def grow(self):
        print "Fruit grow ..."

8.2.3 对象的创建

if __name__ == "__main__":
    fruit = Fruit()
    fruit.grow()

8.3 属性和方法

8.3.1 类的属性

class Fruit:
    price = 0
    def __init__(self):
        self.color = "red"
        zone = "China"
if __name__ == "__main__":
    print (Fruit.price)
    apple = Fruit()
    print (apple.color)
    Fruit.price = Fruit.price + 10
    print ("apple's price:" + str(banana.price))

## 访问私有属性
class Fruit:
    def __init__(self):
        self.__color = "red"
if __name__ == "__main__":
    apple = Fruit()
    print (apple._Fruit__color)
# 输出：red

class Fruit:
    def __init__(self):
        self.__color = "red"
class Apple(Fruit):
    """This is doc"""
    pass
if __name__ == "__main__":
    fruit =Fruit()
    apple = Apple()
    print (Apple.__bases__)
    print (apple.__dict__)
    print (apple.__module__)
    print (apple.__doc__)
# 输出：(<class '__main__.Fruit'>,)
# {'_Fruit__color': 'red'}
# __main__
# This is doc

8.3.2 类的方法

class Fruit:
    price = 0
    def __init__(self):
        self.__color = "red"
    def getColor(self):
        print (self.__color)
    @staticmethod
    def getPrice():
        print (Fruit.price)
    def __getPrice(self):
        Fruit.price = Fruit.price + 10
        print (Fruit.price)
    count = staticmethod(__getPrice)
if __name__ == "__main__":
    apple = Fruit()
    apple.getColor()
    Fruit.count()
    banana = Fruit()
    Fruit.getPrice()

# 输出：red
# 10
# 10

@classmethod
def getPrice(cls):
    print (cls.price)
def __getPrice(cls):
    cls.price = cls.price + 10
    print (cls.price)
count = classmethod(__getPrice)

8.3.3 内部类的使用

class Car:
    class Door:
        def open(self):
            print ("open doot")
    class Wheel:
        def run(self):
            print ("car run")
if __name__ == "__main__":
    car = Car()
    backDoor = Car.Door()
    frontDoor = Car.Door()
    backDoor.open()
    frontDoor.open()
    wheel = Car.Wheel()
    wheel.run()
# 输出：open doot
# open doot
# car run

8.3.4 __init__方法

class Fruit:
    def __init__(self, color):
        self.__color = color
        print (self.__color)
    def getColor(self):
        print (self.__color)
    def setColor(self, color):
        self.__color = color
        print (self.__color)
if __name__ == "__main__":
    color = "red"
    fruit = Fruit(color)
    fruit.getColor()
    fruit.setColor("blue")
# 输出：red
# red
# blue

8.3.5 __del__方法

class Fruit:
    def __init__(self):
        self.__color = color
        print (self.__color)
    def  __del__(self):
        self.__color = ""
        print ("free ...")
    def grow(self):
        print ("grow ...")
if __name__ == "__main__":
    color = "red"
    fruit = Fruit(color)
    fruit.grow()

8.3.6 垃圾回收机制

import gc
class Fruit:
    def __init__(self, name, color):
        self.__name = name
        self.__color = color
    def getColor(self):
        return self.__color
    def setColor(self):
        self.__color = color
    def getName(self):
        return self.__name
class FruitShop:
    def __init__(self):
        self.fruits = []
    def addFruit(self, fruit):
        fruit.parent = self
        self.fruits.append(fruit)
if __name__ == "__main__":
    shop = FruitShop()
    shop.addFruit(Fruit("apple", "red"))
    shop.addFruit(Fruit("banana", "yellow"))
    print (gc.get_referrers(shop))
    del shop
    print (gc.collect())
# 输出：[{'_Fruit__name': 'apple', '_Fruit__color': 'red', 'parent':
# <__main__.FruitShop object at 0x0000020DAAB712B0>}, {'_Fruit__name':
# 'banana', '_Fruit__color': 'yellow', 'parent': <__main__.FruitShop
# object at 0x0000020DAAB712B0>}, {'__name__': '__main__', '__doc__':
# None, '__package__': None, '__loader__':
# <_frozen_importlib_external.SourceFileLoader object at 0x0000020DAA8EC048>,
# '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins'
# (built-in)>, '__file__': 'D:/Python/零基础学 python/第8章 面向对象编程/内容.py',
# '__cached__': None, 'gc': <module 'gc' (built-in)>, 'Fruit':
# <class '__main__.Fruit'>, 'FruitShop': <class '__main__.FruitShop'>, 'shop':
# <__main__.FruitShop object at 0x0000020DAAB712B0>}]
# 1856

8.3.7 类的内置方法

#         1)__new__()
class Singleton(object):
    __instance = None
    def __init__(self):
        pass
    def __new__(cls, *args, **kwargs):
        if Singleton.__instance is None:
            Singleton.__instance = object.__new__(cls, *args, **kwd)
        return Singleton.__instance

            2)__getattr__(), __setattr__(), __getattribute__()
class Fruit(object):
    def __init__(self, color = "red", price = 0):
        self.__color = color
        self.__price = price
    def __getattribute__(self, item):
        return object.__getattribure__(self, name)
    def __setattr__(self, key, value):
        self.__dict__[name] = value
if __name__ == "__main__":
    fruit = Fruit("blue", 10)
    print (fruit.__dict__.get("_Fruit__color"))
    fruit.__dict__["_Fruit__price"] = 5
    print (fruit.__dict__.get("_FRUIT__price"))

           3)__getitem__()
class FruitShop:
    def __getitem__(self, i):
        return self.fruits[i]
if __name__ == "__main__":
    shop = FruitShop()
    shop.fruits = ["apple","banana"]
    print (shop[1])
    for itme in shop:
        print (itme,end=" ")
# 输出：banana
# apple banana 

           4)__str__()
class Fruit:
    '''Fruit类'''
    def __str__(self):
        return self.__doc__
if __name__ == "__main__":
    fruit = Fruit()
    print (str(fruit))
    print (fruit)
#输出：Fruit类
# Fruit类

          5)__call__()
class Fruit:
    class Growth:
        def __call__(self):
            print ("grow ...")
    grow = Growth()
if __name__ == "__main__":
    fruit = Fruit()
    fruit.grow()
    Fruit.grow()
# 输出：grow ...
# grow ...

8.3.8 方法的动态特性

## 动态添加方法
class Fruit:
    pass
def add(self):
    print ("grow ..")
if __name__ == "__main__":
    Fruit.grow = add
    fruit = Fruit()
    fruit.grow()
# 输出：grow ...

## 动态更新方法
class Fruit():
    def grow(self):
        print ("grow ...")

def update():
    print ("grow ...")
if __name__ == "__main__":
    fruit = Fruit()
    fruit.grow()
    fruit.grow = update
    fruit.grow()
# 输出：grow ...
# grow ...

8.4 继承

8.4.1 使用继承

class Fruit:
    def __init__(self, color):
        self.color = color
        print ("fruit's color: %s" % self.color)
    def grow(self):
        print ("grow ...")
class Apple(Fruit):
    def __init__(self, color):
        Fruit.__init__(self. color)
        print ("apple's color: %s" % self.color)
class Banana(Fruit):
    def __init__(self, color):
        Fruit.__init__(self.color)
        print ("banana's color: %s" % self.color)
    def gruit(self):
        print ("banana grow ...")
if __name__ == "__main__":
    apple = Apple("red")
    apple.grow()
    banana = Banana("yellow")
    banana.grow()

## 使用super()调用父类
class Friut(object):
    def __init__(self):
        print ("parent")
class Apple(Friut):
    def __init__(self):
        super(Apple, self).__init__()
        print ("child")
if __name__ == "__main__":
    Apple()
# 输出：parent
# child

8.4.2 抽象基类

from abc import ABCMeta, abstractmethod
class Fruit(metaclass=ABCMeta):
    @abstractmethod
    def grow(self):
        pass
class Apple(Fruit):
    def grow(self):
        print ("Apple growing")
if __name__ == "__main__":
    apple = Apple()
    apple.grow()
# 输出：Apple growing

8.4.3 多态性

class Fruit:
    def __init__(self, color=None):
        self.color = color
class Apple(Fruit):
    def __init__(self, color="erd"):
        Fruit.__init__(self, color)
class Banana(Fruit):
    def __init__(self, color="yellow"):
        Fruit.__init__(self, color)
class FruitShop:
    def sellFruit(self, fruit):
        if isinstance(fruit, Apple):
            print ("sell apple")
        if isinstance(fruit, Banana):
            print ("sell apple")
        if isinstance(fruit, Apple):
            print ("sell Friut")

8.4.3 多态性

class Fruit:
    def __init__(self, color=None):
        self.color = color
class Apple(Fruit):
    def __init__(self, color="erd"):
        Fruit.__init__(self, color)
class Banana(Fruit):
    def __init__(self, color="yellow"):
        Fruit.__init__(self, color)
class FruitShop:
    def sellFruit(self, fruit):
        if isinstance(fruit, Apple):
            print ("sell apple")
        if isinstance(fruit, Banana):
            print ("sell apple")
        if isinstance(fruit, Apple):
            print ("sell Friut")
if __name__ == "__main__":
    shop = FruitShop()
    apple = Apple("red")
    banana = Banana("yellow")
    shop.sellFruit(apple)
    shop.sellFruit(banana)
# 输出：sell apple
# sell Friut
# sell apple

8.4.4 多重继承

class Fruit:
    def __init__(self):
        print ("initialize Fruit")
    def grow(self):
        print ("grow ...")
class Vegetable(object):
    def __init__(self):
        print ("initialize Vegetable")
    def plant(self):
        print ("plant ...")
class Watermelon(Vegetable, Fruit):
    pass
if __name__ == "__main__":
    w = Watermelon()
    w.grow()
    w.plant()
# 输出:initialize Vegetable
# grow ...
# plant ...

　　

8.4.5 Mixin机制

class Fruit:
    def __init__(self):
        pass
class HuskedFruit(Fruit):
    def __init__(self):
        print ("initialize HuskedFruit")
    def husk(self):
        print ("husk ...")
class DecorticatedFruit(Fruit):
    def __init__(self):
        print ("initialize DecorticatedFruit")
    def decorticat(self):
        print ("decorticat ...")
class Apple(HuskedFruit):
    pass
class Banana(DecorticatedFruit):
    pass

class Fruit:  # 水果
    def __init__(self):
        pass
class HuskedFruit(object):  # 削皮水果
    def __init__(self):
        print ("initialize HuskedFruit")
    def husk(self):  # 削皮方法
        print ("husk ...")
class DecorticatedFruit(object):  #削皮水果
    def __init__(self):
        print ("initialize DecorticatedFruit")
    def decorticat(self):  # 削皮方法
        print ("decorticat ...")
class Apple(HuskedFruit, Fruit):  # 是水果，并且是削皮水果。
    pass
class Banana(DecorticatedFruit, Fruit):  # 是水果，并且是削皮水果。
    pass

8.5 运算符的重载

class Fruit:
    def __init__(self, price=0):
        self.price = price
    def __add__(self, other):
        return self.price + other.price
    def __gt__(self, other):
        if self.price > other.price:
            flag = True
        else:
            flag = Fruit
        return flag
class Apple(Fruit):
    pass
class Banana(Fruit):
    pass
if __name__ == "__main__":
    apple = Apple(3)
    print ("苹果的价格：",apple.price)
    banana = Banana(2)
    print ("香蕉的价格：",banana.price)
    print (apple > banana)
    total = apple + banana
    print ("合计：",total)
# 输出：苹果的价格： 3
# 香蕉的价格： 2
# True
# 合计： 5

import sys
class Stream:
    def __init__(self, file):
        self.file = file
    def __lshift__(self, obj):
        self.file.write(str(obj))
        return self
class Fruit(Stream):
    def __init__(self, price = 0, file = None):
        Stream.__init__(self, file)
        self.price = price
class Apple(Fruit):
    pass
class Banana(Fruit):
    pass
if __name__ == "__main__":
    apple = Apple(2, sys.stdout)
    banana = Banana(3, sys.stdout)
    endl = "\n"
    apple<<apple.price<<endl
    banana<<banana.price<<endl
# 输出：2
# 3

8.6 Python与设计模式

8.6.1 设计模式简介

8.6.2 设计模式示例--Python实现工厂方法

class Factory:
    def createFruit(self, fruit):
        if fruit == "apple":
            return Apple()
        elif fruit == "banana":
            return Banana
class Fruit:
    def __str__(self):
        return "fruit"
class Apple(Fruit):
    def __str__(self):
        return "apple"
class Banana(Fruit):
    def __str__(self):
        return "banana"
if __name__ == "__main__":
    factory = Factory()
    print (factory.createFruit("apple"))
    print (factory.createFruit("banana"))
# 输出：apple
# <class '__main__.Banana'>

8.8 习题

1) 则么查看一个类的所有属性。
2) 为什么创建类函数的时候需要添加self变量？可以使用其他变量如this代替self吗？
3) 则么理解Pthon中一切皆对象。
4) 汽车、轮船、火车等都属于交通工具。联系实际情况，编写类Traffic,并继承其他实现类Car,Ship和Train。