13-面向对象2
程序员文章站
2022-08-10 16:43:51
保护对象的属性 如果有一个对象，当需要对其进行修改属性时，有2钟方法： 对象名.属性名 = 数据 >直接修改 对象名.方法名() >间接修改 为了更好的保存属性的安全，即不能随意修改，一般的处理方式为： 将属性定义为私有属性 添加一个可以调用的方法，供调用 运行结果为： 修改代码： 运行结果： 总结 ......
保护对象的属性
如果有一个对象，当需要对其进行修改属性时，有2钟方法：
- 对象名.属性名 = 数据 ---->直接修改
- 对象名.方法名() ---->间接修改
为了更好的保存属性的安全，即不能随意修改，一般的处理方式为：
- 将属性定义为私有属性
- 添加一个可以调用的方法，供调用
11 class Person(object):
12 def __init__(self,name):
13 self.__name = name
14 def getName(self):
15 return self.__name
16 def setName(self,newName):
17 if len(newName)>=5:
18 self.__name = newName
19 else:
20 print('error:名字的长度要大于或者等于5')
21
22 xiaoming = Person('XIAOYAFEI')
23 print(xiaoming.__name)
运行结果为：
Traceback (most recent call last):
File "test.py", line 23, in <module>
print(xiaoming.__name)
AttributeError: 'Person' object has no attribute '__name'
修改代码：
11 class Person(object):
12 def __init__(self,name):
13 self.__name = name
14 def getName(self):
15 return self.__name
16 def setName(self,newName):
17 if len(newName)>=5:
18 self.__name = newName
19 else:
20 print('error:名字的长度要大于或者等于5')
21
22 xiaoming = Person('XIAOYAFEI')
23
24 xiaoming.setName("wang")
25 print(xiaoming.getName())
26
27 xiaoming.setName('lisisi')
28 print(xiaoming.getName())
运行结果：
error:名字的长度要大于或者等于5 XIAOYAFEI lisisi
总结：
- python中没有像C++中public和private这些关键字来区别公有属性和私有属性
- 它是以属性命名方式来区分，如果在属性名前面加了2个下划线'__'，则表示该属性是私有属性，否则为公有属性（方法也是一样，方法名前面加了2个下划线的话表示该方法是私有的，否则为公有的）
__del__()方法
创建对象后，python解释器默认调用__init__()方法；
当删除一个对象时，python解释器也会默认调用一个方法，这个方法为__del__()方法
1 #!/usr/bin/python
2 #coding=utf8
3 """
4 # Author: xiaoyafei
5 # Created Time : 2018-04-08 15:28:14
6
7 # File Name: test2.py
8 # Description:
9
10 """
11 import time
12 class Animal():
13 #初始化方法
14 #创建为对象后会自动被调用
15 def __init__(self,name):
16 print('???????__init__方法被调用???????')
17 self.__name = name
18
19 #析构方法
20 #当对象被删除时，会自动被调用
21 def __del__(self):
22 print('__del__方法被调用')
23 print('%s对象马上被干掉了......'%self.__name)
24
25 #创建对象
26 dog = Animal('嗨皮')
27 #删除对象
28 del dog
29
30 cat = Animal('波斯猫')
31 cat2 = cat
32 cat3 = cat
33
34 print('马上删除cat对象')
35 del cat
36 print('马上删除cat1对象')
37 del cat2
38 print('马上删除cat2对象')
39 del cat3
40
41 print('程序在2秒钟后结束')
42 time.sleep(2)
运行结果如下：
———————__init__方法被调用——————— __del__方法被调用 嗨皮对象马上被干掉了...... ———————__init__方法被调用——————— 马上删除cat对象 马上删除cat1对象 马上删除cat2对象 __del__方法被调用 波斯猫对象马上被干掉了...... 程序在2秒钟后结束
总结：
- 当有1个变量保存了对象的引用时，此对象的引用计数就会加1
- 当使用del删除变量指向的对象时，如果对象的引用计数不为1，比如3，那么此时只会让这个引用计数减1，即变为2，当再次调用del时，变为1，如果再调用1次del，此时会真的把对象进行删除
继承
在程序中，继承描述的是事物之间的所属关系，例如猫和狗都属于动物，程序中便可以描述为狗和猫继承自动物；同理，波斯猫和巴厘猫都继承自猫，而沙皮狗和斑点狗都继承自狗
继承示例
#!/usr/bin/python
#coding=utf8
"""
# Author: xiaoyafei
# Created Time : 2018-04-04 11:35:02
# File Name: 03-单继承.py
# Description:
"""
#定义一个父类
class Cat():
def __init__(self,name,color="白色"):
self.name = name
self.color = color
def run(self):
print('%s------在跑'%self.name)
#定义一个子类,来继承Cat类
class Bosi(Cat):
def __str__(self):
return self.name
def setNewName(self,newName):
self.name = newName
def eat(self):
print("%s------在吃"%self.name)
bs = Bosi("lipeng")
bs.run()
bs.setNewName("小明")
print(bs)
运行结果为：
lipeng------在跑 小明
说明：
- 虽然子类没有定义__init__方法，但是父类有，所以在子类继承父类的时候这个方法就被继承了，所以只要创建Bosi对象，就默认执行了那个继承过来的父类的__init__方法
总结：
- 子类在继承的时候，在定义类时，小括号()中为父类的名字
- 父类的属性、方法，会被继承给子类
注意点
1 #!/usr/bin/python
2 #coding=utf8
3 """
4 # Author: xiaoyafei
5 # Created Time : 2018-04-08 15:45:07
6
7 # File Name: 04-单继承-注意点.py
8 # Description:
9
10 """
11 class Animal():
12 def __init__(self,name='动物',color='白色'):
13 self.__name = name
14 self.color = color
15 def __test(self):
16 print(self.__name)
17 print(self.color)
18 def test(self):
19 print(self.__name)
20 print(self.color)
21
22 class Dog(Animal):
23 def dogTest1(self):
24 #print(self.__name)
25 print(self.color)
26 def dogTest2(self):
27 #self.__test()
28 self.test()
29
30 A = Animal()
31 #print(A.__name) #程序出现异常，不能直接访问私有属性
32 print(A.color)
33 #A.__test() #程序出现异常，不能直接访问私有方法
34 A.test()
35
36 print('----------------------------华丽的分割线----------------------------------')
37 D = Dog(name = '小花狗',color = '黄色')
38 D.dogTest1()
39 D.dogTest2()
- 私有的属性，不能通过对象直接访问，但是可以通过方法访问
- 私有的方法，不能通过对象直接访问
- 私有的属性、方法，不会被子类继承，也不能给访问
- 一般情况下，私有的属性、方法都是不对外公布的，往往来做内部的事情，起到安全的作用
多继承
所谓多继承，即子类有多个父类，并且具有它们的特征
python中多继承的格式如下：
14 class a():
15 def printA(self):
16 print('-aaaaaaaaaaaaa')
17
18 class b():
19 def printB(self):
20 print('------------b')
21
22
23 class c(a,b):
24 def printC(self):
25 print('-cccccccccccccccccc')
26
27 c = c()
28 c.printA()
29 c.printB()
30 c.printC()
运行结果如下：
-aaaaaaaaaaaaa ------------b -cccccccccccccccccc
说明：
- python中是可以多继承的
- 父类中的方法、属性，子类会继承
多继承-注意点
1 #!/usr/bin/python
2 #coding=utf8
3 """
4 # Author: xiaoyafei
5 # Created Time : 2018-04-04 14:29:20
6
7 # File Name: 06-多继承注意点.py
8 # Description:
9 在多个父类中拥有相同的方法应该调用哪一个？？？
10
11 可以使用__mro__方法去查看调用顺序
12 """
13
14 class A():
15 def printA(self):
16 print('aaaaaaaaaaaaaaaaaa')
17 class B():
18 def printA(self):
19 print('bbbbbbbbbbbbbbbbb')
20
21 class S(A,B):
22 def printS(self):
23 print('SSSSSSSSSSSSSSSSSS')
24
25 zi = S()
26 zi.printS()
27 zi. printA()
28 print(S.__mro__) #可以查看C类的对象搜索方法时的先后顺序
运行结果：
SSSSSSSSSSSSSSSSSS aaaaaaaaaaaaaaaaaa (<class '__main__.S'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)
重写父类方法和调用父类方法
重写父类方法
所谓重写，就是子类中，有一个和父类相同名字的方法，在子类中的方法会覆盖掉父类中同名的方法
13 class Cat():
14 def sayHello(self):
15 print('Hello----1')
16
17 class Bosi(Cat):
18 def sayHello(self):
19 print('Hello----4')
20 bosi = Bosi()
21 bosi.sayHello()
运行结果如下：
Hello----4
调用父类方法
1 #!/usr/bin/python
2 #coding=utf8
3 """
4 # Author: xiaoyafei
5 # Created Time : 2018-04-08 17:28:14
6
7 # File Name: 08-调用父类的方法-1.py
8 # Description:
9
10 """
11 class Cat():
12 def __init__(self,name):
13 self.name = name
14 self.color = 'yellow'
15
16 class Bosi(Cat):
17 def __init__(self,name):
18 super().__init__(name)
19
20 def getName(self):
21 return self.name
22
23 bosi = Bosi('波斯猫')
24 print(bosi.name)
25 print(bosi.color)
运行结果如下：
波斯猫 yellow
super()不是父类，而是继承顺序的下一个类
在多重继承是会涉及到继承顺序，super()相当于返回继承顺序的下一个类，而不是父类
多态
多态的概念是应用于Java和c#这一类强语言中，而python崇尚"鸭子类型"
所谓多态：定义时的类型和运行时的类型不一样，此时就形成了多态
python鸭子类型代码：
12 class F1(object):
13 def show(self):
14 print('F1.show')
15 class S1(F1):
16 def show(self):
17 print('S1.show')
18 class S2(F1):
19 def show(self):
20 print('S2.show')
21
22 def Func(obj):
23 print(obj.show())
24
25 s1_obj = S1()
26 Func(s1_obj)
27
28 s2_obj = S2()
29 Func(s2_obj)
上一篇： linq之多表连接
下一篇： Mysql的内连接,外链接,交叉链接