面向对象中—类
目录
一、对象
二、类
2.1定义
2.2类的定义语法
2.3类的实例化
2.4self关键字
三、类的特点
3.1继承性
3.1.1定义
3.1.2单继承
3.1.3多层继承
3.1.4多继承
3.1.5子类方法重写
3.2封装性
3.2.1定义
3.2.2封装中的私有属性和私有⽅法
3.2.3访问私有属性
3.3多态性
3.3.1定义
3.3.2原理图
3.3.3多态代码实现
一、对象
对象，object，现实业务逻辑的⼀个动作实体就对应着面向过程编程中的⼀个对象！
对象通过属性保存数据，通过函数来实行方法来管理数据
二、类
2.1定义
在Python中，采⽤类（class）来生产对象，⽤类来规定对象的属性和方法！也就是说，在Python
中，要想得到对象，必须先有类！ 类就是具有相同或相似属性和动作的⼀组实体的集合！在Python中，对象是指现实中的⼀个具体的实体，而既然现实中的实体都有⼀个类别，所以，OOP中的对象也都应该有⼀个类！
2.2类的定义语法
class 类名(继承对象，默认为object):# 属性# ⽅法class Person(object):# 属性# ⽅法（函数）def eat(self):print('吃零⻝')def drink(self):print('喝可乐')2.3类的实例化
类的实例化就是把抽象的事务具体为现实世界中的实体。类的实例化就是通过类得到对象！
类只是对象的⼀种规范，类本身基本上什么都做不了，必须利⽤类得到对象，这个过程就叫作类的实例化！
基本语法：对象名=类名（）
# 1、定义⼀个类
class Person(object):# 定义相关⽅法def eat(self):print('吃零⻝')def drink(self):print('喝可乐')# 2、实例化对象
p1 = Person()
# 3、调⽤类中的⽅法
p1.eat()
p1.drink()
p2 = Person()通过对其进行实例化得到的对象名，可以调用类中的属性和方法，得到其效果功能
2.4self关键字
# 1、定义⼀个类
class Person():# 定义⼀个⽅法def speak(self):print(self)print('Nice to meet you!')
# 2、类的实例化（⽣成对象）
p1 = Person()
print(p1)
p1.speak()
p2 = Person()
print(p2)
p2.speak()类中的self就是谁实例化了对象，其就指向谁。
三、类的特点
类的三大特点：继承性、封装性、多态性
3.1继承性
class B(object):pass
class A(B):pass
a = A()
a.B中的所有公共属性
a.B中的所有公共⽅法3.1.1定义
⼀个类从另⼀个已有的类获得其成员的相关特性，就叫作继承
⽗类：也叫作基类，就是指已有被继承的类！
⼦类：也叫作派⽣类或扩展类
3.1.2单继承
定义：⼀个类只能继承⾃⼀个其他的类，不能同时继承多个类。这个类会有具有⽗类的属性和⽅法。
# 1、定义⼀个共性类（⽗类）
class Person(object):pass
# 2、定义⼀个个性类（⼦类）
class Student(Person):pass3.1.3多层继承
定义：
在Python继承中，如A类继承了B类，B类⼜继承了C类。则根据 继承的传递性，则A类也会⾃动继承C类中所有属性和方法（公共）
class C(object):def func(self):print('我是C类中的相关⽅法func')class B(C):pass
class A(B):pass
a = A()
a.func()3.1.4多继承
定义：多继承就是允许⼀个类同时继承⾃多个类的特性。
class B(object):pass
class C(object):pass
class A(B, C):pass
a = A()
a.B中的所有属性和⽅法
a.C中的所有属性和⽅法3.1.5子类方法重写
class Animal(object):def eat(self):print('i can eat')# 公共⽅法def call(self):print('i can call')
class Dog(Animal):# 重写⽗类的call⽅法def call(self):print('i can wang wang wang')
class Cat(Animal):# 重写⽗类的call⽅法def call(self):print('i can miao miao miao')
wangcai = Dog()
wangcai.eat()
wangcai.call()
miaomiao = Cat()
miaomiao.eat()
miaomiao.call()类⽅法的调⽤顺序，当我们在⼦类中重构⽗类的⽅法后，Cat⼦类的实例先会在⾃⼰的类 Cat 中查找该⽅法，当找不到该⽅法时才会去⽗类 Animal 中查找对应的⽅法。
3.2封装性
3.2.1定义
① 把现实世界中的主体中的属性和⽅法书写到类的⾥⾯的操作即为封装
② 封装可以为属性和⽅法添加为私有权限，不能直接被外部访问
3.2.2封装中的私有属性和私有⽅法
在⾯向对象代码中，我们可以把属性和⽅法分为两⼤类：公有（属性、⽅法）、私有（属性、⽅法）
公有属性和公有⽅法：⽆论在类的内部还是在类的外部我们都可以对属性和⽅法进⾏操作。
但是有些情况下，我们不希望在类的外部对类内部的属性和⽅法进⾏操作。我们就可以把这个属性或⽅法封装成私有形式。
3.2.3访问私有属性
在Python中，⼀般定义函数名' get_xx '⽤来获取私有属性，定义' set_xx '⽤来修改私有属性值。
class Girl():def __init__(self, name):self.name = nameself.__age = 18# 公共⽅法：提供给外部的访问接⼝def get_age(self):# 内部访问：允许直接访问# 外部访问：根据需求要添加限制条件return self.__age# 公共⽅法：提供给外部的设置接⼝def set_age(self, age):self.__age = age
girl = Girl('⼩美')
girl.set_age(19)
print(girl.get_age())3.3多态性
3.3.1定义
多态是⼀种使⽤对象的⽅式，⼦类重写⽗类⽅法，调⽤不同⼦类对象的相同⽗类⽅法，可以产⽣不同的执⾏结果
不同对象 => 使⽤相同⽅法 => 产⽣不同的执⾏结果。
3.3.2原理图
3.3.3多态代码实现
class Fruit(object): # ⽗类Fruitdef makejuice(self):print('i can make juice')
class Apple(Fruit): # ⼦类：苹果# 重写⽗类⽅法def makejuice(self):print('i can make apple juice')
class Banana(Fruit): # ⼦类：⾹蕉# 重写⽗类⽅法def makejuice(self):print('i can make banana juice')
class Orange(Fruit): # ⼦类：橘⼦# 重写⽗类⽅法def makejuice(self):print('i can make orange juice')
# 定义⼀个公共接⼝（专⻔⽤于实现榨汁操作）
def service(obj):# obj要求是⼀个实例化对象，可以传⼊苹果对象/⾹蕉对象obj.makejuice()
# 调⽤公共⽅法
service(Orange())