python：面向对象：说明和使用【精】

面向对象(Object Oriented,OO)是软件开发方法。：

面向对象的分析方法是利用面向对象的信息建模概念，如实体、关系、属性等，同时运用封装、继承、多态等机制来构造模拟现实系统的方法。

传统的结构化设计方法的基本点是面向过程：系统被分解成若干个过程

而面向对象的方法是采用构造模型的观点，在系统的开发过程中，各个步骤的共同的目标是建造一个问题域的模型。在面向对象的设计中，初始元素是对象，然后将具有共同特征的对象归纳成类，组织类之间的等级关系，构造类库。在应用时，在类库中选择相应的类。

---

“面向对象”和“基于对象”的区别

面向对象的三大特点（封装，继承，多态）缺一不可。通常“基于对象”是使用对象，但是无法利用现有的对象模板产生新的对象类型，继而产生新的对象，也就是说“基于对象”没有继承的特点。而“多态”表示为父类类型的子类对象实例，没有了继承的概念也就无从谈论“多态”。很多流行技术都是基于对象的，它们使用一些封装好的对象，调用对象的方法，设置对象的属性。但是它们无法让程序员派生新对象类型。他们只能使用现有对象的方法和属性。所以当你判断一个新的技术是否是面向对象的时候，通常可以使用后两个特性来加以判断。“面向对象”和“基于对象”都实现了“封装”的概念，但是面向对象实现了“继承和多态”，而“基于对象”没有实现这些

---

简单地来说：
面向过程，注重怎么做。
面向对象，注重谁来做。

---

在面向对象的使用中，我们多是按照如下思路进行：
1.确定职责—即要做的事（方法）
2.对象内部封装不同方法（多个）
3.不同对象调用不同方法

而我们又通常将整件要做的事情写在一个整体中，称为类，类中包含属性和方法。
1.类即模版，对象都是根据这个模版创建出来的。一个类可以有多个对象
2.属性即变量，定量
3.方法为我们要做的事情，执行的动作，为函数
4.类名命名通常采用大驼峰命名法，且不使用下划线

---

下面讲述面向对象的具体使用：

一：定义类：

格式： class 类名()
包含：属性+方法
模版：

class People()：
	#属性：类中的变量
	name = 'xyy'
	age = 21

#方法: 类中的函数
def eat(self):   ##self的作用相当于调用者本身。本示例中无意义。
	print('吃苹果')

二：实例化：通过类创建对象

p1 = People()  ##实例化
p2 = People()  ##多个对象

##获取属性

p1.name
p2.name

##获取方法

p1.eat
p2.eat

在上述这个例子中，完成了类的实例化，即创建对象，并且是多个对象，还获取了类中的属性和类中的方法。

---

三：构造方法（构造函数）：

class People():
	def__init__(self):    ##init：初始化  ##self调用者本身

可以看到’self’,self即为实例化中的’p1’.p1

---

三大特点：封装、继承、多态

---

四：封装：

封装就是把同一类东西放在一起，通过self.xxx调用
多用于不同对象要调用类中同一属性，或者方法，还要产生的结果不完全一样时。

class People():

def __init__(self,name,age):
    ##初始化方法在实例化对象时会自动执行，不需要手动调用
	#类里的self是对象本身
	#将属性定义在方法中，而不是类中
	#self是对象，name是属性，self.name就是将对象和属性封装在一起
    self.name = name
    self.age = age

def run(self):
    print('%s正在跑步...' %(self.name))

p1 = People('xyy',21)
p1.run()

p2 = People('abc',28)
p2.run()

---

五：继承：

继承性是子类自动共享父类数据结构和方法的机制，这是类之间的一种关系。在定义和实现一个类的时候，可以在一个已经存在的类的基础之上来进行，把这个已经存在的类所定义的内容作为自己的内容，并加入若干新的内容。

##定义一个类，可以从现有的某个类继承
##新的类称为子类、扩展类(Subclass)，被继承的称为父类、基类、超类

【继承的工作机制】：

class Father():   #父类
	def __init__(self,name,age):
		self.name = name  #父类属性：名字
		self.age = age  #父类属性：年龄
	def eat(self):   #方法一
		print('%s正在吃' %(self.name))
	def sleep(self): #方法二
		print('%s正在睡' %(self.name))

class Son(Father)：   ##指定父类
	pass   #不做操作

father = Father('xyy',65)  #实例化：创建对象father，并赋予参数，name：xyy，age:65
son = Son('xyy',38)  #实例化：创建对象son，使用类Son，并赋于参数name:xyy，age：38

#调用父类的方法

son.eat()

