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()
标签：name,python,子类,self,面向对象,def,父类,方法,三大 From： https://www.cnblogs.com/wh0915/p/16987413.html