全面详解类以及面向对象的特性（附代码示例）

- 对象 - 类 - 封装 - 继承 - 多态

什么是对象：

通俗来讲，万事万物都是对象——一切皆对象。

标准来讲，对象是类的实例。

理解：对象是一件事、一个实体、一个名词，可以是任何东西。

举例说明：一个学生是一个对象，一个老师是对象，一个班是对象，一个学校也是对象，对象就是具体存在的看得见摸的着的某个实物。

什么是类：

类是一个实物的特征的集合，也是行为和操作的概念的集合，是抽象的概念。

类是面向对象设计中的概念，是面向对象的基础。

理解：类是对现实生活中一类具有共同特征事物的抽象。

举例说明：人类是一个类，张三是类的实例
鱼类是一个类，金鱼是类的实例

对象和类的关系：

类是多个对象归纳总结而来的，是一种概念。由对象总结出类的过程，叫做抽象化，对象是类的具体实现或者实施而来，它是真实的，特指某个事物。由类制作出对象的过程，叫做实例化。

类中只有两个内容：成员属性和成员方法

成员属性：

用于描述类的特征的变量就是成员属性

成员方法：

用于描述类的功能的函数就是成员方法

class People():
    name = "张三" 
    def say(self):
        print(self.name)
peo = People()
peo.say()

class是关键字

People是类名

name = “张三”是成员属性

def say（self）：是成员方法
print（self.name）

peo = People()是实例化类

peo.say是调用实例方法

初始化方法

class People():
    def __init__(self):
        self.name = "李四"
        self.age = 23

    def say(self):
        print(self.name)
        print(self.age)
peo = People()
peo.say()

第一种方法__init__()方法是一种特殊的方法，被称为类的构造函数或者初始化方法，当创建了这个实例时就会调用该方法。

self代表类的实例，而非类，类的方法与普通函数只有一个特别的区别———它们必须有一个额外的第一个参数名称，按照惯例它的名称是self。

方法的分类：

1. 实例方法

   只有实例化对象之后才可以使用的方法，该方法的第一形参接受的一定是对象本身也就是“self”。

	class People():
		def hello(self):
 		print("hello world")

2. 静态方法

   无需实例化，可以通过类直接调用的方法，方法中的参数即不接受对象名也不接受类，一般可以独立调用，跟类中的其他成员关联不大。

	class People():
	    def __init__(self,name,age):
	        self.name = name
	        self.age = age
	
	    def say(self):
	        print("我叫%s，今年%d"%(self.name,self.age))
	
	    @staticmethod
	    def Say():
	        print("我叫%s，今年%d"%('张三',23))
	
	peo = People('张三',23)
	peo.say()
	People.Say()

这个Say的静态方法，调用无需实例化，不需要传递参数self

3. 类方法

   无需实例化，可以通过类直接调用的方法，但是方法的第一个参数接受的一定是类本身

	class People():
	    def __init__(self,name,age):
	        self.name = name
	        self.age = age
	
	    def say(self):
	        print("我叫%s，今年%d"%(self.name,self.age))
	
	    @classmethod
	    def Say(cls):
	        print("我叫%s，今年%d"%('张三',23))
	
	peo = People('张三',23)
	peo.say()
	People.Say()

类方法，第一个参数必须要默认传类，一般习惯用“cls”

整体一起看

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

    def say(self):
        print("我叫%s，今年%d"%(self.name,self.age))

    @classmethod
    def Say(cla):
        print("我叫%s，今年%d"%('李四',24))

    @classmethod
    def cls_Say(cla):
        print("我叫%s，今年%d"%('王五',25))

peo = People('张三',23)
peo.say()
People.Say()
People.cls_Say()

输出结果
我叫张三，今年23
我叫李四，今年24
我叫王五，今年25

面向对象的三大特性

1. 封装
   什么是封装：

   在程序设计中，封装是对具体对象的一种抽象，即将某些部分隐藏起来，在程序外部看不到，其含义是其他程序无法调用。
   要了解封装，离不开“私有化”，就是将类或者是函数中的某些属性限制在某个区域之内，外部无法访问。

   为什么要封装：

   封装数据的主要原因是：保护隐私

   私有化封装 private：

   私有化封装是最高级别的封装。私有化封装之后的成员,只能在类中/对象中访问，类的外部，子类中都不可以访问到。

