封装

  • 封装特征

实际工作中很多的成员不方便为对象之外的访问或者操作的，所以需要限定以下是否可以操作成员。
封装特性就是对于成员操作进行限制的保护性措施！

  • 面向对象的封装分为三个级别
1
2
3
私有化封装  OK
受保护的封装（暂时不讲，在继承章节讲解）
公共的封装  OK
  • 对象/类成员的访问
1
2
3
1.当前类/对象内部访问 （在类的结构内部）
2.类和对象的外部访问  （在类的结构外部）
3.类和对象的子类/子对象的访问（在类的结构外部，在子类/对象的内部）
  • 私有化封装
1
2
方法：在成员属性或者方法名称之前，添加双下划线，就可以私有化成员。
特征：私有化的成员属性和方法，无法在类/对象的外部访问；私有化成员仅允许在类/对象的内部访问
  • 公共的封装
1
2
方法： 任何成员在没有进行私有化操作的时候默认都是公共的封装。
特征： 公共的封装成员属性和方法，在任何位置都可以被访问。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
#声明一个人类
class Human:
  #成员属性
  name = '张三'#允许别人使用
  __sex  = '男' #不允许别人访问
  age = 18
  heart = '健康心脏'#不允许别人访问
  __kidney  = '强大的肾脏'#不允许别人访问 #根据改名策略 将属性修改为 _类名__属性名 ->_Human__kidney

  #成员方法
  #唱歌
  def sing(self):
      print('都如艾米发馊拉稀都')
  #吃饭 #允许别人访问
  def eat(self):
      print('我最喜欢吃西红柿炒番茄了！')
  #跑步 #不允许别人访问
  def __run(self):#私有化
      print('121,121,锻炼身体')
  #聊天(用于测试类.对象的内部访问私有成员)
  def talk(self):
      print('我的名字是',self.name)
      #在类/对象的内部访问私有成员属性
      print('我的肾脏是非常好的',self.__kidney)
      #在类/对象的内部访问私有成员方法
      self.__run()

#实例化对象
zs = Human()

#访问对象的成员属性和方法
#调用唱歌方法
#zs.sing()

#调用跑步方法
#zs.run()
#zs.__run()#私有化封装之后，类/对象的外部无法访问

#测试类./对象内部访问私有成员
zs.talk()

#访问私有化属性--肾脏
#print(zs.kidney)
#print(zs.__kidney)  私有化封装之后，类/对象的外部无法访问！

#知晓改名策略之后，可以访问私有成员（严禁任何人使用该方法访问私有成员）
#print(zs._Human__kidney)
zs._Human__run()
  • 受保护的封装

受保护的封装：在成员名称前面加一个下划线
受保护的目的：仅允许成员在当前类/对象或者子类/子对象中访问，外部禁止
注意：python目前不支持设定受保护的成员，但是开发者由约定的使用方式

1
2
3
4
5
6
          类/对象内      子类/子对象中       类/对象外
私有化        √              ×                  ×

受保护        √              √                  √（实际上不允许）

公共的        √              √                  √
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
#父类
class LiuBei:
  #属性
  __wife = ('甘夫人','糜夫人','孙尚香')#私有化
  _money = '100'#受保护（不是语法是约定）
  skin = '黄色'# 公共
  #方法
  #吃饭
  def eat(self):#公共的
      print('打死我***也不吃~ 真香啊~')
  #学习
  def __study(self):#私有化
      print('好好学习天天向上')
  #做鞋
  def _makeshoes(self):
      print('编草鞋')
  #内部测试受保护成员
  def test(self):
      print(self._money)
      self._makeshoes()

#子类
class LiuShan(LiuBei):
  pass

#检测私有化和公共的封装
#实例化对象
ls = LiuShan()
#print(ls.wife) #私有成员无法在子类.子对象中调用
#ls.study()#私有成员无法在子类.子对象中调用

#print(ls.skin)#公共的成员可以在子类/子对象中调用
#ls.eat()#公共的成员可以在子类/子对象中调用

#调用受保护的成员
#实例化刘备的对象
lb = LiuBei()

#在类和对向外（随便访问）
print(lb._money)
lb._makeshoes()

#在类和对象的内部（随便访问）
lb.test()

#在子类和子对象中
print(ls._money)
ls._makeshoes()

继承

  • 继承的含义

面向对象中的继承就表示一个类获取另外一个类的成员的操作。（并非所有成员）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
#父类
class Father(object):
  #成员属性
  familyname = '刘' #姓氏
  __firstname  = '备' #名字
  sex = '男' #性别
  age = 48    #年龄
  color = '黄色'#肤色
  #媳妇进行私有化操作
  __wife = ('甘夫人','糜夫人','孙尚香')

  #吃饭
  def eat(self):
      print('甜甜圈，咖啡，面包，方便面~')
  #跑
  def run(self):
      print('拔起腿就跑~')
  #做鞋
  def makeshoes(self):
      print('做草鞋')


#声明一个子类
class Son(Father):
  #父类私有化之后，子类独自添加的成员
  firstname = '禅'
  #添加子类独有的成员
  weight = '200斤'

  #做鞋（父类已经具有）  这个操做称之为方法重载
  def makeshoes(self):
      #重新定义功能即可
      print('做皮鞋，不是人造革，是真的皮')

  #跑路(重载父类的操作->在覆盖的同时还要使用原有内容)
  def run(self):
      #添加一个操作
      print('穿上鞋子')

      #调用以下父类的跑路方法(方法1)
      #super().run()#暂时可以认为super表示寻找父类
      #用以下父类的跑路方法(方法2)
      Father.run(self)

      #添加一个操作
      print('好汉饶命')

#打印子类的成员
print(Son.__dict__)

#实例化子类的对象
ls = Son() #子类的对象
#访问子类的姓氏
#print(ls.familyname)
#私有成员，仅仅允许原有类和原有类的对象访问，子类也不可以继承或者访问。
#print(ls.__wife)

#私有化性名
#print(ls.firstname)
#访问子类独有的成员
#print(ls.weight)
#访问做鞋功能
#ls.makeshoes()
#访问跑的方法
ls.run()

继承的特征：

1
2
3
4
5
6
7
8
9
1.在不指定父类的情况下，所有的类均继承自object类（系统提供的！）
2.子类继承父类就具有父类的所有成员。
3.子类继承父类，不会将父类成员复制到子类中，子类如果需要成员，可以找父类索取！
4.私有化的成员，允许在子类中单独建立一份，不会找父类索取私有成员
5.子类可以根据需求添加自己独有的成员来进行操作。
6.子类重载父类的成员。仅仅是对子类/对象有效。并不会影响父类
7.子类在重载父类的方法的时候，可以调用父类的方法来进行操作：
    super().父类方法名() -> 必须是带有self的对象方法才可以使用
    父类名.父类方法名()  -> 任何方式都允许