面向对象-CSDN博客

本文链接：https://blog.csdn.net/weixin_45163516/article/details/97575450

面向对象

面向对象：基于万物皆对象的哲学思想
面向对象只是一种思想，并不是语言。
面向对象和面向过程的区别：
1.都是看待问题的方式，都能解决问题
2.面向对象着眼于找到一个具有特殊功能的对象，然后委托给这个对象给你完成问题。
3.面向过程在于问题的细节，所有事情亲力亲为
python是面向对象的程序设计语言，类与对象是面向对象的核心

类：

一个具有特殊功能实体的集合
类的设计：
1.事物名称［类名］ Person类
2.事物的特征：［名词］[属性]name sex age height weight
3.事物的行为：［动词］[方法]eat sleep playgame coding shopping

实例化对象：

对象名＝类名()

对象：

在类中，一个具有特殊功能的实体，对象才能解决特定的问题，对象通常情况下
也称实例。

类与对象的关系：
类是用于描述某一对象的共同特征［类是对象的抽象］
对象是类的具有体现。

注意：类也是一种数据类型，只不过这种数据类型是你自己定义的，类本身并不占用空间
对象是占用空间的。

构造函数

__ init __ 在实例化对象/创建对象的时候调用

python
    def__init__(self,name,sex,address,age,facevalue,hobby):
        # print("构造函数被调用啦。。")
        self.name = name
        self.sex = sex
        self.address = address
        self.age = age
        self.facevalue = facevalue
        self.hobby = hobby

    def ins(self):
        print("你好，我是你同桌%s,我今年%d岁，我是一个%s,颜值%d,我喜欢%s,我来自于%s"
              %(self.name,self.age,self.sex,self.facevalue,self.hobby,self.address))


if __name__ == '__main__':
    mate = ClassMate("lili","girl","广东",18,90,"吃")
    print(mate.name)
    mate.ins()

析构函数

__ del __ ：在对象被销毁的时候调用

self 的使用

1.self不是一个关键字，可以使用其他的变量名，但是建议使用self，这是一种约定俗成的一种写法
2.self的位置是固定的，必须写在参数列表的第一个位置
3.self代表对象自己本身［类的实例］
4.该参数不需要我们手动传递，当使用对象调用此函数的时候，对象会将自己本身自动的传递进去

成员变量和类变量

类变量：

［又称静态成员变量］
1.定义在类中，并且定义在函数体外
2.调用类变量的时候，使用类名来进行调用，若使用对象来进行调用它也不报错［不建议这么使用］
3.调用的优先级，当使用对象来进行调用的时候，优先寻找成员变量，只有成员变了不存在的时候才找
类变量

成员变量：

1.定义类的函数中,并且绑定在self的身上
2.调用成员变量的时候，使用对象来进行调用，不能使用类名来进行调用

注意：使用对象来更改类变量的时候，更改的结果只作用于当前对象，若使用类名来进行更改
更改结果作用于对于其更改之后的所有的对象。

成员方法和静态方法和类方法

成员方法：

通常情况下在类中的方法，都是成员方法
成员的方法的特征，第一个参数［self］，代表对象本身，
调用成员方法的时候必须使用对象来进行调用。

静态方法：

就是一普通方法，但是写到了类中，
在此方法中与对象与类都没有关系。此时，我们可以将此方法定义为静态方法。
静态方法我们使用@staticmethod装饰器来进行标识。
调用的时候我们使用类名来进行调用。[若使用对象来进行调用也不报错]

类方法：

类方法是绑定在类身上的一类方法，专门给类使用的。类在使用
此方法的时候，会将自身作为参数，传递给参数列表中第一个参数。
创建类方法的时候，使用@classmethod进行标识。

三种方法的使用时机：

1.在当前方法中，若有使用到类变量／类方法／静态方法，但是没有成员变量／成员方法，
这时候我可以将其写成类方法

2.当在当前函数中，使用到了成员变量／成员方法，这时候就必须将此方法写成成员方法