#重写父类方法：
即通过子类中写入相同的方法，执行不同的动作，来达到重写父类方法。

class Son(Father)：
	def eat():
		print('倒立')    
##当调用子类中的方法在父类中已有时，会执行子类的方法，达到重写父类方法的效果
##本例中Father类中已经有eat方法，而子类如果也有eat方法，运行子类方法时，不会输出父类eat方法的结果。

##实例化对象默认执行构造方法，子类没有的方法，默认执行父类方法。

【多次继承：】

class Animal():
	def eat(self):
		print('吃')
	def drint(self):
		print('喝')
	def sleep(self):
		print('睡')

class Cat(Animal):
	def yell(self):
		print('喵')

class Jiqimao(Cat):
	def speak(self):
		print('我会说话')

jqm = Jiqimao()
jqm.speak()
jqm.sleep()

#继承具有传递性，子类具有父类的父类的方法【A继承B，B继承C，则A也继承了C 】

当继承不同类的同一个方法时，会执行先被调用的类的方法

class A():  #定义A类
	def test(self): #test方法
		print('A---test')
	def demo1(self):  #demo方法
		print('A---demo')
class B():  #定义B类
	def test(self):  #test方法
		print('B---test')
	def demo(self):  #demo方法
		print('B---demo')
class C(A,B):  #定义C类，继承A和B
	pass  #无方法

K = C()     #实例化：创建对象K
K.test()    #输出A---test 
K.demo      #输出B---demo   

---

六：str方法：

返回字符串的方法

class People():

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

    def __str__(self):   #str方法
        #必须返回一个字符串
        return '我是 %s' %(self.name)

p1 = People('xyy')
print(p1)

---

七：多态性：

多态性是指相同的操作或函数、过程可作用于多种类型的对象上并获得不同的结果。不同的对象，收到同一消息可以产生不同的结果，这种现象称为多态性。

class Student():
	def get_score(self):
		print('获取成绩')
class Chinese():
	def get_score(self):
		print('获取语文成绩')
class Math():
	def get_score(self):
		print('获取数学成绩')

student1 = Student()
student2 = Chinese()
student3 = Math()
student1.get_score()   ##得到获取成绩
student2.get_score()   ##得到获取语文成绩
student3.get_score()   ##得到获取数学成绩

开闭原则：
对扩展开放：允许子类重写方法
对修改封闭：不修改，直接继承父类方法

---

八：类属性和类方法：

类属性：使用赋值语句在class关键字下定义
类方法：在类内部可以直接访问属性或者其他类方法

示例：

class Student(object):
	count = 0  ##类属性
	
	def __init__(self,name):
		Student.count += 1  #类属性+1
	
	@classmethod   ##调用类方法
	def Show_Student_count(self):   
		print('%d' %self.count)

student1 = Student('xyy')
student1.Show_Student_count()  #常规方法，创建对象，对象调用类中方法
Student.Show_Student_count()  #通过类方法，直接调用类中方法，省去创建对象的过程。

---

九：静态方法：

静态方法：不需要实例化，一般不调用类中属性，是一个单独，和类其他方法属性无关的方法。

class Cat(object):
	
	@staticme   #声明静态方法
	def call():
		print('MIAO')

Cat.call()   #直接调用类中方法

---

十：私有属性，私有方法

##只能在对象内部被访问，外部无法被访问
##私有属性的用法为在定义时加两个下划线’__’

class Women():  #定义类
	def __init__(self,name):  #定义初始化
		self.name = name
		self.__age = 18   ##私有属性
	def __secret(self):    ##私有方法
		print('%s的年龄是%d' %(self.name,self.__age))
lily = Women('lily')
print(lily.name)
print(lily.__age)      ##无法访问
lily.__secret()    ##无法访问

##在类内部写一个公开方法，调用内部的私有属性，即可得到调动私有方法的功能。
class Student(object):

def __init__(self,name,score):
    self.__name = name   ##私有属性
    self.__socre = score

def get_name(self):   ##公开方法
    return self.__name

def get_score(self):  ##公开方法
    return self.__socre

tom = Student('Tom',89)
print(tom.get_score())
print(tom.get_name())

##更改私有属性：通过写一个公开方法，在公开方法内给私有属性赋值，再调用公开方法，达到更改私有属性的效果

class Student(object):

def __init__(self,name,score):
    self.__name = name
    self.__socre = score

def get_name(self):
    return self.__name

def get_score(self):
    return self.__socre

def set_score(self,score):
    self.__socre = score

tom = Student('Tom',89)
tom.set_score(90)
print(tom.get_score())
print(tom.get_name())

---

               大大的小小阳