2020-12-31

OOP

面向对象编程（Object Oriented Programming，OOP，面向对象程序设计）

介绍：

面向过程：根据业务逻辑从上到下写代码

面向对象：将数据与函数绑定到一起，进行封装，这样能够更快速的开发程序，减少了重复代码的重写过程。

面向过程编程最易被初学者接受，其往往用一长段代码来实现指定功能，开发过程的思路是将数据与函数按照执行的逻辑顺序组织在一起，数据与函数分开考虑。

面向对象编程(Object Oriented Programming-OOP)是一种解决软件复用的设计和编程方法。 这种方法把软件系统中相近相似的操作逻辑和操作应用数据、状态,以类的型式描述出来,以对象实例的形式在软件系统中复用,以达到提高软件开发效率的作用。

面向对象的理解：

面向对象是一种设计思想

1.符合人们的思考习惯

2.把执行者变成指挥者

3.简化功能，把复杂的事情简单化

面向对象程序设计的特征

面向对象在实际项目开发中，为了更加符合人类的语言习惯和认识这个世界的思维方式，给这样的程序设计添加了一些特殊的处理让开发人员更加容易理解，同时提高了程序的健壮性、可扩展性和可维护性等

面向对象有三大特征：封装，继承，多态

封装：将对象的敏感的信息封装在对象的内部，不让外界直接访问，提高数据的安全性

继承：通过继承关系，梳理对象和对象之间的关系，同时提高了程序设计功能的强大的扩展性和代码的复用性

多态：程序在运行过程中，实时根据不同的数据执行不同的处理逻辑展现不同的状态，让程序的功能更加的完善健壮

类和对象

面向对象编程的2个非常重要的概念：类和对象

对象是面向对象编程的核心，在使用对象的过程中，为了将具有共同特征和行为的一组对象抽象定义，提出了另外一个新的概念——类 

类就相当于制造飞机时的图纸，用它来进行创建的飞机就相当于对象 

类是对事务的描述，是抽象的。 对象是类的具体体现。

类的构成：

类(Class)由3个部分构成

类的名称:类名  

类的属性:一组数据成员变量 

类的方法:允许对进行操作的方法(行为)成员方法

类的抽象：

拥有相同(或者类似)属性和行为的对象都可以抽像出一个类 

方法: 一般名词都是类(名词提炼法)

定义类：

class 类名（驼峰命名）(object):
    属性 + 方法  
    
class Car:
    # 方法
    def getCarInfo(self):
        print('车轮子个数:%d, 颜色%s'%(self.wheelNum, self.color))
    
    def move(self):
        print('车正在移动...')

说明：

 定义类时有2种：
    新式类和经典类，上面的Car为经典类，如果是Car(object)则为新式类  
    类名 的命名规则按照"大驼峰"

创建对象：

python中，可以根据已经定义的类去创建出一个个对象

创建对象的格式为: 对象名=类名()

class Car:
    # 移动
    def move(self):
        print('车在奔跑...')
        
car1 = Car()
car1.move()

对象添加属性：

BMW = Car()
BMW.color = '黑色'
BMW.wheelNum = 4 #轮子数量
BMW.move()
BMW.toot()
print(BMW.color)
print(BMW.wheelNum)

总结：

	BMW = Car()，这样就产生了一个Car的实例对象，此时也可以通过实例对象BMW来访问属性或者方法  
    
    第一次使用BMW.color  = '黑色’表示给BMW这个对象添加属性，如果后面再次出现BMW.color = xxx表示对属性进行修改 
    
 	BMW是一个对象，它拥有属性（数据）和方法（函数）  
    
    当创建一个对象时，就是用一个模子，来制造一个实物

内置方法：

__init__()方法：

class 类名:
    #初始化函数，用来完成一些默认的设定
    def __init__():
        pass

调用：

class Car:
    def __init__(self):
        self.wheelNum = 4
        self.color = '蓝色'

    def move(self):
        print('车在跑，目标:夏威夷')
        
