Python高级学习第一课——面向对象（一）

1、面向对象（OOP）概述

当解决一个问题的时候，面向对象会把事物抽象成对象的概念，就是说这个问题里面有哪些对象，然后给对象赋一些属性和方法，然后让每个对象去执行自己的方法，问题得到解决。

例如：洗衣机里面放有脏衣服，怎么洗干净？

面向过程的解决方法：

1、执行加洗衣粉方法；

2、执行加水方法；

3、执行洗衣服方法；

4、执行清洗方法；

5、 执行烘干方法；

以上就是将解决这个问题的过程拆成一个个方法（是没有对象去调用的），通过一个个方法的执行来解决问题。

面向对象的解决方法：

1、我先弄出两个对象：“洗衣机”对象和“人”对象

2、针对对象“洗衣机”加入一些属性和方法：“洗衣服方法”“清洗方法”、“烘干方法”

3、针对对象“人”加入属性和方法：“加洗衣粉方法”、“加水方法”

4、然后执行

人.加洗衣粉

人.加水

洗衣机.洗衣服

洗衣机.清洗

洗衣机.烘干

解决同一个问题 ，面向对象编程就是先抽象出对象，然后用对象执行方法的方式解决问题。

面向过程是具体化的，流程化的，解决一个问题，你需要一步一步的分析，一步一步的实现。

面向对象是模型化的，你只需抽象出一个类，这是一个封闭的盒子，在这里你拥有数据也拥有解决问题的方法。需要什么功能直接使用就可以了，不必去一步一步的实现，至于这个功能是如何实现的，管我们什么事？我们会用就可以了。

2、面向对象的三大特性

2.1、封装

• 类：用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。（语法格式如下，其中class是特有写法，用来声明类的，People为类名）

class People(object):
    print("hhhh")
    

• 属性：属性分为私有属性和基本属性，基本属性在类的外部可以进行调用，而私有属性在类外部无法直接进行访问。

class People(object):
#定义基本属性
    name="hh"
#定义私有属性
    _Id="ghhhh"

• 方法：在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self, 且为第一个参数，self 代表的是类的实例。

class People(object):
    # 定义基本属性
    name = ''
    age = 0
    # 定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0

    # 定义构造方法
    def __init__(self, n, a, w):
        self.name = n
        self.age = a
        self.__weight = w
        
    def func(self):
        print("hhjjj")

• 构造方法：构造方法__init__() 是类的特殊方法，可以携带参数，类的实例化操作会自动调用 __init__() 方法。

class Complex:
    def __init__(self, realpart, imagpart):
        self.r = realpart
        self.i = imagpart
x = Complex(3.0, -4.5)
print(x.r, x.i)   # 输出结果：3.0 -4.5

2.2、继承

继承某个类就可以调用这个类的方法和属性，语法如下：

#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))
 
#单继承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))
 
 
 
s = student('ken',10,60,3)
s.speak()

继承分为单继承和多继承

• 单继承：只有一个父类的子类。

class Person(object):   # 定义一个父类
 
    def talk(self):    # 父类中的方法
        print("person is talking....")  
 
 
class Chinese(Person):    # 定义一个子类， 继承Person类
 
    def walk(self):      # 在子类中定义其自身的方法
        print('is walking...')
 
c = Chinese()
c.talk()      # 调用继承的Person类的方法
c.walk()     # 调用本身的方法
 
# 输出
 
person is talking....
is walking...

注意：创建子类的实例时，Python首先需要完成的任务是给父类的所有属性赋值。为此，子类的方法__init__()需要父类施以援手。

class Rectangle(object):
    def __init__(self, width, length):  # 实例化传参时   将初始化参数
        self.width = width
        self.length = length
 
    def get_area(self):
        return self.width * self.length
 
 
class Square(Rectangle):
    def __init__(self, width, length):
        if width == length:
            Rectangle.__init__(self, width, length)  # 此处调用了父类方法，这里的self是正方形的实例，不是矩形的实例
        else:
            print('长度和宽度不相等，不能成为正方形')
 
 
square = Square(25, 25)
square.get_area()
square1 = Square(25, 22)

• 多继承：

  • 一个子类可以继承多个父类是多继承

  • 一层层继承下去是多重继承

