python面向对象

面向对象

面向对象设计思想：将问题的解决或目标的实现关注于对象本身，对象有什么特点，通过做什么事情来达到目的
面向过程设计思想：将解决问题的重点放在过程上，以过程为中心，关注的是事件本身，通过一系列的过程来完成目标
面向对象，就是多个对象各自完成各自的任务，最后完成整个事情，在这个过程中，有两个重要的概念，一个是类，一个是对象类：就是具有共同特征和行为的一组对象的定义，可以说为一个整体的抽象，比如人类，动物类
对象：是一个具体存在的，由类具体化构建出来的东西，相当于一个人，一只猫
关系：对象是类中构建出来的具体存在的，而类是对一堆具有共同特征，共同行为的对象的抽象

类的定义和对象的创建

使用关键字class来定义类，遵守编码规范，类名首字母要大写，使用大写首字，也就是大驼峰法命名，抽象出一个具体的对象只需要 对象名=类名（）就可以了

#定义一个类，由类抽象出一个对象

class Man():
	def run(self):
		print("I am runing")
		
		
man1 = Man()
man1.run()

在定义方法的时候要写参数self，也就是对象，但是不用传入参数，因为self代表当前调用fun本身对象，也就是自己
面向对象有三大特征，封装，继承，多态。我们通过类来抽象出对象，由于对象本身具有类的方法和属性，就可以互相使用和协作，共同完成一件事情。封装就是指将数据封装到对象里面去，需要通过属性来封装。
对象创建方法__new__
这是在有类来构建对象时候首先调用的方法，默认返回当前这个类的对象，属于自动调用然后返回一个对象，在设计模式中需要使用__new__方法来保证只有一个对象，也就是只调用一次创建对象方法。
初始化方法__init__
这个方法是用来对对象初始化的，由解释器自动调用，我们可以在对象初始化的时候传递参数来将对象的属性封装进去，这样的话在类内的其他方法可以访问，在构建对象之后对象本身也可以访问

#定义一个类，由类抽象出一个对象
class Man():

	def __init__(self, name, age):
		self.name = name
		self.age = age
		
	def run(self):
		print("I am %s"%self.name)#内部访问
		print("I am runing")


man1 = Man("albert", 23)
man1.run()
print("I am %s years old"%man1.age)#类外通过对象访问

__str__方法可以打印一些关于对象的信息，在原有的基础上我们再加上这个方法

#定义一个类，由类抽象出一个对象
class Man():

	def __init__(self, name, age):
		self.name = name
		self.age = age

	def __str__(self):
		return "this is a function for print infomation about object"

	def run(self):
		print("I am %s"%self.name)#内部访问
		print("I am runing")


man1 = Man("albert", 23)
print(man1)
man1.run()
print("I am %s years old"%man1.age)

关于属性的隐藏和保护，python中有关于对象的隐藏属性和隐藏方法的语法，以双下划线开头的方法不可以在外部直接修改访问，内部可以调用，类似于C++和Java中的Public和Private

#定义一个类，由类抽象出一个对象
class Man():

	def __init__(self, name, age, pwd):
		self.name = name
		self.age = age
		self.__pwd = pwd
		
	def __str__(self):
		return "this is a function for print infomation about object"
		
	def run(self):
		print("I am %s"%self.name)
		print("I am runing")


man1 = Man("albert", 23, 123456)
print(man1.__pwd)#外部不可以访问

#定义一个类，由类抽象出一个对象
class Man():
	def __init__(self, name, age, pwd):
		self.name = name
		self.age = age
		self.__pwd = pwd

	def __str__(self):
		return "this is a function for print infomation about object"

	def run(self):
		print(self.__pwd)#内部访问
		print("I am %s"%self.name)
		print("I am runing")


man1 = Man("albert", 23, 123456)
man1.run()

这种属性的隐藏方法在外部不可以直接访问，但是我们可以通过自己设置getter和setter方法在外部间接地访问和修改数据，相当于预留了接口用来操作私有属性

#定义一个类，由类抽象出一个对象
class Man():

	def __init__(self, name, age, pwd):
		self.name = name
		self.age = age
		self.__pwd = pwd

	def getter(self):
		return self.__pwd
		
	def setter(self, pwd):
		self.__pwd = pwd

 
