面对对象基础

面对对象编程

1.面对对象不是所有情形都适用

　　1.1函数式编程

def fun1(arg1):
	pass
def fun2(arg1, arg2):
	pass
			
fun1('wuwen')
fun2('henshuai')

　　2.1面对对象编程

class humanBeing:

	def fun1(self, arg1):
		pass
	def fun2(self,arg1, arg2):
		pass
			
obj1 = humanBeing()
obj1.fun1('wuwen')
obj2.fun2('henshuai')

　　结论：单从代码的复杂程度来看，面对对象编程并不是适合所有情况

2.面对对象编程的格式规范：

　　a.定义类

class 类名：
		
	def 方法1(self, arg)
		pass

　　b.根据类创建对象（创建一个**类的实例）

　　　　使用对象去执行类中的方法（函数编程中，我们称之为函数），如下图为类与对象的关系

3.类的方法的默认参数self

　　self，形式参数，代指执行方法的对象，在python内部传递，为封装而生

class humanBeing:
    def fun1(self, name):
        print(self, name)

    def fun2(self, name, gender):
        print(self, name, gender)


obj1 = humanBeing()
print(obj1)
obj1.fun1('wuwen')
obj1.fun2('wuwen', 'female')
'''
<__main__.humanBeing object at 0x02171210>
<__main__.humanBeing object at 0x02171210> wuwen
<__main__.humanBeing object at 0x02131490> wuwen female
总结：self为实例本身的内存地址
'''

　

4.封装：

　　　当每个函数里面都需要用到相同的参数（如上类方法中的name参数），我们可以提前把参数封装到对象(实例)中去

                                             

class humanBeing:
    def fun1(self):
        print(self.name)

    def fun2(self, gender):
        print(self.name, gender)


obj1 = humanBeing()
obj1.name = 'wuwen'
obj1.fun1()
'''
wuwen
'''

　　

5.用初始化封装

　　类名+（） ---->>> 自动执行类中的__init__方法；创建一个对象

　　在__init__方法中执行具体封装的操作

　　__init__有一个特殊名字：构造方法

　　__del__有一个特殊的名字：析构器

class Oldboy:
    def __init__(self, backend, record):
        '''
        构造方法
        :param backend:
        :param record:
        '''
        # 普通字段
        self.backend = backend
        self.record = record

    def fetch(self):
        print(self.backend)

    def add_record(self):
        print(self.record)

    def del_record(self):
        print(self.record)


# 创建对象，并且封装
obj1 = Oldboy('www.oldboy.org', 'wohenshuai')

# 执行方法,执行过程中可以根据self去obj1中去取已经封装在里面的数据
obj1.fetch()
obj1.add_record()
obj1.del_record()

　　5.1 练习

小明,10岁,男,上山去砍柴
小明,10岁,男,开车去东北
小明,10岁,男,最爱大保健

老李,10岁,男,上山去砍柴
老李,10岁,男,开车去东北
老李,10岁,男,最爱大保健

def kanchai(name, age, gender):
    print("%s,%s岁,%s,上山去砍柴" % (name, age, gender))


def qudongbei(name, age, gender):
    print("%s,%s岁,%s,开车去东北" % (name, age, gender))


def dabaojian(name, age, gender):
    print("%s,%s岁,%s,最爱大保健" % (name, age, gender))


kanchai('小明', '10', '男')
qudongbei('小明', '10', '男')
dabaojian('小明', '10', '男')

kanchai('老李', '10', '男')
qudongbei('老李', '10', '男')
dabaojian('老李', '10', '男')

class Foo:
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender

    def kanchai(self):
        print("%s,%s岁,%s,上山去砍柴" % (self.name, self.age, self.gender))

    def qudongbei(self):
        print("%s,%s岁,%s,开车去东北" % (self.name, self.age, self.gender))

    def dabaojian(self):
        print("%s,%s岁,%s,最爱大保健" % (self.name, self.age, self.gender))


xiaoming = Foo('小明', 10, '男')
xiaoming.kanchai()
xiaoming.qudongbei()
xiaoming.dabaojian()

laoli = Foo('老李', 90, '男')
laoli.kanchai()
laoli.qudongbei()
laoli.dabaojian()

　

　　5.2 小游戏（可以用pickle存档）

　　　　pickle可以将一个类的对象序列化

class person:
    def __init__(self, name, age, weight):
        self.Name = name
        self.Age = age
        self.Weight = weight

    def chi(self):
        self.Weight = self.Weight + 2
        print("%s 吃" % self.Name)

    def bodybuilding(self):
        self.Weight = self.Weight - 1


import pickle

# pickle 可以序列化对象，json只能处理字符串，数字，字典，列表与元组
# 游戏存档


ret = pickle.load(open('cundang.log', 'rb'))
print(ret)

if ret:
    print(ret.Weight)
else:
    o1 = person('小明', 5, 200)
    o1.bodybuilding()
    o1.chi()
    o1.chi()
    o1.chi()
    o1.chi()
    o1.chi()
    o1.chi()

    pickle.dump(o1, open('cundang.log', 'wb'))  # 将对象存档

　　

6.继承 

　　6.1 单继承

'''
子类继承父类所有的功能
父类不能使用子类的功能
当父类和子类同时具有某种功能时:
    对于由父类创建的对象，则使用自己的功能，因为它无法继承自己的子类。
    对于子类创建的的对象，我们也使用自己的功能，因为，优先级的先后。
'''

class Animals:
    def chi(self):
        print(self.name + '吃')

    def he(self):
        print(self.name + '喝')

    def piao(self):
        print('爱piao')


