正文

day7-面向对象

人生苦短，我用python  人生苦短，我用python  2022-08-13  475

关键词：

面向对象编程定义

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)

day7面向对象(代码片段)

　　匿名类对象　　创建的类的对象是匿名的。当我们只需要一次调用类的对象时，我们就可以考虑使用匿名的方式创建类的对象。特点是创建的匿名类的对象只能够调用一次！packageday007;//圆的面积classcircledoubleradius;publicdoublege... 查看详情

面向对象进阶(day7)

一、isinstance(obj,cls)和issubclass(sub,super)1、isinstance(obj,cls)检查是否obj是否是类cls的对象classFoo(object):passobj=Foo()isinstance(obj,Foo)2、issubclass(sub,super)检查sub类是否是super类的派生类classFoo(object):passclassBa 查看详情

day7-面向对象高级语法

参考文章：http://www.cnblogs.com/alex3714/articles/5213184.html本节内容：面向对象高级语法部分静态方法、类方法、属性方法类的特殊成员方法反射静态方法 &nbs 查看详情

day7面向对象--反射

反射通过字符串映射或修改程序运行时的状态、属性、方法,有以下4个方法 1、getattr(object,name[,default])->value Getanamedattributefromanobject;getattr(x,‘y‘)isequivalenttox.y. & 查看详情

day7面向对象进阶

面向对象高级语法部分通过@staticmethod装饰器即可把其装饰的方法变为一个静态方法，什么是静态方法呢？其实不难理解，普通的方法，可以在实例化后直接调用，并且在方法里可以通过self.调用实例变... 查看详情

day7面向对象class()学习

面向过程VS面向对象编程范式编程是程序员用特定的语法+数据结构+算法组成的代码来告诉计算机如何执行任务的过程，一个程序是程序员为了得到一个任务结果而编写的一组指令的集合，正... 查看详情

面向对象之多态多态性(day7)

一、多态多态指的是一类事物有多种形态1、动物有多种形态：人，狗，猪importabcclassAnimal(metaclass=abc.ABCMeta):#同一类事物:动物@abc.abstractmethoddeftalk(self):passclassPeople(Animal):#动物的形态之一:人deftalk(self):print(‘sayhello‘)classDog(Animal) 查看详情

day7----面向对象编程进阶

本节内容：面向对象高级语法部分静态方法、类方法、属性方法类的特殊方法反射异常处理Socket开发基础静态方法它与类唯一的关联就是需要通过类名来调用这个方法#静态方法实际跟类没关系,不存在self变量了。#只是名义... 查看详情

day7面向对象--进阶

静态方法（@staticmethod）通过@staticmethod装饰器即可把其装饰的方法变为一个静态方法，什么是静态方法呢？其实不难理解，普通的方法，可以在实例化后直接调用，并且在方法里可以通过self.调用实例变量或类变量... 查看详情

day7面向对象编程

编程范式　　编程是程序员用特定的语法+数据结构+算法组成的代码来告诉计算机如何执行任务的过程，一个程序是程序员为了得到一个任务结果而编写的一组指令的集合，正所谓条条大路通罗马，实现一个任务的方式有很多种... 查看详情

day7-面向对象之继承与派生

一、初识继承什么是继承继承是一种创建新类的方式，新建的类可以继承一个或多个父类（python支持多继承），父类又可称为基类或超类，新建的类称为派生类或子类。子类会“”遗传”父类的属性，从而解决代码重用问题。pyt... 查看详情

面向对象之封装(day7)

一、引子从封装本身的意思去理解，封装就好像是拿来一个麻袋，把小猫，小狗，小王八一起装进麻袋，然后把麻袋封上口子。照这种逻辑看，封装=‘隐藏’，当然，这种理解是相当片面的。二、先看如何隐藏在python中用双下... 查看详情

面向对象之继承与派生(day7)

一、初识继承1、什么是继承继承是一种创建新类的方式，新建的类可以继承一个或多个父类（python支持多继承），父类又可称为基类或超类，新建的类称为派生类或子类。子类会“”遗传”父类的属性，从而解决代码重用问题... 查看详情

面向对象之绑定方法与非绑定方法(day7)

一、类中定义的函数分成两大类1、绑定方法（绑定给谁，谁来调用就自动将它本身当作第一个参数传入）：1)绑定到类的方法：用classmethod装饰器装饰的方法。为类量身定制类.boud_method(),自动将类当作第一个参数传入（其实对象... 查看详情

day7-面向对象之绑定方法与非绑定方法

一、类中定义的函数分成两大类一：绑定方法（绑定给谁，谁来调用就自动将它本身当作第一个参数传入）：　　　　1.绑定到类的方法：用classmethod装饰器装饰的方法。为类量身定制 ... 查看详情

day7课程

本节内容：面向对象高级语法部分静态方法、类方法、属性方法类的特殊方法反射异常处理 Socket开发基础面对对象高级语法部门：一、面向对象高级语法部分　　静态方法（@staticmethod）　　定义... 查看详情

java核心面试宝典day7面向对象常见面试题汇总(代码片段)

Hello，你好呀，我是灰小猿！一个超会写bug的程序猿！用坚持缔造技术、用指尖敲动未来！和很多小伙伴们一样，我也是一名奔波在Java道路上的“创造者”。也想靠技术来改未来，改变世界！因为... 查看详情