man1 = Man("albert", 23, 123456)
print("修改前的密码是："+str(man1.getter()))
man1.setter(456789)
print("修改后的密码是："+str(man1.getter()))

__del__方法
这个方法是在程序运行结束的时候销毁对象的方法，相当于析构函数

#定义一个类，由类抽象出一个对象
class Man():

	def __init__(self, name, age, pwd):
		self.name = name
		self.age = age
		self.__pwd = pwd

	def getter(self):
		return self.__pwd

	def setter(self, pwd):
		self.__pwd = pwd

	def __del__(self):
		print("对象正在销毁")


man1 = Man("albert", 23, 123456)
print("修改前的密码是："+str(man1.getter()))
man1.setter(456789)
print("修改后的密码是："+str(man1.getter()))

可以看到我们并没有调用，但是仍然自动执行了这个函数销毁对象。
在属性名前加上单下划线表示在内部外部都可以访问，但是在导入至别的模块的时候不会一块导入，这种命名虽然在外部可以访问，但是不建议这样做。

继承

继承可以提高代码的重用性，有些重复的功能不用写，继承需要在定义class的时候在括号内加上父类的名字，在python中可以有多重继承，也就是一个子类可以继承多个父类，在子类中，若是重写方法，则不会继承父类中的方法，会优先使用子类中的方法，继承的本质是继承__init__方法才继承父类的公有属性，在多重继承中是按照父类名字的先后按照顺序依次调用的，优先级有先后顺序，若是没有直接的继承关系，则是直接继承所有类的顶级父类object。

class Man():

	def __init__(self, name, age):
		self.name = name
		self.age = age


class China(Man):#继承父类Man

	def print_name(self):
		print(self.name)#并未定义name，age等属性，但是由于继承了父类，所以拥有这些属性


albert = China("albert", 23)
albert.print_name()

多重继承，可以拥有多个父类的方法

class Man():

	def __init__(self, name, age):
		self.name = name
		self.age = age


class Student():

	def __init__(self, name, age):
		self.name = name
		self.age = age

	def study(self):
		print("I am study")


class China(Man, Student):#继承父类Man

	def print_name(self):
		print(self.name)#并未定义name，age等属性，但是由于继承了父类，所以拥有这些属性


albert = China("albert", 23)
albert.print_name()
albert.study()

多重继承的优先级，由于是优先继承Man的方法，所以当Man类拥有study方法的时候，优先调用Man的

#定义一个类，由类抽象出一个对象
class Man():

	def __init__(self, name, age):
		self.name = name
		self.age = age

	def study(self):
		print("he is not study")


class Student():

	def __init__(self, name, age):
		self.name = name
		self.age = age

	def study(self):
		print("I am study")

 
class China(Man, Student):

	def print_name(self):
		print(self.name)


albert = China("albert", 23)
albert.print_name()
albert.study()

如果子类的方法名和父类的方法名相同，则不会调用父类的方法，但是有些时候需要用到，在python中可以使用super来调用父类的方法，使用如下：

class Man():

	def __init__(self, name, age):
		self.name = name
		self.age = age
		print("我是父类的初始化方法")

 
class China(Man):

	def __init__(self, name, age):
		super().__init__(name,age)
		print("我是子类的初始化方法")


albert = China("albert", 23)

多态：python语言作为一种弱类型的语言，多态的体现并不明显，所以并不多做介绍
关于类属性和对象属性的概念
类属性：是指类所具有的属性，在这个类下的所有对象均可以共享这个属性
对象属性：由类抽象出来具体的对象所具有的属性，归对象本身所有，其他的同一个类抽象出来的对象不能访问和操作。

class Man():

	propety = "我是类属性"

	def __init__(self, name, age):
		self.name = name
		self.age = age
		self.propety_object = self.name+"对象属性"


albert = Man("albert", 23)
print(albert.propety)
print(albert.propety_object)
jay = Man("jay", 24)
print(jay.propety)
print(jay.propety_object)

公有的类属性可以被子类继承，私有的类属性不可以被子类继承，类属性的修改需要通过类来进行操作。
类方法：@classmethod，写在方法上面相当于java中的注解，加上了一个修饰器，参数加（cls）
静态方法：@staticmethod，相当于特殊的类方法，没有特定默认参数，可以通过类名来调用
对象方法：就是普通方法，参数加（self）
property的使用
这个相当于是对get和set方法的升级