python 面向对象

 

类的使用示例：

class Student:
    name=""  #类的成员变量，公有的
    age=0  #python中定义变量时必须要赋值
    def __init__(self,name,age):  #构造函数
        self.name=name
        self.age=age
    def getAge(self):  #类中所有的方法定义时都必须要带参数self，且self必须是形参表的第一个参数。
        return self.age  #self表示类的当前实例，相当于c++、java中的this
    def out(self):  #不管函数体中用不用self，形参表中都必须要加上self。传参时不传递self参数。
        print("ok")

student=Student("张三",20)  #创建类的一个实例
print(student.name)  #访问公有成员变量
print(student.getAge())  #调用公有方法

可通过类名直接访问成员变量，但访问到的只是初始值：

class Student:
    name=""
    age=0
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def getAge(self):
        return self.age
    def out(self):
        print("ok")

student=Student("张三",20)
print(student.age)  #20  通过对象来访问成员变量
print(student.getAge())  #20   通过对象来访问
print(Student.age)  #0  通过类名直接访问成员变量，访问到的只是初始值

 不推荐使用类名直接访问成员变量。

在python中，私有的成员变量、方法以__(2个下划线）开头。

私有的成员变量、方法只能在类中访问、调用。

公有的成员变量、方法既可以在类中访问、调用，也可在在类外通过对象来访问、调用。

在类外，可通过类名直接访问公有的成员变量，但访问到的是初始值。

在类外，通过类名只能访问到公有的成员变量，不能访问到私有的成员变量，不能访问到类中的方法。

class Student:
    __name=""  #前缀__表示此成员变量|方法是私有的
    __age=0  #私有的成员变量，只能在类中被访问、使用
    def __init__(self,name,age):
        self.__name=name
        self.__age=age
    def getAge(self):  
        return self.__age
    def __out(self):   #私有方法，只能在类中被调用
        print("ok")  

类中有一系列预定义的方法名：

• __init__ : 构造函数
• __del__ : 析构函数
• __repr__ : 打印，转换
• __setitem__ : 按照索引赋值
• __getitem__: 按照索引获取值
• __len__: 获取长度
• __cmp__: 比较运算
• __call__: 函数调用
• __add__: 加法运算
• __sub__: 减法运算
• __mul__: 乘法运算
• __truediv__: 除法运算
• __mod__: 求余运算
• __pow__: 乘方运算

构造函数：

class Student:
    __name=""
    __age=0

    def __init__(self,name,age):  #构造函数
        self.__name=name
        self.__age=age

    def getAge(self):
        return self.__age

    def getName(self):
        return self.__name

student=Student("张三",20)
print(student.getName())  #张三
print(student.getAge())   #20

class Student:
    __name=""
    __age=0

    def __int__(self):  # 空参构造函数
        pass

    def __init_(self,name):  #一个参数的构造函数
        self.__name=name

    def __init__(self,name,age):  #2个参数的构造函数
        self.__name=name
        self.__age=age

    def getName(self):
        return self.__name

    def getAge(self):
        return self.__age


# student=Student("张三",20)
# print(student.getName(),student.getAge())   #张三 20

#student=Student()  #报错 TypeError: __init__() missing 2 required positional arguments: 'name' and 'age'
#print(student.getName(),student.getAge())

student=Student("李四")  #报错  TypeError: __init__() missing 1 required positional argument: 'age'
print(student.getName(),student.getAge())

"""
python中可以定义多个构造函数，但：
如果有给所有成员变量赋值的构造器时，只能使用这个构造器，如果没有这个构造器，则只能使用空参构造器。
其他构造器无效。
"""

运算符重载：

class Student:
    __name=""
    __age=0

    def __init__(self,name,age):  #构造函数。
        self.__name=name
        self.__age=age

    def __add__(self, other):  #运算符重载，加法运算
        result=Student("",0)  #如果有给全部成员变量赋值的构造器，就必须使用这个构造器，必须传递全部参数
        result.__name=self.__name+other.__name
        result.__age=self.__age+other.__age
        return result

    def getName(self):
        return self.__name

    def getAge(self):
        return self.__age

student1=Student("张三",20)
student2=Student("李四",22)
student=student1+student2
#也可以写成   student=student1.__add__(student2)
print(student.getName())  #张三李四
print(student.getAge())  #42

继承

class  子类(父类):   #单继承
    类体

class  子类(父类1，父类2，父类3,...):   #python支持多继承。逗号分隔。
    类体

重写方法：

class Father:
   def out(self):
       print("father")

class Son(Father):
    def out(self):   #重写方法
        print("son")

son=Son()
son.out()  #调用子类的方法  son
super(Son,son).out()  #调用父类中的方法  father
"""
super(子类名, 子类对象)   表示这个子类对象对应的父类对象
如果是在子类类体(定义）中调用，子类对对象可以用self表示： super(子类名, self)
"""

子类的构造器：

class Father:
   def __init__(self):
       print("father_init")


class Son(Father):
    def __init__(self):
        print("son_init")

son=Son()

"""
如果子类有自己的构造器，则创建子类对象时，会自动调用子类的构造器，不会自动调用父类的构造器。（可以在子类的构造器中手动调用父类的构造器）
如果子类没有自己的构造器，则创建子类对象时，会自动调用父类的构造器。
"""