3.在当前函数中，没有使用类变量／类方法／静态方法／成员方法／成员变量的时候，
我们就可以将此函数写为静态方法。

总结：

1.成员方法不需要装饰器，类方法需要@classmethod，静态方法需要@staticmethod
2.成员方法与类方法都有一个隐式参数，成员方法的是self［代表对象本身］，类方法的是cls［代表类本身］
定义的时候需要将其声明在参数列表的第一个位置。
3.成员方法使用对象来进行调用，静态方法与类方法使用类名来进行调用，［
但是若使用对象来进行调用也不报错］

访问限制

面向对象语言三大特征：

封装、继承、多态

封装：

广义的封装：类与函数的定义的本身就是封装的体现
狭义的封装：类中某些属性，我们不希望外界能够直接访问，这时候，我们
可以将此属性私有化只有本类持有，然后给外界暴露出一个访问接口即可。
封装的本质：属性私有化的过程

优点：

1.提高复用性
2.保证数据的安全性

@property装饰器可以将函数作为属性来进行调用，与此同时他还可以生成一个新的
装饰器，新的装饰器的名字就是@属性.setter, 新的装饰器用来装饰setter函数。

优点：方便调用

继承：

若两个或者两个以上的类具有相同的属性以及方法，我们可以抽出一个类。
在抽取出来的这个类中写共通的部分，那么这个被抽取出来的类我们称之为
父类［超类／基类］，其他类我们称之为子类或者派生类。

class 类名(object):
pass
():继承列表，当小括号没有内容或者小括号不写，或许写object的时候，意思是一样的。
默认继承是object，换句话说：object类是一切类的基类。
单继承：一个子类继承一个父类我们称之为单继承

总结：

1.子类可以直接继承父类所有未私有属性以及方法
2.父类不能调用子类中特有的属性以及方法
3.当子类中含有特殊的属性的时候，需要在子类中重写init函数，
并且在此函数将所有的属性进行声明。并且需要手动调用父类中的init的方法

优点：

1.提高代码的复用性
2.提高代码的可维护性
3.提高代码的安全性

缺点：

增加代码耦合性。

多继承

一个子类继承多个父类，我们称之为多继承。
比如：一个孩子，有一个爸爸，有一个妈妈

总结：

1.子类可以继承所有父类未私有化的属性以及方法
2.若子类存在的特有的／当继承父类中的属性不一致的时候，
我们手动调用父类中的init，父类名.init(self, 参数列表)
3.当多个父类出现同名的函数的时候，子类优先继承写在参数列表前面的那个

多态

在Python中

鸭子模型：若有一只鸟，走路像鸭子，叫声像鸭子，我们可以称这只鸟就是鸭子。
在python中我们不关心数据的类型，我们只关心数据的属性以及其方法的使用。

真正的多态：

指一个事物的多种表现形态，必须依赖于继承而存在。
isinstance(obj,types)
功能：判断obj是否属于指定的types，或者types的子类
types：也可以是一个元组。若是元组，则判断的是obj是否属于types元组中
的某种类型。
若有一个成立，得到的结果就为True，否则为False。

dir(obj)
功能：可以查看obj所有的属性以及方法以列表的形式返回。

函数重写

str系统提供的函数
当调用str／print的时候会自动调用此函数，此函数是给用户使用的，
用来描述对象的显示。

注意：str函数的返回值必须是一个字符串，并且当调用print的时候
打印对象的结果就是此函数的返回值

若在类中存在repr，但是不存在str,
我们可以使用 str = repr

class Person:

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

    def __repr__(self):
        return "%s-%d"%(self.name,self.age)

    __str__ = __repr__
	#重写了add函数
    def __add__(self, other):
        return Person(self.name+other.name,self.age+other.age)

运算重载

repr

单例模式

写在init前面的函数
__ new__

class Person:
    def __new__(cls, *args, **kwargs):
        print("new方法被调用了")
        
    def __init__(self,name):
        self.name = name
        print("init方法被调用了")