OOP 类 与对象

　引子

面向过程：核心是过程二字。

　　　　　　　　　　　　过程指得是问题解解决的步骤，即先干什么再干什么，基于面向过程设计，就好像是设计一条流水线，是一种机械的思维方式。

　　　　　　　　优点：复杂的问题流程化，进而简单

　　　　　　　　缺点：可扩展性差

　　　　　　　　应用：脚本程序，linux系统管理脚本，linux内核，httpd,git

 

面向对象：核心是对象二字。

　　　　　　　　　　　　对象就是特征与技能的结合体，如果把设计程序比喻成创造世界，那你就是这个世界的上帝，与面向过程对机械流水线模式形成鲜明对比，

　　　　　　　　　　　　面向对象更加注重的对先是时间的模拟。

　　　　　　　　优点：可扩展性强

　　　　　　　　缺点： 复杂度高，弄不好的话，就会出现过度设计...

　　类：

　　　　即类型，类别，对象是特征与技能的结合体，so，类就是一系列对象相似的特征与技能的结合体.......

　　程序中，一定先定义类，后调用类来产生对象。

定义类：class Name( ):

 类的继承：

#!/usr/bin/env python
#-*-coding:utf-8-*-
# author='tony'
# filename='class_inherit'

# 继承的基本形式..... 经典类、新式类的基本区别...
'''
继承是一种类与类之间的关系，是一种什么是什么的关系，功能之一就是解决类的代码重用的问题；
    继承是一种创建新类的方式，在python中，新建的类可以继承一个或多个父类，父类也可称为超类过基类，新建的类也可称为，子类
    或派生类。

     查看类的基类：subclass.__base__,有多个基类的话换用tuple 包起来...
     继承： class1(parentclass): 括号里写基类.....
     python3定义的类都默认继承object，so 里面都是新式类，Python2 里有经典类直说，换言之没有继承Object的类都是经典类...
     Python2 手动继承object 就是新式类了...

'''


class OldboyPeople():                           # 定义一个基类.....
    def __init__(self,name,age,sex):            #　初始化函数，可供子类继承....
        self.name = name
        self.age = age 
        self.sex = sex 

        print('this is OldboyPeople is parent_class .... ')

    def eat(self):                             # 方法，子类可继承....
        print('this is {0} eating from {1}....'.format(self.name,'OldboyPeople'))


class OldboyStudent(OldboyPeople):              # 定义子类并继承上面基.....
    def __init__(self,name,age,sex,edu):        # 子类的初始化函数，继承基类方法时扩展自己的...
        OldboyPeople.__init__(self,name,sex)    # 继不继承 ，都可以这样直接调用.... class_name.__init__(self,argv,kwargs)
        self.edu = edu                          # 定制自己的初始化...
        print('this  OldboyStudent name is {0},edu is {1} from {2}'.format(self.name,self.edu,'OldboyStudent_class'))


    def learn(self):                            # 子类自己的方法....
        print('this is {0} learning from {1}... '.format(self.name,'OldboyStudent_class'))

##               指名道姓的方式 访问一个类的属性，跟继承没有关系...

class OldboyTeach(OldboyPeople):                # 定义子类2并继承上面的基类.....
    def __init__(self,name,age,sex,edu):        # 子类的初始化函数，继承基类初始化函数时，扩展自己的....
        OldboyPeople.__init__(self,name,sex,edu) # 继不继承 ，都可以这样直接调用.... class_name.__init__(self,argv,kwargs)
        self.edu = edu                            # 定制自己的初始化....
        print('this is {0} edu... from {1}'.format(self.name,'OldboyTeach_class'))

    def teach(self):                               # 子类自己的方法....
        print('this is {0} teaching from {1}....'.format(self.name,'OldboyTeach'))


t =OldboyTeach('tony',18,'male','博士')       # 先生成一个空的对象在去找初始化.... 优先找自己的，随后找基类的....
t.eat()                                       # 对象调用类的方法...

'''
总结：
    1 继承功能之一：解决类与类之间代码重复问题。
    2 继承是类与类之间的关系，是一种，什么是什么的关系。
    3 在子类派生出的新的子类，以自己为准。
    4 在子类派生出新的方法内重用父类的功能的方式：知名道姓法
        class_name._init__
            这种用类名直接调用：知名道姓法

 

 

 类的组合：

 

 

#!/usr/bin/env python3
#-*-coding:utf-8-*-
# author='tony'
# filename='组合'

# 类继承的查找依赖于一个mro表...
# 每个类都有一个mro列表...


#                        继承是什么是什么的关系,而组合，则不依赖于这种关系 ....
#                                                      依赖继承用super()

class People():
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age   
        self.sex = sex
    def eat(self):
        print(' this is {0} eating '.format(self.name))
        
    def drink(self):
        print('this is {0} drinking '.format(self.name))

    
class Teacher():
    def __init__(self,name,age,sex):
        People.__init__(self,name,age,sex)  # 子类重用父类的方法....　指名道姓方式用．．．
        #super().__init__(name,age,sex)    # super 生成的是一个对象，是bound method 绑定方法自动传self...
        # 这个super()对象 bound method 方式依赖继承...
        self.crouse = []                    # 一个类的属性来之另一个类或多个类的实例化对象,不依赖于继承...
    def teach(self):
        print('{0} is teaching {1}'.format(self.name,self.crouse))


class Student(People):  
    def __init__(self,name,age,sex):
        People.__init__(self,name,age,sex)
        #super().__init__(name,age,sex)    # super 生成的是一个对象，是bound method 绑定方法自动传self...
        # 这个super()对象 bound method 方式依赖继承...
        self.studen = []
    
    def learn(self):
        print('student {0} is learning '.format(self.name))
        

    
class Cruose():
    def __init__(self,cruose,price,lang):
        self.cruose = cruose
        self.price = price
        self.lang = lang
    def cruose_info(self):
        return  '{0} {1} {2}'.format(self.cruose,self.price,self.lang)


python = Cruose('python',30000,'3mons')
linux = Cruose('linux',2000,'2mons')
bigdata = Cruose('bigdata',1000,'1mons')
# python.cruose_inifo()
c = Cruose('python',10000,'3mous')
# c.cruose_info()

tony = Teacher('tong',29,'男',)
tony.crouse.append(python)
tony.crouse.append(linux)
tony.crouse.append(bigdata)
for obj in tony.crouse:
    print(obj.cruose_info())

# 将一个类的对象当做元素添加到类中去，作为类的属性....