面向对象程序设计

1）类中创建__init__（）方法

①创建类的新实例时，会自动执行该方法

②__init__()方法必须包含且第一个为self的参数，可以有多个参数

• __inti__(self)一个参数

class Geese():
    "大雁类"
    def __init__(self):    #构造方法，第一个参数必须有且为self参数，否则会报错
        print("我是大雁类！")

#自动执行构造方法
wildGoose = Geese()

•  __init__(self)多个参数

class Geese:
    "大雁类"
    def __init__(self,beak,wing,claw):
        print("我是大雁类，我有以下特征")
        print(beak)
        print(wing)
        print(claw)

beak1 = "特征1" 
wing1="特征2"
claw1 ="特征3"
wildGoose = Geese(beak1,wing1,claw1)

 2)创建实例方法并访问

def functionName(self,parameterlist):
       block    

①functionName 方法名，一般用小写字母开头

②self 必要参数，表示类的实例

③parameterlist 用于指定self以为的参数

④ block 方法体，实现具体功能

• 创建fly()方法

#创建实例方法并访问
class Geese:
    "大雁类"
    def __init__(self,beak,wing,claw):
        print("我是大雁类，我有以下特征")
        print(beak)
        print(wing)
        print(claw)
    def fly(self,state):
        print(state) 

# 调用方法
beak1 = "特征1" 
wing1="特征2"
claw1 ="特征3"
wildGoose = Geese(beak1,wing1,claw1)
wildGoose.fly("我飞行了")

 3)创建数据成员并访问

①数据成员是指在类中定义的变量，即属性，根据定义的位置不同，又可以分为类属性和实例属性。

②类属性可以通过类名或者实例名访问

• 创建类属性且访问

#创建类中属性
class Geese():
    "燕类"
    neck = "脖子"      #类属性
    wing = "振翅频率高"
    leg = "腿"
    def __init__(self):
        print("我属于燕类，我有以下特征")
        print(Geese.neck)
        print(Geese.wing)
        print(Geese.leg)
        

print(geese.neck) #通过实例名访问类属性
print(Geese.neck)  #通过类名访问类属性

•  动态的为类添加属性

Geese.beak = "动态添加类属性"

geese = Geese()
geese.beak

•  通过实例名称修改实例属性

class Geese():
    def __init__(self):
        self.neck = "脖子"      
        print(self.neck)   

geese = Geese()

geese.neck = '脖子没有天鹅的长'

geese.neck

4）访问限制

①_foo: 表示保护类型的成员，只允许类本身及子类进行访问

②不能使用"from module import *"语句导入

• 创建_neck_swan保护型属性

# _foo:
class Swan:
    "天鹅类"
    _neck_swan = "天鹅的脖子很长"
    def __init__(self):
        print("__init__()",Swan._neck_swan)

swan = Swan()
swan._neck_swan    #保护属性可以通过实例名访问

 ③__fool 私有类型属性，只允许定义该方法的类本身进行访问

④不能通过类的实例进行访问，可以通过“类的实例._类名.__fool”方式访问

• 创建__neck_swan私有类型属性

# __foo:
class Swan:
    "天鹅类"
    __neck_swan = "天鹅的脖子很长"
    def __init__(self):
        print("__init__()",Swan.__neck_swan)

swan = Swan()
swan._Swan__neck_swan

5)属性

①通过@property（装饰器）将一个方法转换为属性

②@property转换后的属性不能重新复制，否则会报错

@property
def methodname(self):
    block

• 创建area属性

class Rect:
    def __init__(self,width,height):
        self.width= width
        self.height=height
    @property     #将方法转换为属性
    def area(self):
        return self.width*self.height

rect = Rect(12,12)  #创建类的实例
print(rect.area)   #输出属性值

 6）为属性添加安全保护机制

①设置为私有属性__fool时，在类体外不能获取它的值

②设置为保护属性_fool时，可以读但不能修改属性

• 创建__show私有属性

class TVshow:
    def __init__(self,show):
        self.__show=show
    @property
    def show(self):
        return self.__show

tvshow = TVshow("少年的你")
tvshow.show

 修改私有属性时会出错

③通过属性不仅可以将属性设置为只读属性，而且可以为属性设置拦截器，即允许对属性进行修改，但修改时需要遵守一定的约束。

class TVshow:
    list_film=['A','B','C']
    def __init__(self,show):
        self.__show=show
    @property
    def show(self):
        return self.__show
    @show.setter   #设置setter方法，让属性可以修改
    def show(self,value):
        if value in TVshow.list_film:
            self.__show="你选择了%s"%value
        else:
            self.__show="你选择的不存在"

tvshow.show='f'
tvshow.show

tvshow.show='B'
tvshow.show

 7）继承

class ClassName(baseclasslist):
    """类的帮助信息"""      #文档字符串
    Statement           #类体

• 创建水果基类及派生类。然后调用基类中的方法

class Fruit():
    color="绿色"
    def havest(self,color):
        print("水果是%s的"%self.color)
        print("水果已经收获")
        print("水果原来是%s的"%Fruit.color)
        
class Apple(Fruit):
        color = '红色'
        def __init__(self):
            print("我是苹果")
class Orange(Fruit):
    color = '橙色'
    def __init__(self):
        print("\n我是橘子")

apple = Apple()
apple.havest(apple.color)

orange=Orange()
orange.havest(orange.color)

 8）方法重写

①当基类中的方法无法满足需求时，可以在派生类中重新定义方法以满足使用

• 重写橘子类中的方法

class Fruit():
    color="绿色"
    def havest(self,color):
        print("水果是%s的"%self.color)
        print("水果已经收获")
        print("水果原来是%s的"%Fruit.color)

class Orange(Fruit):
    color="橙色"
    def __init__(self):
        print("\n我是橘子")
    def havest(self,color):
        print("橘子是%s的"%color)
        print("橘子已经获得了")
        print("橘子原来是%s"%Fruit.color)

orang = Orange()
orang.havest(Orange.color)

 9）派生类中调用基类__init__()的方法

•  在派生类中定义__init__()方法时，不会自动调用基类的__init__()方法

class Fruit():
    def __init__(slef,color):
        print("elf.color)")
        Fruit.color = color
    def havest(self):
        print("水果原来是%s的"%Fruit.color)

class Apple(Fruit):
    def __init__(self):
        print("我是苹果")

apple = Apple()
apple.havest()

•  添加super函数调用基类的__init__()方法

class Fruit():
    def __init__(slef,color):
        print("elf.color)")
        Fruit.color = color
    def havest(self):
        print("水果原来是%s的"%Fruit.color)


class Apple(Fruit):
    color = '红色'
    def __init__(self):
        print("我是苹果")
        super().__init__(Apple.color)   #添加super调用基类__init__()


apple = Apple()
apple.havest()