python的面向对象

一.python的面向对象的重要术语

　1、多态（polymorphism）：一个函数有多种表现形式，调用一个方法有多种形式，但是表现出的方法是不一样的。

　2、继承（inheritance）子项继承父项的某些功能，在程序中表现某种联系

　3、封装（encapsulation）把需要重用的函数或者功能封装，方便其他程序直接调用

　4、类：对具有相同数据或者方法的一组对象的集合

　5、对象：对象是一个类的具体事例

　6、实例化：是一个对象事例话的实现

　7、标识：每个对象的事例都需要一个可以唯一标识这个事例的标记

　8、实例属性：一个对象就是一组属性的集合

　9、事例方法：所有存取或者更新对象某个实例一条或者多条属性函数的集合。

　10、类属性：属于一个类中所有对象的属性，

　11、类方法：那些无须特定的对性实例就能够工作的从属于类的函数。

二、封装、继承、多态

　　一.封装

　　概念

　　公开属性：可以在类以外的任何地方直接访问。

　　私有属性：只能在类的内部被直接访问，在对象属性的前面添加两个下划线表示是私有属性。

　　1.语法

class 类名：
    __属性名 = 属性

 

　　2.属性未被私有化

class Person:
    def __init__(self, name, age):
        # 公开属性
        self.name = name
        self.age = age


p1 = Person("jack", 10)
# 直接访问
print(p1.name, p1.age)  # jack 10

# 修改
p1.name = "tom"
p1.age = 19
print(p1.name, p1.age)  # tom 19

　　3.属性被私有化

　　工作原理：一个属性一旦被私有化，在底层形成了 _类名__属性名 的属性名 ，但是不建议使用。私有化属性在底层的存在形式根据操作系统或者Python解释器的不同会有所差别，如果直接使用此种方式访问，违背了Python跨平台的特点。

class Person:
    def __init__(self, name, age):
        self.__name = name
        self.__age = age


p = Person("jack", 10)
print(p.name,p.age) #AttributeError: 'Person2' object has no attribute 'name'
print(p.__name) #AttributeError: 'Person2' object has no attribute '__name'
print(p._Person__name)  # jack

 

　　4. 暴露给外界访问的函数

　　　在类外面访问属性，无非涉及到两个操作：获取值，修改值。

class Person:
    def __init__(self, name, age):
        self.__name = name
        self.__age = age

    # 返回被私有化属性的值
    def getname(self):
        return self.__name

    def setname(self, name):
        self.__name = name

    def getage(self):
        return self.__age

    def setage(self, age):
        if age < 0:
            age = abs(age)
        self.__age = age


p = Person("jack", 10)
# 获取值
r1 = p.getname()
print(r1)  # jack
# 修改值
p.setname("tom")
r2 = p.getname()
print(r2)  # tom

p.setage(-19)
print(p.getage())  # 19

　　二.继承

　　概念

　　子类继承父类，可以直接享受父类封装好的方法，不需要再次开发

　　继承的传递性，子类拥有父类的全部特性，同时也继承有父类的父类的全部特性

　　1.语法

class 类名(父类名)：
    pass

 　　2.单继承

#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))
 
#单继承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))
 
 
 
s = student('ken',10,60,3)
s.speak()

　　输出结果:　

ken 说: 我 10 岁了，我在读 3 年级

　　3.多继承

#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))
 
#单继承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))
 
#另一个类，多重继承之前的准备
class speaker():
    topic = ''
    name = ''
    def __init__(self,n,t):
        self.name = n
        self.topic = t
    def speak(self):
        print("我叫 %s，我是一个演说家，我演讲的主题是 %s"%(self.name,self.topic))
 
#多重继承
class sample(speaker,student):
    a =''
    def __init__(self,n,a,w,g,t):
        student.__init__(self,n,a,w,g)
        speaker.__init__(self,n,t)
 
test = sample("Tim",25,80,4,"Python")
test.speak()   #方法名同，默认调用的是在括号中排前地父类的方法

　　输出结果

我叫 Tim，我是一个演说家，我演讲的主题是 Python

　　三.多态

　　概念

 　　首先Python不支持多态，也不用支持多态。由于Python为动态语言，参数类型没定，所以本身即是多态的

 

　　1.例子:

class A:    
    def prt(self):    
        print "A"    
class B(A):    
    def prt(self):    
        print "B"    
class C(A):    
    def prt(self):    
        print "C"    
class D(A):    
    pass    
class E:    
    def prt(self):    
        print "E"    
class F:    
    pass    
def test(arg):    
    arg.prt()    
a = A()    
b = B()    
c = C()    
d = D()    
e = E()    
f = F()    
test(a)    
test(b)    
test(c)    
test(d)    
test(e)    
test(f) 

　　输出结果:

A  
B  
C  
A  
E  

　　三、面向对象的各种方法

　　1.静态方法

　　概念

　　所谓静态方法，就是：定义在类中，并且使用 @staticmethod 修饰器修饰，没有 cls 和 self 参数限制的方法我们称之为静态方法。在静态方法中，不会涉及到类中的方法和属性的操作，可以理解为将静态方法寄存在该类的命名空间中。

　　语法:

# 定义的一个类
class Person(object):
    # 类的属性
    name = "小明"
    
    # 静态方法 
    # 【1】定义在类中
    # 【2】使用 @staticmethod修饰器修饰
    # 【3】没有self、cls这样的参数限制
    @staticmethod
    def get_name():
        return Person.name

​　　调用　

　　 对象名.静态方法名()

　　类名.静态方法名()

　　语法:

class Person:
    @staticmethod
    def test():
        print('我是静态方法')

　　2.类方法

　　概念

　　方法前用装饰器@classmethod修饰。第一个参数为cls代表类

　　类方法特点：类方法里面不能调用普通方法

　　语法:

class Person:
    #类方法
    @classmethod
    def test1(cls):
        print('我是类方法')

　　调用

　　对象名.方法名()

　　类名.方法名()

　　3.属性方法　

　　把一个方法变成一个静态属性，属性就不用加小括号那样的去调用了

　　语法:

class Person():
    @property
    def eat(self):
        print("我是属性方法")

　　调用

　　对象名.方法名()

　　类名.方法名