13-面向对象3

13-面向对象3

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

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2020/9/17 0017 21:02
# @Author  : Oliver
#继承是面向对象的三大特性之一
# 通过继承我们可以使一个类获取其他类的属性和方法
# class Person():
#     name=''
#     age=''
# class Doctor():
#     name=''
#     age=''
#
#     def heal(self):
#         print('治病救人！')
#
# class Student():
#     name=''
#     age=''
#
#     def study(self):
#         print('好好学习，天天向上！！！')
#
# object是所有类的父类
# issubclass()检查一个类是不是另一个类的子类
class Animal(object):
    def run(self):
        print('动物跑起来了.....')
    def sleep(self):
        print('动物睡觉...')

a=Animal()
# a.run()

# 需求:定义一个狗类
# 1.直接修改Animal这个类，在这个类中添加我们需要的功能
# 这种方式比较麻烦，并且会违反OCP原则
# 显然这个方式不推荐
# 2.直接创建一个新的类
# 创建一个新类是比较麻烦的，并且需要大量的赋值粘贴，会出现大量的重复代码
# class Dog():
#     def run(self):
#         print('狗跑起来了.....')
#     def sleep(self):
#         print('狗睡觉...')
#     def speak(self):
#         print('汪汪汪！')
#
# 3.直接从Animal类中继承他的属性和方法
# 在定义类的时候，可以在类名的后面加上一个括号，这个括号中可以指定当前类的父类（超类、基类）
class Dog(Animal):
    def speak(self):
        print('汪汪汪！')
    def run(self):
        print('狗再跑！！')#更新了狗的方法
d=Dog()
# Dog中没有sleep的方法，但是父类有，很明显d可以调用，这就是Dog继承了Animal这个父类的方法和属性
d.run()
d.sleep()
d.speak()
#判断d是不是Dog的实例
r=isinstance(d,Dog)
print(r)#最后发现是的
#判断d是不是Animal的实例
r=isinstance(d,Animal)
print(r)#最后发现是的
# 也就是d也是父类的实例
print()

print(issubclass(Dog,Animal))
print(issubclass(Animal,object))

结果显示：

狗再跑！！
动物睡觉...
汪汪汪！
True
True

True
True

Process finished with exit code 0

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

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2020/9/17 0017 21:27
# @Author  : Oliver
# 重写/覆盖（override）

class A(object):
    def test(self):
        print('A....')
class B(A):
    def test(self):
        print('B....')
class C(B):
    pass
c=C()
c.test()

结果显示：

B....

Process finished with exit code 0

• 3、super()
  • super()可以获取当前类的父类
  • 并且通过super()返回对象调用父类方法时，不需要传递self

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2020/9/17 0017 21:37
# @Author  : Oliver
# 父类中所有的方法都会被子类继承，包括特殊的方法
class Animal(object):
    def __init__(self,name,sex):
        self._name=name
        self._sex=sex

    @property
    def sex(self):
        return self._sex

    @sex.setter
    def sex(self, sex):
        self._sex = sex
    @property
    def name(self):
        return self._name

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

    def run(self):
        print('动物跑起来了.....')
    def sleep(self):
        print('动物睡觉...')

class Dog(Animal):
    def __init__(self,name,age,sex):
        # self._name=name
        # self._age=age
        # self._sex=sex
        # Animal.__init__(self,name,sex)
        super().__init__(name,sex)
    @property
    def age(self):
        return self._age

    @age.setter
    def age(self,age):
        self._age = age
    def speak(self):
        print('汪汪汪！！！')
    def run(self):
        print('狗在跑.....')

d=Dog('试试',4,'男')
print(d.name)
print(d.sex)

# super()可以获取当前类的父类

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

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2020/9/18 0018 12:34
# @Author  : Oliver
# 类名.__bases__这个属性可以用来获取当前类的父类
class A(object):
    def test(self):
        print('A....')
class B(object):
    def test(self):
        print('B....')
# 可以在类名的（）后边添加多个类，来实现多重继承
class C(A,B):
    pass
c=C()
print(C.__bases__)
# (<class '__main__.B'>,)元组还有逗号，说明可以有多个父类
print(B.__bases__)
c.test()
# 多个父类中有同名的方法，则会先在第一个父类中寻找，然后找第二个，找第三个...前面会覆盖后面的

结果显示：

(<class '__main__.A'>, <class '__main__.B'>)
(<class 'object'>,)
A....

Process finished with exit code 0

• 5、多态
  • 多态是面向对象的三大特性之一。从字面理解就是多种形态
  • 一个对象可以以不同形态去呈现
  • 面向对象三大特性
    • 封装 确保对象中数据的安全
    • 继承 保证了对象的扩展性
    • 多态 保证了程序的灵活性

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2020/9/18 0018 12:50
# @Author  : Oliver

# 多态也是面向对象的三大特性之一
# 一个对象可以以不同的形态去呈现
class A:
    def __init__(self,name):
        self._name=name

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

