面向对象学习一

面向对象学习一

开发的思想
面向过程：根据业务逻辑从上到下写垒代码
函数式：将某功能代码封装到函数中，日后便无需重复编写，增强代码的重用性和可读性
面向对象：对函数进行分类和封装

面向对象技术
类(Class)：用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。
方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
实例变量：定义在方法中的变量，只作用于当前实例的类。
继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。
实例化：创建一个类的实例，类的具体对象。
方法：类中定义的函数。
对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

对象：对象是描述其属性的数据以及对这些数据施加的一组操作封装在一起构成的统一体。程序中所有东西都是对象。可以将对象想象成一种新类型的变量，它保存着数据，对外提供服务，对自己的数据进行操作。
程序：程序是一系列对象的组合。对象之间通过消息传递机制组合起来，相互调用彼此的方法，实现程序的复杂功能。

每个对象都有自己的存储空间，可以容纳其他对象。利用封装机制，可以以现有对象为基础构造出新的对象。因此，虽然对象的概念很简单，但程序中可以实现任意复杂的对象。
每个对象都有一种类型。每个对象都是某个类的一个实例，其中类是类型type的同义词。类最主要的特征是对外接口。
同一类型的所有对象都能够接收相同的消息。子类与父类具有“同一类型” 。

现实世界的对象拥有两个特征：状态和行为。而面向对象程序设计语言中的对象是以现实世界中对象为模型构造的，所以也具有状态与行为，其中状态保存在一组变量中，行为则通过方法实现。

对象的方法一方面把对象的内部变量包裹、保护起来，使得只有对象自己的方法才能操作这些内部变量；另一方面，对象的方法还是对象与外部环境和其他对象交互、通信的接口，外界对象通过这些接口驱动对象执行指定的行为，提供相应的服务。

将类实例化就得到了现实世界实体的面向对象的映射——对象。
类描述了同一类对象都具有的数据和行为。

1）创建类
类就是一个模板，模板里可以包含多个函数，函数里实现一些功能
对象则是根据模板创建的实例，通过实例对象可以执行类中的函数

第一种：
class Foo: #类名Foo
def Good(self): #类方法Good()
print(‘Good’)
def Introduce(self,name): #类方法Introduce()
print(‘my name is %s!’%name)

obj=Foo() #根据类Foo创建对象obj，一定记得在类名后面加上括号
obj.Good() #执行类中方法Good()
obj.Introduce(“yanjinfeng”) #执行类中方法Introduce()

执行结果：
Good
my name is yanjinfeng!

第二种：
使用class语句来创建一个新类，class之后为类的名称，类名后有一括号，括号中为基类（可以有多个基类）然后以冒号结尾。
classClassName(BaseClass1,BaseClass2,…):
‘optional class documentation string’#类的帮助信息；类的帮助信息可以通过ClassName.__doc__查看。
class_suite #类体；Class_suite由类成员、方法、数据属性组成

举例：
#coding=utf-8
class Employee(object):#Employee为类名，object为基类（可以有很多基类）
empCount = 0 #类变量
def init(self, name, salary) :#类的构造函数
self.name = name
self.salary = salary
Employee.empCount += 1
def displayCount(self) : #类方法
print ("total employee ",Employee.empCount)
def displayEmployee(self) :
print (“name :”,self.name , “, salary :”, self.salary)

empCount变量：empCount变量是一个类变量（也叫静态变量），它的值将在这个类的所有实例之间共享。可以在内部类或外部类使用Employee.empCount访问
init()：类中第一个方法，被称做类的构造函数或初始化方法，只要创建类的实例，就会调用这个方法。如果没显示定义这个方法，默认会给一个空的构造方法。
类方法中参数中的self，代表实例本身，相当于java中的this指针。并且类中所有的方法中都必须有self，并且写在第一个参数位置。
所有类都是继承至基类object。

2）访问类的实例方法或属性
访问对象的属性及方法，需要使用（.）来访问。如果访问类变量，既可以直接使用类名称访问，也可以用类的实例名称访问。
注意：
在实例化类时，不需要再显示写self参数了，会默认带入，表示指向实例本身。

举例：
#coding=utf-8
class Employee(object):#所有员工基类
empCount = 0
def init(self, name, salary) :#类的构造函数
self.name = name
self.salary = salary
Employee.empCount += 1
def displayCount(self) : #类方法
print ("total employee ",Employee.empCount)
def displayEmployee(self) :
print (“name :”,self.name , “, salary :”, self.salary)

emp1 = Employee(“yanjinfeng”,100) #对象实例化；分别对应构造函数中的name和salary两个参数
emp2 = Employee(“vivian”,500) #对象实例化；分别对应构造函数中的name和salary两个参数
emp1.displayEmployee() #访问对象的方法
emp2.displayEmployee() #访问对象的方法
print (“Total Employee %d” % Employee.empCount)

执行结果：
name : yanjinfeng , salary : 100
name : vivian , salary : 500
Total Employee 2

类和对象在内存中是如何保存？
类以及类中的方法在内存中只有一份，而根据类创建的每一个对象都在内存中需要存一份

总结：
函数式的应用场景 --> 各个函数之间是独立且无共用
面向对象编程的应用场景→各个函数公用一组数据

函数式编程 和 面向对象 如何选择？
须知：对于 C# 和 Java 程序员来说不存在这个问题，因为该两门语言只支持面向对象编程（不支持函数式编程）。而对于 Python 和 PHP 等语言却同时支持两种编程方式，且函数式编程能完成的操作，面向对象都可以实现；而面向对象的能完成的操作，函数式编程却不一定能（函数式编程无法实现面向对象的封装功能）。所以，一般在Python开发中，全部使用面向对象 或 面向对象和函数式混合使用

1. 多函数需使用共同的值，如：数据库的增、删、改、查操作都需要连接数据库字符串、主机名、用户名和密码
2. 需要创建多个事物，每个事物属性个数相同，但是值的需求
   如：张三、李四、杨五，他们都有姓名、年龄、血型，但其都是不相同。即：属性个数相同，但值不相同

封装
封装：将内容封装到某个地方，以后再去调用被封装在某处的内容。
在使用面向对象的封装特性时，
1）将内容封装到某处
2）从某处调用被封装的内容

举例：
class Foo: #类名Foo
def init(self,name,age): #构造方法
self.name=name
self.age=age

obj1=Foo(‘yanjinfeng’,‘30’) #根据类Foo创建对象obj1；将yanjinfeng和30分别封装到obj1,self的name和age属性中
obj2=Foo(‘vivian’,‘17’)

**：self 是一个形式参数，当执行 obj1 = Foo(‘yanjinfeng’,‘30’) 时，self 等于 obj1
**：当执行 obj2 = Foo(‘vivian’,‘17’) 时，self 等于 obj2
所以，内容其实被封装到了对象 obj1 和 obj2 中，每个对象中都有 name 和 age属性，在内存里类似于下图来保存。