class People():
    def __init__(self,name,age):
        self.name = name    #公有化属性name
        self.__age = age    #私有化属性age

    def __say(self):        #私有化方法
        print(self.name)
        print(self.__age)

    def say1(self):         #公有化方法
        print(self.name)
        print(self.__age)

    def say2(self):
        print(self.__age)
        self.__say()
        
if __name__ == '__main__':
    peo = People('张三',18)
    print(peo.name)
    print(peo.__age)    #不可调用
    peo.__say()         #不可调用
    peo.say1()
    peo.say2()
    

私有化封装后的限制
类中/对象中 可以访问
类外/对象外 不可以访问
子类/子类对象 不可以访问

注意：在python中实现的封装操作，不是通过权限限制而是通过改名(name mangling 改名策略)实现的，名字变了找不到而已。
可以通过 对象名._类名__方法或类名._类名__方法名访问到（但禁止这么干）

2. 继承
   什么是继承：

   继承就是可以获取另外一个类中的成员属性和成员方法。（并非所有成员）

   为什么要继承：

   继承的作用是增加代码的复用性，节省不必要的重复代码，提高开发效率，同时可以设置类之间的关系。

   继承的两个概念：

   父类：用于被继承的类，称之为父类，也叫作基类或者超类
   子类：继承其他类的类，称之为子类，也叫作派生类。

   普通继承

	class Father():
	    def money(self):
	        print("我是父亲，我有银子")
	
	class son(Father):
	    def shopping(self):
	        print("我是儿子，我要银子")
        
	s = son()
	s.money()
	s.shopping()

son继承了father的方法，可以调用继承的方法。

构造函数的继承

	class Father():
	    def __init__(self,name,age):
	        self.name = name
	        self.age = age
	
	class son(Father):
	    def __init__(self,name,age,score):
	        super().__init__(name,age)
	        self.score = score
	        print(self.name,self.age,self.score)
	
	s = son("张小明",10,90)

son通过super()继承了father的初始化name，age，并调用实例化。

ptyhon可以继承多个类

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

class Mother():
    def __init__(self,eye,face):
        self.eye = eye
        self.face = face

class Son(Father):
    def __init__(self,name,age,score):
        super(Son,self).__init__(name,age)
        self.score = score
        print(name,age,score)

class Girl(Father,Mother):
    def __init__(self,name,face):
        super(Girl,self).__init__(name,face)
        print(name,face)

s = Son("张小明",10,90)
g = Girl("张小丽","漂亮")

方法重载

class People():          #父类
    def __init__(self,name,age):
        self.name=name
        self.__age=age
    def say(self):
        print(self.name,self.__age)   #最先输出 张三 18
    def jok(self):
        print('嘿嘿')                #第四个输出 嘿嘿

class Student(People):    #子类
    def __init__(self,xh,name,age,score):
        super().__init__(name,age)  #将重载的父类方法借调过来使用
        self.xh=xh
        self.score=score
    def say(self):
        super().say()
        print('新说法')           # 第二个输出 新说法
        print('父类',self.name)   #第三个输出  父类 张三
zs=Student(1001,'张三',18,89)
zs.say()
zs.jok()

继承的特征
1.所有类都是继承自object类
2.子类继承父类则可以访问父类的所有成员。（私有成员除外）
3.子类继承父类并不会将父类的所有成员复制到子类当中，而是间接通过父类来访问的，
4.子类可以具有自己独有的属性和方法
5.子类可以重载父类中的方法，只需要设置和父类指定成员相同的名称即可实现重载，重载之后的成员，子类只会访问当前类中的成员，而不会调用父类中同名的成员
6.子类中如果重载父类的方法，并且还想将重载的父类方法借调过来使用，可以在重载的方法中使用如下方法

注意：
1.子类永远在父类的前面
2.如果继承了多个父类，那么按照()中的顺序在列表中摆放
3.如果多个类同时继承了一个父类，孙子类中只会选取第一个父类中的父类的该方法

4. 多态

   多个不同的类具有共同的方法，各个类调用方法，返回值不同。把方法f提取出来，封装为一个接口。不同类的实例作为参数，传入接口，得到不同返回值。

class Dog():
    def jiao(self):
        print('汪汪')
        
class Cat():
    def jiao(self):
        print('喵喵')

class Pig():
    def jiao(self):
        print('哼哼')
        
def jiao(obj):
    obj.jiao()
    
d=Dog()
c=Cat()
p=Pig()

jiao(d)
jiao(c)
jiao(p)

python的多态用一句话概括就是，有这种方法，并且传入相应的参数就行