封装、继承、多态

 

一、对象

• 1、基本格式

# 定义类

class SQLHelper:

# 定义方法

def fetch(self,host,username,password,sql):    //self参数必须由，由python去自动传值，其他参数接受用户传入的“实际数据”

pass

def create(self,host,username,password,sql):

pass

def remove(self,host,username,password,sql):

pass

def modify(self,host,username,password,sql):    

pass

# 实例化

obj = SQLHelper()

# 方法调用

obj.remove("1.1.1.1","user1","123","select * from db1")               

• 对象指针：
• 实例化对象：实际上是，对象内部的”对象指针“指向了创建该对象的类
• 执行方法   ：实际上是，对象内部的”对象针指“向了类中的方法，并给予执行

• 问题：
• 此时，执行每个方法，都需要传很多参数

• 2、对象的封装（变量赋值）：

# 类定义

class SQLHelper:

def fetch(self,sql):

# 利用 self.hhost ，self.uusername, self.pwd 链接数据库

# 执行sql

pass

def create(self,sql):

# 利用 self.hhost ，self.uusername, self.pwd 链接数据库

# 执行sql

pass   

# 实例化

obj = SQLHelper()

# 封装数据给对象

obj.hhost = "1.1.1.1"

obj.uusername = "user1"

obj.pwd = "123"

# 方法调用

obj.fetch('select * from db1') 

obj.create('create db1') 

• python将obj名称传递给self参数：
• 此时，self表示实例化出的对象，即此时可在方法内部通过self来获取该对象属性的值
• 因此，在方法调用之前，只需要将实例化出的对象封装一遍（通用的变量进行赋值），所有的方法在类内部就可使用self来获取些通用数据

• 问题：
• 不同的对象需要封装不同的数据，因此，若要连接几十个DB，则需要封装几十次初始化数据

• 2.2、构造方法

• __init__() 方法称为构造方法，python在实例化对象时，会自动执行该方法 

# 定义类

class SQLHelper:

# 方法

def __init__(self,args1,args2,args3):

self.hhost = args1

self.uusername = args2

self.pwd = args3

def  fetch(self,sql):

# 连接数据库

# 执行sql语句

pass   

# 实例化

obj1 = SQLHelper('1.1.1.1','user1','redhat')  // 实例化一个对象，并封基础装数据给该对象

obj2 = SQLHelper('2.2.2.2','user1','redhat')

# 调用

obj1.create('create db1')    //直接调用方法

obj2.create('create db1')

• 2.3、对象封装对象：

• 可以封装任意类型数据的，对象中，可以封装多层，相当于嵌套，对象中封装对象

# 定义

class c1:

def __init__(self,name,obj):

self.name = name

self.obj = obj 

class c2:

def  __init__(self,name,age):

self.name = name

self.age = age

# 实例化

c2_obj = c2('bb',11)

c1_obj = c1('aa',c2_obj)   # 将一个对象封装进本对象中

• 解释：
• 
• 此时，c1_obj.obj 代表的是 c2_obj，c1_obj.obj.age 则为11

二、类继承：

• 查找顺序为一条道走到黑再走下一条，若有共同父类，则最后查找共同父类
• 1、单继承

 # 父类、基类

class F1:

def show(self):

print('show')

# 子类、派生类

class F2(F1):       //表示F2继承F1 ，继承F1中方法 相当于在F2中加了一段父类中的代码（就是这样，绕的时候直接代码贴过去看）

def bar(self):

print('bar')

def show(self):

print('show')

# 实例化、调用

obj = F2()

obj.show()

• 优先级：
• 若子类中方法和父类中方法冲突，则子类中优先级较高，即会执行子类中方法
• 即，对于obj的每次方法调用，都应该先从自己的类中找

• 2、多继承

# 父类1

class c1:

def f1(self):

pass

# 父类2

class c2:

def f2(self):

pass

# 子类

class c3(c2,c1):        //继承2个父类，且若父类中有方法冲突（方法名称一样），则写在前面的父类优先级高

def f3(self):

pass

• 优先级

      

# 父类中没有共同祖先

1、在本身类中找

2、在第一个父类中找

3、在父类的父类中递归找

4、若还找不到，则最后找第二个父类

# 父类中有共同祖先：

1、在本身类中找

2、在第一个父类中找

3、在父类的父类中递归找，在共同父类前停止，开始递归第二个父类

4、若还找不到，则最后找第二个父类 

• 注意：
• 通过class定义类，在类中自定义方法，和python内置类 list , str, tuple, dict，是一样样的

class Foo:

                def ...

obj = Foo()   //则类型为Foo类型

三、类多态

• python 本身就支持多态

def function(arg):  

print(arg)

func(1)

func([1,2,3])

传入的参数可以是任意类型，字串、列表等

• 其他语言需要指定变量类型，即参数只能是一种形态

def func(int arg)

• 其他语言若想要多态

# java 要多态

class A:

pass

class B:

pass

class C:

pass

def func(A arg):    //arg类型为A类型或A的子类型，即 多态

pass 

参考：http://www.cnblogs.com/wupeiqi/articles/4493506.html