class B:
    def __init__(self, name):
        self._name = name

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

    @name.setter
    def name(self, name):
        self._name = name
class C:
    pass
a=A('张三')
b=B('李四')
c=C()
# 定义一个函数  这种形式就是多态
def speak(obj):
    print('你好%s'%obj.name)
# 只要对象有name就可以，不用对象是A，还是B
# 适应性更高

speak(a)
# speak(c)
# 这种形式就违反了一个多态的原则
def speak2(obj):
    # 类型检查
    if isinstance(obj,A):#只能处理一类对象
        print('你好%s'%obj.name)

speak2(a)


# 举个例子好理解
lst=[1,2,3]
print(len(lst))
s='python'
print(len(s))
# len()可以处理不同对象，就相当于上述的speak（）
# 这就是一个多态
# 列表字符串都封装了__len__,这是他们的共同点

• 6、属性和方法
  • 属性
    • 类属性，直接在类中定义的属性是类属性
    • 类属性可以通过类或类的实例访问到。但是类属性只能通过类对象来修改，无法通过实例对象修改
    • 实例属性 通过实例对象添加的属性属于实例属性
    • 实例属性只能通过实例对象来访问和修改，类对象无法访问修改
  • 方法
    • 在类中定义，以self为第一个参数的方法都是实例方法
    • 实例方法在调用时,Python会将调用对象以self传入
    • 实例方法可以通过类实例和类去调用
    • 当通过实例调用时，会自动将当前调用对象作为self传入
    • 当通过类调用时，不会自动传递self，我们必须手动传递self
    • 类方法 在类的内容以@classmethod 来修饰的方法属性类方法
    • 类方法第一个参数是cls 也会自动被传递。cls就是当前的类对象
    • 类方法和实例方法的区别，实例方法的第一个参数是self，类方法的第一个参数是cls
    • 类方法可以通过类去调用，也可以通过实例调用
  • 静态方法
    • 在类中用@staticmethod来修饰的方法属于静态方法
    • 静态方法不需要指定任何的默认参数，静态方法可以通过类和实例调用
    • 静态方法，基本上是一个和当前类无关的方法，它只是一个保存到当前类中的函数
    • 静态方法一般都是些工具方法，和当前类无关

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2020/9/18 0018 13:24
# @Author  : Oliver

class A:
    # 类属性：直接在类中定义的属性就是类属性
    # 类属性可以通过类对象和实例对象来访问
    # 类属性只能通过类对象来修改，不能通过实例对象来修改
    count=0
    def __init__(self):
        self.name='张三'
        #  这其实是一个实例属性，因为self就是a，通过self将这个属性添加到了当前的实例对象中

        # 这是实例方法
    def test(self):
        print('这是个test方法！！！')
    # 类方法
    #在类的内部使用@classmethod修饰的方式属于类方法
    # 类方法的第一个参数cls，也会自动传递，cls表示的就是当前的类对象
    @classmethod
    def test2(cls):
        print('这是个test2方法！！！')
        print(cls.count)
    # 静态方法
    # 在类中被@staticmethod来修饰的方法属于静态方法
    @staticmethod
    def test3(self):
        print('这是个test3方法！！！')
a=A()
# 实例属性：通过实例对象添加的属性是实例属性
# a.count=10
# A.count=10
# print('A',A.count)
# print('a',a.count)
#
# print('a',a.name)
# print('A',A.name)这个是会报错的
# 实例属性只能通过实例对象来访问、修改，类对象无法访问修改

a.test()
A.test(a)
# a.test()等价于A.test(a)
A.test2()
a.test2()
# A.test2()等价于a.test2()

A.test3()
a.test3()

结果显示：

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2020/9/18 0018 13:24
# @Author  : Oliver

class A:
    # 类属性：直接在类中定义的属性就是类属性
    # 类属性可以通过类对象和实例对象来访问
    # 类属性只能通过类对象来修改，不能通过实例对象来修改
    count=0
    def __init__(self):
        self.name='张三'
        #  这其实是一个实例属性，因为self就是a，通过self将这个属性添加到了当前的实例对象中

        # 这是实例方法
    def test(self):
        print('这是个test方法！！！')
    # 类方法
    #在类的内部使用@classmethod修饰的方式属于类方法
    # 类方法的第一个参数cls，也会自动传递，cls表示的就是当前的类对象
    @classmethod
    def test2(cls):
        print('这是个test2方法！！！')
        print(cls.count)
    # 静态方法
    # 在类中被@staticmethod来修饰的方法属于静态方法
    @staticmethod
    def test3(self):
        print('这是个test3方法！！！')
a=A()
# 实例属性：通过实例对象添加的属性是实例属性
# a.count=10
# A.count=10
# print('A',A.count)
# print('a',a.count)
#
# print('a',a.name)
# print('A',A.name)这个是会报错的
# 实例属性只能通过实例对象来访问、修改，类对象无法访问修改

a.test()
A.test(a)
# a.test()等价于A.test(a)
A.test2()
a.test2()
# A.test2()等价于a.test2()

A.test3()
a.test3()