class Dog(Animals):
    def __init__(self, name):
        self.name = name

    def wang(self):
        print(self.name + '汪汪汪~')

    def piao(self):
        print('不爱piao')


obj1 = Dog('桃桃')
obj1.piao()
'''
不爱piao
'''

　　6.2 多继承（笔试易考）

#!/usr/bin env python
# -*- coding:utf-8 -*-
'''
在c++和java中，一个子类只能继承一个父类
但是在python中，一个子类可以继承多个父类
'''


class Animals:
    def chi(self):
        print(self.name + '吃')

    def he(self):
        print(self.name + '喝')

    def piao(self):
        print('爱piao')


class Uncle:
    def du(self):
        print('赌')

    def piao(self):
        print('很爱piao')


class Dog(Animals, Uncle):
    '''
    先继承Animals和Uncle父类中不重复的方法
    对不重复的方法：优先找自己，其次第一个父类Animals，最后第二个父类Uncle
    '''
    def __init__(self, name):
        self.name = name

    def wang(self):
        print(self.name + '汪汪汪~')

    def piao(self):
        print('不爱piao')

obj1 = Dog('taotao')
obj1.piao()
'''
不爱piao
'''

　　6.3 继承顺序

　　　　6.3.1 无共同父类

class A:
    def f(self):
        print('A')


class B:
    def f1(self):
        print('B')


class C(A):
    def f(self):
        print('C')


class D(B):
    def f1(self):
        print('D')


class E(C, D):
    def f(self):
        print('E')


obj1 = E()
obj1.f1()
'''
D
'''

　　　　6.3.2 有共同父类

class Top:
    def f1(self):
        print('Top')

class A(Top):
    def f(self):
        print('A')


class B(Top):
    def f1(self):
        print('B')


class C(A):
    def f(self):
        print('C')


class D(B):
    def f1(self):
        print('D')


class E(C, D):
    def f(self):
        print('E')


obj1 = E()
obj1.f1()
'''
D
'''

　　

7.多态 

　　 Pyhon不支持Java和C#这一类强类型语言中多态的写法，但是原生多态，其Python崇尚“鸭子类型”

class F1:
    pass


class S1(F1):

    def show(self):
        print 'S1.show'


class S2(F1):

    def show(self):
        print 'S2.show'


# 由于在Java或C#中定义函数参数时，必须指定参数的类型
# 为了让Func函数既可以执行S1对象的show方法，又可以执行S2对象的show方法，所以，定义了一个S1和S2类的父类
# 而实际传入的参数是：S1对象和S2对象

def Func(F1 obj):
    """Func函数需要接收一个F1类型或者F1子类的类型"""
    
    print obj.show()
    
s1_obj = S1()
Func(s1_obj) # 在Func函数中传入S1类的对象 s1_obj，执行 S1 的show方法，结果：S1.show

s2_obj = S2()
Func(s2_obj) # 在Func函数中传入Ss类的对象 ss_obj，执行 Ss 的show方法，结果：S2.show

class F1:
    pass


class S1(F1):

    def show(self):
        print 'S1.show'


class S2(F1):

    def show(self):
        print 'S2.show'

def Func(obj):
    print obj.show()

s1_obj = S1()
Func(s1_obj) 

s2_obj = S2()
Func(s2_obj) 

8.经典问答　

　　问题一：什么样的代码才是面向对象？

　　答：从简单来说，如果程序中的所有功能都是用 类 和 对象 来实现，那么就是面向对象编程了。

　　问题二：函数式编程 和 面向对象 如何选择？分别在什么情况下使用？

　　答：须知：对于 C# 和 Java 程序员来说不存在这个问题，因为该两门语言只支持面向对象编程（不支持函数式编程）。

　　　　而对于 Python 和 PHP 等语言却同时支持两种编程方式，且函数式编程能完成的操作，面向对象都可以实现；而面

　　　　向对象的能完成的操作，函数式编程不行（函数式编程无法实现面向对象的封装功能）。

　　　　所以，一般在Python开发中，全部使用面向对象 或 面向对象和函数式混合使用

9.面对对象的应用场景

　　9.1 多函数需使用共同的值，如：数据库的增、删、改、查操作都需要连接数据库字符串、主机名、用户名和密码

class SqlHelper:

    def __init__(self, host, user, pwd):

        self.host = host
        self.user = user
        self.pwd = pwd

    def 增(self):
        # 使用主机名、用户名、密码（self.host 、self.user 、self.pwd）打开数据库连接
        # do something
        # 关闭数据库连接

    def 删(self):
        # 使用主机名、用户名、密码（self.host 、self.user 、self.pwd）打开数据库连接
        # do something
        # 关闭数据库连接

    def 改(self):
        # 使用主机名、用户名、密码（self.host 、self.user 、self.pwd）打开数据库连接
        # do something
        # 关闭数据库连接

    def 查(self):
    # 使用主机名、用户名、密码（self.host 、self.user 、self.pwd）打开数据库连接
        # do something
        # 关闭数据库连接# do something

　　9.2 需要创建多个事物，每个事物属性个数相同，但是值的需求

　　　　如：张三、李四、杨五，他们都有姓名、年龄、血型，但其都是不相同。即：属性个数相同，但值不相同

class Person:

    def __init__(self, name ,age ,blood_type):

        self.name = name
        self.age = age
        self.blood_type = blood_type


    def detail(self):
        temp = "i am %s, age %s , blood type %s " % (self.name, self.age, self.blood_type)
        print temp

zhangsan = Person('张三', 18, 'A')
lisi = Person('李四', 73, 'AB')
yangwu = Person('杨五', 84, 'A')