面向对象

面向对象编程：

Object Oriented Programming，简称 OOP，是一种程 序设计思想。

OOP 把对象作为程序的基本单元（一切皆为对象）

面向对象的程序设计把计算机程序视为多个对象的集合

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

Python中的类提供了面向对象编程的所有基本功能：类的继承机制允许多个基类，派生类可以覆盖基类中的任何方法，方法中可以调用基类中的同名方法。

对象可以包含任意数量和类型的数据。

类的定义：

class 类名(父类):
    属性
    方法

class stu(object):
    name = “zhangsan”
    def sleep(self):
        print(“I am sleeping”)

#name:  属性
#sleep函数：方法

类的使用：

obj = stu()     #实例化一个stu类的对象obj
print(obj.name)   #访问类中的属性
obj.sleep()    #调用类中的方法

__init__() 方法（构造方法）:

类在实例化一个对象的时候会自动调用__init__方法。

obj = stu()  #此时对应的 __init__() 方法就会被调用

当然， __init__() 方法可以有参数，参数通过 __init__() 传递到类的实例化操作上。

class stu(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age

obj = stu('zhangsan', 18)
print(obj.name, obj.age)

self:

self 代表的是类的实例，代表当前对象的地址，而 self.class 则指向类。

class stu:
    def add(self):
        print(self)
        print(self.__class__)
obj = stu()
obj.add()

运行结果：
<__main__.stu object at 0x000001940D4715C0>
<class '__main__.stu'>

通过__init__方法的默认参数实现：实例化对象的时候既可以传参也可以不传参。

class stu(object):
    def __init__(self, name="zhangsan", age=18):
        self.name = name
        self.age = age

s = stu()
print(s.name,s.age)

运行结果：
zhangsan 18

属性的定义：

class stu(object):
    def __init__(self, name, age):
        self.name = name   #定义属性name
        self.age = age    #定义属性age

属性和方法的访问：

在类的外部访问：object.属性    object.方法  （object为对象名）。

class stu(object):
    name = “zhangsan”
    def sleep(self):
        print(“I am sleeping”)

s  = stu()
print(s.name) 
s.sleep()

在类的内部访问：self.属性 self.方法(实参列表)

class Test(object):
    def __init__(self, name):
        self.name = name
    def func1(self):
        print(self.name)
    def func2(self):
        self.func1()

类中的属性默认是可以在类的外部通过类的实例化对象访问的。

如果希望内部属性不被外部访问（对象通过句点符号引用），可以在属性名称前加上 双下划线 __， 该属性则为私有属性，只能在类内部访问。

class Test(object):
    def __init__(self, name):
        self.__name = name
    def func1(self):
        print(self.__name)

通过类的实例化对象访问和修改私有属性。

class Test(object):
    def __init__(self, name=None):
        self.__name = name
    def get_name(self):
        return self.__name
    def set_name(self, name):
        self.__name = name
s = Test()
s.set_name('zhangsan')
name = s.get_name()
print(name)

面向对象三大特征：

1.封装

到底封装的是什么？

-属性(数据)

-方法

2.继承

面向对象编程的优点之一：代码重用。实现代码重用的方法 -> 继承

类的非私有方法和非私有属性可以继承给他的子类

继承的类：子类、派生类

被继承的类：父类、基类

继承基类的方法：

class Animal(object):
    def run(self):
        print('Animal run')
class Dog(Animal):
    pass

d = Dog()
d.run()

继承基类属性：

#继承非私有属性
class Animal(object):
    def __init__(self, name):
        self.name = name
class Dog(Animal):
    pass

d = Dog("wangcai")
print(d.name)

多重继承：

假设我们要实现以下4种动物： Dog - 狗狗 Bat - 蝙蝠 Parrot - 鹦鹉 Ostrich - 鸵鸟。

如果按照哺乳动物和鸟类归类，我们可以设计出这样的类的层次：

class Animal(object):
    pass
# 大类:
class Mammal(Animal):
    pass
class Bird(Animal):
    pass
# 各种动物:
class Dog(Mammal):
    pass

class Manmal(object):
    def run(self):
        print('Running...')

class Flyable(object):
    def fly(self):
        print('Flying...')

class Bat(Manmal, Flyable):
    pass

3.多态

一个类的方法有多种形态。

子类继承父类的方法时，如果需要对父类的方法进行修改，则需要在子类中对该方法进行“重写”。

class Animal(object):
    def __init__(self, name):
        self.__name = name
    def run(self):
        print('animal run')
class Dog(Animal):
    #重写
    def run(self):
        print('dog run')
        super().run()

d = Dog("dog")
d.run()

获取对象信息：

type()

isinstance()

dir()

获得一个对象的所有属性和方法，可以使用 dir()函数，它返回 一个包含字符串的 list。

__new__()方法

对象的构造和内存的分配

一个类只能构造一个对象，在实际工作过程中某些事物就是唯一的！！

考察的核心：一个对象的构造的过程：__new__() -> __init__()

class Earth(object):
    Instance = None
    #注意：__new__的参数是cls 而是不是self
    #cls：这个类本身
    #首先我们需要明白一件事情：构造一个对象其实就是需要在内存中开辟一块空间
    #如果我们使用某个类来构造一个对象，对象的内存空间的分配是由类实现的
    #重写object类中的__new__
    def __new__(cls, *args, **kwargs):
        #如果这个类构造过对象，不需要重新分配空间了
        if cls.Instance == None:
            #如果这个类没有构造过对象，则需要分配空间
            cls.Instance = super().__new__(cls,*args, **kwargs)
            #print(type(Instance))
            return cls.Instance
        else:
            return cls.Instance

earth = Earth()
print(earth)
earth = Earth()
print(earth)

super() 函数是用于调用父类(超类)的一个方法。

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

单列模式：

class Earth(object):
    _instance = None
    def __init__(self):
        print("Hi, I Am The Earth")
    def __new__(cls):
        # 如果这个类在此之前没有构造过对象，则构造一个对象
        if cls._instance == None:
            print("new earth")
            cls._instance = super().__new__(cls)
            # print(type(cls._instance))
            return cls._instance
        # 如果这个类再此之前已经构造过对象，则不构造对象返回原来的对象
        else :
            return cls._instance

e1 = Earth()
e2 = Earth()
print(id(e1), id(e2))

鸭子类型：

class Dog(object):
    def swimming(self):
        print('dog swimming')

def func(obj):
    obj.swimming()

duck = Duck()
dog = Dog()

func(duck)
func(dog)