python-面向对象三大特性

python-面向对象三大特性

封装

继承

多态

封装

'''封装
    封装就是把类的属性和方法封装到类的内部，只能在内部使用，不能在类外部使用
    把属性和方法前面加两个下划线，这个属性和方法就成为类的私有属性和私有方法'''
​

示例

#示例
class woman:
    def __init__(self):
        self.name="玛丽"
        self.__weight=200#在属性前面加两个下划线就属于这个类的私有属性
    def __eat(self):#这是一个类的私有方法
        print("%s胖是因为吃的多"%self.name)
w=woman()
print(w.name)#类的私有属性只能在类的内部使用，在外部无法调用私有属性和私有方法
#案例
'''设计一个类：user
    类的属性
        name，
            私有属性：__password
    类的方法
        show_name
            私有方法：__show_password'''
class user:
    def __init__(self):
        self.name="admin"
        self.__password="123456"
    def show_name(self):
        print(self.name)
    def __show_password(self):
        print(self.__password)
u=user()
u.show_name()#在类的外部不能访问私有属性和私有方法
#u.__show_password()/访问不了

　　

继承

'''继承
    类A继承自类B
        那么类B会拥有类A的所有属性的方法
        但是如果类A中有私有属性/私有方法。类B无法继承'''
​

示例

class A:
    def __init__(self):
        self.name="这是类A的属性和方法"
    def show_name(self):
        print(self.name)
class B(A):
    def show_name(self):
        print(self.name)
b=B()#实例化类B创建对象b
b.show_name()#在类B中调用类A的属性和方法

　　

有关继承的专业属于/别称

'''有关继承的专业术语
    子类==派生类
        子类：类B是类A的子类
        类B是类A的派生类
    父类=基类
        类A是类B的父类
        类A是类B的基类
    继承=派生
        类B继承自类A
        类B派生自类A'''

#一个父类可以拥有多个自类继承，每个子类可以拥有自己的特有方法和属性

class animal:#父类
    def sleep(self):#父类的方法
        print("睡")
​
    def eat(self):#父类的方法
        print("吃")
​
class dog(animal):#子类
    def run(self):#子类自己的方法
        print("跑")
​
class erha(dog):#二级子类
    def kawayi(self):#二级子类自己的方法
        print("萌")
​
e = erha()#创建二级子类的对象
e.sleep()#调用父类的方法
e.eat()#调用父类的方法
e.run()#调用一级子类的方法
e.kawayi()#调用二级子类的方法
'''类中可以不写属性'''

　　

方法的重写

'''当父类的方法不能满足子类的需求
    方法重写的方式有两种
        覆盖父类的方法
        扩展父类的方法'''

覆盖父类的方法

'''当子类中出现与父类相同的方法，在子类中相同的方法会覆盖父类的方法'''
class cat:
    def sleep(self):
        print("这是父类的方法")
    def dink(self):
        print("这个是没有覆盖，子类可以正常调用的方法")
class car(cat):
    def sleep(self):
        print("此时子类的方法覆盖了父类的方法")
c1=car()
c1.sleep()#此时调用的方法就是属于子类自己的方法
c1.dink()#应为这个dink方法没有被子类覆盖，所以在子类创建的对象中任然可以正常使用

　　

​

扩展父类的方法

#扩展父类的方法
'''如果父类的方法不满完全满足子类，子类可以在父类的方法基础上增加功能
    语法
        def 与父类相同的方法名：
            super().与父类相同的函数名
            扩展后执行的代码'''
class F:
    def fulei(self):
        print("这是父类原有的方法")
class s(F):
    def fulei(self):
        super().fulei()
        print("子类扩展了父类")
c5=s()
c5.fulei()#调用子类扩展后的方法
'''输出的结果并不会输出到一行而是输出为两个结果'''

　　

父类的私有成员不会继承给子类

class fu:
    def name(self):
        print("这是父类的公有方法，可以继承给子类")
    def __ps(self):
        print("这是父类的私有方法，不会继承给子类")
class zi(fu):
    def zilei(self):
        pass
c1=zi()
c1.name()
#c1.__ps()不会继承给子类
#练习
class father:
    def __init__(self):
        self.name="张三"
        self.house="别墅"
    def sleep(self):
        print("睡")
    def eat(self):
        print("吃")