BMW = Car()

print('车的颜色为:%s'%BMW.color)
print('车轮胎数量为:%d'%BMW.wheelNum)        

说明：

	1. 创建类,自动初始化__init__ 内的类属性 + 方法
    
    2. 给定类的基础属性 + 方法
    
    3. __init__(self)中，默认有1个参数名字为self

魔法方法：

	在python中方法名如果是<code>__xxxx__()</code>的，那么就有特殊的功能，因此叫做“魔法”方法
    
   使用print输出对象的时候，只要自己定义了__str__(self)方法

理解self:

class Animal:
    def __init__(self,name):
        self.name = name
    
    def printName(self):
        print('名字为:%s'% self.name)
        
    def myPrint(animal):
        animal.printName()

dog1 = Animal('西西')
myPrint(dog1)

dog2 = Animal('北北')
myPrint(dog2)

总结：

	所谓的self，可以理解为自己 

	可以把self当做C++中类里面的this指针一样理解，就是对象自身的意思 
    
	某个对象调用其方法时，python解释器会把这个对象作为第一个参数传递给self，所以开发者只需要传递后面的参数即可

应用：存放家具：

class Home:
    def __init__(self, area):
        self.area = area #房间剩余的可用面积
        #self.light = 'on' #灯默认是亮的
        self.containsItem = []

    def __str__(self):
        msg = "当前房间可用面积为:" + str(self.area)
        if len(self.containsItem) > 0:
            msg = msg + " 容纳的物品有: "
            for temp in self.containsItem:
                msg = msg + temp.getName() + ", "
            msg = msg.strip(", ")
        return msg
    
    #容纳物品
    def accommodateItem(self,item):
        #如果可用面积大于物品的占用面积
        needArea = item.getUsedArea()
        if self.area > needArea:
            self.containsItem.append(item)
            self.area -= needArea
            print("ok:已经存放到房间中")
        else:
            print("err:房间可用面积为:%d,但是当前要存放的物品需要的面积为%d"%(self.area, needArea))
    

class Bed:
    def __init__(self,area,name = '床'):
        self.name = name
        self.area = area

    def __str__(self):
        msg = '床的面积为:' + str(self.area)
        return msg

    #获取床的占用面积
    def getUsedArea(self):
        return self.area

    def getName(self):
        return self.name

#创建一个新家对象
newHome = Home(100)#100平米
print(newHome)

#创建一个床对象
newBed = Bed(20)
print(newBed)

#把床安放到家里
newHome.accommodateItem(newBed)
print(newHome)

#创建一个床对象
newBed2 = Bed(30,'席梦思')
print(newBed2)

#把床安放到家里
newHome.accommodateItem(newBed2)
print(newHome)

总结：

	如果一个对象与另外一个对象有一定的关系，那么一个对象可用是另外一个对象的属性。	

保护对象的属性：

	如果有一个对象，当需要对其进行修改属性时，有2种方法:
        对象名.属性名 = 数据 ---->直接修改 
        
        对象名.方法名() ---->间接修改 
        
       	为了更好的保存属性安全，即不能随意修改，一般的处理方式为 将属性定义为私有属性

class People(object):
    def __init__(self, name):
        self.__name = name

    def getName(self):
        return self.__name

    def setName(self, newName):
        if len(newName) >= 5:
            self.__name = newName
        else:
            print("error:名字长度需要大于或者等于5")

xiaoming = People("xx")

xiaoming.setName("yy")
print(xiaoming.getName())

xiaoming.setName("lisi")
print(xiaoming.getName())

总结：

	Python中没有像C++中public和private这些关键字来区别公有属性和私有属性 
    
	它是以属性命名方式来区分，如果在属性名前面加了2个下划线’__’，则表明该属性是私有属性，否则为公有属性（方法也是一样，方法名前面加了2个下划线的话表示该方法是私有的，否则为公有的）

