Table of Contents
访问限制
定义
练习
继承
继承定义
新式类和经典类
多态
练习
访问限制
定义
在Class内部，可以有属性和方法，而外部的代码可以通过直接调用实例变量的方法来操作数据。但是这种操作方法有很大的弊端：外部的代码可以自由修改实例中的属性
class Student(object):
def __init__(self,name,age):
self.name = name
self.age = age
def getScore(self,score):
print('The student score is %.2f' %score)
student = Student('xiaoming',55)
print(student.age)
student.age = 66
print(student.age)
这种情况下很不安全，因此很多时候我们要让内部属性不被外部访问，可以在属性的名称前加上两个下划线__，在python中，实例的变量名以__开头就变成一个私有变量(private)，只有内部可以访问，外部不可以访问。
class Student(object):
def __init__(self,name,age):
self.__name = name
self.__age = age
def getScore(self,score):
print('The student score is %.2f' %score)
student = Student('xiaoming',55)
print(student.age)
这样就可以保证外部代码不能随意修改对象内部的状态，进行访问控制限制保护，提高了安全性。
那么这样的话，问题就来了，我们要是想让外部获取或者修改私有变量该怎么办？添加set和get方法
# 允许外部获取
class Student(object):
...
def get_name(self):
return self.__name
def get_score(self):
return self.__score
# 允许外部修改
class Student(object):
...
def set_score(self, score):
self.__score = score那么，双下划线开头的实例变量是不是一定不能从外部访问呢？不，我们可以通过"_类名__变量名"来访问，但是不建议，这种方法不能版本的Python会将变量改成不同的变量名。
练习
class Student(object):
def __init__(self, name, gender):
self.__name = name
self.__gender = gender
def get_gender(self):
return self.__gender
def set_gender(self,gender):
self.__gender = gender
bart = Student('Bart', 'male')
if bart.get_gender() != 'male':
print('测试失败!')
else:
bart.set_gender('female')
if bart.get_gender() != 'female':
print('测试失败!')
else:
print('测试成功!')
继承
继承定义
在OOP程序设计中，当我们定义一个class的时候，可以从某个现有的class继承，新的class称为子类（Subclass），而被继承的class称为基类、父类或超类（Base class、Super class）。
子类可以继承父类的属性、继承父类方法，如果一个方法在父类和子类中都存在，那么子类会将父类中的方法重写。
class Father(object):
def __init__(self,name,age):
self.name = name
self.age = age
def age(self):
print('%s is eating...' %self.name)
def set_goal(self):
print('%s set a goal' %self.name)
# Son继承于Father类
class Son(Father):
def eat(self):
print('%s daoli eating...' %self.name)
father = Father('dsd','24')
son = Son('szy','34')
# 继承父类属性
print(son.name)
# 继承父类方法
son.set_goal()
# 子类重写父类方法
son.eat()
新式类和经典类
新式类是深度优先：是指从起始页开始，一个链接一个链接跟踪下去，处理完这条线路之后再转入下一个起始页，继续追踪链接。
深度优先的顺序是：A-B-D-E-I-C-F-G-H【递归实现】
# python2中深度优化
class D():
def test(self):
print('test in D...')
class C(D):
def test(self):
print('test in C...')
class B(D):
pass
# def test(self):
# print('test in B...')
class A(B,C):
pass
# def test(self):
# print('test in A...')
a = A()
print(a.test())
经典类是广度优先：是指先抓取起始页中的所有网页，然后在选择其中的一个连接网页，继续抓取在此网页中链接的所有网页。
广度优先的顺序为：A-B-C-D-E-F-G-H-I 【队列实现】
# python3中广度优先
class D(object):
def test(self):
print('test in D...')
class C(D):
def test(self):
print('test in C...')
class B(D):
pass
# def test(self):
# print('test in B...')
class A(B,C):
pass
# def test(self):
# print('test in A...')
a = A()
print(a.test())
多态
多态：一个操作的意义取决于被操作对象的类型，相同的消息给予不同的对象会引发不同的动作。多态意味着变量并不知道引用的对象是什么，根据引用对象的不同表现不同的行为方式在处理多态对象时，只需要关注他的接口即可.同一个操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。
练习
class Student():
def get_score(self):
print('Student score...')
class Chinese():
def get_score(self):
print('Chinese score...')
class Math():
def get_score(self):
print('Math score...')
student = Student()
chinese = Chinese()
math = Math()
student.get_score()
chinese.get_score()
math.get_score()
