Python学习第十三课-面向对象三

一、封装

1.1 概念

• 出现封装的原因:我们需要一种方式来增强数据的安全性,形成的约定俗成的规定，同时看到你这么创建属性，那么就不会轻易修改属性值
  • 1.属性不能随意修改
  • 2.属性不能改为任意的值
• 封装是面向对象的三大特性之一(封装、继承和多态)
• 封装是指隐藏对象中一些不希望被外部所访问到的属性或方法

class Car:
    def __init__(self, name):
        self.hidden_name = name

    def get_name(self):
        return self.hidden_name

    def set_name(self, name): # 如果没有则表示name不能修改
        self.hidden_name = name


c1 = Car('奔驰')
print(c1.hidden_name)
print(c1.get_name())
c1.set_name("法拉利")
print(c1.get_name())
c1.set_name("保时捷")
print(c1.get_name())
'''
奔驰
奔驰
法拉利
保时捷
'''

• 我们也可以提供给一个getter()和setter(方法是外部可以访问到属性

  • getter()获取对象中指定的属性
  • setter() 用来设置对象指定的属性

• 使用封装，确实增加了类的定义的复杂程度，但是它也确保了数据的安全

  • 1.隐藏属性名，使调用者无法随意的修改对象中的属性
  • 2.增加了getter()和setter()方法,很好控制属性是否是只读的
  • 3.使用setter()设置属性， 可以在做一个数据的验证
  • 4.使用getter(方法获取属性，使用setter()方法设置属性可以在读取属性和修改属性的同时做一些其他的处理

• 可以为对象的属性使用双下划线开头_ xxx。 双下划线开头的属性,是对象的隐藏属性，隐藏属性只能在类的内部访问，无法通过对象访问

• 其实隐藏属性只不过是Python自动为属性改了一个名字–>_ 类名_属性名例
  如

_ name ->_ Person_ name

• 这种方式实际.上依然可以在外部访问，所以这种方式我们一般不用。一般我们会将-些私有属性以_开头
• 一般情况下，使用_开头的属性都是私有属性,没有特殊情况下不要修改私有属性

1.2 getter()和setter(方法）

class Ref:
    def __init__(self, name):
        self.hidden_name = name
        self.long = '0.5米'  # 公共属性
        self.wide = '0.5米'  # 公共属性
        self.high = '1.8米'  # 公共属性

    def open_ref(self):
        print("打开{}冰箱".format(self.hidden_name))

    def get_into_ref(self, boject):
        print("把{}装入{}冰箱".format(boject, self.hidden_name))

    def close_ref(self):
        print("关上{}冰箱".format(self.hidden_name))
    # getter()和setter(方法）
    def get_name(self):
        return self.hidden_name
    # setter(方法）
    def set_name(self, name):
        self.hidden_name = name


ref = Ref('美的')
ref.open_ref()
ref.get_into_ref('大象')
ref.close_ref()

print('当前冰箱品牌为{}'.format(ref.get_name()))

ref.set_name('奥克斯')

print('修改后 冰箱品牌为{}'.format(ref.get_name()))
'''
打开美的冰箱
把大象装入美的冰箱
关上美的冰箱
当前冰箱品牌为美的
修改后 冰箱品牌为奥克斯
'''

1.3 property装饰器

• 我们可以使用@property装饰器来创建只读属性，@property装饰器会将方法转换为相同名称的只读属性，可以与所定义的属性配合使用，这样可以防止属性被修改
• @property装饰器 使得属性的获取和修改，变得更加简洁

 class C(object):
            @property
            def x(self):
                "I am the 'x' property."
                return self._x
            @x.setter
            def x(self, value):
                self._x = value
            @x.deleter
            def x(self):
                del self._x
        # (copied from class doc)

class Person:
    def __init__(self, name):
        self.__name = name

    @property  # getter方法
    def name(self):
        return self.__name

    @name.setter
    def name(self, name):
        self.__name = name


p1 = Person('刘亦菲')
p2 = Person('周慧敏')
print(p1.name)
p1.name = '关之琳'
# p1.__name = '紫紫' 无效
print(p1.name)
'''
刘亦菲
关之琳
'''

1.4 练习

1、智能手机的默认语言是英文，但是制造手机时可以将语言默认成中文，编写手机类，采用无参构造方法时，表示默认语言，可用有参构造法时，修改默认语言。

class Phone(object):
    def __init__(self):
        # self.name ="英文"
        self.__name = "英文"
        print('智能手机的默认语言是{}'.format(self.__name))

    @property
    def name(self):
        return self.__name

    @name.setter
    def name(self, name):
        self.__name = name
        return self.__name


nokia = Phone()
# print(nokia.name) # 英文
# print(nokia.__name) # AttributeError: 'Phone' object has no attribute '__name'
# nokia.__name = "中文" # 无效
nokia.name = "中文"
print('将智能手机的默认语言设置为{}'.format(nokia.name))
'''
智能手机的默认语言是英文
将智能手机的默认语言设置为中文
'''

二、继承

2.1 概念

• 继承是面向对象三大特性之一
• 通过继承我们可以使一个类获取到其他类中的属性和方法
• 在定义类时，可以在类名后面的括号中指定当前类的父类(超类、基类)
• 继承提高了类的复用性。让类与类之间产生了关系。有了这个关系，才有了多态的特性

2.2 应用

class Person(object):
    name = "人"
    def speak(self):
        print("{}会说话".format(self.name))

class Doctor(Person):#括号里是你要继承的父类的名称
    name = '医生'
    def cure(self):
        print("{}会治病".format(self.name))

class Police(Person):
    name = '警察'


a = Person()
a.speak()
d = Doctor()
d.speak()
d.cure()
# a.cure() # AttributeError: 'Person' object has no attribute 'cure'
p = Police()
p.speak()

print(isinstance(d, Doctor)) #i sinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。   isinstance() 会认为子类是一种父类类型，考虑继承关系。
print(isinstance(d, Person))
print(issubclass(Person, Doctor))# 描述 issubclass() 方法用于判断参数 class 是否是类型参数 classinfo 的子类。 语法：issubclass(class, classinfo)
'''
人会说话
医生会说话
医生会治病
警察会说话
True
True
False
'''

class Fruit:
    name = '水果'
    color = '绿色'

    def harvest(self):
        print('{} 是 {}的'.format(self.name, self.color))
        print('水果 是 {}的'.format(Fruit.color))


class Apple(Fruit):
    name = '苹果'
    color = '红色'


class Orange(Fruit):
    name = '橘子'
    color = '橙色'


apple = Apple()
apple.harvest()

orange = Orange()
orange.harvest()
'''
苹果 是 红色的
水果 是 绿色的
橘子 是 橙色的
水果 是 绿色的
'''

三、方法的重写

3.1 方法重写概念

• 如果在子类中有和父类同名的方法，则通过子类实例去调用方法时，会调用子类的方法而不是父类的方法，这个特点我们称之为方法的重写(覆盖)
• 当我们调用一个对象的方法时:
  • 会优先去当前对象中寻找是否具有该方法，如果有则直接调用
  • 如果没有，则去当前对象的父类中寻找，如果父类中有则直接调用父类中的方法
  • 如果没有，则去父类中的父类寻找，以此类推,直到找到object,如果依然没有找到就报错了

3.2 练习

class A:
    def fa(self):
        print('from A_fa')

    def test(self):
        self.fa()  # b.fa

class B(A): # 括号里是
    def fa(self):
        print('from B_fa')


b=B()
b.test()
‘’‘
from B_fa
’‘’

class Fruit:
name = ‘水果’
color = ‘绿色’

def harvest(self):
    print('{} 是 {}的'.format(self.name, self.color))
    print('水果 是 {}的'.format(Fruit.color))

class Apple(Fruit):
name = ‘苹果’
color = ‘红色’

class Fruit:
    name = '水果'
    color = '绿色'

    def harvest(self):
        print('{} 是 {}的'.format(self.name, self.color))
        print('水果 是 {}的'.format(Fruit.color))


class Apple(Fruit):
    name = '苹果'
    color = '红色'

class Orange(Fruit):
    name = '橘子'
    color = '橙色'

    def harvest(self, color):
        print('{} 是 {}的'.format(self.name, self.color))
        print('水果 是 {}的'.format(Fruit.color))



orange = Orange()
orange.harvest(orange.color)

'''
橘子 是 橙色的
水果 是 绿色的
'''

3.3 super() 函数

• super() 可以获取当前类的父类
• 并且通过super() 返回对象调用父类方法时，不需要传递self
• super() 函数是用于调用父类(超类)的一个方法。
• super() 是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题。
• MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表。
• 建立在方法的重写之上，有需要重新调用父类的方法

3.3.1 语法

以下是 super() 方法的语法:

super(type[, object-or-type])

参数

type – 类。
object-or-type – 类，一般是 self

实例：

class A:
    def add(self, x):
        y = x + 1
        print(y)

 
class B(A):  # 括号里面写的是你要继承的弗雷德名称
    def add(self, x): # 这就是方法的重新，时间里在继承的基础上面的，并且是重写同名的方法
        super().add(x) #这就是调用父类的同名的方法


b = B()
b.add(2)  
'''
3
'''

4.4 练习

class FooParent(object):
    def __init__(self):
        self.parent = 'I\'m the parent.'
        print('Parent')

    def bar(self, message):
        print("%s from Parent" % message)


class FooChild(FooParent):
    def __init__(self):
        # super(FooChild,self) 首先找到 FooChild 的父类（就是类 FooParent），然后把类 FooChild 的对象转换为类 FooParent 的对象
        super(FooChild, self).__init__()
        print('Child')

    def bar(self, message):
        super(FooChild, self).bar(message)
        print('Child bar fuction')
        print(self.parent)


if __name__ == '__main__':
    fooChild = FooChild()
    fooChild.bar('HelloWorld')
'''  
Parent
Child
HelloWorld from Parent
Child bar fuction
I'm the parent.
'''

四、多重继承

4.1 简介

• 在Python中是支持多重继承的。也就是我们可以为一个类同时指定多个父类
• 可以在类名的（）后边添加多个类，来实现多重继承
• 多重继承，会使子类同时拥有多个父类,并且会获取到所有父类中的方法
• 在开发中没有特殊情况，应该尽量避免使用多重继承。因为多重继承会让我们的代码更加复杂
• 如果多个父类中有同名的方法,则会先在第一个父类中寻找, 然后找第二个,找第三个…前面会覆盖后面的

4.2 练习

# 类定义
class people:
    # 定义基本属性
    name = ''
    age = 0
    # 定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0

    # 定义构造方法
    def __init__(self, n, a, w):
        self.name = n
        self.age = a
        self.__weight = w

    def speak(self):
        print("%s 说: 我 %d 岁。" % (self.name, self.age))


# 单继承示例
class student(people):
    grade = ''

    def __init__(self, n, a, w, g):
        # 调用父类的构函
        people.__init__(self, n, a, w)
        self.grade = g

    # 覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级" % (self.name, self.age, self.grade))


# 另一个类，多重继承之前的准备

class speaker():
    topic = ''
    name = ''

    def __init__(self, n, t):
        self.name = n
        self.topic = t

    def speak(self):
        print("我叫 %s，我是一个演说家，我演讲的主题是 %s" % (self.name, self.topic))


# 多重继承
class sample(speaker, student):
    a = ''

    def __init__(self, n, a, w, g, t):
        student.__init__(self, n, a, w, g)
        speaker.__init__(self, n, t)


test = sample("Tim", 25, 80, 4, "Python")
test.speak()  # 方法名同，默认调用的是在括号中排前地父类的方法
'''
我叫 Tim，我是一个演说家，我演讲的主题是 Python
'''