面向对象学习三

面向对象学习：
Python类中隐藏数据
Python的内置方法：类中的方法名前后都有两个下划线，init()
Python中的私有方法：类中的方法名前面有两个下划线，如__setId()，不能在类外部调用
Python中的私有属性：类中的属性前有两个下划线，如__name，不能在类的外部被使用或直接访问

类的私有属性
1）类的私有属性在类内部的方法中使用时的语法：self.__private_attrs。
举例：
#coding=utf-8
class Person(object):
__secretCount = 0 #私有属性
def init(self, name): #内置方法
self.name = name #实例属性
self.__inName = ‘ads’ #私有属性
def visit_private_attribute( self ):
self.__secretCount += 1
print ("__secretCount:", self.__secretCount)
print ("__inName：", self.__inName)

p = Person(“prel”)
p.visit_private_attribute()
print (“在类外直接通过实例访问私有属性”)
print (p.__inName) #不能在类的外部访问私有属性

执行结果：
__secretCount: 1
__inName： ads
在类外直接通过实例访问私有属性
Traceback (most recent call last):
File “C:/Users/admin/PycharmProjects/untitled1/test.py”, line 15, in
print (p.__inName)
AttributeError: ‘Person’ object has no attribute ‘__inName’

2）可以使用 object._className__attrName 从外部访问私有属性
举例：
#coding=utf-8
class Person(object):
__secretCount = 0 #私有属性
def init(self, name): #内置方法
self.name = name #实例属性
self.__inName = ‘ads’ #私有属性
def visit_private_attribute( self ):
self.__secretCount += 1
print ("__secretCount:", self.__secretCount)
print ("__inName：", self.__inName)

p = Person(“prel”)
p.visit_private_attribute()
print (“使用另一种方法访问私有属性：”)
print (p._Person__secretCount)
print (p._Person__inName)

执行结果：
__secretCount: 1
__inName： ads
使用另一种方法访问私有属性：
1
ads

注意：python的语法并不是那么严格的能够保证私有变量不被随意改动

类私有方法：
1）类的私有方法在类内部调用语法： self.__private_methods
举例：

#coding=utf-8
class Person(object):
id = 12 #类静态成员在这儿定义，注意缩进
def init(self,name): #内置方法
self.name = name
self.__inName = ‘ads’
def __setId(self,id): #隐藏方法
Person.id = id * 2
def getId(self):
self.__setId(18) #类内部调用隐藏方法
return Person.id

p = Person(“prel”)
print (p.getId())
print (“类外部调用私有方法”)
print (p.__setId(10)) #不能在类的外部访问私有方法

执行结果：
Traceback (most recent call last):
36
类外部调用私有方法
File “C:/Users/admin/PycharmProjects/untitled1/test.py”, line 16, in
print (p.__setId(10))
AttributeError: ‘Person’ object has no attribute ‘__setId’

2）尝试使用 object._className__methods调类私有方法，尝试失败

#coding=utf-8
class Person(object):
id = 12 #类静态成员在这儿定义，注意缩进
def init(self,name): #内置方法
self.name = name
self.__inName = ‘ads’
def __setId(self,id): #隐藏方法
Person.id = id * 2
def getId(self):
self.__setId(18) #类内部调用隐藏方法
return Person.id

p = Person(“prel”)
print (p.getId())
print (“尝试另一种类外部调用私有方法”)
print (p._Person__setId(10)) #在类外部不能调用类内部私有方法成功

执行结果：
36
尝试另一种类外部调用私有方法
None

继承：继承完全可以理解成类之间的类型和子类型关系。即一个派生类（derived class）继承基类（bass class）字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。
继承可以实现代码的重用。

继承基本语法：
class 派生类名（基类名1 [, 基类名2…]）：
‘Optional class documentation string’
class_suite
基类名写在括号里，基本类是在类定义的时候，在元组之中指明的。如果在继承元组中列了一个以上的基类，那么它就被称作” 多重继承” 。

继承的特点：
1）子类不会继承基类的构造方法
2）子类在调用基类的方法时，需要加上基类的类名前缀，且需要带上self参数变量
3）先在本类中查找需要调用的方法，找不到才去基类中找
4）子类只继承父类所有公有的属性和方法，并且也可以在子类中通过父类名来调用，而对于私有的属性和方法，子类是不进行继承的，因此在子类中是无法通过父类名来访问的

举例：
#encoding=utf-8
class Animal: #父类Animal
def eat(self):
print ("%s 吃 " %self.name)
def drink(self):
print ("%s 喝 " %self.name)
def shit(self):
print ("%s 拉 " %self.name)
def pee(self):
print ("%s 撒 " %self.name)

class Cat(Animal): #子类Cat，继承父类Animal
def init(self, name):
self.name = name
self.breed = ‘猫’
def cry(self):
print ("%s 喵喵叫"%self.name)

class Dog(Animal): #子类Dog，继承父类Animal
def init(self, name):
self.name = name
self.breed = ‘狗’
def cry(self):
print ("%s 汪汪叫"%self.name)

######### 执行

c1 = Cat(‘小白家的小黑猫’) #对子类Cat进行实例化
c1.eat() #调用父类Animal中的方法
c1.pee() #调用父类Animal中的方法
c1.cry()

d1 = Dog(‘胖子家的小瘦狗’) #对子类Dog进行实例化
d1.eat() #调用父类Animal中的方法
d1.shit() #调用父类Animal中的方法
d1.cry()

执行结果：
小白家的小黑猫 吃
小白家的小黑猫 撒
小白家的小黑猫 喵喵叫
胖子家的小瘦狗 吃
胖子家的小瘦狗 拉
胖子家的小瘦狗 汪汪叫

继承的本质：对于面向对象的继承来说，其实就是将多个类共有的方法提取到父类中，子类仅需继承父类而不必一一实现每个方法。