面向对象

面向对象 - 元类：
    python 一切皆对象  # 类也是对象
        意义：1.可以被引用 2.可以当作函数的参数传入 3.可以当作函数的返回值 4.可以当作容器类的元素
    1.元类：
        类的类就叫元类  type
        class 定义的类 元类就是 type  type(Foo) == <class 'type'>
        元类（type）--》实例化--》类（class）--》实例化--》对象
    2.定义类的两种方式：
        1.class 关键字得方式  class Foo: ...
        2.type 元类  定义类得三要素：类名，类的基类们，类得名称空间
            Chinese1=type(class_name,class_bases,class_dic)
    3.自定义元类的作用：
        1.控制类得行为:
            def __init__(self,class_name,class_bases,class_dic)
            能得到 类名,基类,类体 -- 可操作 限制类名 类体 等操作
            class Chinese(object,metaclass=Mymeta)-->过程:先到元类__init__()走一遍
        2.控制类得实例化:
            def __call__(self, *args, **kwargs):
            能得到 对象的属性
                1.造空对象 2.初始化obj(里面调用__init__()) 3.返回obj
                obj=object.__new__(self)
                self.__init__(obj,*args,**kwargs)
                return obj
            obj=Chinese('alice',12)-->过程: 先到元类__call__()走一遍
    4.自定义元类的应用：
        单例模式?  eg:obj1=int(1) obj2=int(1) obj1 is obj2 == True 多个对象使用同一块内存 "优化策略"
        单例模式的实现方式:
            1.绑定给类的绑定方法：
                __instance=None
                @classmethod
                def singleton(cls):
                    if not cls.__instance:
                        obj=cls()
                        cls.__instance=obj
                    return cls.__instance
            2.利用元类实现:
                class Mymeta(type):
                    def __init__(self,class_name,class_bases,class_dic):
                        super().__init__(class_name,class_bases,class_dic)
                        self.__instance=None

                    def __call__(self, *args, **kwargs):
                        if not self.__instance:
                            obj = object.__new__(self)
                            self.__init__(obj)
                            self.__instance=obj
                        return self.__instance

# class Foo:
#     pass
# f=Foo()
# print(type(f))
# print(type(Foo))

# g={'x':1,'y':2}
# l={}
# exec("""
# global x,m
# x=10
# m=100
# z=3
# """,g,l)
# print(g)
# print(l)
# -------------------------
# 产生类得第一种方式：
class Chinese:
    country='China'
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def talk(self):
        print('%s is talking'%self.name)

# obj=Chinese('alice',12)
# obj.talk()
# print(obj.name,obj.age)

#产生类得第二种方式：
class_name='Chinese'
class_base=(object,)
class_body="""
country='China'
def __init__(self,name,age):
    self.name=name
    self.age=age

def talk(self):
    print('%s is talking'%self.name)
"""
# class_dic={}
# exec(class_body,globals(),class_dic)
# # print(class_dic)
# ch = type(class_name,class_base,class_dic)
# obj1=ch('alice',12)
# print(obj1.__dict__)
# print(ch.__dict__)
# print(ch)
# print(obj1,obj1.name,obj1.age)

#自定义元类 控制类的行为:
class Mymeta(type):  #元类
    # print('--1--')
    def __init__(self,class_name,class_bases,class_dic):   # 控制类的创建
        # print(class_name)
        # print(class_bases)
        # print(class_dic)
        if not class_name.istitle():
            raise TypeError('类名的首字母必须大写')
        if '__doc__' not in class_dic or not class_dic['__doc__'].strip():
            raise TypeError('必须有注释,且注释不能为空')

        super(Mymeta, self).__init__(class_name,class_bases,class_dic)

    def __call__(self, *args, **kwargs):  # 控制类的实例化
        # print(self)
        # print(args)
        # print(kwargs)
        obj=object.__new__(self)           #1.造空对象
        self.__init__(obj,*args,**kwargs)  #2.初始化obj
        return obj                        #返回obj


class Chinese(object,metaclass=Mymeta):
    '''
    中文人的类
    '''
    country='China'
    def __init__(self,name,age):
        print('--2--')
        self.name=name
        self.age=age

    def talk(self):
        print('%s is talking'%self.name)

    def __call__(self, *args, **kwargs):
        print(self)
        print(args)
        print(kwargs)


# obj=Chinese('alice',12)   # 触发它的类的 __call__() 元类
# obj(1,2,3,a=1,b=2)    # 触发它的类的 __call__()  Chinese
# print(obj.__dict__)
# print(Chinese.__dict__)
#
# print(type(Chinese))
# Chinese=Mymeta(class_name,class_bases,class_dir)
# print(obj.__dict__)

#自定义元类的应用:

# obj1=int(1)
# obj2=int(1)
# print(id(obj1))
# print(id(obj2))
# print(obj1 is obj2)  # 实现了单例模式 参数相同 多个对象 使用同一块内存 是一种优化策略

# 单例模式 实现方式一：

class Mymeta(type):
    def __init__(self,class_name,class_bases,class_dic):
        super().__init__(class_name,class_bases,class_dic)
        self.__instance=None

    def __call__(self, *args, **kwargs):
        if not self.__instance:
            obj = object.__new__(self)
            self.__init__(obj)
            self.__instance=obj
        return self.__instance



class Mysql(object,metaclass=Mymeta):
    # __instance=None
    def __init__(self):
        self.host='127.0.0.1'
        self.port=3306

    # @classmethod
    # def singleton(cls):
    #     if not cls.__instance:
    #         obj=cls()
    #         cls.__instance=obj
    #     return cls.__instance

    def conn(self):
        pass

    def execute(self):
        pass

# obj1=Mysql()
# obj2=Mysql()
# print(obj2.__dict__)
# print(id(obj1))
# print(id(obj2))

# obj1=Mysql.singleton()
# obj2=Mysql.singleton()
# # print(obj1.__dict__)
# print(id(obj1))
# print(id(obj2))

# obj1=Mysql()
# obj2=Mysql()
# print(id(obj1))
# print(id(obj2))

面向对象 - 软件开发：
    1.软件的开发其实一整套规范，我们所学的只是其中的一小部分，一个完整的开发过程，需要明确每个阶段的任务，
        在保证一个阶段正确的前提下再进行下一个阶段的工作，称之为软件工程
    2.面向对象的软件工程包括下面几个部分：
        1.面向对象分析（object oriented analysis ，OOA）
        2 面向对象设计（object oriented design，OOD）
        3 面向对象编程（object oriented programming，OOP）
        4 面向对象测试（object oriented test，OOT）
        5 面向对象维护（object oriendted soft maintenance，OOSM）
    3.面向对象实战 参考
        http://www.cnblogs.com/linhaifeng/articles/6182264.html
        http://www.cnblogs.com/linhaifeng/articles/7341318.html