python 面向对象（二）

  成员共分为三类:   

一、变量:                     

　　- 实例变量(字段)
　　　　- 公有实例变量(字段)
　　　　- 私有实例变量(字段)
　　- 类变量(静态字段)
　　　　- 公有类变量(静态字段)
　　　　- 私有类变量(静态字段)

class Student:
    school = "蓝翔"       #公有的类变量
    __grade = "一年级"    #私有的类变量
    def __init__(self,name):
        self.name = name    #公有的实例变量
        self.__age = 18    #私有的实例变量

stu = Student("Tom")
print(stu.name)
# print(stu.__age)      #私有的实例变量不能在类外部访问
print(Student.school)
# print(Student.__grade)    #私有的类变量不能在类外部访问

二、方法                  

　　实例方法
　　　　有个self参数

　　静态方法 ： 如果方法无需使用对象中封装的值,那么就可以使用静态方法

　　　　方法上边有@staticmethod
　　　　参数可有可无

　　类方法 ： 如果在方法中会使用到当前类，那么就用类方法

　　　　方法上边有@classmethod
　　　　有个cls参数

class Student:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def dyname(self):       #实例方法
        print(self.name)
    @staticmethod
    def dy(x):              #静态方法：如果方法无需使用对象中封装的值,那么就可以使用静态方法
        print("哈哈哈",x)
    @classmethod
    def dy2(cls):           #类方法：如果在方法中会使用到当前类，那么就用类方法
        print(cls)
stu = Student("Tom",18)
stu.dyname()
Student.dy("s15")
Student.dy2()

三、属性                

　　方法上有@property

　　只有一个self参数 

　　调用时无需加括号 对象.方法

　　对于简单的方法，当无需传参且有返回值时可以使用 

class Student:
    def __init__(self):
        pass

    @property
    def shuxing(self):
        return 1
obj = Student()
print(obj.shuxing)

 四、 类成员的修饰符             

　　公有成员： 在任何地方都可以访问

　　私有成员： 只能在类的内部访问，不能在外部访问

　　私有成员和公有成员的定义不同： 私有成员定义时要加双下划线

 五、主动调用其他类的成员      

　　方法一：

　　　　类名.实例方法(自己传self)

class Base(object):

    def f1(self):
        print("bbb")

class Foo(object):

    def f1(self):
        print("aaa")
        Base.f1(self)

obj = Foo()
obj.f1()

　　方法二：

　　　　super 按照类的继承顺序，找下一个

　　　　super().f1()

　　

class Base1(object):

    def f1(self):
        super().f1()
        print("base1.f1")

class Base2(object):

    def f1(self):
        print("base2.f1")

class Foo(Base1,Base2):
    pass

obj = Foo()
obj.f1()

　　

 六、特殊成员               

#1. 类名() 自动执行 __init__
obj = Foo(1,2)

#2. 对象() 自动执行 __call__
ret = obj(6,4,2,k1=456)

#3. 对象['xx']  自动执行 __getitem__
ret = obj['yu']
print(ret)

#4. 对象['xx'] = 11  自动执行 __setitem__
obj['k1'] = 123

#5. del 对象[xx]     自动执行 __delitem__
del obj['uuu']

#6. 对象+对象         自动执行 __add__
obj1 = Foo(1,2)
obj2 = Foo(88,99)
ret = obj2 + obj1
print(ret)

#7. with 对象        自动执行 __enter__ / __exit__
obj = Foo(1,2)
with obj as f:
    print(f)
    print('内部代码')
 # 8. 真正的构造方法
class Foo(object):
    def __init__(self, a1, a2):     # 初始化方法
        """
        为空对象进行数据初始化
        :param a1:
        :param a2:
        """
        self.a1 = a1
        self.a2 = a2

    def __new__(cls, *args, **kwargs): # 构造方法
        """
        创建一个空对象
        :param args:
        :param kwargs:
        :return:
        """
        return object.__new__(cls) # Python内部创建一个当前类的对象(初创时内部是空的.).

obj1 = Foo(1,2)
print(obj1)

obj2 = Foo(11,12)
print(obj2)