python 面向对面编程

面向对象编程（或者可以称为 面向类编程）。 面向对象 提供的是一种 "语法功能", 为编程提供的一种 更丰富的 思维模式

1.声明类

例 ---创建汽车类型

class car():
    #声明成员属性---可以认为是一系列的 变量
    wheelNO=4  # 声明在class 定义下第一层的 属性(变量) 属于整个类 所用。 使用时  要通过类名称加点号 调用。 例：car.wheelNO

    #声明类的构造方法：构造方法 是一个class中必须存在的方法, 作用： 1.实例化对象（创建该类型的实际数据） 2.为实例进行属性的 初始化
    def __init__(self,co='黑色',ty='轿车',br='BYD'):
        self.color = co  # self 表示实例(类的每一个实际数据)自身。 self.变量名  声明的是属于实例自身的成员属性
        self.type = ty
        self.brand = br        
    
    #声明成员方法（本质是函数)。 方法中通常第一个参数是"self"， 代表该方法  属于该类的实例的 方法
    def move(self,x,y):
        print('本实例',id(self), '移动到的新坐标是',x,y)
        self.v1=100 
        #  如果写了 上面这句话， 语法上表示： 当该类的 某一个实例 调用了move方法后， 这个实例会增加一个成员 属性v1 且值为100
        #  但在实例 没调用move方法 之前 ， 实例自身是没有v1属性的
        # 注： 上面的  "self.v1" 仅仅为了说明 语法规则， 不代表v1 在 car类中 有什么具体 功能意义。
        
    def printSelf(self):
        print(self.brand,self.color,self.type)   # 在本方法中 通过"self.属性名"  表示访问本实例的 其他成员
        # 以上代码 可以表示  类的实例成员  之间的相互访问
        
    # 不属于 实例的方法
    1.静态成员方法
        @staticmethod     # 在类的成员方法定义上一行 加上  “@名称 ” 这种语法格式  称为“装饰器”
        def roolback():
            print('这是 该类的静态方法')   #静态方法  通过类名称 加点号 调用， 例： ca.roolback()
        
    2.类方法
        @classmethod 
        def clsM1(cls):   # 也通过类名称 调用的方法
            print('属于类自身的方法')        

2.创建car类型的 实例(该类型的 实际数据)

c1=car() 
# 创建car类的实例 会自动的 调用类中的 " __init__()" 方法,  调用形式上的变化 遵守函数参数 语法规则
# 例如上面这行， 调用了__init__方法   但没有传递任何参数， 表示使用该方法的 默认参数值

c2=car('白色','SUV',"BMW")
c3=car(ty="MPV",co='灰色',br="五菱")

c1.printSelf()
c2.printSelf()
# print(c1.v1)

c3.move(10, 20)
c2.move(100, 200)
print(c2.v1,c3.v1)

# 调用 类的成员，它们不属于 类的实例， 只属于类自身， 只能通过  类名称  调用
print(car.wheelNO)
car.roolback()
car.clsM1()

3.类的私有属性

class car():
    wheelNO=4 
    def __init__(self,co='黑色',ty='轿车',br='BYD'):
        self.color = co   #  self 表示实例(类的每一个实际数据)自身。  self.变量名   声明的是 属于实例自身的 成员属性
        self.type = ty
        self.brand = br  
        self.__age=1      # 私有化成员，格式：在成员名字的前面加 双下划线
                          # 私有成员 不能被类外部 代码 通过实例名称  直接访问   
        self.__old=1.0
    
    def move(self,x,y):
        print('本实例',id(self), '移动到的新坐标是',x,y)

    def printSelf(self):
        print(self.brand,self.color,self.type)   # 在本方法中 通过"self.属性名"  表示访问本实例的 其他成员
        # 以上代码 可以表示  类的实例成员  之间的相互访问
        
    def setAge(self,ag):   #  实现对 __age属性的“封装”
        if(1<ag<20):       #  “封装”： 一个成员被私有化， 之后再通过其他公开的方法  间接访问，
            self.__age=ag  #  并且在 间接访问的 途径中  加入逻辑限定
        else:
            print('参数有误，未做任何改变')
            
    def getAge(self):
        return self.__age
    
    def getOlder(self):
        if self.type=="轿车":
            self.__carOld()
            return self.__old
            
    def __carOld(self):   #  本方法 根据类的语法规则 是“私有方法” , 只能在类中被调用
        if(1<self.__age<=2):
            self.__old=0.8
        elif 2<self.__age<=5:
            self.__old=0.7
        elif 5<self.__age<=10:
            self.__old=0.5
        else:
            self.__old=0.3
    
c1=car()
# c1.__age   # 此句 代码 会报错， 因为 __age属性 是c1实例的 私有属性 ， 语法上 无法直接访问
c1.setAge(5)
print(c1.color,c1.getAge(),c1.getOlder())

4.继承

继承， 扩展一个类 的方式 写一个新类

1. 定义 父类(超类 --super class)
class A():              
    def __init__(self):
        self.v1=10
        self.__v2=20
        
    def AObjM1(self):
        print('AObjeM1')
        
    def __AObjM2(self):
        print('AObjM2')
    
2.定义 子类
class B(A):
    def __init__(self):  # 如果 子类单独写了 构造方法  将会覆盖  父类继承过来的  构造方法， 此时父类的构造方法  不会 自动执行
        self.v3=30
        super().__init__() # 明确 声明调用 父类的构造方法
    
    def BObjeM1(self):
        print('BObjeM1')
        #self.__AObjM2()   #  父类的私有 成员无法继承到 子类中，  这句是会报错的
        # print(self.__v2)
        print(self.v1,self.v3)

3.创建子类实例  
b1=B()
b1.BObjeM1()
print(b1.v1)
b1.AObjM1()

【面向对象练习】

1.创建父类 shap 包含 x， y int型属性 和 showXY()方法 返回x y 值

2.创建子类 Rec 扩展实例成员方法 printType 根据实例自身 xy的关系， 输出“正方形” 或 “长方形”

3.创建子类 Tri 扩展一个int型 实例成员 z,

扩展两个方法 printType() 根据实例自身的情况 输出 “无法构成” “普通” “等腰” “等边”; 私有方法 __isTri() 输出bool值 代表判断 实例自身是否构成三角形

1.父类
class shap(): 
    def __init__(self,a=2,b=3):
        self.x=a
        self.y=b   
    
    def showXY(self):
        return self.x, self.y            
    

2.子类 Rec
class Rec(shap):
    
    def printType(self):
        if self.x == self.y :
            print("正方形")
        else:
            print("长方形")
        
3.子类 Tri
class Tri(shap):
    
    def __init__(self,i=1,j=1,k=1):  # 子类构造方法
        self.z=k
        super().__init__(i,j)        # 调用父类构造方法  并且把 i j 传递给父类的 a 和 b
        
    def __isTri(self):               # 定义 实例的私有 成员方法  
        a=self.x
        b=self.y
        c=self.z
        if a+b>c and a+c>b and b+c>a :
            return True
        else:
            return False
        
    def printType(self): 
        a=self.x
        b=self.y
        c=self.z 
        if not self.__isTri() :
            print('不能构成')
        elif  a==b and b==c :
            print("等边")
        elif  a==b  or a==c or b==c :
            print('等腰')
        else:
            print("普通")

4.创建实例        
r1=Rec()
r2=Rec(3,3)
r1.printType()
r2.printType()
t1=Tri()
t1.printType()

t2=Tri(1,2,3)
t2.printType()

t3=Tri(2,2,3)
t3.printType()

t3.x=3
t3.y=4
t3.z=5   
t3.printType()