python-面向对象(上)

面向对象（上）

python一切皆对象，类也是对象，对于同一个类，类对象只有一个，但实例对象可以有多个
	类对象拥有类属性和类方法，实例对象拥有实例属性和实例方法
	内部访问和外部访问，所有在类定义时的访问都属于内部访问，所有在类定义后的访问都属于外部访问
1.构造方法__new__()
	构造方法用于创建 <实例对象> 并返回该创建对象，该方法一般不需要重写
	def __new__(cls):  cls代表当前的类对象
		语句体
2.初始化方法__init__()
	用于初始化构造方法创建出的 <实例对象> ，当我们通过 类名(参数表) 构造实例对象时，会依次调用构造方法和初始化方法并返回由构造方法创建出的实例对象，在该方法中我们可以定义并初始化实例属性,该方法是唯一不能从父类继承的方法，必须重写
	实例属性分类：
		(1)公有实例属性：类外部可直接访问
			定义格式:  self.实例属性名
			访问格式:(内部/外部)  self.实例属性名
		(2)私有实例属性：定义时在属性名前加两个下划线"__"，类外部不可直接访问，但不是不能访问
			定义格式:  self.__实例属性名
			访问格式: (内部)  self.__实例属性名
					 (外部)  self._类名__实例属性名
	def __init__(self[,形参表]):
		self.实例属性名1 = 初始值1  # 公有实例属性
		self.实例属性名2 = 初始值2
		...
		self.__实例属性名p1 = 初始值p1  # 私有实例属性
		self.__实例属性名p2 = 初始值p2
3.析构方法__del__()
	用于销毁 <实例对象> ，回收为其分配的资源，python具有垃圾回收机制，会自动调用父类的该方法回收资源，一般无需重写该方法
	def __del__(self):
		语句体
4.类属性与类方法
	类属性或类方法，属于类对象，与实例对象无关，不可在类方法中使用实例对象的属性和方法(因为实例对象不一定存在)
	类属性：属于类对象，也分为公有和私有
	定义格式：
		(1)公有类属性：类属性名 = 初始值
		(2)私有类属性：__类属性名 = 初始值
	访问格式：
		(1)公有类属性：(内部/外部) 类名.类属性名   注：类方法中访问比较特殊，参考下文
		(2)私有类属性：(内部) 类名.__类属性名      注：类方法中访问比较特殊，参考下文
						(外部) 类名._类名__类属性名
		
	类方法：属于类对象，可直接通过访问其他类方法和类属性，不可访问实例属性或实例方法
	访问格式：(内部)  cls.类属性名/cls.类方法名()
			 (外部)  类名.类属性名/类名.类方法名()
	定义格式：
			@classmethod
			def 类方法名(cls[,形参表]):
				语句体
	静态方法：不属于类对象，相当于定义在类内部的全局函数,不可直接访问类属性或类方法
	访问格式：(内部/外部)  类名.类属性名/类名.类方法名()
	定义格式：
			@staticmethod
			def 静态方法名([形参表]):
				语句体
	将方法转变为属性调用(主要用于私有属性的外部访问)
			@property 
			def 属性名(self):
				return self.__属性名
			@属性名.setter
			def 属性名(self,参数):
				if 检查条件:
					self.__属性名 = 参数
#--------------------------------------------------------# 
			class People(object):
			    def __init__(self,name,age):
			        self.name = name 
			        self.__age = age
			    @property
			    def age(self):
			        return self.__age
			    @age.setter
			    def age(self,num):
			        if self.__age<num<1000:
			            self.__age = num
			            
			p1 = People("小明",20)
			print(p1.age)
			p1.age = 30
			print(p1.age)
#------------------------------------------------------#
	实例方法：属于实例对象，不可直接访问类对象属性或方法
	访问格式：类名.类属性名/类名.类方法名()
