Python 快速了解面向对象
python面向对象
- 1.python 面向对象概念
- 2. 类和对象
- 2.1 类的概念（class）
- 2.2 对象的概念
- 2.3 初始化方法
- 2.4 实例方法（普通方法）
- 3. 类属性和实例属性
- 3.1 类属性
- 3.2 实例属性
- 3.3 深度剖析 self
- 4. 类方法
- 4.1 静态方法
- 5. 面向对象的特征
- 5.1 封装
- 5.2 对外提供访问的接口
- 5.3 继承
- 5.31 单继承
- 5.32 多继承
- 5.4 子类重写父类的方法
- 5.5 子类不想重写父类方法 只想扩展
- 5.6 多态
1.python 面向对象概念
面向对象是程序设计封装的一种思想 ! ! !
1，列表是将各种不同的数据类型的数据封装到一个容器里面 --> 数据层面的封装
2，函数是将一段代码封装到一起 --> 语句层面的封装
3，面向对象是将具有相同属性和方法的代码封装到一起 --> 程序设计层面的封装
那么 为什么要用面向对象呢？
面向对象的好处：拓展性强，比方王者荣耀新增一个英雄很方便。
解耦和，降低程序的维护成本
2. 类和对象
2.1 类的概念（class）
类是模板，具有相同特征和行为的一类事务。
比如说王者荣耀里面的 射手类 法师类 战士类 刺客类等等
2.2 对象的概念
对象是一个由具体产生的实例，比方说：射手类-->鲁班，法师类-->妲己
写在类里面的函数称之为方法
例如 定义一个射手类
class sheshou：
"""射手类"""
#类的属性（一般指的是变量）
gongji = 1700 #攻击力
fangyu = 300 防御力
#行为（实例方法）
def sheji（self）
print("我的攻击力是：{}，防御能力是：{}".format(self.gongji,self.fanyu))
luban = Sheshou() #实例化，将类实例化出一个具体的对象，由射手类创建出一个鲁班对象
print(luban) #打印出来的是一个地址，通过这个地址可以找到luban这个对象
luban.sheJi() #通过对象去调用方法
houyi = Sheshou() #创建一个后裔
houyi.sheJi() #用这个实例出来的后裔对象 去调用sheji方法
#Sheshou.sheJi() #实例方法不能直接通过类去调用
# luban = Sheshou() #实例方法可以通过实例对象去调用
# luban.sheJi()
2.3 初始化方法
初始化方法是魔术方法之一， 所谓魔术方法就是在符合一定条件可以自动调用
class Sheshou:
"""射手类"""
def __init__(self): #初始化方法（魔术方法）
print("今天是个好日子")
luban = Sheshou() #实例化的过程就是这个类初始化的过程
#在实例化的时候 这个初始化的魔术方法会自动调用
2.4 实例方法（普通方法）
实例方法，会隐含一个self参数，实例方法不属于类，属于实例。通过实例对象才能调用。
不能直接通过类去调用.
class Sheshou:
"""射手类"""
#行为（实例方法）
def sheJi(self):
print("我的攻击力是：{}，防御能力是：{}".format(self.gongji,self.fanyu))
#只有实例化一个对象 才可以通过那个对象去调用实例方法
3. 类属性和实例属性
3.1 类属性
类属性是直接定义在类里面的变量，属于类本身。可以去访问它也可以去修改它
class Sheshou:
"""射手类"""
#类属性（变量）
gongji = 1700 #攻击力
fanyu = 300 #防御力
print(Sheshou.gongji) #访问
Sheshou.gongji = 1500 #修改
print(Sheshou.gongji)
#类属性可以之间通过类进行访问修改
3.2 实例属性
实例属性不是直接定义在类的里面，通过初始化方法注入到类里面
class Sheshou:
"""射手类"""
def __init__(self,gongji,fangyu):
#初始化方法（魔术方法）
self.gongji = gongji #实例属性
self.fangyu = fangyu #实例属性
print("今天是个好日子")
print(Sheshou.gongji) #会报错 实例化属性不能直接通过类名去调用，必须通过实例化才能够访问它,修改它
#你得先实例一个对象出来 再通过实例对象去调用实例属性
3.3 深度剖析 self
class Sheshou:
"""射手类"""
#所谓魔术方法就是在符合一定条件可以自动调用
def __init__(self,gongji,fangyu):#初始化方法（魔术方法）
self.gongji = gongji #实例属性
self.fangyu = fangyu #实例属性
print("self是：{}".format(self))
luban = Sheshou(1200,100)
print("luban是：{}".format(luban)) print("\n====================================================\n")
houyi = Sheshou(600,180)
print("houyi是：{}".format(houyi))
#充足的证据证明self就是当前对象，当前实例化的对象是谁，那么self就指向谁
#当生成luban这个对象的时候 self当前就指向luban
#当生成houyi这个对象的时候 self当前就指向houyi
4. 类方法
类方法属于类，不会隐含self，会隐含一个cls。
类方法需要使用@classmethod装饰器来进行修饰。
类方法可以直接通过类去调用，也可以被实例化对象调用。
class Cat:
"""猫类"""
def __init__(self,nickname,color):
self.nickname = nickname
self.color = color
@classmethod #@classmethod是一个装饰器，作用就是为这个方法添加一个额外的功能
def zhuaLaoShu(cls):
print("抓老鼠")
#直接通过类名调用
Cat.zhuaLaoShu() #会被成功调用，因为调用的对象是一个类方法 ，可以通过类进行直接调用
问题：类方法中能不能使用实例属性？
答案肯定是：不能。
# 原因：类方法的加载不需要实例化，初始化方法没有被调用。 实例属性就没来得及注入
4.1 静态方法
静态方法需要使用@staticmethod来修饰
静态方法没有隐含任何参数，既可以实例化后通过对象去调用， 也可以直接被类调用。
静态方法不能访问类变量和实例变量，也不能使用self 要在类中使用静态方法，需在类成员函数前面加上@staticmethod标记符，以表示下面的成员函数是静态函 数。
使用静态方法的好处是，不需要定义实例即可使用这个方法。另外，多个实例共享此静态方法
（静态方法 无法访问类属性、实例属性，相当于一个相对独立的方法，跟类其实没什么关系，简单讲，静态方法就是放在 一个类的作用域里的函数而已。
静态方法的应用：抽取工具类
接下来请看如下案例：
我们先用面向对象写一个人机猜拳的游戏：
用户类：
class User:
"""用户类"""
#初始化方法，在实例化的时候自动调用
def __init__(self,userName):
self.userName = userName
#实例方法（普通方法）
def chuZhao(self):
uz = int(input("亲爱的{}，请出招（1-剪刀 2-石头 3- 布）：".format(self.userName)))
if uz == 1:
print("{}出招：剪刀".format(self.userName))
elif uz == 2:
print("{}出招：石头".format(self.userName))
else:
print("{}出招：布".format(self.userName))
return uz
电脑类：
class Computer:
"""用户类"""
# 初始化方法，在实例化的时候自动调用
def __init__(self, nickName):
self.nickName = nickName # 实例方法（普通方法）
def chuZhao(self):
import random cz = random.randint(1,3) #这边利用一个随机函数 随机生成（1-3）
if cz == 1:
print("{}出招：剪刀".format(self.nickName))
elif cz == 2:
print("{}出招：石头".format(self.nickName))
else:
print("{}出招：布".format(self.nickName))
return cz
进行比较：
from oop.人机猜拳.用户 import *
from oop.人机猜拳.电脑 import *
zs = User("小张") #实例化
xa = Computer("小爱同学") #实例化
u = zs.chuZhao() #通过对象去调用实例化方法
c = xa.chuZhao() #通过对象去调用实例化方法
if u == c:
print("平局")
elif u == 1 and c == 3 or u == 2 and c == 1 or u == 3 and c == 2:
print("{}胜利！".format(zs.userName))
else:
print("{}胜利！".format(xa.nickName))
这边我门可以利用静态方法去进行一个抽取
抽取出一个工具类
如上所述：
我们可以看到上诉代码有一些重复性的区域
这边进行一个抽取工具类的操作
工具类：
class Utils:
@staticmethod
def zhaoShi(name,zhao):
if zhao == 1:
print("{}出招：剪刀".format(name))
elif zhao == 2:
print("{}出招：石头".format(name))
else:
print("{}出招：布".format(name))
用户类：
from oop.人机猜拳.工具类 import *
class User:
"""用户类"""
#初始化方法，在实例化的时候自动调用
def __init__(self,userName):
self.userName = userName
#实例方法（普通方法）
def chuZhao(self):
uz = int(input("亲爱的{}，请出招（1-剪刀 2-石头 3- 布）：".format(self.userName)))
Utils.zhaoShi(self.userName,uz) #在此调用工具类的方法
return uz
电脑类：
from oop.人机猜拳.工具类 import *
class Computer:
"""用户类"""
# 初始化方法，在实例化的时候自动调用
def __init__(self, nickName):
self.nickName = nickName
# 实例方法（普通方法）
def chuZhao(self):
import random cz = random.randint(1,3)
Utils.zhaoShi(self.nickName,cz) #在此调用工具类的方法
return cz
对比类：
from oop.人机猜拳.用户 import *
from oop.人机猜拳.电脑 import *
zs = User("小张") #实例化
xa = Computer("小爱同学") #实例化
u = zs.chuZhao() #通过对象去调用实例化方法
c = xa.chuZhao() #通过对象去调用实例化方法
if u == c:
print("平局")
elif u == 1 and c == 3 or u == 2 and c == 1 or u == 3 and c == 2:
print("{}胜利！".format(zs.userName))
else:
print("{}胜利！".format(xa.nickName))
5. 面向对象的特征
5.1 封装
封装的概念
将类的属性或者方法私有化，不让外界直接访问，对外提供一个访问的接口。
提高数据的安全性。不用去管类 的具体细节，就可以获取类的实现接口，提高了开发的效率。
将类私有化！！！
只用在类属性或方法前加上__（两个下横杠即可）
class Woman:
"""女人类"""
#常识：女生的年龄是不能随意访问的
def __init__(self,name,age,weight):
self.name = name #姓名
self.__age = age #年龄 #私有化
self.weight = weight #体重
def show(self): print("我的名字叫：{}，年芳：{}，体重：斤".format(self.name,self.__age,self.weight))
binbin = Woman("冰冰",18,120)
#binbin.age = 190 #不能通过对象随意访问属性，数据不安全
binbin.age = 150 #私有化后，就不能随意访问和修改
binbin.name = "小凤"
binbin.show()
5.2 对外提供访问的接口
class Woman:
"""女人类"""
#常识：女生的年龄是不能随意访问的
def __init__(self,name,age,weight):
self.name = name #姓名
self.__age = age #年龄 私有化
self.weight = weight #体重
#定义set和get方法，是一个外界可以访问的接口
def setAge(self,age):#设置
#可以在这个方法里面加上业务逻辑，可以起到保护数据安全的作用
if age > 120 or age < 0:
age = 18
print("年龄不合法！年龄将自动设置为18岁")
else:
self.__age = age
def getAge(self): #定义一个获取 方法
return self.__age
def show(self):
print("我的名字叫：{}，年芳：{}，体重：{} 斤".format(self.name,self.getAge(),self.weight)) binbin = Woman("冰冰",18,120)
#binbin.age = 190 #不能通过对象随意访问属性，数据不安全
#binbin.age = 150 #私有化后，就不能随意访问和修改
binbin.name = "小凤"
binbin.setAge(220) #可以通过指定的接口访问
binbin.show()
#这边通过一个指定的 setAge()的接口 去获取年龄数据
再通过getAge()去返回一个年龄
5.3 继承
子类继承父类，子类可以拥有父类的所有属性及所有方法。
这样可以大大提高代码的复用性。 java只支持单继承，或者是多层继承。 python支持多继承，多层继承
5.31 单继承
class Animal:
"""动物类"""
def __init__(self,name,sex):
self.name = name
self.sex = sex
def eat(self):
print("{}吃饭，性别：{}".format(self.name,self.sex))
def drink(self):
print("喝")
class Cat(Animal): #继承动物类
pass
class Dog(Animal): #继承动物类
pass
c = Cat("小肥猫","雌") #父类拥有的方法 子类也拥有
c.eat() #通过子类去调用父类的方法
d = Dog("旺财","雄")
d.eat()
5.32 多继承
class Animal:
"""动物类"""
def __init__(self,name,sex):
self.name = name
self.sex = sex
def eat(self):
print("{}吃饭，性别：{}".format(self.name,self.sex))
def drink(self):
print("喝")
class People:
def sing(self):
print("唱歌")
class Cat(Animal,People): #同时继承动物类 和People类
pass
class Dog(Animal,People): #同时继承动物类 和People类
pass
c = Cat("小肥猫","雌")
c.sing()
c.eat()
d = Dog("旺财","雄")
d.sing()
d.eat()
5.4 子类重写父类的方法
如果子类有一个与父类名相同的方法，则这个方法会被子类重写
class Animal:
"""动物类"""
def drink(self):
print("喝")
class fish(Animal):
"""鱼类"""
def drink(self): #子类重写父类的方法，父类的方法会被子类的方法覆盖
print("喝水")
c = fish()
c.drink()
#结果为喝水
5.5 子类不想重写父类方法 只想扩展
class Animal:
"""动物类"""
def drink(self):
print("喝")
class fish(Animal):
"""鱼类"""
def drink(self):
super().drink() #子类拓展父类的方法，不会完全覆盖父类的方法，保留父类方法的同时，拓展 自己的业务
print("喝水")
这时候只需要加上一句 super()就行，这样子类只会扩展，而不会重写
5.6 多态
多态的定义：不同的子类对象调用相同的方法产生不同的执行结果
多态使用前提：需要继承和对父类方法进行重写
多态的作用：一种接口多种实现，实现接口的重用
实现多态的步骤：
1，定义新的子类继承父类
2，重写对应的父类方法
3，使用子类的方法直接处理,不调用父类的方法
总结：不同的子类对象 使用同一个方法 结果输出需要的执行结果 -- 父类引用指向子类对象
在学校，铃声响起的时候，对于学生来说是放学，对于老师是下班
class School:
"""学校"""
def music(self):
print("打铃")
class Student(School):
def music(self):
print("铃声响起，放学了")
class Teacher(School):
def music(self):
print("铃声响起，下班了")
s = Student() #实例化出一个学生对象
t = Teacher() #实例化一个老师出来
def jiekou(obj): #传入学生对象，实现学生的业务。传入老师，实现老师的业务。同一个接口，不同实现
obj.music()
jiekou(t) #通过不同的参数 产生不同的结果 #传入老师 就是老师的music()方法
#传入学生 就是学生的music()的方法