面向对象概念及三大特点

面向对象：

面向对象的基本概念

面向对象   oop : object oriented programming
我们之前学习的编程方式就是面向过程的
面向过程和面向对象，是两种不同的编程方式
对比面向过程的特点，可以更好的了解什么是面向对象

过程和函数(都是对一段功能的代码进行封装)
过程：是早期的一个编程概念
    过程类似于函数，只能执行，但是没有返回值
函数：不仅能执行，还可以返回结果(return)

面向过程 和 面向对象 的基本概念

1、面向过程：---侧重于怎么做？
1.把完成某一个需求的 所有步骤 从头到尾 逐步实现
2.根据开发要求，将某些功能独立的代码封装成一个又一个函数
3.最后完成的代码，就是顺序的调用不同的函数
特点：
1.注重步骤与过程，不注重职责分工
2.如果需求复杂，代码会变得很复杂
3.开发复杂项目，没有固定的套路，开发难度很大

面向对象：--谁来做?
相比较函数，面向对象是更大的封装，根据职责在一个对象中封装多个方法
1.在完成某一个需求前，首先确定职责--要做的事(方法)
2.根据职责确定不同的对象，在对象内部封装不同的方法(多个)即我们所说的函数。
3.最后完成代码，就是顺序的让不同的对象调用不同的方法
特点：
1.注重对象和职责，不同的对象承担不同的职责
2.更加适合对复杂的需求变化，是专门应对复杂项目的开发，提供的固定套路
3.需要在面向过程的基础上，再学习一些面向对象的语法

熟悉面向对象编程
python    java    c++

类:是对一群具有相同特征或行为的事物的一个统称，不能直接使用(比如：飞机制造图纸不能飞上天)
    特征:属性
    行为：方法
对象：由类创建出来的一个具体的存在，可以直接使用(用图纸制造出来的飞机可以飞上天)

注意！！！   在程序开发中：应该先有类 再有对象

类的设计
1.类名： 这类事物的名字，满足大驼峰命名法
    大驼峰命名法
        每一个单词的首字母大写
        单词与单词只见没有下划线
2.属性： 这个类创建出的对象有什么样的特征
3.方法： 这个类创建出的对象有什么样的行为

注意！！！面向对象的三大特点：

1.封装：根据职责将属性和方法封装到一个抽象的类中

2.继承:实现代码的重用，相同的代码不需要重复的写

3.多态：(以封装和继承为前提)，不同的子类对象调用相同的方法，产生不同的执行结果

封装

1.封装是面向对象编程的一大特点

2.面向对象编程的第一步 将属性和方法封装到一个抽象的类中(为什么说是抽象的，因为类不能直接使用)

3.外界使用类创建对象，然后让对象调用方法

4.对象方法的细节都被封装在类的内部

例1、

#定义一个Person类

class Person:def __init__(self, name, weight):# 初始化方法中增加两个参数由外界传递# self.属性 = 形参self.name = nameself.weight = weightdef __str__(self):# 输出一段字符串return '我的名字叫 %s 体重是 %.2f' % (self.name, self.weight)def run(self):print '%s 爱跑步' % self.name# 在对象方法的内部，是可以直接访问对象的属性self.weight -= 0.5def eat(self):print '%s 吃东西' % self.nameself.weight += 1xx = Person('小明', 75.0)
xx.run()
xx.eat()
print xx# 同一个类创建出来的多个对象之间，属性互补干扰
xm = Person('小丽', 45.0)
xm.run()
xm.eat()
print xm
print xx

例2：摆放家具

要求：

1.房子有户型，总面积和家具名称列表

新房子没有任何的家具

2.家具有名字和占地面积，其中

床：占4平米

衣柜：占2平面

餐桌：占1.5平米

3.将以上三件家具添加到房子中

4.打印房子时，要求输出:户型，总面积，剩余面积，家具名称列表

class HouseItem:# 初始化方法def __init__(self, name, area):self.name = nameself.area = areadef __str__(self):return '[%s] 占地 %.2f' % (self.name, self.area)"""
家具名称列表 []
"""class House:def __init__(self, house_type, area):# 需要从外界传递进来的参数self.house_type = house_typeself.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.判断家具的面积是否超过房子的面积，如果超过了，提示不能添加这个家具2.将家具的名称 追加到家具名称列表中去3.用房子的剩余面积 - 家具的面积"""if item.area > self.free_area:print '%s 的面积太大了，无法添加' % item.name# 如果不满足，下方的代码就不执行return# 将家具的名称添加到列表中self.item_list.append(item.name)# 计算剩余面积self.free_area -= item.area# 1.创建家具
bed = HouseItem('bed', 400)
print bed
chest = HouseItem('chest', 2)
print chest
table = HouseItem('table', 1.5)
print table# 2.创建房子对象
my_home = House('两室一厅', 400)
# 添加家具到房子里面去
my_home.add_item(bed)
my_home.add_item(chest)
my_home.add_item(table)
print my_home

