面向对象(初级篇)

Posted 2021-01-02 kend

一. 面向对象代码如何编写
面向对象编程需要使用"类"和"对象"来实现, 面向对象编程就是对"类"和"对象"的使用
类: 就是一个模板,模板里可以包含多个函数, 函数实现一些功能
对象: 就是根据模板创建的实例, 通过实例对象可以执行类中的函数


class Foo:   # 创建类
    def Bar(self):  #创建类中的函数, 在类中定义的函数叫方法
        pass
obj = Foo()  #根据类创建对象obj
创建对象就是在类Foo() 的后面加括号即可


class Foo:
    def bar(self):
        print("bar")

    def hello(self,name):
        print("i am %s" % name)

根据类Foo 创建对象obj
obj = Foo()     # 创建对象
obj.bar()      # 通过对象调用方法bar
obj.hello("alex") # 通过对象调用方法hello

总结
面向对象: 创建对象 ---> 通过对象执行方法



二. 面向对象三个特征:封装, 继承,  多态(了解)
1. 封装:
    将内容封装在某处
    从某处调用被封装的内容

先封装:
class Foo:

    def __init__(self,name,age):  #构造方法
        self.name = name
        self.age = age

根据Foo创建对象
自动执行Foo 类的__init__方法
obj1 = Foo("张三",20)   # 将 "张三" 和 "20" 分别封装在 obj1 和 self 的name 和 age 属性中
obj2 = Foo("李四",22)   # 将 "李四" 和 "22" 分别封装在 obj1 和 self 的name 和 age 属性中

self是一个形式参数, 当执行 obj1 = Foo("张三",20)的时候, self = obj1
                    当执行 obj2 = Foo("李四",22)的时候, self = obj2
所以内容其实被封装在了对象 obj1 和obj2 里面了, 每个对象里面都有 name 和age属性


再调用:
被调用有两种情况:
    通过对象直接调用
    通过self 间接调用

直接调用:
class Foo:

    def __init__(self,name,age):
        self.name = name
        self.age = age

obj = Foo("alex",22)
print(obj.name)
print(obj.age)

通过self 间接调用被封装的内容:
class Foo:

    def __init__(self,name,age):
        self.name = name
        self,age = age

    def detail(self):
        print(self.name)
        print(self.age)

obj = Foo("alex", 22)
obj.detail()# Python默认会将obj1传给self参数，即：obj1.detail(obj1)，
所以，此时方法内部的 self ＝ obj，即：self.name 是 alex ；self.age 是22

总结:面向对象的封装就是使用构造方法(__init__方法)将内容封装到对象中,
然后通过对象直接或者 self间接获取被封装的内容

2. 继承
########################1. 基本使用 ###########################

##### 基本写法
"""
class SuperBase:
    def f3(self):
        print(‘f3‘)

class Base(SuperBase):  # 父类,基类
    def f2(self):
        print(‘f2‘)

class Foo(Base):        # 子类,派生类

    def f1(self):
        print(‘f1‘)

obj = Foo()
obj.f1()
obj.f2()
obj.f3()
# 原则:现在自己类中找,么有就去父类
"""

分别为猫和狗创建一个类
class 猫：

    def 喵喵叫(self):
        print ‘喵喵叫‘

    def 吃(self):
        # do something

    def 喝(self):
        # do something

    def 拉(self):
        # do something

    def 撒(self):
        # do something

class 狗：

    def 汪汪叫(self):
        print ‘喵喵叫‘

    def 吃(self):
        # do something

    def 喝(self):
        # do something

    def 拉(self):
        # do something

    def 撒(self):
        # do something
吃、喝、拉、撒是猫和狗都具有的功能，而我们却分别的猫和狗的类中编写了两次
如果使用继承 可以如下
class 动物:

    def 吃(self):
      # do something

    def 喝(self):
      # do something

    def 拉(self):
      # do something

    def 撒(self):
      # do something

# 在类后面括号中写入另外一个类名，表示当前类继承另外一个类
class 猫(动物)：

    def 喵喵叫(self):
        print(‘喵喵叫‘)

# 在类后面括号中写入另外一个类名，表示当前类继承另外一个类
class 狗(动物)：

    def 汪汪叫(self):
        print(‘wangwang叫‘)

总结: 对于面向对象的继承而言,就是将多个类共有的方法提取到父类中, 子类仅需继承父类的就行

class Parents: #父类
    def func(self): #父类的方法
        pass

class children: #子类  子类继承父类,有父类中的所有方法
    pass

zi = children() #创建子类对象
zi.func() #调用父类中的方法


#练习
"""
class Base:
    def f1(self):
        print(‘base.f1‘)

    def f3(self):
        self.f1() # obj是那一个类(Foo),那么执行方法时,就从该类开始找.
        print(‘base.f3‘)

class Foo(Base):
    def f1(self):
        print(‘foo.f1‘)

    def f2(self):
        print(‘foo.f2‘)
        self.f3()  # obj是那一个类(Foo),那么执行方法时,就从该类开始找.


obj = Foo()
obj.f2()  # obj是那一个类(Foo),那么执行方法时,就从该类开始找.
# foo.f2
# foo.f1
# base.f3

obj2 = Base()
obj2.f3()
# base.f1
# base.f3
"""
# 总结: self是哪个类的对象,那么就从该类开始找(自己没有就找父类)


如果是多继承呢? (先继承左边的,再继承右边的)
########################2. 多继承 ###########################
"""
class Base1:
    def show(self):
        print(‘Base1.show‘)

class Base2:
    def show(self):
        print(‘Base2.show‘)

class Foo(Base1,Base2):
    pass

obj = Foo()
obj.show()
"""
# 左边更亲

class Base1:
    def f1(self):
        print(‘base1.1‘)
    def f2(self):
        print(‘base1.f2‘)

class Base2:
    def f1(self):
        print(‘base2.f1‘)

    def f2(self):
        print(‘base2.f2‘)

    def f3(self):
        print(‘base2.f3‘)
        self.f1()

class Foo(Base1,Base2):

    def f0(self):
        print(‘foo.f0‘)
        self.f3()
# 1. 多继承先找左边
# 2. self到底是谁,self是那个类的对象,那么就从该类开始找(自己没有就找父类)
obj = Foo()
obj.f0()
#结果
# foo.f0
# base2.f3
# base1.1



class Base:
    def f1(self):
        print(‘base.f1‘)

class Foo(Base):
    def f3(self):
        print(‘foo.f3‘)

    def f2(self):
        print(‘foo.f2‘)
        self.f3() # obj是那一个类(Foo),那么执行方法时,就从该类开始找.

obj = Foo()
obj.f2() # obj是那一个类(Foo),那么执行方法时,就从该类开始找.
#结果
# foo.f2
# foo.f3


3. 多态: 指的是一种事物有多重形态
动物有多种形态: 人, 狗, 猫
import abc
class Animal(metaclass=abc.ABCMeta): #同一类事物:动物
    @abc.abstractmethod
    def talk(self):
        pass

class People(Animal): #动物的形态之一:人
    def talk(self):
        print(‘say hello‘)

class Dog(Animal): #动物的形态之二:狗
    def talk(self):
        print(‘say wangwang‘)

class Pig(Animal): #动物的形态之三:猫
    def talk(self):
        print(‘say miaomiao‘)