面向对象
类和对象是面向对象的两大核心
类
定义
类是对一群具有相同特征和行为的事物的统称，是抽象的
特征被称为属性，行为被称为方法
语法
类型要符合大驼峰命名
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()
|