面向对象编程的基本规则 python例子

一、面对过程和面向对象的比较

 

面向过程

优点：性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗资源;比如单片机、嵌入式开发、 Linux/Unix等一般采用面向过程开发，性能是最重要的因素

个人理解：其实就是函数式编程，最简单粗暴地决定问题

缺点：没有面向对象易维护、易复用、易扩展

 

面向对象

优点：易维护、易复用、易扩展。由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统 更加灵活、更加易于维护

个人理解：就是要解决问题同时多些思考，把某个功能抽象出来成对象，设计以后更加容易拓展和复用的程序

缺点：性能比面向过程低

 

例子：

老板给个需求：实现中秋节所有商品打六折功能

# 面向过程 如果以后需求不会怎么改动 这样做是正确的
def get_discount_price(price):
    return price * 0.6

# 面向对象 考虑拓展性 知道以后需求会拓展（增加其他节日、中秋节规则改变等）
class Festival(object):
    def get_discount_price(price):
        return price

class MidAutumn(Festival):
    def get_discount_price(price):
        return price * 0.6

 

去权衡设计是否会拓展很重要

 

二、两个标准：低耦合和高内聚

就是指模块之间低耦合、模块内部高内聚，以追求软件系统的可重用和易维护。一个完整的系统，模块与模块之间，尽可能的使其独立存在。也就是说，让每个模块，尽可能的独立完成某个特定的子功能。模块与模块之间的接口，尽量的少而简单。如果某两个模块间的关系比较复杂的话，最好首先考虑进一步的模块划分。实际上这两个规则可能会处于冲突情况，这就要结合实际情况去考虑了。

低耦合：模块之间的联系越少越好，依赖越少越好

高内聚：指模块的功能越集中越好，类似于单一功能原则

 

 

三、三大基本特征

1、封装

隐藏细节、提供接口

# 封装
class Dog(object):
    def __init__(self, name):
        self.name = name
        self.age = 0

    def set_age(self, age):
        self.age = 3

dog = Dog('boby')
dog.age = 2  # 不合理的赋值
dog.set_age(2)  # 封装，隐藏self.age成员变量细节

 

2、继承

是指在已存在的类的基础上扩展产生新的类。

子类继承了父类，它拥有父类的所有特性，是实现代码重用、扩展软件功能的重要手段。

 

# 继承
class Person(object):
    def __init__(self, name):
        self.name = name

class Student(Person):  # Student类继承Person类
    def set_school(self, school):
        self.school = school

 

3、多态  

基本含义是“拥有多种形态”，具体指在程序中用相同的名称来表示不同的含义。

例如：用同一方法名来表示不同的操作。

条件①必须要有继承的情况存在；
条件②在继承中必须要有方法覆盖（重写）；
条件③必须由父类的引用指向派生类的实例，并且通过父类的引用调用被覆盖的方法；

# 多态
class Animal(object):
    def __init__(self, name):
        self.name = name

    def roar(self):
        print 'animal~'

class Dog(Animal):
    def roar(self):  # 方法重写 多态
        print 'woof'

class Cat(Animal):
    def roar(self):  # 方法重写 多态
        print 'miaow'

注: python是弱类型，没有重载说法

 

能够根据子类对象的不同，得到不同的结果，这就是多态性。

 

 

重载和重写

 

 

 

四、四种关系：依赖、关联、聚合和组合关系

 

1、聚会和组合是关联关系的一种
2、这几种关系的耦合度从小到大  依赖 < 关联 < 聚合 < 组合

# 一个简单的宠物类
class Cat(object):
	def __init__(self, name):
		self.name = name
		self.master = None

	@classmethod
	def speak(self):
		print 'meow'

依赖关系

# 依赖 局域变量、方法的形参、静态方法的调用
class Person(object):
	def __init__(self, name):
		self.name = name

	def play_pet(self):
		pet = Cat('kitt')  # 局域变量调用
		pet.speak()

	def touch_pet(self):
		Cat.speak()  # 静态方法调用

	def talk_pet(self, pet):
		pet.speak()  # 方法的形参

关联关系

# 关联 一般做成员变量来实现有，单向\双向关联 耦合度：单向 < 双向
class Person(object):
	def __init__(self, name):
		self.name = name
		self.pet = Cat('kitt')  # 成员变量单项关联
		self.pet.master = self  # 双向关联

聚合关系

# 聚合 关联关系的一种 整体与部分的关系，他们之间存在着包容关系，整体和部分，可以分离
class Person(Person):
	def __init__(self, name):
		self.name = name
		self.pet = Cat('kitt')  # 包含的关系 人和宠物可以分离

组合关系

class Head(object):
	def comments(self):
		print 'it is a head'

# 组合也是整体与部分的关系，但是整体与部分不可以分开，他们之间是共生共死的
class Person(object):  # 整体（多对一）
	def __init__(self, name):
		self.name = name
		self.head = Head()  # 组合关系 人和头不可以分离

 

 

五、五大设计原则

1、单一职责原则 Single Duty

核心思想：一个类应该只有一个引起它变化的原因。

 

2、开放封闭原则Open Closed Principle

核心思想：对扩展开放,对修改封闭。

 

3、里氏替换原则 Liskov Subsitution Principle

核心思想：子类必须能够替换掉它们的父类型。

 

4、接口隔离原则 InterFace Segregation Principle

核心思想:使用多个小的专门的接口,而不要使用一个大的总接口.

 

5、依赖倒置原则 Dependency Inversion Principle

核心思想: 高层模块不应该依赖底层模块，两者都应该依赖抽象。抽象不应该依赖细节，细节应该依赖抽象。

 

未完待续