python面向对象编程

面向对象编程

面向对象 oop:object oriented programming

面向对象的基本概念

我们之前学习的编程方式就是面向过程的

面向过程和面向对象，是两种不同的编程方式

对比面向过程的特点，可以更好的了解什么是面向对象

 

过程和函数(都是对一段功能的代码进行封装)

过程：是早期的一个编程概念

过程类似于函数，只能执行，但是没有返回值

函数：不仅能执行，还可以返回结果(return)

===================================================================

面向过程 和 面向对象 的基本概念

 

面向过程：---侧重于怎么做？

1.把完成某一个需求的 所有步骤 从头到尾 逐步实现

2.根据开发要求，将某些功能独立的代码封装成一个又一个函数

3.最后完成的代码，就是顺序的调用不同的函数

特点：

1.注重步骤与过程，不注重职责分工

2.如果需求复杂，代码会变得很复杂

3.开发复杂项目，没有固定的套路，开发难度很大

 

面向对象：--谁来做?

相比较函数，面向对象是更大的封装，根据职责在一个对象中封装多个方法

1.在完成某一个需求前，首先确定职责--要做的事(方法)

2.根据职责确定不同的对象，在对象内部封装不同的方法(多个)

3.最后完成代码，就是顺序的让不同的对象调用不同的方法

特点：

1.注重对象和职责，不同的对象承担不同的职责

2.更加适合对复杂的需求变化，是专门应对复杂项目的开发，提供的固定套路

3.需要在面向过程的基础上，再学习一些面向对象的语法

 

举例子：植物大战僵尸。。。。（我们可以看到，使用面向对象编程，这样做大大减轻了主程序的职责 ）

向日葵         豌豆射手     僵尸

生命值        生命值     生命值

生产阳光()     发射子弹()   移动()

摇晃()     咬()

 

 

================================================================

面向对象的两个核心概念

类和对象

目标

类和对象的概念

类和对象的关系

类的设计

 

类和对象的概念

类和对象是面向对象编程的两个核心概念

类：是对一群具有相同特征或行为的事物的一个统称，是抽象的，不能直接使用(就好比，飞机图纸不能直接飞上天)

特征:被称为属性

行为:被称为方法

类 就相当于制造飞机时的图纸，是一个模板，是负责创建对象的

 

对象：是由类创建出来的一个具体的存在，可以直接使用(图纸创造出来的飞机，可以飞上天)

由哪一个类创建出来的对象，就拥有哪一个类种法定义的属性和方法

“对象就相当于用图纸创造出来的飞机”

#在程序开发中，应该先有类，再有对象

 

类和对象的关系

类是模板，对象是根据类这个模板创建出来的，应该先有类，再有对象

类只需要有一个 而对象可以有很多个（一张图纸可以造出很多架飞机）

不同对象之前属性可以不相同(比如飞机的颜色 等等。。)

类中定义了什么属性和方法，使用这个类创建出来的对象中就有什么属性和方法，不可能多也不可能少

"""

"""

1.类名：满足这类事物的名字(大驼峰命名法)

        大驼峰命名法：

        1.每个单词的首字母大写

        2.单词与单词之间没有下划线

2.属性:这个类创建出来的对象有什么样的特征

3.方法：这个类创建出来的对象有什么样的行为

类名的确定：

名词提炼法:分析整个业务流程，出现的名词，通常就是找到的类名

“””

 

 

 

面向对象的基本语法：

定义一个只包含方法的类

class 类名：

    def 方法1(self,参数列表):

        pass

    def 方法2(self,参数列表):

        pass

方法的定义格式和之前学的函数几乎一样

区别在于第一个参数必须是self

 

 

创建对象

当一个类定义完成之后，要使用这个类来创建对象

对象变量 = 类名()

 

 

 

 

 在面向对象开发中，引用的概念是同样适用的

tom = Cat():在等号右侧我们使用cat类创建了一个猫对象，在等号左侧使用tom这个变量接收了这个猫对象

python解释器在执行到此句代码的时候，在内存中为这个猫对象分配了一个内存空间，然后再让tom这个变量记录了猫对象在内存中的地址

在python中使用类创建对象之后，tom变量中仍然记录的是对象在内存中的地址

也就是tom变量引用了新建的猫对象

使用print输出对象变量，默认情况下，是能够输出这个变量引用的对象是由哪一个类创建的象，以及在内存中的地址(十六进制表示)

提示：在计算机中，通常使用十六进制表示内存地址

 

 

 

 

self的内存地址和tom/lazy_cat这个对象的内存地址是一样

哪一个对象调用的方法，self就是哪一个对象的引用

 

self:

在调用方法的时候，程序员不需要传递self参数(但是定义的时候，第一个参数必须是self)

在方法内部：可以通过self.访问对象的属性

 

 

 

 

在日常开发中，不推荐在类的外部给对象增加属性

如果在运行的时候，没有找到属性，程序就报错

对象应该包含有哪些属性，应该封装在类的内部

 

 

 

 

 

 

初始化方法：

类名() 就可以创建一个对象

当使用类名()创建对象的时候，python解释器会自动执行以下操作

    1.为对象在内存中分配空间 ---创建对象

2.调用初始化方法

 

 

 