5.实例属性与实例方法
	实例属性或方法，属于实例对象，与类对象无关，但可访问类属性或类方法(因为类对象定义后就已经存在)
	实例方法：属于实例对象，不可直接访问类对象属性或方法
	访问格式：类名.类属性名/类名.类方法名()
	
注：所有私有属性或方法，除非有特殊要求，一般情况不建议直接访问

代码演示

# People为类名，一般采用驼峰命名法
class People(object): 
    """定义people类"""
    
    # 公有类属性
    c_name = "People"
    # 私有类属性
    __name = "__People"
    

    # 重写初始化方法
    def __init__(self,name,age,work,salary):
        '''             类初始化方法
            注：此方法必须重写，这是唯一不能从父类继承的方法
        '''
        # 定义公有实例属性
        self.name = name          
        self.work = work

        # 定义私有实例属性
        self.__salary = salary
        self.__age = age
        

    #--------实例方法访问其他方法或属性:属于内部访问-------#
    def infor(self):
        # 访问：公有实例属性
        print(self.name)
        # 访问：私有实例属性
        print(self.__salary)
        # 访问：公有实例方法
        self.print_age()
        # 访问：私有实例方法
        self.__print_salary()
        # 访问：公有类属性
        print(People.c_name)
        # 访问：私有类属性
        print(People.__name)
        # 访问：公有类方法
        People.public_infor()
        # 访问：私有类方法
        People.__private_infor()
        # 访问：公有静态方法
        People.spublic_infor()
        # 访问：私有静态方法
        People.__sprivate_infor()

        
    #--------类方法访问其他方法或属性：属于内部访问---------#
    @classmethod
    def c_acc(cls):
        # 访问：公有类属性
        print(cls.c_name)
        # 访问：私有类属性
        print(cls.__name)
        # 访问：公有类方法
        cls.public_infor()
        # 访问：私有类方法
        cls.__private_infor()
        # 访问：公有静态方法
        cls.spublic_infor()
        # 访问：私有静态方法
        cls.__sprivate_infor()
        
        
    #--------静态方法访问其他方法或属性：属于内部访问---------#
    @staticmethod
    def s_acc():
        # 访问：公有类属性
        print(People.c_name)
        # 访问：私有类属性
        print(People.__name)
        # 访问：公有类方法
        People.public_infor()
        # 访问：私有类方法
        People.__private_infor()
        # 访问：公有静态方法
        People.spublic_infor()
        # 访问：私有静态方法
        People.__sprivate_infor()

    #------------定义实例方法--------------#
    # 公有实例方法
    def print_age(self):
        print(self.__age)
    # 私有实例方法
    def __print_salary(self):
        print(self.__salary)

        
    #------------定义类方法---------------#
    # 公有类方法
    @classmethod
    def public_infor(cls): 
        print("classmethod 类名：{0}".format(cls.__name))
    # 私有类方法
    @classmethod
    def __private_infor(cls): 
        print("classmethod 类名：{0}".format(cls.__name))

    
    #-------------定义静态方法--------------#
    # 公有静态方法
    @staticmethod
    def spublic_infor():
        print("staticmethod 类名：{0}".format(People.__name))
    # 私有静态方法
    @staticmethod
    def __sprivate_infor():
        print("staticmethod 类名：{0}".format(People.__name))  



#----------外部访问----------#
# 访问：公有类属性
print(People.c_name)
# 访问：私有类属性
print(People._People__name)
# 访问：公有类方法
People.public_infor()
# 访问：私有类方法
People._People__private_infor()
# 访问：公有静态方法
People.spublic_infor()
# 访问：私有静态方法
People._People__sprivate_infor()
#--------------------------------#
# 注：访问实例属性或方法必须先创建实例对象
i_people = People("小明",18,"programer",5000)
# 访问：公有实例属性
print(i_people.name)
# 访问：私有实例属性
print(i_people._People__salary)
# 访问：公有实例方法
i_people.print_age()
# 访问：私有实例方法
i_people._People__print_salary()