本文详细介绍了面向对象编程中的类、继承、封装和权限控制的概念。通过实例展示了如何创建类、使用私有变量、数据重用以及封装。同时，探讨了多继承、类的重载以及继承的局限性。还提到了super关键字在多继承中的作用，以及如何通过isinstance()判断对象类型。最后，通过多态性示例展示了不同类实例间调用相同方法的能力。
为什么要使用类
封装，数据的重用都得用到，下划线为私有变量
'''
def add(num1,num2):
return num1+num2
#封装,数据的重用
num1=10
num2=20
print(add(num1,num2))
str1="aaa"
str2="bbbb"
print(add(str1,str2))
'''
#1.数据的重用 2数据的封装权限
class Addclass:
def __init__(self,num1,num2):
self.__num1=num1 #节约了变量重复定义
self.__num2=num2
def add(self):
return self.__num1+self.__num2
a1=Addclass(10,20)
#print(a1.num1)#显示
#print(a1.num2)
print(a1.__num1)
print(a1.add())
a2=Addclass("10","20")
print(a2.add())
权限设计
能看出，我们把需要的变量写入函数里，对它进行初始化，不能改变的设为私有变量，当我们调用时就写入我们需要的参数并且想调用私有的话得输入正确的信息比如密码，这就是权限的含义。
class bankcount:
def __init__(self,username,password,money):
self.__username=username
self.__password=password
self.__money=money
def __getmoney(self):
return self.__money
def getmoney(self,password):
if self.__password==password:
return self.__getmoney()
else:
print("密码错误请重新输入")
def addmoney(self,addmoney):
if addmoney>=0:
self.__money+=addmoney
def getmoney(self,getmoney,password):
if self.__password==password:
self.__money-=getmoney
else:
print("密码错误请重新输入")
haipeng= bankcount("haipeng","123321",10008000)
print(haipeng.getmoney("123321"))
#haipeng.__money=100
#print(haipeng.__getmoney())
#__代表私有，私有属性，私有方法，只有自己在内部调用
#私有设计密码权限，
类的继承
先在REN中写入我们需要的参数，chinesename与email并进行初始化，再写入一个函数，发送邮件，这时我们再写一个baidu调用REN，我们同样写入我们需要的参数，此时调用REN里的参数chinesename，email，我们不需要再对chinesename、email进行初始化同样写一个邮件回复，这时候我们再建一个类Google，那么我们写一个信息，包含人名、英文名、百度id、电话跟邮箱，这时候我们先是调用REN中的函数sendemail，再调用Baidu里的sendms发现均可，那么我们就知道代码继承并且在Baidu的里面chinesename跟email被重用了，并且覆盖。
class Ren: #继承代码重用
def __init__(self,chinesename,email):
self.email=email
self.chinesename=chinesename
def sendmail(self):
print("发邮件给",self.email)
class Baidu(Ren):#继承Ren的属性方法
def __init__(self,chinesename,englishname,baiduid,mobile,email):
Ren.__init__(self,chinesename,email)
self.englishname=englishname
self.baiduid=baiduid
self.mobile=mobile
def sendsms(self):
print("发短信给",self.mobile)
class Google(Ren):
def __init(self):
pass
#白 玉 Bai Yu 6601 13426199746 baiyu@baidu.com
baiduer=Baidu("白 玉", "Bai Yu","6601","13426199746", "baiyu@baidu.com")
baiduer.sendmail()
baiduer.sendsms()
多继承
看到结果，其实很好发现一句写在里面的话类里的方法是前者覆盖后者，而属性是后者覆盖前者，所以要一一对应上，从结果来看jt.momey是干爹的钱因为用的是前者干爹的类方法，所以是100000000，但是疼只有亲爹有，所以输出亲爹疼女儿，潜规则同理，do就跟money同理，wantto就是自己的类属性了
class 美女演员亲爹:
def __init__(self):
self.money=10000
self.car="自行车"
self.livein="天桥下"
def buy(self):
print("买不起车，房，买不起高档化妆品")
def do (self):
print("农民工")
def 疼(self):
print("亲爹疼女儿")
class 美女演员的干爹:
def __init__(self):
self.money=1000000000000
self.car="兰博基尼"
self.livein="长安街1号18号别墅"
def buy(self):
print("买买买买")
def do (self):
print("土豪房地产开发商")
def 潜规则(self):
print("潜规则干女儿")
class 美女演员(美女演员的干爹,美女演员亲爹):#方法，前者覆盖后者
def __init__(self):
美女演员亲爹.__init__(self) #属性，后来覆盖前者
美女演员的干爹.__init__(self)
def wanto(self):
print("潜规则无所谓，但是一定要有钱花")
jt=美女演员()
print(jt.money)
jt.疼()
jt.潜规则()
jt.buy()
jt.do()
jt.wanto()
#多继承，同时继承两个类的属性，方法，
继承的局限性
私有变量无法被继承
class dawang:
def __init__(self ):
self.money=100000000
self.__wife="wife"
self.xiaosan="xiaosan"
pass
class xiaowang(dawang):
def __init__(self):
dawang.__init__(self)
pass
xw=xiaowang()
print(dir(xw))
print(xw.money)
print(xw.xiaosan)
#print(xw.__wife)#私有变量不可以继承
print(xw._dawang__wife)
类的重载
重载就是对新的类型做一种解释，比如这里的例子，想要直接h1+h2,会报错，所以我们可以看到对加法进行了__add__方法的重载，h3=h1+h2 也就转换成了，h3=h1.add(h2)将h2作为otherhouse加到h1上
'''
print(1+2) #针对整数
print("1"+"2")#针对字符串
'''
class housearea:
def __init__(self, area):
self.area=area #面积
def show(self):
print("面积",id(self),self.area)
def __add__(self,otherhouse): #对新的类型做出一种解释
return housearea(self.area+otherhouse.area)
h1=housearea(120)
h1.show()
h2=housearea(360)
h2.show()
h3=h1+h2 #对已有的类型做出新的解释
#h3=h1.__add__(h2) #函数
h3.show()
print(1+2) #针对整数
print("1"+"2")#针对字符串
类的一般属性
对类的解释
class 美女演员的干爹:
'''
hello ,我是土豪
'''
def __init__(self):
self.money=1000000000000
self.car="兰博基尼"
self.livein="长安街1号18号别墅"
def buy(self):
print("买买买买")
def do (self):
print("土豪房地产开发商")
def 潜规则(self):
print("潜规则干女儿")
print(美女演员的干爹.__doc__)#类的说明
print(美女演员的干爹.__name__)#类的名称
print(美女演员的干爹.__module__)#从哪里开始执行
print(美女演员的干爹.__bases__)#父类
print(美女演员的干爹.__dict__)#字典
super
绿色注释的可以看出每次都要调用一次父类爷，super使用后只有4次，不会再初始化父类多次
'''
class 爷:
def __init__(self):
print("爷构造了一次")
class 大儿子(爷):
def __init__(self):
爷.__init__(self)
print("大儿子构造了一次")
class 二儿子(爷):
def __init__(self):
爷.__init__(self)
print("二儿子构造了一次")
class 小儿子(爷):
def __init__(self):
爷.__init__(self)
print("小儿子构造了一次")
class 媳妇(大儿子,二儿子,小儿子):
def __init__(self):
大儿子.__init__(self)
二儿子.__init__(self)
小儿子.__init__(self)
xf=媳妇()
'''
class 爷:
def __init__(self):
print("爷构造了一次")
class 大儿子(爷):
def __init__(self):
super().__init__()
print("大儿子构造了一次")
class 二儿子(爷):
def __init__(self):
super().__init__()
print("二儿子构造了一次")
class 小儿子(爷):
def __init__(self):
super().__init__()
print("小儿子构造了一次")
class 媳妇(大儿子,二儿子,小儿子):
def __init__(self):
super().__init__() #父类初始化，多继承多个父类
xf=媳妇()
instance
判断类型
a=10
print(isinstance(a,int))#判断类型
b="123"
print(isinstance(b,str))
c=1
print(isinstance(c,(str,float))) #判断属于类型之一
class father:
pass
class son(father):
pass
print(isinstance(father(),father))
print(type(father())==father)
print(isinstance(son(),father))#isinstall,根据父类区别，不能识别父类与子类
print(type(son())==father)#精确识别type
多态
我们可以发现makesever调用以上多种方法，这就是多态，并不是同一个类里的，却能调用。
class sever:
def make(self):
print("先森你好，你需要什么东东")
class makeapple(sever):
def make (self):
print("生产苹果")
class makeorange(sever):
def make(self):
print("生产橘子")
class makeshit(sever):
def make(self):
print("生产shit")
def makesever(obj):#接口不变
obj.make()
m1=sever()
makesever(m1)
m2=makeapple()
makesever(m2)
m3= makeorange()
makesever(m3)
m4= makeshit()
makesever(m4)
扫一扫
132
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