class son(father):
    def show_eat(self):
        self.eat()
    def show_sleep(self):
        self.sleep()
    def show_house(self):
        print(self.house)#house是一个属性不能调用只能在print里面输出
s=son()
s.eat()#这是父类的方法
s.show_eat()#这是子类的方法
s.sleep()#这是父类的方法
s.show_sleep()#这是子类的方法
s.show_house()#这是父类的属性

　　

多态

'''多态
    不同的子类，调用相同的父类方法，产生不同的结果
    多态的前提是不同的子类来自同一个父类，子类覆盖父类的方法'''
class F:
    def fu(self):
        print("这是父类的方法")
    def fu2(self):
        self.fu()
class z1(F):
    def fu2(self):
        print("子类1覆盖了父类的方法")
class z2(F):
    def fu2(self):
        print("子类2也覆盖了父类的方法")
f=F()#给父类创建对象
f.fu2()#正常调用父类的方法
z=z1()#创建子类1的对象
z.fu2()#在子类中调用父类的方法
x=z2()#创建子类2的对象
x.fu2()#在子类2中调用父类的方法
'''在子类覆盖父类的情况下，不同的子类调用相同的父类方法时出现的结果也是不同的'''

　　

类属性和类方法

'''类属性
    定义在类里面，方法外面，定义的时候不需要self关键字，语法类似于普通的变量
    不需要把类实例化为对象
    直接通过：
            类名.属性名使用'''

class dog():
    name="二哈"#在这个位置的变量叫类属性
    def __init__(self):
        pass
print(dog.name)#在类外面可以直接使用类名.类方法使用
dog.name="大黄"#也可以通过类名.类方法="值"进行修改

　　

类方法

'''类方法
    类方法不需要把类实例化为对象，通过类名.类方法调用
    使用@classmethod修饰的方法就是类方法
    类方法的第一个参数时cls（不是self）
    类方法内部不能使用普通属性，也不能调用普通方法
        因为类方法和类属性是不需要通过实例化就可以进行调用，而普通方法和属性一定要通过实例化类才能调用'''
class dog1():
    name="富贵"#这是类属性
    @classmethod
    def set_name(cls,name):#这是类方法，可以通过类名.类方法名直接调用
        cls.name=name
    def __init__(self):#这是普通方法
        self.age=20#用调用类方法的方式无法调用普通方法必须实例化类才可以
print(dog1.name)#调用类属性
dog1.set_name("平安")#调用类方法
c=dog1()#实例化类
print(c.age)#实例化类以后才可以调用普通方法

　　

在普通方法中使用类属性和类方法

'''在普通方法中使用类属性和类方法
    普通方法中通过
            类名.类属性
            类名.类方法
                    使用类属性和类方法'''
class dos:
    name="富贵"#类属性
    @classmethod#类方法使用@classmethod进行修饰
    def get_name(cls):#类方法
        return cls.name#调用类方法返回类属性的值
    def __init__(self):#普通方法
        dos.name="平安"#在普通方法里面修改类属性
        print(dos.get_name())#在普通方法里面调用类方法
c=dos()#实例化类
c.get_name()#在普通方法里面调用类方法
'''在普通方法里面使用类方法/类属性，需要将类实例化后才能使用'''

　　

静态方法

'''在类中通过@staticmethod修饰的方法叫静态方法
    静态方法与类方法一致，不需要通过实例化类就可以进行调用
    通过：
        类名.静态方法名
            就可以调用静态方法
    静态方法不能访问类中的其他成员，静态方法就是一个堵路与类存在的函数'''
class doss:
    @staticmethod
    def help():#静态方法不用谢self和cls
        print("这是一个静态参数")
doss.help()
'''静态方法的使用场景
    当代码两特别大的时候，函数也会特别多，为了避免函数的重名，可以把同名函数放到不同的类里面，作为静态方法
    说人话就是个隔离窗口防止函数重名'''
class dog:
    @staticmethod
    def help():
        print("这是一个静态方法")
​
class A:
    @staticmethod
    def help():
        print("这是第二个静态方法help")
dog.help()
A.help()

　　

​