面向对象 oop:object oriented programming
面向对象的基本概念
我们之前学习的编程方式就是面向过程的
面向过程和面向对象,是两种不同的编程方式
对比面向过程的特点,可以更好的了解什么是面向对象
过程和函数(都是对一段功能的代码进行封装)
过程:是早期的一个编程概念
过程类似于函数,只能执行,但是没有返回值
函数:不仅能执行,还可以返回结果(return)
===================================================================
面向过程 和 面向对象 的基本概念
面向过程:---侧重于怎么做?
1.把完成某一个需求的 所有步骤 从头到尾 逐步实现
2.根据开发要求,将某些功能独立的代码封装成一个又一个函数
3.最后完成的代码,就是顺序的调用不同的函数
特点:
1.注重步骤与过程,不注重职责分工
2.如果需求复杂,代码会变得很复杂
3.开发复杂项目,没有固定的套路,开发难度很大
面向对象:--谁来做?
相比较函数,面向对象是更大的封装,根据职责在一个对象中封装多个方法
1.在完成某一个需求前,首先确定职责--要做的事(方法)
2.根据职责确定不同的对象,在对象内部封装不同的方法(多个)
3.最后完成代码,就是顺序的让不同的对象调用不同的方法
特点:
1.注重对象和职责,不同的对象承担不同的职责
2.更加适合对复杂的需求变化,是专门应对复杂项目的开发,提供的固定套路
3.需要在面向过程的基础上,再学习一些面向对象的语法
举例子:植物大战僵尸。。。。(我们可以看到,使用面向对象编程,这样做大大减轻了主程序的职责 )
向日葵 豌豆射手 僵尸
生命值 生命值 生命值
生产阳光() 发射子弹() 移动()
摇晃() 咬()
================================================================
面向对象的两个核心概念
类和对象
目标
类和对象的概念
类和对象的关系
类的设计
类和对象的概念
类和对象是面向对象编程的两个核心概念
类:是对一群具有相同特征或行为的事物的一个统称,是抽象的,不能直接使用(就好比,飞机图纸不能直接飞上天)
特征:被称为属性
行为:被称为方法
类 就相当于制造飞机时的图纸,是一个模板,是负责创建对象的
对象:是由类创建出来的一个具体的存在,可以直接使用(图纸创造出来的飞机,可以飞上天)
由哪一个类创建出来的对象,就拥有哪一个类种法定义的属性和方法
“对象就相当于用图纸创造出来的飞机”
#在程序开发中,应该先有类,再有对象
类和对象的关系
类是模板,对象是根据类这个模板创建出来的,应该先有类,再有对象
类只需要有一个 而对象可以有很多个(一张图纸可以造出很多架飞机)
不同对象之前属性可以不相同(比如飞机的颜色 等等。。)
类中定义了什么属性和方法,使用这个类创建出来的对象中就有什么属性和方法,不可能多也不可能少
1.类名:满足这类事物的名字(大驼峰命名法)
大驼峰命名法:
1.每个单词的首字母大写
2.单词与单词之间没有下划线
2.属性:这个类创建出来的对象有什么样的特征
3.方法:这个类创建出来的对象有什么样的行为
类名的确定:
名词提炼法:分析整个业务流程,出现的名词,通常就是找到的类名
练习1:
需求:
小明今年18岁,身高1.75,每天早上要跑步,会去吃东西
小美今年17岁,身高1.65 小美不跑步,小美喜欢吃东西
Person
name
age
height
run()
eat()
练习2:
一只黄颜色的狗狗叫大黄
看见生人旺旺叫
看见家人摇尾巴
Dog
name
color
shout()
shake()
面向对象的基本语法:
定义一个只包含方法的类
class 类名:
def 方法1(self,参数列表):
pass
def 方法2(self,参数列表):
pass
方法的定义格式和之前学的函数几乎一样
区别在于第一个参数必须是self
小猫爱吃鱼,小猫要喝水
class Cat: def eat(self): print '小猫爱吃鱼' def drink(self): print '小猫爱喝水' """ 创建对象 当一个类定义完成之后,要使用这个类来创建对象 对象变量 = 类名() """ # 创建猫对象 tom = Cat() tom.drink() tom.eat()
小猫爱喝水
小猫爱吃鱼
在面向对象开发中,引用的概念是同样适用的
tom = Cat():在等号右侧我们使用cat类创建了一个猫对象,在等号左侧使用tom这个变量接收了这个猫对象
python解释器在执行到此句代码的时候,在内存中为这个猫对象分配了一个内存空间,然后再让tom这个变量记录了猫对象在内存中的地址
在python中使用类创建对象之后,tom变量中仍然记录的是对象在内存中的地址
也就是tom变量引用了新建的猫对象
使用print输出对象变量,默认情况下,是能够输出这个变量引用的对象是由哪一个类创建的象,以及在内存中的地址(十六进制表示)
提示:在计算机中,通常使用十六进制表示内存地址
class Cat: def eat(self): print '小猫爱吃鱼' def drink(self): print '小猫爱喝水' tom = Cat() tom.eat() tom.drink() print tom addr = id(tom) print addr # %x:打印格式为十六进制 print '%x' % addr # %d:打印格式为十进制 print '%d' % addr lazy_cat = Cat() lazy_cat.drink() lazy_cat.eat() print lazy_cat # 两个对象的内存地址不一样, # 我们就断定这两只猫是不同的猫 lazy_cat2 = lazy_cat print lazy_cat2
小猫爱吃鱼
小猫爱喝水
<__main__.Cat instance at 0x7fd050b41170>
140532683903344
7fd050b41170
140532683903344
小猫爱喝水
小猫爱吃鱼
<__main__.Cat instance at 0x7fd050b41200>
<__main__.Cat instance at 0x7fd050b41200>
self的内存地址和tom/lazy_cat这个对象的内存地址是一样
哪一个对象调用的方法,self就是哪一个对象的引用
self:
在调用方法的时候,程序员不需要传递self参数(但是定义的时候,第一个参数必须是self)
在方法内部:可以通过self.访问对象的属性
class Cat: def eat(self): print '%s 爱吃鱼' % self.name def drink(self): print '%s 爱喝水' % self.name tom = Cat() # 给tom对象添加一个属性 tom.name = 'Tom' tom.eat() tom.drink() print tom
Tom 爱吃鱼
Tom 爱喝水
<__main__.Cat instance at 0x7f31e7a5e1b8>
在日常开发中,不推荐在类的外部给对象增加属性
如果在运行的时候,没有找到属性,程序就报错
对象应该包含有哪些属性,应该封装在类的内部
初始化方法:
类名() 就可以创建一个对象
当使用类名()创建对象的时候,python解释器会自动执行以下操作
1.为对象在内存中分配空间 ---创建对象
2.调用初始化方法
class Cat(): # 初始化方法 def __init__(self): print '这是一个初始化方法' # 使用类名()创建对象的时候,会自动调用初始化方法:__init__ tom = Cat()
这是一个初始化方法
改造初始化方法--初始化的同时设置初始值:
在开发中,如果希望在创建对象的同时,就设置对象的属性,可以对__init__方法进行改造
1.把希望设置的属性值,定义成__init__方法的参数
2.在方法内部使用self.属性名 = 形参 接收外部传递的参数
3.在创建对象时,使用类名(属性1,属性2..)调用
class Cat(): def __init__(self, new_name): # self.属性名 = 属性的初始值 # self.name = 'Tom' self.name = new_name # 在类中 任何方法都可以使用self.name def eat(self): print '%s 爱吃鱼' % self.name tom = Cat('Tom') # print tom print tom.name tom.eat() lazy_cat = Cat('Lazy_cat') lazy_cat.eat()
Tom
Tom 爱吃鱼
Lazy_cat 爱吃鱼
__del__方法:
在python中
当使用类名()创建对象时,为对象分配完空间后,自动调用__init__方法
当一个对象被从内存中销毁前(把这个对象从内存中删除掉),会自动调用__del__方法
应用场景
__init__改造初始化方法,可以让创建对象更加灵活
__del__如果希望在对象被销毁前,再做一些事情,可以考虑一下__del__方法
生命周期(出生到死亡)
一个对象从调用类名()创建,生命周期开始
一个对象的__del__方法一但被调用,生命周期结束
在对象的生命周期内,可以访问对象属性,或者让对象调用方法
__str__方法:
在python中,使用python输出对象变量,默认情况下,会输出这个变量引用的对象是由哪>一个类创建的对象,
以及在内存中的地址(十六进制表示)
如果在开发中,希望使用print输出对象变量时,能够打印自定义的内容,就可以利用__str__这个内置方法了
class Cat(): def __init__(self, new_name): self.name = new_name print '%s 来了' % self.name def __del__(self): print '%s 走了' % self.name # tom 是一个全局变量(s所以当我们的代码全部执行完之后,系统才会 # tom 这个对象进行回收) tom = Cat('Tom') print tom.name # del 关键字 可以删除一个对象 del关键字自己调用__del__方法 del tom print '*' * 50
Tom 来了
Tom
Tom 走了
**************************************************
class Cat: def __init__(self, name): self.name = name def __str__(self): # 必须返回一个字符串 return '我是westos' tom = Cat('Tom') print tom
我是westos
封装
1.封装是面向对象编程的一大特点
2.面向对象编程的第一步,将属性和方法封装到一个抽象的类中(为什么类是抽象的?)
3.外界使用类创建对象,然后让对象调用方法
4.对象方法的细节都被封装在类的内部
小明和小美爱跑步
1.小明体重75.0公斤
小美体重45.0公斤
2.小明每次跑步会减肥0.5公斤
3.小明每次吃东西体重会增加1公斤
class Person: def __init__(self, name, weight): # 在初始化方法中增加两个参数由外界传递 # self.属性 = 形参 self.name = name self.weight = weight def __str__(self): return '我的名字叫 %s 体重是 %.2f' % (self.name, self.weight) def run(self): # pass print '%s 爱跑步' % self.name # 在对象方法的内部,是可以直接访问对象的属性 self.weight -= 0.5 def eat(self): # pass print '%s 吃东西' % self.name self.weight += 1 xiaoming = Person('小明', 75.5) xiaoming.run() xiaoming.eat() print xiaoming xiaomei = Person('小美', 45.0) xiaomei.eat() xiaomei.run() # 同一个类创建的多个对象之间,属性互不干扰 print xiaomei print xiaoming
小明 爱跑步
小明 吃东西
我的名字叫 小明 体重是 76.00
小美 吃东西
小美 爱跑步
我的名字叫 小美 体重是 45.50
我的名字叫 小明 体重是 76.00
继承
封装:根据职责将属性和方法封装到一个抽象的类中
继承:实现代码的重用,相同的代码不需要重复的写
class Animal: def eat(self): print '吃' def drink(self): print '喝' def run(self): print '跑' def sleep(self): print '睡' class Cat(Animal): # 子类拥有父类的所有属性和方法 def call(self): print '喵喵~' fentiao = Cat() fentiao.eat() fentiao.drink() fentiao.run() fentiao.sleep() fentiao.call()
吃
喝
跑
睡
喵喵~
# 子类继承自父类,可以直接享受父类中已经封装好的方法
单继承
1.继承的概念:子类拥有父类的所有属性和方法(子类只需要封装自己特有的方法)
2.语法
class 类名(父类):
def 子类特有的方法
继承的传递性(爷爷 爸爸 儿子)
1.C 类从B类继承 ,B类又从A类继承
2.那么C类就具有B类和A类的所有属性和方法
class Animal: def eat(self): print '吃' def drink(self): print '喝' def run(self): print '跑' def sleep(self): print '睡' class Cat(Animal): # 子类拥有父类的所有属性和方法 def call(self): print '喵喵~' class Hellokitty(Cat): def speak(self): print '我可以说日语' # 创建一个Hellokitty对象 kt = Hellokitty() kt.speak() kt.call() # 继承的传递性 子类拥有父类的父类的属性和方法 kt.eat() kt.drink() kt.sleep() kt.run()
我可以说日语
喵喵~
吃
喝
睡
跑
方法的重写
1.覆盖父类的方法(重写父类方法)
2.对父类方法进行扩展
class Animal: def eat(self): print '吃' def drink(self): print '喝' def run(self): print '跑' def sleep(self): print '睡' class Cat(Animal): # 子类拥有父类的所有属性和方法 def call(self): print '喵喵~' class Hellokitty(Cat): def speak(self): print '我可以说中文' def call(self): # 1.针对子类特有的需求,编写代码 print '你好' # 2.调用原本子阿父类中封装的方法 Cat.call(self) # 3.增加其他子类代码 print '@$@!$#@!$!#' kt = Hellokitty() # 如果子类中,重写了父类的方法 # 在运行中,只会调用在子类中重写的方法而不会调用父类的方法 kt.call()
你好
喵喵~
@$@!$#@!$!#
多继承
子类拥有一个父类叫作单继承
子类可以拥有多个父类,并且具有所有父类的属性和方法
例如:孩子会继承自己父亲和母亲的特征
class A: def test(self): print 'A---------test 方法' def demo(self): print 'A--------demo方法' class B: def test(self): print 'B -------test方法' def demo(self): print 'B ---------demo 方法' class C(B, A): """多继承可以让子类对象,同时具有多个父类的属性和方法""" pass # 创建子类对象 c = C() c.test() c.demo()
B -------test方法
B ---------demo 方法
新式类和旧式(经典)类:
object是Python为所有对象提供的基类,提供有一些内置的属性和方法,可以使用dir函数查看
新式类:以object为基类的类,推荐使用
经典类:不以object为基类的类,不推荐使用
在python3.X中定义的类时,如果没有指定父类,会默认使用object作为基类--python3.x中定义的类都是新式类
在python2.x中定义类时,如果没有指定父类,则不会以object作为基类
####推荐使用新式类#############
新式类和旧式类在多继承时---会影响到方法的搜索顺序
为保证编写的代码能够同时在python2.x和python3.x运行
今后在定义类时,如果没有父类,建议统一继承自object
>>> class A(object):
... pass
...
>>> a = A()
>>> dir(a) #查看内置的属性和方法
['__class__',
'__delattr__',
'__dict__',
'__doc__',
'__format__',
'__getattribute__',
'__hash__',
'__init__',
'__module__',
'__new__',
'__reduce__',
'__reduce_ex__',
'__repr__',
'__setattr__',
'__sizeof__',
'__str__',
'__subclasshook__',
'__weakref__']
---------------------------------------------------
>>> class B:
... pass
...
>>> b=B()
>>> dir(b)
['__doc__', '__module__']
==========================================================================
Python 早期,它对于class的定义在很多方面都是严重有问题的。当他们承认这一点的时候已经太迟了,
所以逼不得已,他们需要支持这种有问题的class 。
为了解决已有的问题,他们需要引入一种“新类”,这样的话“旧类”还能继续使用,而你也有一个新的正确的类可以使用了。
这就用到了“类即是对象”的概念。他们决定用小写的“object”这个词作为一个类,让你在创建新类时从它继承下来。
私有属性和私有方法
应用场景
在实际开发中,对象的某些属性或方法可能只希望在对象的内部使用,而不希望在外部被访问到
私有属性 就是 对象 不希望公开的 属性
私有方法 就是 对象 不希望公开的 方法
class Women: def __init__(self, name): self.name = name # 定义私有属性 self.__age = 18 def __secret(self): # 在对象的方法内部,是可以访问对象的私有属性的 print '%s 的年龄是 %d' % (self.name, self.__age) lily = Women('lily') # 私有属性,在外界不能被直接访问 # print lily.__age # 私有方法,同样不允许在外界直接访问 # lily.__secret()
class A(object): def __init__(self): self.num1 = 100 # 定义私有属性 self.__num2 = 200 def __text(self): print '私有方法 %d %d' % (self.num1, self.__num2) def test(self): print '父类的私有方法 %d' % self.__num2 self.__text() class B(A): def demo(self): # 在子类的对象方法中,不能访问父类的私有属性 # print '访问父类的私有属性 %d' %self.__num2 # 在子类的对象方法中,不能调用父类的私有方法 # self.__test() print '子类方法 %d' % self.num1 self.test() # 创建一个子类对象 b = B() print b # 在子类方法的内部能访问父类的公有属性和调用父类的公有方法 b.demo() # 在外界访问父类的公有属性和调用公有方法 print b.num1 # 在外界不能直接访问对象的私有属性/调用私有方法 # print b.__num2 # b.__text()
<__main__.B object at 0x7ff48b2be410>
子类方法 100
父类的私有方法 200
私有方法 100 200
100