注意：对于两个类等的使用且相互有使用和被使用的关系，则被使用的类应该先开发

继承

单继承

继承的概念:子类拥有父类的所有属性和方法,目的是实现代码的重用，相同的代码不需要重复的写。

继承的语法

class 类名(父类)：

def 子类特有的方法

例1：

创建一个Animal类

class Animal(object):def eat(self):print '吃'def drink(self):print '喝'def run(self):print '跑'def sleep(self):print '睡'#创建一个Cat类（其中Cat类是Animal类的子类）
# 子类机车父类的所有属性和方法并且子类创建自己独特的属性方法
class Cat(Animal):def call(self):print '喵喵'lily = Cat()
lily.eat()
lily.drink()
lily.run()
lily.sleep()
lily.call()

总结：

子类继承自父类，可以直接享受父类中已经封装好的属性和方法

子类中应该根据自己的职责，封装子类特有的属性和方法

注意：

以上所说的继承，可以有以下两种说法，意思是一样的

说法1：Cat类是Animal类的子类，Animal类是Cat类的父类，Cat从Animal类继承

说法2：Cat类是Animal类的派生类，Animal类是Cat类的基类，Cat类从Animal类派生

应该注意：平级之间没有任何必然联系

例2：

class Animal(object):def eat(self):print '吃'def drink(self):print '喝'def run(self):print '跑'def sleep(self):print '睡'class Dog(Animal):def bark(self):print '旺旺'lucy = Dog()lucy.eat()lucy.drink()lucy.run()lucy.sleep()lucy.bark()class Muyang(Dog):def speak(self):print '我会保护羊'lily = Muyang()lily.eat()lily.drink()lily.run()lily.sleep()lily.bark()lily.speak()

总结：

继承的传递性，子类拥有父类的父类的属性和方法

继承的传递性：（爷爷 父亲 儿子）

1.Muyang类从Dog类继承，Dog类又从Animal类继承

2.那么Muyang类就具有Dog类和Animal类的所有属性和方法

子类Muyang拥有父类以及父类的父类中封装的所有属性和方法

例3：

重写父类方法 1：

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：

重写父类方法2：

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):# 针对子类特有的需求，编写代码print '你很调皮'# 调用原本在父类中封装的代码Cat.call(self)# 增加其他的子类代码print '@#￥Y%……&**&……%Y￥#@'kt = Hellokitty()
kt.call()

总结：

若重写了父类的方法，则调用的时候只调用子类而不调用父类；

但若子类在写的时候还调用了父类，则相当于父类的扩展，调用的时候子类重写的方法和父类已有的方法一起调用。

例5：

定义属性注意的事项：

class Bird:def __init__(self):self.hungry = True# 鸟吃过了以后就不饿了def eat(self):if self.hungry:print 'I am eating'self.hungry = Falseelse:print 'No thanks'class SongBird(Bird):def __init__(self):self.sound = 'Zd0ci!'#注意：Bird.__init__(self)def sing(self):print self.soundlittle_bird = SongBird()
little_bird.eat()
little_bird.sing()

例5：

多继承可以让子类对象，同时具有多个父类的属性和方法

class A(object):
    def test(self):
        print 'A-----test 方法'

def demo(self):
        print 'A-----demo 方法'

class B(object):
    def test(self):
        print 'B------test 方法'

def demo(self):
        print 'B-------demo方法'

class C(B, A):
    """多继承可以让子类对象，同时具有多个父类的属性和方法"""
    pass

# 创建子类对象
c = C()
c.test()
c.demo()

若将上面的class C(B, A)换成class C(A, B)

则结果为：

多态：

(以封装和继承为前提)，不同的子类对象调用相同的方法，产生不同的执行结果

例如：

定义一个类

人类
work(self):

创建两个子类
程序员   设计师
这两个子类调用了相同的方法

产生的结果如下：

class Dog(object):def __init__(self, name):self.name = namedef work(self):print '%s 正在工作' % self.nameclass xiaotiandog(Dog):# 父类方法不能满足子类的方法，重写game方法def game(self):# 在使用继承时，子类拥有父类的所有属性和方法print '%s 飞到天上玩...' % self.nameclass Person(object):def __init__(self, name):self.name = namedef game_with_dog(self, dog):print '%s 和 %s 快乐的玩耍' % (self.name, dog.name)# 让狗玩耍dog.game()# 1.创建一个狗对象
#wangcai = Dog('旺财')
wangcai = Xiaotiandog('旺财')
# 2.创建一个小明对象(小明是一个人)
xiaoming=Person('小明')
# 3.让小明调用和狗玩的方法(把之前创建的狗对象传递进去)
xiaoming.game_with_dog(wangcai)
"""
案例小结：
Person类中只需要让狗对象调用game方法(这是子类的父类中封装的方法)，而不关心具体是什么狗game方法是在Dog父类中定义的
在程序执行时，传入不同的狗对象的实参，就会产生不同的执行效果