python-----面向对象简单理解

Posted 2021-01-31 phililps

　　我记得之前学习java时就常常听到，什么是面向对象呢，“封装，继承，多态”。

　　python中也一样，也是这些定论。在程序中是先有类，再有对象，对象由类产生，

　　对象指的是类的实例，类是创建对象的模板，一个类可以创建多个对象，每个对象都是类类型的一个变量；创建对象的过程也叫作类的实例化。

　　（一）下面是一些常用的知识可以先了解一下

　　类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
　　类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
　　数据成员：类变量或者实例变量, 用于处理类及其实例对象的相关的数据。
　　方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
　　局部变量：定义在方法中的变量，只作用于当前实例的类。
　　实例变量：在类的声明中，属性是用变量来表示的。这种变量就称为实例变量，是在类声明的内部但是在类的其他成员方法之外声明的。
　　继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是　　　　    模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
　　实例化：创建一个类的实例，类的具体对象。
　　方法：类中定义的函数。
　　对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

　  （二）下面的几个python为类内置的特殊属性

　　类名.__name__# 类的名字(字符串)
　　类名.__doc__# 类的文档字符串
　　类名.__base__# 类的第一个父类(在讲继承时会讲)
　　类名.__bases__# 类所有父类构成的元组(在讲继承时会讲)
　　类名.__dict__# 类的字典属性
　　类名.__module__# 类定义所在的模块
　　类名.__class__# 实例对应的类(仅新式类中)

  （三）主要的几点需要理解的
　　3.1  继承：继承是一种创建新类的方式，新建的类可以继承一个或多个父类（python支持多继承），父类又可称为基类或超类，新建的类称为派生类或子类。
　　　　　　　　字类继承父类后，会继承所有属性(数据属性和函数属性)。
　　　　　　　　继承中有一种特殊的类为抽象类，其与普通类的不同之处在于：抽象类中只能有抽象方法（没有实现功能），该类不能被实例化，只能被继承，且子类必须实现抽象方法。
　　　　　　　　在字类中调用父类的方法有2中，1为即父类名.父类方法()   2为super()
　　　　　　　　记得看过一位老师的教学给了一个很好的例子可以区分这2个调用方法
　　　　　　　　

# 父类名.父类方法名
class A:
    def __init__(self):
        print(‘A的构造方法‘)
class B(A):
    def __init__(self):
        print(‘B的构造方法‘)
        A.__init__(self)


class C(A):
    def __init__(self):
        print(‘C的构造方法‘)
        A.__init__(self)


class D(B,C):
    def __init__(self):
        print(‘D的构造方法‘)
        B.__init__(self)
        C.__init__(self)

    pass
f1=D()
‘‘‘
D的构造方法
B的构造方法
A的构造方法
C的构造方法
A的构造方法
‘‘‘

print(D.__mro__)
‘‘‘
(<class ‘__main__.D‘>, <class ‘__main__.B‘>, <class ‘__main__.C‘>, <class ‘__main__.A‘>, <class ‘object‘>)
‘‘‘

#使用super()
class A:
    def __init__(self):
        print(‘A的构造方法‘)
class B(A):
    def __init__(self):
        print(‘B的构造方法‘)
        super(B,self).__init__()


class C(A):
    def __init__(self):
        print(‘C的构造方法‘)
        super(C,self).__init__()


class D(B,C):
    def __init__(self):
        print(‘D的构造方法‘)
        super(D,self).__init__()

f1=D() #super()会基于mro列表,往后找
‘‘‘
D的构造方法
B的构造方法
C的构造方法
A的构造方法
‘‘‘
当你使用super()函数时,Python会在MRO列表上继续搜索下一个类。只要每个重定义的方法统一使用super()并只调用它一次,那么控制流最终会遍历完整个MRO列表,每个方法也只会被调用一次

3.2多态：就是同一事物的不同表现形式

import abc
class jilei(metaclass=abc.ABCMeta): #同一类事物
    @abc.abstractmethod
    def talk(self):
        pass

class People(jilei): #形态之一:人
    def talk(self):
        print(‘hello‘)

class Dog(jilei): #形态之二:狗
    def talk(self):
        print(‘goujiao‘)

class Pig(jilei): #形态之三:猪
    def talk(self):
        print(‘zhujiao‘)

3.3封装：在python中将数据使用双下划线开头的方式隐藏起来，使外部不可以直接访问。表面上是限制了我们直接访问，其实知道了类名和属性名就可以拼出名字：_类名__属性，然后就可以访问了，             　　　　 在继承中，父类如果不想让子类覆盖自己的方法，可以将方法定义为私有的。

　　　　封装在于明确区分内外，使得类实现者可以修改封装内的东西而不影响外部调用者的代码；而外部使用用者只知道一个接口(函数)，只要接口（函数）名、参数不变，使用者的代码永远无需改变

#类的设计者
class A:
    def __init__(self,length,high):

        self.__length=length
        self.__high=high
    def tell_area(self): #对外提供的接口，隐藏了内部的实现细节
        return self.__length * self.__high


#使用者
r1=A(20,20)
print(r1.tell_area()) #使用者调用接口tell_area

 

　　　　待续。。。。