python --访问限制、继承和多态

一. 访问限制:

1. 定义

在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会将变量改成不同的变量名。

2. 练习

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('测试成功!')

二. 继承

1. 定义

在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()

2. 新式类和经典类

新式类是深度优先：是指从起始页开始，一个链接一个链接跟踪下去，处理完这条线路之后再转入下一个起始页，继续追踪链接。 

深度优先的顺序是：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()