class Base(object):
    def play(self):
        print('Base is playing!')
 
        
class A(Base):  # 继承Base
    name=""
    def __init__(self,name):#带参数的构造函数
        self.name=name
    def play(self):  # 自动覆盖父类的此方法
        print('A is playing')
 
        
class B(Base):  # 继承Base
    money=""
    def __init__(self,money):#带参数的构造函数
        self.money=money
    def play(self):
        print('B is playing')
 
        
class C(A, B):  # 继承A,B 
#当带有参数时，写法如下：
      def __init__(self,name,money):#带参数的构造函数
        A.__init__(self,name)
        B.__init__(self,money)
 
c = C()
c.play()

注意：父类中方法名相同，默认调用的是在括号中靠前面的父类的方法

• 方法重写：当子类继承父类之后，如果子类不想使用父类的方法，可以通过重写来覆盖父类的方法。为此，可在子类中定义一个这样的方法，即它与要重写的父类方法同名。这样，Python将不会考虑这个父类方法，而只关注你在子类中定义的相应方法。

class Parent:  # 定义父类
    def myMethod(self):
        print('调用父类方法')
 
 
class Child(Parent):  # 定义子类
    def myMethod(self):            #重写父类方法
        print('调用子类方法')
 
 
c = Child()  # 子类实例
c.myMethod()  # 子类调用重写方法

当子类重写父类方法之后，子类如果想再次调用父类的方法，可以使用这两种方法

#方法一
class C(A, B):  # 继承A,B
    def play(self):  #覆盖父类
        B.play(self)  # 指定继承B类内的play方法
#方法二
class C(A, B):
 
    def play(self):
 
        super().play()
        print('这是C')

• super()用法：super 函数可以调用父类的方法，在父类中也使用super函数之后，可以通过调用类的mro方法属性来查看继承关系

class Base(object):
    def play(self):
        print('Base is playing!')
 
        
class A(Base):  # 继承Base
    def play(self):  # 自动覆盖父类的此方法
        super().play()  # 调用父类方法
        print('A is playing!')
 
a = A()
a.play()
print(A.mro())#查看继承关系
#打印结果为：
Base is playing!
A is playing!
[<class '__main__.A'>, <class '__main__.Base'>, <class 'object'>]

2.3、多态

让具有不同功能的函数可以使用相同的函数名，这样就可以用一个函数名调用不同内容(功能)的函数，且不会影响到类的内部设计。例如：

#例1：
class Duck(object):                                  # 鸭子类
    def fly(self):
        print("鸭子沿着地面飞起来了")

class Swan(object):                                  # 天鹅类
    def fly(self):
        print("天鹅在空中翱翔")

class Plane(object):                                 # 飞机类
    def fly(self):
        print("飞机隆隆地起飞了")

def fly(obj):                                        # 实现飞的功能函数
    obj.fly()

duck = Duck()
fly(duck)

swan = Swan()
fly(swan)

plane = Plane()
fly(plane)

===运行结果：===================================================================================
鸭子沿着地面飞起来了
天鹅在空中翱翔
飞机隆隆地起飞了
#例2：
class bus1(truck):                   #继承truck
    name=""

    def __init__(self,name):#带参数的构造函数
        self.name=name
    def func(self):
        print(self.name + "是客车，汽车的重量是:" + self.heave + "，种类是:" + self.category)

class bus2(truck):                   #继承truck
    name=""

    def __init__(self,name):#带参数的构造函数
        self.name=name
    def func(self):
        print(self.name + "是客车，汽车的重量是:" + self.heave + "，种类是:" + self.category)

class bus3(truck):                   #继承truck
    name=""

    def __init__(self,name):#带参数的构造函数
        self.name=name
    def func(self):
        print(self.name + "是客车，汽车的重量是:" + self.heave + "，种类是:" + self.category)


def fp(obj):            #定义打印方法
    obj.func()
b=car.bus1("东风路28路公交车")#实例化对象1
b2=car.bus1("东风路906路公交车")#实例化对象2
b3=car.bus1("东风路B32路公交车")#实例化对象3

x=[b,b2,b3]#将对象存入列表中

#循环输出
for i in range(3):
    fp(x[i])
    print(x[i].truck_conduct())
    print("________________")