首页 > 代码库 > 封装、继承、多态

封装、继承、多态

2024-08-11 05:34:32   217人阅读

<style></style>
 
一、对象
  • 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

 

封装、继承、多态


联系
我们