面向对象编程定义

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. React Native windows搭建记录

    因为是window电脑上运行的,所以测试的是安卓 1: 安装jdk:jdk-8u45-windows-x64.exe 2: 配置JAVA的环境变量 在安卓的配置基础上添加一个变量ANDROID_HOM ...

  2. Linux2.6内核进程调度系列--scheduler_tick()函数2.更新实时进程的时间片

    RT /** * 递减当前进程的时间片计数器,并检查是否已经用完时间片. * 由于进程的调度类型不同,函数所执行的操作也有很大差别. */ /* 如果是实时进程,就进一步根据是FIFO还是RR类型的实 ...

  3. Android编码规范05

    编码逻辑规范总结: 1.避免使用多个类放在一个文件里,除非是一次性使用的内部类 2.一个方法代码长度最好不要超过35行 3.原则上尽量不要修改自动生成的文件,如R文件 4.Final String 取 ...

  4. 我的第一篇博客----LCS学习笔记

    LCS引论 在这篇博文中,博主要给大家讲一个算法----最长公共子序列(LCS)算法.我最初接触这个算法是在高中学信息学竞赛的时候.那时候花了好长时间理解这个算法.老师经常说,这种算法是母算法,即从这 ...

  5. Oracle数据库,数据的增、删、改、查

    oracle数据库中,数据的增.删.改.查,通过SQL语句实现 SQL:结构化查询语言: 特点:不区分大小写:字符串用单引号引起来:语句结束用分号表示结束: 行注释,在语句的最前面加"--& ...

  6. 学习sql中的排列组合,在园子里搜着看于是。。。

    学习sql中的排列组合,在园子里搜着看,看到篇文章,于是自己(新手)用了最最原始的sql去写出来: --需求----B, C, F, M and S住在一座房子的不同楼层.--B 不住顶层.C 不住底 ...

  7. 《Ansible权威指南》笔记(1)——安装,ssh密钥登陆,命令

    2016-12-23 读这本<Ansible权威指南>学习ansible,根据本书内容和网上的各种文档,以及经过自己测试,写出以下笔记.另,这本书内容很好,但印刷错误比较多,作者说第二版会 ...

  8. 搭建基于PHP的www服务器

    安装MySQL #!/bin/bash mount |grep "/dev/sr0" if [ "$?" != 0 ];then mount /dev/sr0 ...

  9. hdu1695 GCD(莫比乌斯反演)

    题意:求(1,b)区间和(1,d)区间里面gcd(x, y) = k的数的对数(1<=x<=b , 1<= y <= d). 知识点: 莫比乌斯反演/*12*/ 线性筛求莫比乌 ...

  10. Unity需要频繁登录是什么情况

    这个问题会在Unity 5.5.0p3中修复 都一样,等新版本吧