面向对象（类、对象，继承、封装、多态）

面向对象

类和对象是面向对象的两大核心

类

定义

类是对一群具有相同特征和行为的事物的统称，是抽象的

特征被称为属性，行为被称为方法

语法

类型要符合大驼峰命名
class 类名(object):
    def 方法名(self,参数)：
    	代码块
    def 方法名(self,参数)：
       代码块

对象

定义

对象是由类创建的具体存在，在程序中现有类才有对象

比如制作飞机，要先有图纸再有飞机这个实体

语法

创建对象的语法
对象名 = 类名()

代码

class animals:
    color = "yellow"
    def sellp(self):
        print("睡觉")
    def eat(self,food):
        print("吃"+food)


dog = animals()
print(dog.color)
dog.eat("骨头") 

补充

1.类需不需要参数，比如类名（object）

可以写也可以不写，python3.x中的所有类都继承了object，即使你不写也会默认继承object

2.方法为什么要用self

self是类的实例，并不是一个类

self和java中的this一样，你可以使用this，但是在python中约定俗成的就是self

class animals(object):
    color = "yellow"
    def duixiang(self):
        print(self)
    def sellp(self):
        print("睡觉")
    def eat(self,food):
        print("吃"+food)

class dog(animals):
    def duixiang(self):
        print(self)

"""
self是类的对象，是本类的对象，即使是继承关系，他也是子类的对象，并不是父类的对象
"""

d = dog()
d.duixiang()
an = animals()
an.duixiang()

自定义类

#pass是空语句，不做任何事情，只是为了保持结构的完整性
#初始化就相当于我们的构造函数，给参数一个默认值，或者是定义某些参数

        

class animals():
    def __init__(self,name,color="白色",age=5):
        self.name = name
        self.color = color
        self.age = age
    def eat(self,food):
        print("爱吃"+food)
    def jiao(self,jiaosheng):
        print(jiaosheng)
        print(self)
dog = animals("小白")
dog.eat("骨头")   

例子

"""
定义一个人类，
初始化以下属性  名字，性别默认男，年龄默认18
方法：睡觉，吃饭，任务(比如学生要学习，教师要教学)
打印方法，打印人的名字，性别和年龄

打印学生对象的信息，比如学生对象的名字是小明，学生的任务是学习

"""
class person():
    def __init__(self,name,sex="男",age=18):
        self.name = name
        self.sex = sex
        self.age = age
    def sleep(self):
        print("睡觉")
    def eat(self):
        print("一天三顿饭")
    def qita(self,zhiye):
        print(zhiye)
    #相当于我们tostring方法，把所有的信息展示出来
    def show(self):
        s = '姓名：%s,性别：%s,年龄：%d' %(self.name,self.sex,self.age)
        return s

student =person("小明")
print(student.show())
student.qita("学习")

继承

继承：继承就是子类继承父类的特征和行为，python支持多继承，多继承在以后不常用，最多会出现三个继承，因为他很复杂，我们那单继承举例

语法

class 类1(object):
    pass
class 类2(object)：
    pass
class 类3(类1，类2)：
    pass

代码

"""
定义一个人类
学生类继承人类，同时定义一个花钱的方法
"""

class person():
    def __init__(self,name,sex="男",age=18):
        self.name = name
        self.sex = sex
        self.age = age
    def sleep(self):
        print("睡觉")
    def eat(self):
        print("一天三顿饭")
    def qita(self):
        print("不同的人有不同的任务")
    def show(self):
        s = '姓名：%s,性别：%s,年龄：%d'%(self.name,self.sex,self.age)
        return s
class student(person):
    def huaqian(self):
        print("花钱神兽")

#同样我们可以调用人类中的方法和属性
#继承person类以后，初始化方法也继承过来了，所以一定不要忘了给参数

s = student("小明")
print(s.show())
class aminal():
    def eat(self):
        print("都需要吃饭")
class person():
    def gongzuo(self):
        print("赚钱养女朋友")

class teacher(aminal,person):
    def hauqian(self):
        print("花钱消费任性")

t = teacher()
t.eat()
t.gongzuo()
t.hauqian()

重点（一定要会）

1.继承完以后我们可以不可以重写方法

2.能不能保留父类的一些方法里面的代码

3.字类可以初始化，可以理解为，字类可以有构造方法吗

4.那么初始化的时候，能不能保留父类的初始化呢

