Day7-面向对象

Posted 2020-08-20 人生苦短，我用python

面向对象编程定义

OOP编程是利用“类”和“对象”来创建各种模型来实现对真实世界的描述，使用面向对象编程的原因一方面是因为它可以使程序的维护和扩展变得更简单，并且可以大大提高程序开发效率 ，另外，基于面向对象的程序可以使它人更加容易理解你的代码逻辑，从而使团队开发变得更从容。

面向对象的几大特性：

封装：

　　防止数据被随意修改

　　使外部程序不需要关注对象内部的构造，只需要通过对象对外提供的接口进行直接访问即可。

　　在类中对数据的赋值、内部调用对外部用户是透明的，这使类变成了一个胶囊或容器，里面包含着类的数据和方法

继承：

　　一个类可以派生出子类，在这个父类里定义的属性、方法自动被子类继承

　　通过父类--子类移最小代码量的方式实现不同角色的共同点和不同点

多态：

　　多态是面向对象的重要特性,简单点说:“一个接口，多种实现”，指一个基类中派生出了不同的子类，且每个子类在继承了同样的方法名的同时又对父类的方法做了不同的实现，这就是同一种事物表现出的多种形态。

面向对象的使用场景：

　　多个函数需传入多个共同的参数

　　根据一个模板创建，如上帝造人

 

类的定义和封装：