改造初始化方法--初始化的同时设置初始值：

在开发中，如果希望在创建对象的同时，就设置对象的属性，可以对__init__方法进行改造

1.把希望设置的属性值，定义成__init__方法的参数

2.在方法内部使用self.属性名 = 形参 接收外部传递的参数

3.在创建对象时，使用类名(属性1，属性2..)调用

 

__del__方法：对象被从内存中销毁前，会被自动调用

__str__方法：返回对象的描述信息，print函数输出使用

 

__del__方法：

在python中

当使用类名()创建对象时，为对象分配完空间后，自动调用__init__方法

当一个对象被从内存中销毁前(把这个对象从内存中删除掉)，会自动调用__del__方法

应用场景

__init__改造初始化方法，可以让创建对象更加灵活

__del__如果希望在对象被销毁前，再做一些事情，可以考虑一下__del__方法

 

 

生命周期(出生到死亡)

一个对象从调用类名()创建，生命周期开始

一个对象的__del__方法一但被调用，生命周期结束

在对象的生命周期内，可以访问对象属性，或者让对象调用方法

 

__str__方法：

在python中，使用python输出对象变量，默认情况下，会输出这个变量引用的对象是由哪>一个类创建的对象，

以及在内存中的地址(十六进制表示)

如果在开发中，希望使用print输出对象变量时，能够打印自定义的内容，就可以利用__str__这个内置方法了

"""

 

 

 

私有属性和私有方法

应用场景

在实际开发中，对象的某些属性或方法可能只希望在对象的内部使用，而不希望在外部被访问到

私有属性 就是 对象 不希望公开的 属性

私有方法 就是 对象 不希望公开的 方法

 

 

 

封装：根据职责将属性和方法封装到一个抽象的类中

 

 

封装

1.封装是面向对象编程的一大特点

2.面向对象编程的第一步，将属性和方法封装到一个抽象的类中(为什么类是抽象的？)

3.外界使用类创建对象，然后让对象调用方法

4.对象方法的细节都被封装在类的内部

 

 

 

 

继承：实现代码的重用，相同的代码不需要重复的写

 

单继承

1.继承的概念：子类拥有父类的所有属性和方法(子类只需要封装自己特有的方法)

2.语法

class 类名(父类):

def 子类特有的方法

 

 

继承的传递性(爷爷 爸爸 儿子)

    1.C 类从B类继承 ，B类又从A类继承

2.那么C类就具有B类和A类的所有属性和方法

 

 

方法的重写

1. 覆盖父类的方法(重写父类方法)

如果子类中重写了父类的方法,在运行中,只会调用在子类中重写的方法而不会调用父类中的方法

2.对父类方法进行扩展

(1)针对子类特有的需求,编写代码

(2)调用原本父类中封装的方法

(3)增加其他子类代码

 

 

多继承

    子类拥有一个父类叫作单继承

    子类可以拥有多个父类，并且具有所有父类的属性和方法

例如:孩子会继承自己父亲和母亲的特征

 

多继承可以让子类对象,同时继承多个父类的属性和方法

 

 

 

 

新式类和旧式类:新式类和旧式(经典)类：

object是Python为所有对象提供的基类，提供有一些内置的属性和方法，可以使用dir函数查看

新式类：以object为基类的类，推荐使用

经典类：不以object为基类的类，不推荐使用

在python3.X中定义的类时，如果没有指定父类，会默认使用object作为基类--python3.x中定义的类都是新式类

在python2.x中定义类时，如果没有指定父类，则不会以object作为基类

####推荐使用新式类#############

 

新式类和旧式类在多继承时---会影响到方法的搜索顺序

 

为保证编写的代码能够同时在python2.x和python3.x运行

今后在定义类时，如果没有父类，建议统一继承自object

 

 

 

Python 早期,它对于class的定义在很多方面都是严重有问题的。当他们承认这一点的时候已经太迟了,

所以逼不得已,他们需要支持这种有问题的class 。

为了解决已有的问题,他们需要引入一种“新类”,这样的话“旧类”还能继续使用,而你也有一个新的正确的类可以使用了。

这就用到了“类即是对象”的概念。他们决定用小写的“object”这个词作为一个类,让你在创建新类时从它继承下来。

 

 

 

 

私有属性和私有方法

 

 

 

class A(object):

    def __init__(self):

        self.num1 = 100

        # 定义私有属性

        self.__num2 = 200

    def __text(self):

        print '私有方法 %d %d' %(self.num1,self.__num2)

    def test(self):

        print '父类的私有方法 %d' %self.__num2

        self.__text()

 

class B(A):

    def demo(self):

        # 在子类的对象方法中，不能访问父类的私有属性

        #print '访问父类的私有属性 %d' %self.__num2

        # 在子类的对象方法中，不能调用父类的私有方法

        #self.__test()

        print '子类方法 %d' %self.num1

        self.test()

# 创建一个子类对象

b = B()

print b

# 在子类方法的内部能访问父类的公有属性和调用父类的公有方法

b.demo()

# 在外界访问父类的公有属性和调用公有方法

print b.num1

# 在外界不能直接访问对象的私有属性/调用私有方法

# print b.__num2

# b.__test()