1.继承完以后我们可以不可以重写方法
#学生不应该是个对象，是个类的话更加好操作，那把学生定义成类，他要继承人类

class student(person):
    def huaqian(self):
        print("花钱神兽")
    def qita(self):
        print("学生的任务是：好好学习天天向上")

#继承person类以后，初始化方法也继承过来了
s = student("小明")
print(s.show())

#我们调用其他会发现，调用的是子类的其他，并不是父类的其他
"""
所以我们python也支持重写
1.不同的两个类    2.继承关系      3.方法名，参数相同
"""
s.qita()


2.能不能保留父类的一些方法里面的代码

class student(person):
    def huaqian(self):
        print("花钱神兽")
    def qita(self):
        #调用父类的方法
        super().qita()
        print("学生的任务是：好好学习天天向上")

#继承person类以后，初始化方法也继承过来了
s = student("小明")
"""
可不可以保留这样的一句话，
不同的人有不同的任务，学生的任务是：好好学习天天向上
意思是在父类的基础上重新添加代码
"""
s.qita()

3.字类可以初始化，可以理解为，字类可以有构造方法吗

class student(person):
    def __init__(self, name,hobbit,sex="男", age=18,):
       self.hobbit = hobbit

4.那么初始化的时候，能不能保留父类的初始化呢
class student(person):
    def __init__(self, name, hobbit,sex="男", age=18):
        #引用父类的初始化
        super().__init__(name, sex=sex, age=age)
        self.hobbit = hobbit
s = student("小明","打游戏")
print(s.name)
print(s.age)

公有 私有

静态属性：直接写在类里面的是静态属性

动态属性：写在初始化里面的是动态属性，因为它可以改变

静态方法：staticmethod

普通方法：

公有：公共的

私有：不允许外部访问的，私有的

组合起来有：公有静态属性、公有动态属性、公有静态方法、公有普通方法

私有静态属性、私有动态属性、私有静态方法、私有普通方法

公有静态属性

class person():
    food = "馒头，公有静态属性" #比如所有的人喜欢吃馒头
    def eat(self): #类内部访问
        print("所有的人喜欢吃"+self.food) 

class student(person):
    def studentEat(self):#派生类访问
        print("学生喜欢吃"+self.food)

#类访问。就是类自己可以访问
print(person.food)

#类内部访问
p = person()
p.eat()

#派生类访问
s =  student()
s.studentEat()

私有静态属性

class person():
    __gongju = "手机，私有静态属性"
    def wan(self):#类内部访问
        print(self.__gongju)
    
class student(person):
    def chagang(self):#派生类访问
        print(self.__gongju,"这是能随便查的吗")

#类访问----->报错
#print(person.__gongju )  

#类内部访问
p = person()
p.wan()

#派生类访问--->报错
s= student()
s.chagang()

公有动态属性

"""
通过对象访问
类内部可以访问:类的内部的某个方法
派生类可以访问: 类1继承类2，类1是派生类
"""

class person():
    def __init__(self,name,sex,age):
        #以下这些属于公有字段/成员变量
        self.name = name
        self.sex = sex
        self.age =age
    def perShow(self):#类内部访问
        print(self.name)
        print(self.sex)
        print(self.age)

class student(person):
    def show(self):#派生类的使用
        print(self.name)
        print(self.sex)
        print(self.age)

#通过对象访问
p = person("张三","男",18)
print(p.name)

#类内部可以访问
p.perShow()

#派生类可以访问
s = student("小明","男",70)
s.show()

私有动态字段

class person():
    def __init__(self,name,phone,idCar):
        self.name = name #公有字段
        self.__phone = phone #私有字段
        self.__idCar = idCar #私有字段
    def perShow(self):#类内部访问
        print(self.name)
        print(self.__phone)
        print(self.__idCar)
    
class student(person):
    def show(self):#派生类的使用
        print(self.name)
        print(self.__phone)
        print(self.__idCar)

#通过对象访问-----失败报错
p = person("张三","11111111111","223456789098865432")
#print(p.name)
#print(p.__idCar)
#print(p.__phone)

#类内部可以访问----成功
p.perShow()

#派生类可以访问----失败报错
s = student("xiaoming","11111111111","223456789098865432")
s.show()

"""
总结：私有的普通字段只能在类的内部访问
"""

公有普通方法

class person():
    def drink(self):
        print("所有人都得喝水,公有的普通方法")
    def he(self):#类内部
        self.drink()


class student(person):
    pass