__del__()方法：

	创建对象后，python解释器默认调用__init__()方法； 
    
    当删除	一个对象时，python解释器也会默认调用一个方法，这个方法为__del__()方法

import time

class Animal(object):
    # 初始化方法
    # 创建完对象后会自动被调用
    def __init__(self, name):
        print('__init__方法被调用')
        self.__name = name
        
    # 析构方法
    # 当对象被删除时，会自动被调用
    def __del__(self):
        print("__del__方法被调用")
        print("%s对象马上被干掉了..."%self.__name)

dog = Animal("哈皮狗")

del dog

cat = Animal("波斯猫")
cat2 = cat
cat3 = cat

print("---马上 删除cat对象")
del cat
print("---马上 删除cat2对象")
del cat2
print("---马上 删除cat3对象")
del cat3

print("程序2秒钟后结束")
time.sleep(2)

总结：

	当有1个变量保存了对象的引用时，此对象的引用计数就会加1 当使用del删除变量指向的对象时
    
    如果对象的引用计数不只1个，比如3，那么此时只会让这个引用计数减1，即变为2，当再次调用del时，变为1，如果再调用1次del，此时会真的把对象进行删除

类的特性

继承

class Cat(object):
    def __init__(self, name, color="白色"):
        self.name = name
        self.color = color

    def run(self):
        print("%s--在跑"%self.name)

# 子类
class Bosi(object):
    def setNewName(self, newName):
        self.name = newName

    def eat(self):
        print("%s--在吃"%self.name)

bs = Bosi("印度猫")
print('bs的名字为:%s'%bs.name)
print('bs的颜色为:%s'%bs.color)
bs.eat()
bs.setNewName('波斯')
bs.run()

总结：

	虽然子类没有定义__init__方法，但是父类有，所以在子类继承父类的时候这个方法就被继承了，所以只要创建Bosi的对象，就默认执行了那个继承过来的__init__方法 
    
    子类在继承的时候，在定义类时，小括号()中为父类的名字 父类的属性、方法，会被继承给子类

注意点：

class Animal(object):
    def __init__(self, name='动物', color='白色'):
        self.__name = name
        self.color = color

    def __test(self):
        print(self.__name)
        print(self.color)

    def test(self):
        print(self.__name)
        print(self.color)

class Dog(Animal):
    def dogTest1(self):
        #print(self.__name) #不能访问到父类的私有属性
        print(self.color)
        
        
    def dogTest2(self):
        #self.__test() #不能访问父类中的私有方法
        self.test()

A = Animal()
#print(A.__name) #程序出现异常，不能访问私有属性
print(A.color)
#A.__test() #程序出现异常，不能访问私有方法
A.test()

print("------分割线-----")

D = Dog(name = "小花狗", color = "黄色")
D.dogTest1()
D.dogTest2()

总结：

	私有的属性，不能通过对象直接访问，但是可以通过方法访问 私有的方法，不能通过对象直接访问 
    
    私有的属性、方法，不会被子类继承，也不能被访问 一般情况下，私有的属性、方法都是不对外公布的，往往用来做内部的事情，起到安全的作用

多继承：

	所谓多继承，即子类有多个父类，并且具有它们的特征

class A:
    def printA(self):
        print('----A----')

class B:
    def printB(self):
        print('----B----')
        
        
class C(A,B):
    def printC(self):
        print('----C----')

obj_C = C()
obj_C.printA()
obj_C.printB()        
        

说明：

	python中是可以多继承的，在java中叫接口 
    
    父类中的方法、属性，子类会继承

重写/覆盖父类的方法：

	所谓重写，就是子类中，有一个和父类相同名字的方法，在子类中的方法会覆盖掉父类中同名的方法

#coding=utf-8
class Cat(object):
    def sayHello(self):
        print("halou-----1")

class Bosi(Cat):
    def sayHello(self):
    	print("halou-----2")
        
