正文

day6面向对象

（野生程序员）  （野生程序员）  2022-09-10  667

关键词：

面向对象介绍(http://www.cnblogs.com/alex3714/articles/5188179.htm)

世界万物，皆可分类

世界万物，皆为对象

只要是对象，就肯定术语某种类

　　（1）特性封装、继承、多态

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

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

Polymorphism 多态
　　多态是面向对象的重要特性,简单点说:“一个接口，多种实现”，指一个基类中派生出了不同的子类，且每个子类在继承了同样的方法名的同时又对父类的方法做了不同的实现，这就是同一种事物表现出的多种形态。
编程其实就是一个将具体世界进行抽象化的过程，多态就是抽象化的一种体现，把一系列具体事物的共同点抽象出来, 再通过这个抽象的事物, 与不同的具体事物进行对话。
　　对不同类的对象发出相同的消息将会有不同的行为。比如，你的老板让所有员工在九点钟开始工作, 他只要在九点钟的时候说：“开始工作”即可，而不需要对销售人员说：“开始销售工作”，对技术人员说：“开始技术工作”, 因为“员工”是一个抽象的事物, 只要是员工就可以开始工作，他知道这一点就行了。至于每个员工，当然会各司其职，做各自的工作。
多态允许将子类的对象当作父类的对象使用，某父类型的引用指向其子类型的对象,调用的方法是该子类型的方法。这里引用和调用方法的代码编译前就已经决定了,而引用所指向的对象可以在运行期间动态绑定

class

object

(2）语法属性、方法、构造函数、析构函数

私有方法，私有属性

创建类，并实例化两个对象

class Role(object):
    '''创建一个角色的类'''
    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

    def shot(self):                         #方法(动态属性）
        print("shotting.......")

    def get_shot(self):
        print("ah....,I got shot......")

    def buy_gun(self,gun_name):
        print("%s just bougnt %s" %(self.name,gun_name))

r1 = Role("alex","police","AK47")    #实例化，又可以称为初始化分类
r2 = Role("jack","terroist","B15")   #生成一个角色
r1.buy_gun("AK47")

把一个类变成一个具体对象的过程叫实例化。

__init__(self)：构造函数，作用是在实例化时做一些类的初始化工作。

r1 = Role("alex","police","AK47") #实例化，又可以称为初始化分类与Role("alex","police","AK47")是一样的，赋给一个变量的目的是防止被销毁，python的内存回收机制，如果没有变量，开辟的内存将会被回收。

调用r1 = Role("alex","police","AK47")等价于Role(r1,"alex","police","AK47")其中，self相当于r1，把r1当做参数传进去了。

上面实例化过程中，self相当于r1，self.name等价于r1.name。每次实例化，都会把实例化的名字传进去，r1 = Role("alex","police","AK47") 》Role(r1,"alex","police","AK47"), r2 = Role("jack","terroist","B15")》Role(r2,"jack","terroist","B15")

　　r1 = Role("alex","police","AK47")    #实例化，又可以称为初始化分类
　　r2 = Role("jack","terroist","B15")   #生成一个角色
　　r1.buy_gun("AK47")
    r2.get_shot()   #调用r2相当于Role.get_shot(r2)

上面调用的过程中，r2.get_shot()相当于Role.get_shot(r2)。实例变量的作用域就是实例本身。

类中的函数叫方法；

类变量和实例变量的方法：

class Role(object):
    '''创建一个角色的类'''
    n = 123    #类的变量，存在类的内存中
    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

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

    def get_shot(self):
        print("ah....,I got shot......")

    def buy_gun(self,gun_name):
        print("%s just bougnt %s" %(self.name,gun_name))

# r1 = Role("alex","police","AK47")    #实例化，又可以称为初始化分类
# r2 = Role("jack","terroist","B15")   #生成一个角色

print(Role.n)

上面代码中，我们给类添加了一个变量n，可以发现，我们没有创建实例，就可以调用，说明n是存在类变量中的。

下面创建实例，看是否可以调用：

class Role(object):
    '''创建一个角色的类'''
    n = 123    #类的变量，存在类的内存中
    name = "我是类name"
    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

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

    def get_shot(self):
        print("ah....,I got shot......")

    def buy_gun(self,gun_name):
        print("%s just bougnt %s" %(self.name,gun_name))

r1 = Role("alex","police","AK47")    #实例化，又可以称为初始化分类
r2 = Role("jack","terroist","B15")   #生成一个角色

print(Role.n)
print("r1.n:",r1.n)

上面，实例里面不包含n，但是也可以了，说明实例没有这个变量会去类里面找。

现在我们创建了一个name的类变量，由于实例里面也包含name属性。看是调用那个方法。

class Role(object):
    '''创建一个角色的类'''
    n = 123    #类的变量，存在类的内存中
    name = "我是类name"
    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

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

    def get_shot(self):
        print("ah....,I got shot......")

    def buy_gun(self,gun_name):
        print("%s just bougnt %s" %(self.name,gun_name))

r1 = Role("alex","police","AK47")    #实例化，又可以称为初始化分类
r2 = Role("jack","terroist","B15")   #生成一个角色

print(Role.n)
print("r1.n:",r1.n)
print("r1.name:",r1.name)
运行结果如下
123
r1.n: 123
r1.name: alex

从上面代码可以看出，先去实例里面找变量，如果没有才会去类中进行查找。

下面给类修改变量。

class Role(object):
    '''创建一个角色的类'''
    n = 123    #类的变量，存在类的内存中
    name = "我是类name"
    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

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

    def get_shot(self):
        print("ah....,I got shot......")

    def buy_gun(self,gun_name):
        print("%s just bougnt %s" %(self.name,gun_name))

r1 = Role("alex","police","AK47")    #实例化，又可以称为初始化分类
r1.name = "chenronghua"     #给实例修改名字
r2 = Role("jack","terroist","B15")   #生成一个角色
r2.name = "小猪猪"    #给实例重新进行赋值

print(Role.n)
print("r1.n:",r1.n)
print("r1.name:",r1.name)
运行结果如下：
123
r1.n: 123
r1.name: chenronghua

从上面可以看出，实例化之后，我们可以给实例化的变量重新赋值，修改里面的值。

下面我们给实例本身添加一个新的属性：

class Role(object):
    '''创建一个角色的类'''
    n = 123    #类的变量，存在类的内存中
    name = "我是类name"
    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

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

    def get_shot(self):
        print("ah....,I got shot......")

    def buy_gun(self,gun_name):
        print("%s just bougnt %s" %(self.name,gun_name))

r1 = Role("alex","police","AK47")    #实例化，又可以称为初始化分类
r1.name = "chenronghua"
r1.bullet_vests = True       #属性不存在，重新创建一个属性
r2 = Role("jack","terroist","B15")   #生成一个角色
r2.name = "小猪猪"

print("bullet_vests",r1.bullet_vests)
print("r2.bullet_vests:",r2.bullet_vests)
运行结果如下：
bullet_vests True
Traceback (most recent call last):
  File "/home/zhuzhu/第六天/CF.py", line 29, in <module>
    print("r2.bullet_vests:",r2.bullet_vests)
AttributeError: 'Role' object has no attribute 'bullet_vests

上面，我们给r1实例创建了一个bullet_vests的新属性，可以看出，能够给实例r1创建新的属性，创建的属性r2实例是不具备的。

下面来删除实例里面的变量：删除r1实例中的weapon

class Role(object):
    '''创建一个角色的类'''
    n = 123    #类的变量，存在类的内存中
    name = "我是类name"
    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

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

    def get_shot(self):
        print("ah....,I got shot......")

    def buy_gun(self,gun_name):
        print("%s just bougnt %s" %(self.name,gun_name))

r1 = Role("alex","police","AK47")    #实例化，又可以称为初始化分类
r1.name = "chenronghua"
del r1.weapon      #删除实例r1中的weapon
r2 = Role("jack","terroist","B15")   #生成一个角色
r2.name = "小猪猪"

print(r2.weapon)
print(r1.weapon)
运行结果如下：
B15
Traceback (most recent call last):
  File "/home/zhuzhu/第六天/CF.py", line 29, in <module>
    print(r1.weapon)
AttributeError: 'Role' object has no attribute 'weapon

从运行结果可以看出，删除实例r1中的weapon之后，实例r2中的weapon不受影响，但是实例r1中的weapon不存在了。

如果我们删除Role类中的weapon，那么肯定r1.weapon和r2.weapon都不能调用。

下面来看一下，实例里面是否可以修改类变量：

class Role(object):
    '''创建一个角色的类'''
    n = 123    #类的变量，存在类的内存中
    name = "我是类name"
    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

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

    def get_shot(self):
        print("ah....,I got shot......")

    def buy_gun(self,gun_name):
        print("%s just bougnt %s" %(self.name,gun_name))

r1 = Role("alex","police","AK47")    #实例化，又可以称为初始化分类
r1.name = "chenronghua"
r1.n = "666可以改吗"       #修改类中的变量，看是否可以成功
r2 = Role("jack","terroist","B15")   #生成一个角色
r2.name = "小猪猪"

print("r1.n:",r1.n)
print("r2.n:",r2.n)
运行结果如下：
r1.n: 666可以改吗
r2.n: 123

从上面代码可以看出，r1.n="666可以改吗"等于在实例r1中重新创建了一个变量n，因为实例r1中不存在n，不影响类本身Role.n中的值。

类内存和类生成的实例内存。

类变量的用途？大家共用的属性，节省开销。比如防弹衣，默认是没有穿防弹衣的，我们可以在类中定义一个bullet_vests=""，这样，每个人都具有了防弹衣的属性。当某人买了放单衣的时候，直接r1.bullet_vests=True即可。虽然可以在属性里面定义，但是这样每个属性里面都创建了bullet_vests，浪费了内存。在类中只需创建一次即可。

析构函数

析构函数：在实例释放、销毁的时候执行的，通常用于做一些收尾工作，如关闭一些数据库链接，打开的临时文件，可以在里面进行操作。

class Role(object):
    '''创建一个角色的类'''
    n = 123    #类的变量，存在类的内存中
    name = "我是类name"
    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

    def __del__(self):     #不需要传参数，实例结束之后自动执行,不用调用直接执行    析构函数
        print("%s 彻底死了" %self.name)

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

    def get_shot(self):
        print("ah....,I got shot......")

    def buy_gun(self,gun_name):
        print("%s just bougnt %s" %(self.name,gun_name))

r1 = Role("alex","police","AK47")    #实例化，又可以称为初始化分类
r1.name = "chenronghua"
r1.n = "666可以改吗"
r2 = Role("jack","terroist","B15")   #生成一个角色
r2.name = "不努力"


r1.get_shot()
r2.shot()
运行结果如下：
ah....,I got shot......
shotting.......
chenronghua 彻底死了
不努力 彻底死了

从上面代码可以看出，__del__析构函数在程序退出的时候自动执行。就是在我们运行玩类之后，自动销毁变量。是在所有调用结束不使用的时候才销毁的。

__del__析构函数不需要自己调用，在程序调用结束后自动执行。

私有方法，私有属性

私有方法，私有属性：就是只能内部访问，外部访问不了。

比如上面类中的self.life_value属性，我们知道，任何人执行程序都可以调用r1.life_value=0,直接让生命值变为0，如下：

class Role(object):
    '''创建一个角色的类'''
    n = 123    #类的变量，存在类的内存中
    name = "我是类name"
    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

    def __del__(self):     #不需要传参数，实例结束之后自动执行,不用调用直接执行
        print("%s 彻底死了" %self.name)

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

    def get_shot(self):
        print("ah....,I got shot......")

    def buy_gun(self,gun_name):
        print("%s just bougnt %s" %(self.name,gun_name))

r1 = Role("alex","police","AK47")    #实例化，又可以称为初始化分类
r2 = Role("jack","terroist","B15")   #生成一个角色

print("modify before:",r1.life_value)
r1.life_value = 0
print("modify after:",r1.life_value)
运行结果如下：
modify before: 100
modify after: 0
alex 彻底死了
jack 彻底死了

从上面代码可以看出，开始的时候r1.life_value生命值是100满的，但是我们修改了生命值，直接让生命值变成0；可以看出，生命值直接改变了。假如是一款游戏的话，上来直接别人修改生命值就挂了，还没有摸过女生的屁股就死了，这他妈也太冤枉了吧。所以，这样肯定是不行的，不能让外部调用机密的属性，只能在内部进行调用。如下：

class Role(object):
    '''创建一个角色的类'''
    n = 123    #类的变量，存在类的内存中
    name = "我是类name"
    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

    # def __del__(self):     #不需要传参数，实例结束之后自动执行,不用调用直接执行
    #     print("%s 彻底死了" %self.name)

    def show_status(self):
        print("name:%s weapon:%s life_value:%s" %(self.name,self.weapon,self.__life_value))

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

    def get_shot(self):
        print("ah....,I got shot......")

    def buy_gun(self,gun_name):
        print("%s just bougnt %s" %(self.name,gun_name))

r1 = Role("alex","police","AK47")    #实例化，又可以称为初始化分类
r2 = Role("jack","terroist","B15")   #生成一个角色
print(r1.__life_value)
运行结果如下：
Traceback (most recent call last):
  File "/home/zhuzhu/第六天/CF.py", line 30, in <module>
    print(r1.__life_value)
AttributeError: 'Role' object has no attribute '__life_value'

从上面运行结果可以看出，当我们把变量life_value设置为私有变量__life_value的时候，外部是不能够调用的。错误提示是：Role类中没有__life_value属性。

既然私有属性不能在外部调用，那么我们就在程序内部调用。

class Role(object):
    '''创建一个角色的类'''
    n = 123    #类的变量，存在类的内存中
    name = "我是类name"
    def __init__(self,name,role,weapon,life_value=100,money=15000):
        '''初始化变量day6
Python面向对象Python从设计之初就已经是一门面向对象的语言，正因为如此，在Python中创建一个类和对象是很容易的。本章节我们将详细介绍Python的面向对象编程。如果你以前没有接触过面向对象的编程语言，那你可能需要先了解...  查看详情  
                
day6面向对象编程
面向对象编程介绍OOP编程是利用“类”和“对象”来创建各种模型来实现对真实世界的描述，使用面向对象编程的原因一方面是因为它可以使程序的维护和扩展变得更简单，并且可以大大提高程序开发效率，另外，...  查看详情  
                
day6面向对象基础(代码片段)
　　java面向对象　　面向对象思想：　　1.设计类，并设计类的成员（成员变量&成员方法）;　　 2.通过类，来创建类的对象（也称作类的实例化）;　　3.通过“对象.属性”或“对象.方法”来调用，完成相应的功能；　...  查看详情  
                
day6-面向对象学习
面向对象介绍特性classobject封装继承https://segmentfault.com/a/1190000002685939python2经典类是按照深度优先来继承的；新式类是按照广度优先继承的。python3经典类，新式类都是按照广度优先来继承的多态 语法属性方法 构造函数析...  查看详情  
                
面向对象的程序设计(day6)
一、面向过程与面向对象面向过程：核心是过程二字，过程即解决问题的步骤，就是先干什么再干什么基于该思想写程序就好比在设计一条流水线，是一种机械式的思维方式优点：复杂的过程流程化，进而简单化缺点：扩展性差...  查看详情  
                
day6面向对象
继承1.1  类和类之间的常见关系。   1：既然继承是描述类和类之间的关系，就需要先来了解类和类之间的常见关系1.1.1  现实生活的整体与部分举例说明1：现实生活   1：学生  是人&nbs...  查看详情  
                
day6面向对象--继承多态
继承   继承：就像遗传一样，继承就是拥有父类的所有方法和属性，并且能够定义自己独特的属性和方法，对上面的类进行扩展。   可以什么都不写，直接继承父类，如下：   classPeople(object):def_...  查看详情  
                
day6面向对象--类的特殊成员方法
类的特殊成员方法   1.__doc__　　表示类的描述信息classFunc(object):‘‘‘__doc__方法是用来打印类的描述信息‘‘‘deftell(self):passdefenroll(self):passprint(Func.__doc__)#输出：类的描述信息运行结果如下：__doc__方法是用来打印类...  查看详情  
                
day6心得
面向对象编程介绍为什么要用面向对象进行开发？面向对象的特性：封装、继承、多态类、方法、  引子你现在是一家游戏公司的开发人员，现在需要你开发一款叫做<人狗大战>的游戏，你就思考呀，人狗作战，那至...  查看详情  
                
java核心面试宝典day6面向对象常见面试题汇总(代码片段)
Hello，你好呀，我是灰小猿！一个超会写bug的程序猿！用坚持缔造技术、用指尖敲动未来！和很多小伙伴们一样，我也是一名奔波在Java道路上的“创造者”。也想靠技术来改未来，改变世界！因为...  查看详情  
                
java核心面试宝典day6面向对象常见面试题汇总(代码片段)
Hello，你好呀，我是灰小猿！一个超会写bug的程序猿！用坚持缔造技术、用指尖敲动未来！和很多小伙伴们一样，我也是一名奔波在Java道路上的“创造者”。也想靠技术来改未来，改变世界！因为...  查看详情  
                
day6老王开枪打人
...main():‘‘‘用来控制这个程序的流程‘‘‘pass#1.创建alex对象#2.创建1个枪对象#3.创建1个弹夹对象#4.创建子弹对象#5.创建一个敌人#6.alex把子弹安装到弹夹中#7.alex把弹夹安装到枪中#8.alex拿枪#9.alex拿枪打jackif__name__=="__main__":main()&nb...  查看详情  
                
go(day6[接口])
Go接口Interface定义:Interface类型可以定义?组?法，?来表示?个对象的?为特征。interface不能包含任何变量。  查看详情  
                
day6面相对象编程类的继承经典类新式类
类变量与实例变量构造函数__author__=‘meng‘classFoo:#n=12345#类变量def__init__(self,name,age):#构造函数#在实例化时做一些类的初始化工作self.name=name#实例变量（静态属性），作用域就是实例本身self.age=agedefshot(self):#类的方法功能（动态...  查看详情  
                
改善程序与设计的55个具体做法day6
 条款13：以对象管理资源资源，包括但不限于内存、句柄、GDI对象、数据库连接等。内存要记得释放，句柄要记得closehandle，GDI对象要记得删除，数据库连接要记得关闭，等等等等。以对象来管理这些资源就是利用对象的构...  查看详情  
                
day6java学习第六天---;方法
...方法System.out.println(),那它是什么？调用System系统类中的out对象的println()方法Java方法是语句的集合，它们在一起执行一个功能。方法是解决一类问题的步骤的有序组合方法包含于类或对象中方法  查看详情  
                
day6.列表函数
1.list.append(obj)  在列表末尾添加新的对象2.list.count(obj)  统计某个元素在列表中出现的次数3.list.extend(seq)  在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）4.list.index(obj)  从...  查看详情  
                
day6_time模块
...特定的格式输出时间print(time.localtime())　　#得到的是一个对象，如果想要看下面的子模块，看哪个模块就在后边加上（.模块）就好，一定不要忘了点print(time.localtime())#time.str  查看详情