面向过程就是分析出解决问题所需要的步骤,然后用函数把这些步骤一步一步实现,使用的时候一个一个依次调用就可以了;
面向对象是把构成问题事务分解成各个对象,建立对象的目的不是为了完成一个步骤,而是为了描叙某个事物在整个解决问题的步骤中的行为。
1、简单的动物特性的面向对象编程
# _*_ coding:utf-8 _*_ """ file: 面向对象_3.py date: 2018-07-23 18:29 author: jiong desc: 类的设计: 在程序中,要设计一个类,通常需要满足以下三个需求: 1.类名 这类事物的名字,满足大驼峰命名法 2.属性 这类事物具有什么样的特征 3.方法 这类事物具有什么样的行为 面向对象的基础语法: 定义简单的类: 定义只包含方法的类: class 类名: def 方法1(self,参数列表): pass def 方法2(self,参数列表): pass 当一个类定义完成之后,要使用这个类来创建对象,语法格式如下: 对象变量 = 类名() 需求 小狗爱吃肉,小狗爱玩耍 """ # 定义一个类,但是只有一个类是无法输出的 class Dog(): def eat(self): print '小狗爱吃肉' def play(self): print '小狗爱玩耍' # 将类转换到对象 dou = Dog() dou.eat() dou.play()
2、一个类可以创建多个对象
# _*_ coding:utf-8 _*_ """ file: 面向对象_1.py date: 2018-07-23 13:40 author: jiong desc: 需求: 小猫爱吃鱼,小猫爱喝水 """ class Cat(): # 哪一个对象调用的方法,self就是哪一个对象的引用 def eat(self): print '%s like eating fish' % self.name def drink(self): print '小猫爱喝水' # 创建猫对象 dudu = Cat() dudu.name = 'dudu' #给猫一个名字 dudu.eat() dudu.drink() print dudu #addr = id(dudu) # %x:打印格式为十六进制的内存地址 #print '%x' % addr # %x:打印格式为十进制的内存地址 #print '%d' % addr # 再创建一个猫对象(内存地址与dudu的不同) lazy_cat = Cat() lazy_cat.name = 'bobo' lazy_cat.eat() lazy_cat.drink() print lazy_cat lazy_cat2 = lazy_cat print lazy_cat2 #内存地址与lazy_cat相同
3、在类的外部给对象增加属性会报错:(还是刚才的脚本做了点修改)
# _*_ coding:utf-8 _*_ """ file: 面向对象_2.py date: 2018-07-23 16:15 author: jiong desc: 需求:小狗爱吃骨头,小狗喜欢汪汪叫 """ class Dog(): # self:哪一个对象调用的方法,self就是哪一个对象的引用 def eat(self): print '%s love a bone' % self.name def shout(self): print '小狗喜欢汪汪叫' # 创建狗对象 shoutao = Dog() shoutao.name = 'shoutao' shoutao.eat() shoutao.shout() print shoutao addr = id(shoutao) # %x:打印格式为十六进制 print '%x' % addr # %d:打印格式为十进制 print '%d' % addr # 再创建一个狗对象 Dog_1 = Dog() Dog_1.eat() Dog_1.shout() Dog_2 = Dog_1 print Dog_2
# _*_ coding:utf-8 _*_ """ file: 面向对象_4.py date: 2018-07-23 22:52 author: jiong desc: 初始化方法 我们现在已经知道了使用 类名() 就可以创建一个对象 当使用类名()创建对象时,python的解释器就会自动执行以下操作: 1.为对象在内存中分配空间--创建对象 2.调用初始化方法为对象的属性设置初始值--初始化方法(__init__) 这个初始化方法就是__init__方法,__init__时对象的内置方法 __init__方法是专门用来定义一个类具有那些属性的方法 """ class Cat(): def __init__(self): print '这是一个初始化方法' # self.属性名 = 属性的初始值 self.name = 'dudu' # 使用 类名() 创建对象的时候,会自动调用初始化方法_init_ dudu = Cat() print dudu.name class Cat(): def __init__(self, new_name): self.name = new_name # 在类中,任何方法都可以使用self.name def eat(self): print '%s like eating fish' % self.name dudu = Cat('dudu') print dudu.name dudu.eat() lazy_cat = Cat('lazy_cat') lazy_cat.eat()
1、直接调用初始化不加入形参
# _*_ coding:utf-8 _*_ """ file: 面向对象_5.py date: 2018-07-23 22:59 author: jiong desc: """ class Cat(): def __init__(self): self.name = 'Tom' # 在类中,任何方法都可以使用self.name def eat(self): print '%s 爱吃鱼' % self.name tom = Cat() print tom.name tom.eat() # 重新定义一个猫输出还是Tom,显然不合理 lazy_cat = Cat() lazy_cat.eat()
2、调用初始化加入形参
# _*_ coding:utf-8 _*_ """ file: 面向对象_6.py date: 2018-07-23 23:01 author: jiong desc: """ class Cat(): def __init__(self,new_name): # new_name为形参 # 在类中,任何方法都可以使用self.name self.name = new_name def eat(self): print '%s 爱吃鱼' % self.name tom = Cat('tom') # 必须给传递实际的参数不然会报错 print tom.name tom.eat() lazy_cat = Cat('lazy_cat') # 必须给传递实际的参数不然会报错 lazy_cat.eat()
1.封装:根据职责将属性和方法封装到一个抽象的类中
定义类的准则
2.继承:实现代码的重用,相同的代码不需要重复的编写
设计类的技巧
子类针对自己特有的需求,编写特定的代码
3.多态:
不同的子类对象调用相同的方法,产生不同的执行结果
# _*_ coding:utf-8 _*_ """ file: 封装_1.py date: 2018-07-23 23:05 author: jiong desc: 封装: 1.封装是面向对象编程的一大特点 2.面向对象编程的第一步 将属性和方法封装到一个抽象的类中 3.外界使用类创建对象,然后让对象调用方法 4.对象方法的细节都被封装在类的内部 需求: 1.xx爱跑步 2.xx体重50公斤 3.xx每次跑步会减肥0.5公斤 4.xx每次吃东西体重会增加1公斤 """ class Person(): def __init__(self,new_name,weight): self.name = new_name self.weight = weight def __str__(self): return '我的名字叫%s 体重是%.2f' % (self.name,self.weight) def run(self): print '%s 爱跑步' % self.name self.weight -= 0.5 def eat(self): print '%s 吃东西' % self.name self.weight += 1 name = Person('jiong',52.0) #name.run() name.eat() print name
1、士兵开枪案例:
# _*_ coding:utf-8 _*_ """ file:士兵开枪.py date:2018-07-21 7:21 AM author:Jiong desc: """ class Gun(): def __init__(self,model): # 枪的型号 self.model = model # 子弹的数量 self.bullet_count = 0 def add_bullet(self,count): self.bullet_count += count def shoot(self): # 1.判断子弹的数量 if self.bullet_count <= 0: print '%s 没有子弹' % self.model return # 2.发射子弹 self.bullet_count -= 1 # 3。提示发射信息 print '%s 突突突 %d' %(self.model,self.bullet_count) class Soldier(): def __init__(self,name): self.name = name self.gun = None def fire(self): # 1.判断士兵没有枪 if self.gun == None: print '%s 需要一把枪' %self.name return # 2.高喊口号 print 'go!!! %s' % self.name # 3.让枪装填 self.gun.add_bullet(50) # 4.让枪发子弹 self.gun.shoot() # 1.创建枪对象 ak47 = Gun('AK47') # ak47.add_bullet(50) # ak47.shoot() # 创建士兵 ryan = Soldier('Ryan') ryan.gun = ak47 ryan.fire() print ryan.gun
2、摆放家具(没有完成添加家具)
# _*_ coding:utf-8 _*_ """ file:摆放家具1.py date:2018-07-21 5:44 AM author:Jiong desc: 1.房子有户型,总面积和家具名称列表 新房子没有任何家具 2.家具有名字和占地面积,其中 床:占4平米 衣柜:占2平米 餐桌:占2平米 3.将以上三件家具添加到房子中 4.打印房子时,要求输出:户型,总面积,剩余面积,家具名称列表 小结: 1.创建了一个房子类,使用__init__和__str__两个内置的方法 2.准备了一个add_item方法 准备添加家具 3.使用 房子类 创建了一个房子对象 4.让 房子对象 调用三次add_item方式,将三件家具以实参的形式传递到add_item """ class Furniture(): # 初始化方法 def __init__(self,name,area): self.name = name self.area = area def __str__(self): return '[%s] 占地%.2f' %(self.name,self.area) class House(): def __init__(self,house_type,area): self.house_type = house_type self.area = area #剩余面积 self.free_area = area #家具名称列表 self.item_list = [] def __str__(self): return '户型:%s\n总面积:%.2f[剩余面积:%.2f]\n家具%s'\ % (self.house_type,self.area,self.free_area,self.item_list) def add_item(self,item): print '要添加%s' % item # 1.判断家具的面积 if item.area > self.free_area: print '%s 的面积太大了,无法添加' % item.name # 如果不满足,下方的代码就不执行 return # 2.将家具的名称添加到列表中 self.item_list.append(item.name) # 3.计算剩余面积 self.free_area -= item.area # 创建家具 bed = Furniture('bed',4) print bed chest = Furniture('chest',2) print chest table = Furniture('table',2) print table #创建房子对象 my_home = House('两室一厅',100) # 添加家具 my_home.add_item(bed) my_home.add_item(chest) my_home.add_item(table) print my_home
1、单继承
# _*_ coding:utf-8 _*_ """ file:继承_1.py date:2018-07-21 8:15 AM author:Jiong desc: 单继承 1.继承的概念,语法和特点 继承的概念:子类 拥有的所有法方法和属性(子类只需要封装自己特有的方法) 2.继承的语法 class 类名(父类) def 子类特有的方法 """ 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 '喵喵喵' mm = Cat() mm.eat() mm.drink() mm.run() mm.sleep() mm.call() # 子类继承自父类,可以直接享受父类中已经封装好的方法 # 子类中应该根据自己的职责,封装子类特有的属性和方法
2、继承的传递性
# _*_ coding:utf-8 _*_ """ file:继承_2.py date:2018-07-21 8:44 AM author:Jiong desc: 继承的传递性:(爷爷,父亲,儿子) 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.run() kt.sleep()
3、重写父类
# _*_ coding:utf-8 _*_ """ file:继承_3.py date:2018-07-21 8:49 AM author:Jiong desc: 重写父类方法有两种情况: 1.覆盖父类的方法 2.对父类方法进行扩展 1.覆盖父类的方法 如果在开发中,父类的方法的实现和子类方法的实现, 完全不同,就可以使用覆盖的方法, 在子类中重新编写父类的方法 具体实现方法,就相当于在子类中定义了 一个和父类同名的方法并且实现 重写之后,在运行时,只会调用子类的重写方法 而不会再调用父类封装的方法 """ 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): print '偶哈呦 空你起哇' kt = Hellokitty() # 如果子类中,重写了父类的方法 # 在运行中,只会调用子类中重写的方法,不会调用父类的方法 kt.call()
4、对父类的方法进行扩展
# _*_ coding:utf-8 _*_ """ file:继承_4.py date:2018-07-21 9:02 AM author:Jiong desc: 对父类的方法进行扩展: 如果在开发中,子类的方法实现包含有父类的方法实现 (父类原本封装的方法实现是子类方法的一部分就可以使用扩展方法) 1.在子类中重写父类的方法 2.在需要的位置使用 父类名.方法(self)来调用父类方法的执行 (使用父类名称调用父类方法) 3.代码其他的位置针对子类的需求,编写子类特有的代码实现 """ 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): print '偶哈呦 空你起哇' # 调用原本在父类中封装的方法 Cat.call(self) kt = Hellokitty() kt.call()
5、多继承
# _*_ coding:utf-8 _*_ """ file:多继承.py date:2018-07-22 1:13 AM author:Jiong desc: 多继承: 子类拥有一个父类叫做单继承 子类可以拥有多个父类,并且具有所有父类的属性和方法 例如:孩子会继承自己父亲和母亲的特性 """ class A(object): 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(): def teat(self): print 'C----test 方法' def demo(self): print 'C----demo 方法' class D(A,B,C): # 多继承可以让子类对象,同时具有多个父类的属性和方法 pass d = D() d.test() d.demo()
3、多态
# _*_ coding:utf-8 _*_ """ file:多态.py date:2018-07-22 2:40 AM author:Jiong desc: 多态 不同的子类(这是之前提到的继承的知识) 对象调用相同的方法,产生不同的执行结果 """ class Cat(object): def __init__(self,name): self.name = name def play(self): print '%s 喜欢玩毛球' % self.name class HelloKetty(Cat): def play(self): print '%s 会说日语' % self.name class Person(object): def __init__(self,name): self.name = name def play_with_cat(self,a): print '%s 和 %s 玩耍' % (self.name,a.name) a.play() # 创建一个猫对象 maiomiao = Cat('喵喵') # maiomiao.play() # 创建一个人对象 xiaoming = Person('小明') # 让小明和猫玩耍 xiaoming.play_with_cat(maiomiao)