#创建类
class Dog(object):
　　#构造函数
    def __init__(self,name):
        self.NAME = name#普通属性
    def sayhi(self):
        print(\'hello,my name is %s\'%self.NAME)
    def eat(self,food):
        print(\'%s eat %s\'%(self.NAME,food))
#根据类Dog创建对象
自动执行__init__构造方法
d = Dog(\'alex\')#实例化对象，把alex封装到d self的name属性中
d.sayhi()
d.eat(\'sb\')

class Dog(object) 创建一个类

def __init__构造函数，类创建对象时自动执行

类中定义的函数称为方法

 

封装，顾名思义就是将内容封装到某个地方，以后再去调用被封装在某处的内容。

所以，在使用面向对象的封装特性时，需要：

• 将内容封装到某处
• 从某处调用被封装的内容

class Foo(object):
    def __init__(self,name,age):
        self.name = name
        self.age = age
f1 = Foo(\'alex\',18)
f2 = Foo(\'wusir\',18)
print(f1.age)
print(f2.age)

分析一波：

1.内容封装到某处

当执行f1 = Foo(\'alex\',18)，f2 = Foo(\'wusir\',18)时，self等于f1，f2，内容被封装到了对象f1，f2中，两个对象都有name和age的属性。

2.调用被封装的内容

• 直接调用

f1.age和f2.age就是通过对象直接调用被封装的对象

• 通过self间接调用被封装的内容

class Foo(object):
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def sayhi(self):
        print("hello,my name is [%s],I\'m [%s] years old"%(self.name,self.age))
f1 = Foo(\'alex\',18)
f2 = Foo(\'wusir\',18)
f1.sayhi()
f2.sayhi()

 

来一个稍微复杂点的封装

class F1:
    def __init__(self,n):
        self.N=n
        print(\'F1\')
class F2:
    def __init__(self,arg1):
        self.a = arg1
        print(\'F2\')
class F3:
    def __init__(self,arg2):
        self.b = arg2
        print(\'F3\')
o1 = F1(\'alex\')
o2 = F2(o1)
o3 = F3(o2)

有以上代码，现在想要通过o3来获取‘alex’，如果通过o1获取很简单o1.N，通过o3呢？o3.b.a.N

 

综上所述，对于面向对象的封装来说，其实就是使用构造方法将内容封装到对象中，然后通过对象直接或者self间接获取被封装的内容。

公有属性，私有属性，普通属性

class Role(object):
    nationality = \'jp\'#公有属性
    def __init__(self, name, role, weapon, life_value=100, money=15000):
        self.name = name#成员属性
        self.role = role
        self.weapon = weapon
        self.life_value = life_value
        self.money = money
        self.__heart = \'normale\'#私有属性

    def shot(self):
        print("shooting...")

    def got_shot(self):
        print("ah...,I got shot...")
        self.__heart = \'die\'
    def get_heart(self):#对外部提供只读的接口
        return self.__heart

    def buy_gun(self, gun_name):
        print("just bought %s" % gun_name)
p1 = Role(\'alex\',\'police\',\'ak47\')
print(p1.money)
print(p1.__heart)#直接这样访问是不行的
p1.got_shot()
print(p1.get_heart())

print(p1._Role__heart)#强制访问私有属性
对象名+._类名+私有属性名

*类中定义的私有方法或者构造函数中定义的私有属性，在实例化的时候都是不能通过对象直接调用的，只能在类中在定义一个方法，在这个方法中通过self.__方法()或者self.__属性实现调用。

公有属性的应用场景：每个对象中保存相同的东西

 

继承：

面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。

通过继承创建的新类称为“子类”或“派生类”。

被继承的类称为“基类”、“父类”或“超类”。

继承的过程，就是从一般到特殊的过程。

要实现继承，可以通过“继承”（Inheritance）和“组合”（Composition）来实现。

在某些 OOP 语言中，一个子类可以继承多个基类。但是一般情况下，一个子类只能有一个基类，要实现多重继承，可以通过多级继承来实现。

继承概念的实现方式主要有2类：实现继承、接口继承。

Ø         实现继承是指使用基类的属性和方法而无需额外编码的能力；

Ø         接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力(子类重构父类方法)

 

在进行继承的学习之前，先来看一下新式类和经典类的区别

首先定义类时经典类：class A 　　新式类：class A(object)

在继承时经典类：SchoolMember.__init__(self,name,age,sex)　　　　新式类：super(Teacher, self).__init__(name, age, sex)

在多继承时，新式类是广度优先方式查找

class Person(object):
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def talk(self):
        print(\'person is talking...\')
    def walk(self):
        print(\'is walking\')
class BlackPerson(Person):
#先继承再重写
    def __init__(self,name,age,sex):
        self.sex = sex
        Person.__init__(self,name,age)
        print(self.name,self.age,self.sex)
    def walk(self):
        print(\'walking fast\')
    def talk(self):
       print(\'speak english\')

b = BlackPerson(\'alex\',18,\'strong\')
b.talk()
b.walk()

 

b继承了Person的talk和walk方法

下面是复杂一点的继承

定义SchoolMember类，在构造函数中self.enroll每次实例化对象时都会执行，Teacher和Student类都继承了SchoolMember的tell方法，同时又自己定义了方法。

 

class SchoolMember(object):
    member = 0
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
        self.enroll()#每个对象实例化时都会执行
    def enroll(self):
        print(\'just enrolled a new school member [%s]\'%self.name)
        SchoolMember.member += 1
    def tell(self):
        print(\'----info:%s-----\'%self.name)
        for k,v in self.__dict__.items():
            print(k,v)
        print(\'----end:%s-----\'%self.name)

class Teacher(SchoolMember):
    def __init__(self,name,age,sex,salary,course):
        #SchoolMember.__init__(self,name,age,sex)
        super(Teacher, self).__init__(name, age, sex)
        self.salary = salary
        self.course = course
    def teaching(self):
        print(\'teacher [%s] is teaching [%s]\'%(self.name,self.course))
class Student(SchoolMember):
    def __init__(self,name,age,sex,course,tuition):
        #SchoolMember.__init__(self,name,age,sex)#经典类
        super(Student,self).__init__(name,age,sex)
        self.course = course
        self.tuition = tuition
        self.amount = 0
    def pay_tuition(self,amount):
        print(\'student [%s] has just paid [%s]\'%(self.name,amount))
        self.amount+=amount
t1 = Teacher(\'wusir\',28,\'f\',3000,\'python\')
s1 = Student(\'alex\',33,\'N/A\',\'pys15\',30000)
s2 = Student(\'alex1\',34,\'m\',\'pys15\',11000)

print(SchoolMember.member)
t1.tell()
s2.tell()

继承过程分析

class F1(object):
    def __init__(self):
        print(\'F1\')
    def a1(self):
        print(\'F1a1\')
    def a2(self):
        print(\'F1a2\')
class F2(F1):
    def __init__(self):
        print(\'F2\')
    def a1(self):
        self.a2()
        print(\'F2a1\')
    def a2(self):
        print(\'F2a2\')
class F3(F2):
    def __init__(self):
        print(\'F3\')
    def a2(self):
        print(\'F3a2\')
obj = F3()
obj.a1()

输出结果F3a2 F2a1

第四步中self.a2()中的self指的是调用当前方法的对象，self--obj  obj是F3的对象，F3里面有a2这个方法 

 

静态方法

属性：

　　普通属性（保存在对象中）

　　静态属性（保存在类中）

方法：

　　普通方法(保存在类中，调用者是对象，至少有self参数)

　　静态方法（保存在类中，调用者是类（不需要创建对象），任意个参数）

            class F1:

                @staticmethod
                def a1(a1,a2):
                    print(\'alex\')

            F1.a1(1,2)

 

 

析构函数

__del__

class Role(object):
    nationality = \'jp\'
    def __init__(self, name, role, weapon, life_value=100, money=15000):#公有
        self.name = name#成员属性
        self.role = role
        self.weapon = weapon
        self.life_value = life_value
        self.money = money
        self.__heart = \'normale\'

    def shot(self):#公有，只存一份
        print("shooting...")

    def got_shot(self):
        print("ah...,I got shot...")
        self.__heart = \'die\'

    def buy_gun(self, gun_name):
        print("just bought %s" % gun_name)
    #对外提供只读的访问接口
    def get_heart(self):
        return  self.__heart
    def __del__(self):
        print(\'hehhe\')
r1 = Role(\'Alex\', \'police\', \'AK47\')
print(r1.name)
#在实例化对象结束后执行析构函数

 多态

class Animal:
    def __init__(self,name):
        self.name = name
    def talk(self):
        print(\'gun\')

class Dog(Animal):
    def talk(self):
        return \'wang\'
class Cat(Animal):
    def talk(self):
        return(\'miao\')

d= Dog(\'d\')
c= Cat(\'c\')
def animal_talk(obj):
    print (obj.talk())
animal_talk(d)
animal_talk(c)