#类对象访问
p = person()
p.drink()

#类内部
p.he()

#派生类访问
s = student()
s.drink()

私有普通方法

class person():
    def __wc(self):
        print("厕所，私有普通方法")
    def Wcc(self):#类内部访问
        self.__wc()
class student(person):
    pass

#对象访问----->报错
p = person()
#p.__wc()

#类内部访问---->成功
p.Wcc()

#派生类访问---->报错
s = student()
s.__wc()

公有静态方法

"""
静态方法的关键字:staticmethod  [ˈmeθəd]方法
语法：@staticmethod
"""

class person():
    @staticmethod
    def jiaoliu():
        print("所有的人都有朋友,公有的静态方法")
    def aihao(self):#类内部访问
        self.jiaoliu()

class student(person):
    pass

#对象访问
p = person()
p.jiaoliu()

#类内部访问
p.aihao()

#派生类访问
s = student()
s.jiaoliu()
#类直接访问
person.jiaoliu()

私有静态方法

class person():
    @staticmethod
    def __jiaoliu():
        print("所有的人都有朋友,公有的静态方法")
    def aihao(self):#类内部访问
        self.__jiaoliu()

class student(person):
    pass

#对象访问 ---->报错
p = person()
#p.jiaoliu()

#类内部访问
p.aihao()

#派生类访问---->报错
s = student()
#s.jiaoliu()
#类直接访问
#person.jiaoliu()

总结

"""
公有静态属性：1.类访问 2.类内部访问 3.派生类访问
私有静态属性：只能类内部访问
------------------------------------------------
公有动态属性：1.类对象 2.类内部访问 3.派生类访问
私有动态属性：只能类内部访问
------------------------------------------------
公有普通方法：1.类对象 2.类内部访问 3.派生类访问
私有普通方法：只能类内部访问
----------------------------------------------
公有静态方法：1.类对象 2.类内部访问 3.派生类访问 4.类直接访问
私有静态方法：只能类内部访问
"""

封装

class person():
    #初始化
    def __init__(self,name,sex,age,phone,idCar):
        self.__name = name
        self.__sex = sex
        self.__age = age
        self.__phone = phone
        self.__idCar = idCar
    def eat(self):
        print("吃饭")
    def sleep(self):
        print("睡觉")
    def __wc(self):
        print("wc")
    def show(self):
        print(self.__name )
        print(self.__sex) 
        print(self.__age)
        print(self.__phone)
        print(self.__idCar)

多态

一个对象多种形态

举例，比如动物类，所有的动物都要吃饭，但是狗类吃的骨头，猫类吃的鱼

那怎么让一个动物类的吃有多种形式呢，在狗和猫这两个子类中重写eat方法

class animal():
    def __init__(self,name):
        self.name = name 
    def eat(self):
        print("吃饭")
        
class dog(animal):
    def eat(self):
        print("吃骨头")

class cat(animal):
    def eat(self):
        print("吃鱼")

d = dog("哈士奇")
print(d.name)
d.eat()

c = cat("白猫")
print(c.name)
c.eat()

练习

"""
定义一个名为Vehicles（交通工具）的基类，
   私有属性brand（商标）和color（颜色），
   成员方法run（行驶）和showInfo（显示信息，在控制台显示商标和颜色），并编写构造方法初始化其成员属性。
编写Car（小汽车）类继承于Vehicles类，增加int型成员属性seats（座位），增加成员方法showCar（在控制台显示小汽车的信息），并编写构造方法。
编写Truck（卡车）类继承于Vehicles类，增加float型成员属性load（载重），增加成员方法showTruck（在控制台显示卡车的信息），并编写构造方法。
"""

class Vehicles():
    def __init__(self,brand,color):
        self.__brand = brand         
        self.__color = color

    def run(self):
        print("我已经开动了")
    def showInfo(self):
        print(self.__brand,self.__color)

class Car(Vehicles):
    def __init__(self,brand,color,seats):
        super().__init__(brand,color)
        self.__seats = seats
    def showCar(self):
        self.showInfo()
        print(self.__seats)
class Truck(Vehicles):
    def __init__(self,brand,color,load):
        super().__init__(brand,color)
        self.__load = load
    def showTruck(self):
        self.showInfo()
        print(self.__load)

c = Car("7Q","绿色",5)
c.run()
c.showCar()
t = Truck("五菱宏光","蓝色",6.66)
t.run()
t.showTruck()