python高级-面向对象特性(12)

1、继承的概念

在现实生活中，继承通常指的是子女继承父辈的财产，在程序中，继承描述的是事物之间的所属关系，例如猫和狗都属于动物，程序中即可以描述为猫和狗继承自动物；同理，波斯猫和巴厘猫都继承自猫，而沙皮狗和斑点狗都继承足够，以下如所示：

 

2、继承的示例

class Cat(object): def __init__(self,name,color="白色"): self.name = name self.color = color def run(self): print("%s:在跑"%self.name) class Bosi(Cat): def setNewName(self,newName): self.name = newName def eat(self): print("%s：在吃"%self.name) bs = Bosi("波斯猫") print("bs的名字是：%s，颜色是:%s"%(bs.name,bs.color)) bs.eat() bs.setNewName("汤姆猫") bs.run()

运行结果为：

bs的名字是：波斯猫，颜色是:白色
波斯猫：在吃
汤姆猫:在跑

说明：

• 虽然子类没有定义__init__()方法，可是父类有。因此在子类集成父类的时候这个方法就被继承了，因此只要建立Bosi的对象，就默认执行了那个继承过来的__init__()方法
• 子类在继承的时候，在定义类时，小括号()中为父类的名字
• 父类的全部非私有的属性、方法、会被继承给子类

注意：

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

class Animal(object): def __init__(self, name = "动物",color = "白色"): self.__name = name self.color = color def __test1(self): print(self.__name) print(self.color) def test2(self): print(self.__name) print(self.color) class Dog(Animal): def dogTest1(self): #不能访问父类的私有属性：AttributeError: 'Animal' object has no attribute '__name' #print(self.__name) print(self.color) def dogTest2(self): #self.__test1() self.test2() A = Animal() #print(A.__name) print(A.color) #不能访问父类的私有方法：AttributeError: 'Animal' object has no attribute '__test1' #A.__test1() A.test2() print("-----------------分割线-----------------") D = Dog(name="阿黄",color = "黄色") D.dogTest1() D.dogTest2()

运行结果为：

白色 动物 白色 -----------------分割线----------------- 黄色 阿黄 黄色

 

3、多继承

从图中可以看出，所谓多继承，即子类有多个父类，而且具备它们的特征

Python中多继承的格式以下:

class A: def printA(self): print("---A---") class B: def printB(self): print("---B---") #定义一个子类继承A，B class C(A,B): def printC(self): print("---C---") obj_C = C() obj_C.printA() obj_C.printB()

运行结果为：

---A---
---B---

说明

• python中是能够多继承的
• 父类中的方法、属性，子类会继承
• 若是多个父类中有同一个方法，谁写在前面就调用谁的方法

class A: def printA(self): print("---A---") class B: def printB(self): print("---B---") #定义一个子类继承A，B class C(A,B): def printC(self): print("---C---") obj_C = C() obj_C.printA() obj_C.printB() #能够查看一个雷的对象搜索方法时的前后顺序 print(C.__mro__)

运行结果为:

---A---
---B--- (<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)

 

4、重写父类方法与调用父类方法

一、重写父类方法

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

 

class Cat(object): def sayHello(self): print("Hello:Cat") class Bosi(Cat): def sayHello(self): print("Hello:Bosi") bs = Bosi() bs.sayHello()

 

运行结果为：Hello:Bosi

二、调用父类方法

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

    

class Bosi(Cat): def __init__(self,name): #Cat.__init__(self,name) #python2的语法 #调用父类的方法 super().__init__(name) def getName(self): return self.name pass bs = Bosi("波斯") print(bs.name) print(bs.color)

运行结果为：

波斯
黄色

 

5、多态

• 多态的概念是应用于Java和C#这一类强类型语言中
• 所谓多态：定义时的类型和运行时的类型不同，此时就成为多态

class F1(object): def show(self): print("F1.show") class S1(F1): def show(self): print("S1.show") class S2(object): def show(self): print("S2.show") def func(obj): obj.show() s1_obj = S1() func(s1_obj) s2_obj = S2() func(s2_obj)

