面向对象编程定义

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-面向对象的更多相关文章

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

    本节内容: 面向对象高级语法部分 经典类vs新式类 静态方法.类方法.属性方法 类的特殊方法 反射 异常处理 Socket开发基础 作业:开发一个支持多用户在线的FTP程序 经典类vs新式类 把下面代 ...

  2. day7 面向对象进阶

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

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

    面向对象 初级篇   python支持 函数 与 面向对象   什么时候实用面向对象? 面向对象与函数对比 类和对象 创建类 class 类名 def 方法名(self,xxxx) 类里面的方法,只能 ...

  4. day7 面向对象编程

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

  5. Day7 面向对象和类的介绍

    面向对象讲解: ''' 面向过程: 核心是过程二字,过程指的是问题的解决步骤,基于过程去设计程序,就好比在设计一条流水线,是一种机械式的思维方式. 优点:复杂的问题流程化,进而简单化 缺点:可扩展性差 ...

  6. Python之旅Day7 面向对象&异常处理

    ########################################面向对象初识######################################### 面向对象简介 面向对象编 ...

  7. day7 面向对象class()学习

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

  8. Java学习day7面向对象编程1-对象和类

    一.Java编程中对象和类的概念 1,什么是类? 答:类是客观存在的,抽象的,概念的东西. 2,什么是对象? 答:对象是具体的,实际的,代表一个事物.例如:车是一个类,汽车,自行车就是他的对象. 关于 ...

  9. day7面向对象--反射

    反射 通过字符串映射或修改程序运行时的状态.属性.方法, 有以下4个方法     1.getattr(object, name[, default]) -> value Get a named ...

  10. day7面向对象--进阶

    静态方法(@staticmethod)     通过@staticmethod装饰器即可把其装饰的方法变为一个静态方法,什么是静态方法呢?其实不难理解,普通的方法,可以在实例化后直接调用,并且在方法里 ...

随机推荐

  1. [Android]Android端ORM框架——RapidORM(v2.1)

    以下内容为原创,欢迎转载,转载请注明 来自天天博客:http://www.cnblogs.com/tiantianbyconan/p/6020412.html [Android]Android端ORM ...

  2. iOS - ViewController的生命周期

    iOS SDK中提供很多原生的ViewController,大大提高了我们的开发效率:那么下面我们就根据开发中我们常用的ViewController谈一谈它的生命周期: (一)按照结构和用法可以对iO ...

  3. 二维码合成,将苹果和安卓(ios和android)合成一个二维码,让用户扫描一个二维码就可以分别下载苹果和安卓的应用

    因为公司推广的原因,没有合适的将苹果和安卓(ios和android)合成一个二维码的工具. 因为这个不难,主要是根据浏览器的UA进行判断,所以就自己开发了一个网站 网站名称叫:好推二维码  https ...

  4. 信息系统实践手记6-JS调用Flex的性能问题一例

    说明:信息系统实践手记系列是系笔者在平时研发中先后遇到的大小的问题,也许朴实和细微,但往往却是经常遇到的问题.笔者对其中比较典型的加以收集,描述,归纳和分享. 摘要:此文描述了笔者接触过的部分信息系统 ...

  5. MySQL:procedure, function, cursor,handler

    Procedure & Function Procedure 语法: CREATE [DEFINER = { user | CURRENT_USER }] PROCEDURE sp_name ...

  6. class.c 添加中文注释(3)

    int class_device_register(struct class_device *class_dev) { /* [cgw]: 初始化一个struct class_device */ cl ...

  7. 如何通过JS调用某段SQL语句

    如何通过JS调用某段SQL语句,这样的需求在报表.数据平台开发中很常见.以报表平台FineReport开发为例,例如在点击某个按钮之后,来判断一下数据库条数,再决定下一步操作.那这在后台如何实现呢? ...

  8. Winform进程、线程

    进程: 一般来说,一个程序就是一个进程,不过也有一个程序需要多个进程支持的情况. 进程要使用的类是:Process它在命名空间:System.Diagnostics; 1.静态方法Start(); 2 ...

  9. get方式和set方式提交时乱码

    request.setChracterEncoding("utf-8");只对form表单的post提交方式有效. 当使用get提交的时候:

  10. linux网络编程tcp

    之前学习的时候笔记没有保存好,这次重新编写一个案例. 客户端实现程序代码: #include <string.h> #include <stdlib.h> #include & ...