bosi = Bosi()

bosi.sayHello()        

#coding=utf-8 (覆盖父类的方法)
class Cat(object):
    def __init__(self,name):
        self.name = name
        self.color = 'yellow'
        
class Bosi(Cat):
    def __init__(self,name):
        # 调用父类的__init__方法1(python2)
        #Cat.__init__(self,name)
        # 调用父类的__init__方法2
        #super(Bosi,self).__init__(name)
        # 调用父类的__init__方法3
        super().__init__(name)

    def getName(self):
        return self.name
    
bosi = Bosi('xiaohua')

print(bosi.name)
print(bosi.color)    

静态方法：

类方法

类方法: 
	是类对象所拥有的方法，需要用修饰器@classmethod来标识其为类方法，对于类方法，第一个参数必须是类对象，一般以cls作为第一个参数

class People(object):
    country = 'china'
    
  	#类方法，用classmethod来进行修饰
    @classmethod
    def getCountry(cls):
        return cls.country  

p = People()
p.country=1
print( p.getCountry())    		#可以用过实例对象引用
print (People.getCountry())    	#可以通过类对象引用

类方法还有一个用途就是可以对类属性进行修改：

class People(object):
    country = 'china'	
    #类方法，用classmethod来进行修饰
    @classmethod
    def getCountry(cls):
        return cls.country

    @classmethod
    def setCountry(cls,country):
        cls.country = country

p = People()
print( p.getCountry())    #可以用过实例对象引用
print (People.getCountry() )   #可以通过类对象引用

p.setCountry('japan')   

print(p.getCountry())   
print(People.getCountry())

静态方法

通过修饰器@staticmethod来进行修饰，静态方法不需要多定义参数

class People(object):
    country = 'china'
    
    @staticmethod
    #静态方法
    def getCountry():
        return People.country
    
print(People.getCountry())

总结：

	从类方法和实例方法以及静态方法的定义形式就可以看出来，类方法的第一个参数是类对象cls，那么通过cls引用的必定是类对象的属性和方法；
	
	而实例方法的第一个参数是实例对象self，那么通过self引用的可能是类属性、也有可能是实例属性（这个需要具体分析），不过在存在相同名称的类属性和实例属性的情况下，实例属性优先级更高。
	
	静态方法中不需要额外定义参数，因此在静态方法中引用类属性的话，必须通过类对象来引用

__new__的使用：

class A(object):
    def __init__(self):
        print(self)
        print("这是 init 方法")
        
    def __new__(cls):
        print(id(cls))
        ret = object.__new__(cls)
        return ret

总结：

	__new__至少要有一个参数cls，代表要实例化的类，此参数在实例化时由Python解释器自动提供
    
    • __new__必须要有返回值，返回实例化出来的实例，这点在自己实现__new__时要特别注意，可以return父类__new__出来的实例，或者直接是object的__new__出来的实例 
    
    •__init__有一个参数self，就是这个__new__返回的实例，__init__在__new__的基础上可以完成一些其它初始化的动作，__init__不需要返回值 
    
    • 我们可以将类比作制造商，__new__方法就是前期的原材料购买环节，__init__方法就是在有原材料的基础上，加工，初始化商品环节

单例设计模式：

class Singleton(object):
    __instance = None
    __first_init = False
    
    def __new__(cls, age, name):
        if not cls.__instance:
            cls.__instance = object.__new__(cls)
        return cls.__instance

    def __init__(self, age, name):
        if not self.__first_init:
            self.age = age
            self.name = name
            Singleton.__first_init = True

a = Singleton(18, "wangcai")
b = Singleton(8, "xiaoqiang")

print(id(a))
print(id(b))

print(a.age)
print(b.age)

a.age = 19
print(b.age)

14403232
14403232
18
18
19

总结：

	单例模式: 
        	调用同一个类，使用相同的内存空间，运行程序