面向对象基础

1面向对象不是所有情况都适用

2面向对象编程

  a定义类  

      class 类名:

             def  方法1(self,参数)

  b根据类创建对象

       使用对象执行类中方法

3 self，形式参数，python内部传递

      obj=abc()

      obj.abc()===>self:obj

 4 类+括号 =》 自动执行类中的__init__方法，在__init__方法中执行具体封装的操作__init__有一个特殊的名字:构造方法。

   __del__解释器销毁对象时候自动调用，析构方法。

封装：

   使用场景：当同一类型的方法具有相同的参数，直接封装到对象即可

                 把类当做模板，创建多个对象，对象内封装的数据不一样

5派生类可以继承基类中所有的功能

6派生类和基类同时存在，优先找派生类

7多继承的时查找方法，先自己然后左面优先class aaa(a,b),先找自己，然后a，然后b

 继承：

   多继承

8多态

  多种形态

  python本身支持多态

 扩展：

   重载，函数名相同，参数个数不同.(python不支持)

   重写，派生类中重新实现基类的方法(还有点关系)

先来简单的类

class test:

    def abc(self,num):
        print(num)

    def abc2(self):
        print("abc2")

obj=test()
obj.abc(10)

对象和类的区别：

根据上面图来用代码进一步理解：

class test:

    def abc(self):
        print(self)

obj1=test()
print(obj1)
obj1.abc()


obj2=test()
print(obj2)
obj2.abc()


结果：

<index.test instance at 0x0000000002CB5408>
<index.test instance at 0x0000000002CB5408>

<index.test instance at 0x0000000002C5C6C8>
<index.test instance at 0x0000000002C5C6C8>

这里可以看出self是什么东西了吧就是创建实例的obj，在执行类中的方法就是obj地址.xxx  

封装

先来个简单的封装

class test:

    def abc(self):
        print(self.pk) #打印pk变量

obj1=test()
obj1.pk=123  #在对象中封装数据，但是这个不是非主流的封装方式。只是实验
print(obj1.pk)

obj2=test()
obj2.pk="abc"  
obj2.abc()     #执行abc方法，这个方法和obj1执行方式不一样.但是意思都是一样的。这样就是封装将某个变量封装在对象中以后有需要就拿就可以了

结果：
123
abc

__init__()构造方法：一般这样封装

class test:
    def __init__(self,pk):
        self.pk=pk
    def abc(self):
        print(self.pk)

obj1=test(11) #初始化实例的时候必须先执行__init__方法
print(obj1.pk)

obj2=test("abc")
obj2.abc()

执行父类的构造方法 

#-*- coding:utf-8 -*-
class base(object):
    def __init__(self):
        print("base")
        self.age=19

class s1(base):
    def __init__(self):
        print("s1")
        self.name="zhangsan"
        #执行父类构造方法1.super方法就是找父类的方法，s1就是告诉super找s1的父类，self就是zhhangsan的实例。找到父类__init__方法并执行,super
        #会自动给我们传递参数给__init__()函数，这里不用奇怪
        super(s1,self).__init__()
        #第二种方法知道就好，不推荐使用.主要在于如果是多继承super会按照object类的方式查找。而这个需要自己写。主要多继承需要写很多
        #base.__init__(self)


zhangsan=s1()
print(zhangsan.name)
print(zhangsan.age)

继承

class base:
    def chi(self):
        print("chi")

    def he(self):
        print("he")

class Cat(base):
    def __init__(self,name):
          self.name=name
    def jiao(self):
        print("miao  ")

class Dog(base):
    def __init__(self,name):
          self.name=name
    def jiao(self):
        print("wang  ")

h1=Dog("zs")
h1.chi()
h1.jiao()


结果：
chi
wang  
chi
miao  

class base:
    def chi(self):
        print("chi")

    def he(self):
        print("he")

class base1:
    def chi(self):
        print("base1 chi")

    def he(self):
        print("base1 he")

class Cat(base):
    def __init__(self,name):
          self.name=name
    def jiao(self):
        print("miao  ")

#多继承在查找方法的时候左面优先，base先找然后在找base1
class Dog(base,base1):
    def __init__(self,name):
          self.name=name
    def jiao(self):
        print("wang  ")

h1=Dog("zs")
h1.chi()
h1.jiao()

h1=Cat("zs")
h1.chi()
h1.jiao()


结果：
chi
wang  
chi
miao 

第一种查找

第二种查找

PY3中顺序D-->B--->E-->C--->A

py2中有二种,带object跟py3一样,不带D-->B--->A -->E-->C

#python2中如果不加object查找方式就是左面全部找完在找右面。
#加上的话d--->b--->e--->c--->a  最后找共同的父类
#在python3中就只有第二种方式，py2中尽量都是使用带object的
class A(object):   
    def f1(self):
        print("A")

class B(A):
    def f1(self):
        print("B")

class C(A):
    def f1(self):
        print("C")

class D(B):
    def f1(self):
        print("D")
class E(A):
    def f1(self):
        print("E")
class F(D,E):
    pass
F1=F()
F1.f1()

 扩展：

class A(object):
    def aa(self):
        print("A")

class B(A):
    def f1(self):
        print("B")
        self.aa()

class C():
    def aa(self):
        print("C")


class F(C,B):
    pass

F1=F()
F1.f1()

#这里只要记住不管方法中的方法再去调什么方法都的开之前
这个方法是谁执行的。这里是F1那么不管如何调用都是以F1为准
结果：
B
C