Day7-面向对象

面向对象编程定义

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)#强制访问私有属性对象名+._类名+私有属性名

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

继承:

面向对象编程 (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

析构函数

__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)
#在实例化对象结束后执行析构函数
时间: 2024-10-07 06:08:32

Day7-面向对象的相关文章

Python之路,Day7 - 面向对象编程进阶

本节内容 面向对象高级语法部分 静态方法.类方法.属性方法 类的特殊方法 反射 异常处理 Socket开发基础 作业开发一个支持多用户在线的FTP程序 面向对象高级语法部分 静态方法 通过@staticmethod装饰器即可把其装饰的方法变为一个静态方法什么是静态方法呢其实不难理解普通的方法可以在实例化后直接调用并且在方法里可以通过self.调用实例变量或类变量但静态方法是不可以访问实例变量或类变量的一个不能访问实例变量和类变量的方法其实相当于跟类本身已经没什么关系了它与类唯一的关联就是需要通过

day7 面向对象进阶

面向对象高级语法部分 通过@staticmethod装饰器即可把其装饰的方法变为一个静态方法,什么是静态方法呢?其实不难理解,普通的方法,可以在实例化后直接调用,并且在方法里可以通过self.调用实例变量或类变量,但静态方法是不可以访问实例变量或类变量的,一个不能访问实例变量和类变量的方法,其实相当于跟类本身已经没什么关系了,它与类唯一的关联就是需要通过类名来调用这个方法. class SchoolMember(object): def __init__(self,name,age,sex):

Python全栈开发,Day7 - 面向对象学习

本章内容 面向对象编程介绍 面向对象开发 面向对象的特性 一.面向对象编程介绍 介绍之前,先说一个例子: 你的老板要你做一款枪战游戏,游戏里面有很多的角色,比如CF里面的潜伏者和保卫者,在游戏里还有很多的玩家,每个玩家都有不同的名字和装扮,但是你发现这些玩家同一个阵容(潜伏者.保卫者)里的玩家具有很多相同的属性,于是你开始写代码,首先定义潜伏者1,名字.武器......等,然后保卫者1,同样,名字.武器......:代码如下: 1 def defenders(name,weapon,*args)

python小白-day7 面向对象高级部分

python 面向对象(进阶篇) 本篇将详细介绍Python 类的成员.成员修饰符.类的特殊成员以及类的反射. 类的成员 类的成员可以分为三大类:字段.方法和属性 注:所有成员中,只有普通字段的内容保存对象中,即:根据此类创建了多少对象,在内存中就有多少个普通字段.而其他的成员,则都是保存在类中,即:无论对象的多少,在内存中只创建一份. 一.字段 字段包括:普通字段和静态字段,他们在定义和使用中有所区别,而最本质的区别是内存中保存的位置不同. 普通字段属于对象 静态字段属于类 1 2 3 4 5

Day7 - 面向对象高级语法

参考文章:http://www.cnblogs.com/alex3714/articles/5213184.html 本节内容: 面向对象高级语法部分 静态方法.类方法.属性方法 类的特殊成员方法 反射 静态方法                                                                                   通过 @staticmethod 装饰器即可把其装饰的方法变为一个静态方法,什么是静态方法呢?其实不难理解,普通的方法,可

python_way ,day7 面向对象 (初级篇)

面向对象 初级篇 python支持 函数 与 面向对象 什么时候实用面向对象? 面向对象与函数对比 类和对象 创建类 class 类名 def 方法名(self,xxxx) 类里面的方法,只能对象去调用 对象 = 类名() 通过对象执行方法 对象.方法名(xxxx) 设计,增删改查功能 函数式: def fetch(self,host,port name passwd,sql) pass def create(self,host,port name passwd,sql) pass def re

day7 面向对象编程

编程范式 编程是程序员用特定的语法+数据结构+算法组成的代码来告诉计算机如何执行任务的过程,一个程序是程序员为了得到一个任务结果而编写的一组指令的集合,正所谓条条大路通罗马,实现一个任务的方式有很多种不同的方式, 对这些不同的编程方式的特点进行归纳总结得出来的编程方式类别,即为编程范式. 不同的编程范式本质上代表对各种类型的任务采取的不同的解决问题的思路, 大多数语言只支持一种编程范式,当然也有些语言可以同时支持多种编程范式. 两种最重要的编程范式分别是面向过程编程和面向对象编程 面向过程编程

day7 面向对象class()学习

    面向过程 VS 面向对象     编程范式 编程是程序员用特定的语法+数据结构+算法组成的代码来告诉计算机如何执行任务的过程,一个程序是程序员为了得到一个任务结果而编写的一组指令的集合,正所谓条条大路通罗马,实现一个任务的方式有很多种不同的方式, 对这些不同的编程方式的特点进行归纳总结得出来的编程方式类别,即为编程范式. 不同的编程范式本质上代表对各种类型的任务采取的不同的解决问题的思路, 大多数语言只支持一种编程范式,当然也有些语言可以同时支持多种编程范式. 两种最重要的编程范式分别是

day7 面向对象(二)

匿名类对象 创建的类的对象是匿名的.当我们只需要一次调用类的对象时,我们就可以考虑使用匿名的方式创建类的对象.特点是创建的匿名类的对象只能够调用一次! package day007; //圆的面积 class circle { double radius; public double getArea() { // TODO Auto-generated method stub return Math.PI * radius * radius; } public void setRadius(do

day7面向对象--进阶

静态方法(@staticmethod)     通过@staticmethod装饰器即可把其装饰的方法变为一个静态方法,什么是静态方法呢?其实不难理解,普通的方法,可以在实例化后直接调用,并且在方法里可以通过self.调用实例变量或类变量,但静态方法是不可以访问实例变量或类变量的,一个不能访问实例变量和类变量的方法,其实相当于跟类本身已经没什么关系了,它与类唯一的关联就是需要通过类名来调用这个方法. class Dog(object): def __init__(self,name): self