面向对象

什么是面向对象：

#面向对象
class SQLHelper:
    def fetch(self, sq1):
        print(sq1)
        print(self.hhost)                #执行被封装的函数hhost
        print(self.uusername)            #执行被封装的函数uusername
        print(self.pwd)                  #执行被封装的函数pwd
    def create(self, sq1):
        pass
    def remove(self, nid):
        pass
    def modify(self, name):
        pass
obj = SQLHelper()
obj.hhost = ("cl.star.com")             #代表把参数传入 hhost 中封装
obj.uusername = ("Guido")               #代表把参数传入 uusername 中封装
obj.pwd = ("123")                       #代表把参数传入 pwd 中封装
obj.fetch("select*from A")             #执行对象obj的fetch方法，将封装的参数传入self中,(" ")中的参数传入sq1

 

什么时候用面向对象：

      当某一些函数具有相同参数时，可以使用面向对象的方式，将参数的值一次性封装在对象里，以后到对象中直接取值。

 

self是什么：

      self是一个python会自动传值得形式参数，哪个对象执行该方法，self就是那个对象。

obj1.fetch("kdi")     self = obj1
obj2.fetch("kdi")     self = obj2

 

构造方法：

　　类中有一个特殊的方法__init__,类（）时对象被建立 __init__就会自动被执行

　　这个方法可以用来对你的对象做一些你希望的初始化。注意，这个名称的开始和结尾都是双下划线。

class SQLHelper:
    def __init__(self, a1, a2, a3):    #封装数据
        print("自动执行__init__")
        self.hhost = a1                #a1 = slkj.com   self = obj1
        self.uusername = a2            #a2 = Guido  self = obj1
        self.pwd = a3                  #a3 = 123    self = obj1
    def fetch(self, sq1):          #sq1 = select*from A
        pass
    def remove(self, nid):
        pass
    def modify(self, name):
        pass
obj1 = SQLHelper("slkj.com", "Guido", 123)
obj1.fetch("select*from A")

 

类与对象的关系：

两种类型的域——

　　　　　　　　类的变量和对象的变量，它们根据是类还是对象拥有这个变量而区分。

类的变量：由一个类的所有对象（实例）共享使用。只有一个类变量的拷贝，所以当某个对象对类的变量做了改动的时候，这个改动会反映到所有其他的实例上。

对象的变量：由类的每个对象（实例）拥有。因此每个对象有自己对这个域的一份拷贝，即他们不是共享的，在同一个类的不同实例中，虽然对象的变量有相同的名称，但是是互不相关的。

面向对象的三大特性：

封装、继承、多态

　　封装：

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
    def show(self):
        print(self.name)
class c3:
    def __init__(self, a1):
        self.money = 123
        self.aaa = a1
c2_obj = c2("aa", 11)                #c2_obj是c2的类,name="aa",age=11
c1_obj = c1("Guido", c2_obj)         #c1_obj是c1类型,name="Guido",obj=c2_obj
print(c1_obj.obj.age)
c3_obj = c3(c1_obj)                  #c1_obj=a1
print(c3_obj.aaa.name,type(c3_obj.aaa.name))

 

继承：

面向对象编程带来的好处之一就是代码重用，实现这种方法之一是通过继承机制。继承完全可以理解成类之间的类型和子类型关系。

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:Guido's admirers


class We:
    def __init__(self, name):
        self.name = name

    def li(self):
        print("TT", self.name)


class No(We):
    def __init__(self, age, name):
        We.__init__(self, name)
        self.age = age

    def MM(self):
        print("Good", self.name, self.age)

obj = No("guido", 27)
obj.MM()


执行结果：
Good 27 guido

　　

单继承：

相当于把父类写入子类里

class F1:
    def show(self):
        print("show")
    def foo(self):
        print(self.name)
class F2(F1):                     #子类，派生类
    def __init__(self, name):
        self.name = name
    def bar(self):
        print("bar")
    def show(self):
        print("F2.show")
obj = F2("Guido")
obj.show()                       #优先执行本类中的同名方法
obj.foo()

class S1:
    def F1(self):
        self.F2()
    def F2(self):
        pass
class S2(S1):
    def F3(self):
        self.F1()
    def F2(self):
        pass
obj = S2()
obj.F3()
obj1 = S1()
obj1.F1()
#执行过程中子类中没有的方法去父类里找，父类中与子类中同时有的方法，子类中的方法优先执行。

 

多继承：

class c3(c1,c2)

 

 

多态：

多种形态，多种类型

def func(arg):
    print(arg)
func(1)              #对对象进行封装时数据可以是多种类型
func("Guido")
func([11, 22, 33])

 在：c#与java中没有多态，指定形式参数时要指出参数类型，只能通过类的继承增加多态的形式，类与该类的子类。

#此代码只做演示便于理解，不是正确的。
def func(int arg):
    func(123)
    func("Guido")      #报错
    
class A:
    pass
class B(A):
    pass
class C(A):
    pass
def func(A, arg):    #aeg参数：必须是A类型或A的子类型
    print(arg)
obj = A(arg)
func(obj)