python学习第十五天

1.面向对象和面向过程

    面向过程: 以我为中心. 按照事物的发展"流程".

    面向对象: 以对象为中心.
    万事万物皆为对象(object)

2.如何编写面向对象程序(重点)

先创建类: 归类. 对某些事物进行总结.  相当于图纸

    使用类可以创建对象:
        class 类名(object)
            def __init__(self, name, age): # 构造方法. 创建对象的时候自动调用这个方法
                self.name = name
                self.age = age

        def 方法名(self, 参数);
            方法体(return)
    创建对象:
        变量(引用, 句柄) = 类名(参数)
        # 访问对象的属性信息
        对象.属性
        # 方法的访问:
        对象.方法()

    练习：
            # #Lol 类名，类是对事物的定义，归类
            # # 自己定义类时，类名首字母大写
            # class Lol():
            #     pass

            # #  创建对象 ： 变量 = 类()
            # c1 = Lol()  # 把类的概念进行实例化.通过类来创建对象
            # c1.sheshou = '金克斯'  # 属性
            # c1.zhongdan = '阿狸'
            # c1.shangdan = '阿卡丽'
            # c1.daye = '卡兹克'
            # c1.fuzhu = '布隆'
            # # . 的
            # # 对象.属性
            # print(c1.shangdan)
            # print(c1.daye)
            # print(c1.zhongdan)
            # print(c1.sheshou)
            # print(c1.fuzhu)

            # print('\n\n')

            # c2 = Lol()  # 把类的概念进行实例化.通过类来创建对象
            # c2.sheshou = '老鼠'  # 属性
            # c2.zhongdan = '风男'
            # c2.shangdan = '鳄鱼'
            # c2.daye = '皇子'
            # c2.fuzhu = '莫甘娜'
            # print(c2.shangdan)
            # print(c2.daye)
            # print(c2.zhongdan)
            # print(c2.sheshou)
            # print(c2.fuzhu)



            # class Lol():
            #     # 构造方法。在创建的对象的时候由系统自动访问这个方法
            #     # self : 自身，自己  类的对象。当前正在创建的对象
            #     def __init__(self, shangdan, daye, zhongdan, sheshou, fuzhu):  # 谁在调用,self就是谁,self由python自动传递
            #         self.shangdan = shangdan
            #         self.daye = daye
            #         self.zhongdan = zhongdan
            #         self.sheshou = sheshou
            #         self.fuzhu = fuzhu
            # c3 = Lol('狗头','梦靥','泽拉斯','奥巴马','锤石')
            # print(c3.shangdan,end='\t\t')
            # print(c3.daye,end='\t\t')
            # print(c3.zhongdan,end='\t\t')
            # print(c3.sheshou,end='\t\t')
            # print(c3.fuzhu)
            # print('*********************VS*********************')
            # c4 = Lol('瑞文','盲僧','卡特琳娜','Vn','巨魔')
            # print(c4.shangdan,end='\t\t')
            # print(c4.daye,end='\t\t')
            # print(c4.zhongdan,end='\t\t')
            # print(c4.sheshou,end='\t\t\t')
            # print(c4.fuzhu)



            # class Lol():
            #     # 构造方法。在创建的对象的时候由系统自动访问这个方法
            #     # self : 自身，自己  类的对象。当前正在创建的对象
            #     def __init__(self, shangdan, daye, zhongdan, sheshou, fuzhu):  # 谁在调用,self就是谁,self由python自动传递
            #         self.shangdan = shangdan
            #         self.daye = daye
            #         self.zhongdan = zhongdan
            #         self.sheshou = sheshou
            #         self.fuzhu = fuzhu
            #     # 方法.该类型的对象能够执行哪些操作
            #     def youxi(self, game):  # 谁调用这个方法，self 就是谁
            #         # 我要用game中的self.shangdan打上路
            #         print('我要玩%s' % game)
            # c4 = Lol('瑞文','盲僧','卡特琳娜','Vn','巨魔')
            # c4.youxi('LOL')


    对比面向对象和面向过程:
        看需求.
        大型项目更适合用面向对象
        小型脚本程序更适合面向过程

3.面向对象的三大特征：封装，继承，多态
    对属性封装
        self.xxx = xxxx
    对方法封装
    
继承：子类自动拥有父类中除了私有内容以外的其他所有内容

    子类在父类的基础上扩展了一些功能，(派生)
        class Foo:
            def a(self):
                pass
            def c(self):
                pass
        class bar(Foo):
            def d(self):
                pass
        b = bar()
        b.a()
        b.c()
        b.d()

多态：同一个对象，拥有多种形态，  Java\c++