运行结果为：S1.show、S2.show

 

6、类属性、实例属性

了解类基本的东西以后，下面看一下python中这几个概念的区别、

在前面的例子中咱们接触到的就是实例属性（对象属性），类属性就是类对象所拥有的属性，它被全部类对象的实例对象所共有，在内存中只存在一个副本，这个和C++中类的静态成员变量有点相似。对于公有的类属性，在类外能够经过类对象和实例对象访问

一、类属性

class Person(object): name = "Tom" #公有的类属性
    __age = 12   #私有的类属性
 p = Person() print(p.name)        #正确
print(Person.name)   #正确
        
#print(p.__age) #错误，不能再类外经过实例变量访问类的私有属性 #print(Person.__age) #错误，不能再类外经过类对象访问类的私有属性

运行结果为：Tom、Tom

二、实例属性（对象属性）

class Person(object): address = "广州"
    def __init__(self): self.name = "Se7eN_HOU" self.age = 29 p = Person() p.age = 18 #实例属性
print(p.name)    #正确
print(p.address) #正确。实例对象能够访问类属性
print(p.age)     #正确

     
print(Person.address)   #正确 #print(Person.name) #错误，类不能访问实例属性 #print(Person.age) #错误，类不能访问实例属性

运行结果为：

Se7eN_HOU 广州 18 广州

三、经过实例去修改类属性

class Person(object): address = "广州" #类属性
 p = Person() print(p.address)    #正确
print(Person.address) #正确

print("-------分界线--------") p.address = "北京"
print(p.address) print(Person.address) print("-------分界线--------") Person.address = "上海"
print(p.address) print(Person.address)

运行结果为：

广州 广州 -------分界线-------- 北京 广州 -------分界线-------- 北京 上海

说明：

• 若是须要在类外修改类属性，必须经过类对象去引用而后进行修改。
• 若是经过实例对象去引用，会产生一个同名的实例属性，这种方式修改的是实例属性，不会影响到类属性。
• 若是经过实例对象去引用该类的类的属性，实例属性其实会从新建立一个新的属性。

 

7、类方法

类方法：是类对象所拥有的方法，须要用修饰器@classmethod来标识其为类方法，对于类方法，第一个参数必须是类对象，通常以cls做为第一个参数（固然能够用其余名称的变量做为其第一个参数，可是大部分人都习惯以’cls’做为第一个参数的名字，就最好用’cls’了），可以经过实例对象和类对象去访问。

class Person(object): country = "china" @classmethod def getCountry(cls): return cls.country p = Person() print(p.getCountry()) #正确，实例对象能够调用类方法
print(Person.getCountry())

运行结果为：china、china

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

class Person(object): country = "china" @classmethod def getCountry(cls): return cls.country @classmethod def setCountry(cls,newCountry): cls.country = newCountry p = Person() print(p.getCountry()) #正确，实例对象能够调用类方法
print(Person.getCountry()) p.setCountry("CHINA") print(p.getCountry()) Person.setCountry("中国") print(Person.getCountry())

运行结果为：

china
china
CHINA
中国

结果显示在用类方法对类属性修改以后，经过类对象和实例对象访问都发生了改变

 

8、静态方法

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

class Person(object): country = "china" @staticmethod def getCountry(): return Person.country p = Person() print(p.getCountry()) print(Person.getCountry())

运行结果为：china、china

总结：

实例方法：

• 定义：第一个参数必须是实例对象，该参数名通常约定为“self”，经过它来传递实例的属性和方法（也能够传类的属性和方法）；
• 调用：只能由实例对象调用。

类方法：

• 定义：使用装饰器@classmethod。
• 第一个参数必须是当前类对象，该参数名通常约定为“cls”，经过它来传递类的属性和方法（不能传实例的属性和方法）；
• 调用：实例对象和类对象均可以调用。

静态方法：

• 定义：使用装饰器@staticmethod。参数随意，没有“self”和“cls”参数，可是方法体中不能使用类或实例的任何属性和方法；
• 调用：实例对象和类对象均可以调用。