python 面对对象三大特性

. 继承

　　1. 单继承

　　　　继承是一种创建新类的方式，在python中，新建的类可以继承一个或多个父类，父类又可称为基类或超类，新建的类称为派生类或子类.

　　　　面向对象的编程带来的主要好处之一是代码的重用，实现这种重用的方法之一是通过继承机制.

　　　　如果没有指定基类，python的类会默认继承object类，object是所有python类的基类，它提供了一些常见方法（如__str__）的实现

　　　　语法:

　　　　　　class 派生类名(基类名)

　　　　　　　　.............

　　　　子类以及子类实例化的对象,可以访问父类的任何方法或者变量

　　　　类名可以访问父类所有内容

　　　　子类的实例化对象也可以访问父类的所有内容

class Animal:

    def __init__(self, name, sex, age):
        self.name = name
        self.sex = sex
        self.age = age

    def eat(self,a1):
        print('%s吃%s' % (self.name,a1))

    def drink(self):
        print('%s喝东西' % (self.name))


class Cat(Animal):

    def miaow(self):
        print('喵喵叫')
    # def eat(self):  # 若子类创建了和父类中相同的方法,只执行自己类中的方法
    #     print(666)

class Brid(Animal):

    def __init__(self, name,sex,age,wing): # self b1对象 name '鹦鹉',sex '公',age 20,  wing '绿翅膀'
        '''
        self=b1对象
        name='鹦鹉'
        sex='公'
        age= 20,
        wing='绿翅膀'
        '''
        # Animal.__init__(self, name, sex, age)
        super().__init__(name,sex,age)  #  super(Brid,self).__init__(name,sex,age)    即想执行子类的方法,也想执行父类的方法
        self.wing = wing
    def bark (self):
        print('嗷嗷叫')

    def eat(self,argv):
        super().eat(argv)
        print('鸟吃虫子...')

class Chook(Animal):
    def crow(self):
        print('大爷laiwanya')

b1 = Brid('鹦鹉','公',20,'绿翅膀')
b1.eat('金蝉')

　　　　如果既想执行子类的方法,有想执行父类的方法,一共有两种方法:

　　　　　　1. 父类名.__方法名__(self,父类属性)

　　　　　　2. super().__方法名__(父类的属性)

 

　　2. 多继承

　　　　多继承的查询顺序以经典类或者新式类区分:

　　　　　　新式类:遵循广式优先查询　　一条路走到倒数第二级,判断是否有其他路可以走到终点,如果有则返回走其他路,没有直接到终点

　　　　　　经典类:遵循深度优先查询　　一条路走到终点　　

　　　　其中单继承中,经典类或者新式类的查询方式都是一样的

 

二. 封装

　　封装，顾名思义就是将内容封装到某个地方，以后再去调用被封装在某处的内容.

　　封装就是把类中的属性和方法定义为私有的，方法就是在属性名或方法名前加双下划线，而一旦这样定义了属性或方法名后，python会自动将其转换为_类名__属性名（方法名）的格式，在类的内部调用还是用双下划线加属性名或方法名，在类的外部调用就要用_类名__属性名（方法名）。父类的私有属性和方法，子类无法对其进行修改

　　所以，在使用面向对象的封装特性时，需要：

　　　　将内容封装到某处

　　　　从某处调用被封装的内容

# 广义的封装: 实例化一个对象,给对象空间封装一些属性.
# 狭义的封装: 私有制.

# 私有成员:私有静态字段,私有方法,私有对象属性

# 私有静态字段

class B:
    __money = 100000

class A(B):
    name = 'xxx'
    __age = 1000

    def func(self):
        print(self.__age)
        print(A.__age)    # 对于私有静态字段,类的内部可以访问.
        print('func....')
    def func1(self):
        print(self.__money)
        print(A.__money)
a1 = A()
print(a1.name)
print(A.name)

print(a1.__age)  # 通过实例化对象不能访问私有静态字段
print(A.__age)  # 通过类名也不能访问私有静态字段
# 对于私有静态字段,类的外部不能访问.

　　总结:

　　　　对于私有静态字段,只有在本类内部才可以访问. 在类的外部,派生类均不可以访问

 

三. 多态

　　 多态就是不同的对象可以调用相同的方法然后得到不同的结果，有点类似接口类的感觉，在python中处处体现着多态，比如不管你是列表还是字符串还是数字都可以使用+和*。

　　多态: 同一个对象的多种形态

　　　　即使子类继承了一个或多个父类, 依然可以执行自己本类中的方法

　　python 中有鸭子类型:

　　　　鸭子类型就是,不同的类中含有相同的方法(函数),统称这些类为鸭子

class Str:
    def index(self):
        pass
 
class List:
    def index(self):
        pass
 
class Tuple:
    def index(self):
        pass

 

转载于:https://www.cnblogs.com/dong-/p/9373914.html