面向对象是一种编写代码的思维方式：程序是由什么构成的
类，其实是一种抽象······
user类：是把用户相关信息抽象到一起
- 类名采用驼峰结构，并且首字母大写。
一般来说，类由属性和行为（方法）组成
- 属性表示了这个类的特点，行为（方法）规定了这个类的功能
- 程序（类）=数据结构（属性）+算法（行为、方法）
类->实例：实例是类的具体化
self指的是：当前对象（方法的调用者）
class Cat:
'''
构造方法，该方法会在创建对象（实例）的时候，自动调用
'''
def __init__(self,color,name):
'''
函数定义在类里叫做方法
:param color:
:param name:
'''
self.color=color
self.__name=name
def catchRat(self):
print(self.__name+'抓到了老鼠')
#创建一个实例
#实例化对象的过程：1、分配内存出来(__new__) 2、初始化值(__init__)
tom=Cat('Blue','Tom')
tom.catchRat()
#私有属性
print(tom.name)
tom.name='JiaFeiCat'
print(tom.name)
属性私有化
1、两个下划线开头 2、自己约定_单下划线
双下划线为什么能够隐藏变量？dict里面装的是实例的所有属性
双下划线开头的属性会被转换成类名_属性名，所以查不到
print(tom.dict)
class Student:
def __init__(self,name,age):
self.__name=name
self.__age=age
def set_name(self,name):
if not len(name)<3:
self.__name=name
def get_name(self):
return self.__name
@property
def age(self):
return self.__age
@age.setter
def age(self,age):
if age>0 and age<100:
self.__age=age
s=Student('zhangsan',20)
#提供了get、set方法
print(s.get_name())
s.set_name('lisi')
print(s.get_name())
s.age=50
print(s.age)
类也是一个对象
self.属性名:实例属性
在类里直接定理的属性叫做类属性，类属性由所有对象共享
class User:
num=0
def __init__(self,name):
self.name=name
User.num+=1
def print_name(self):
print(self.name,User.num)
@classmethod
def creat_user(cls,name,age):
# print(cls)
user=cls(name)
user.age=age
# print(user)
return user
@staticmethod
def sum(a,b):
return a+b
def __str__(self):
return self.name
u=User('zs')
u.print_name()
u1=User('ls')
u1.print_name()
u2=User.creat_user('zs',20)
print(u2.age)
print(u2.name)
print(User.sum(2,3))
- @classmethod 修饰的方法是类方法，类方法可以通过类名调用，类方法必须有一个类型参数：cls
- @statemethod 修饰的方法是静态方法，通过类名可以访问，仿作普通函数来用
模拟一个游戏，有一个怪兽(monster),还有一个玩家(hero)
import random as rn
class Sprite:
def __init__(self,name):
self.blood=100
self.power=12
self.name=name
def attack(self,monster):
minus=rn.randrange(self.power-5,self.power+5)
if monster.has_living():
monster.minus_blood(minus)
print(monster.name+':'+str(monster.blood))
def minus_blood(self, num):
self.blood -= num
def has_living(self):
if self.blood>0:
return True
return False
m=Sprite('哥斯拉')
h=Sprite('奥特曼')
while m.has_living() and h.has_living():
m.attack(h)
h.attack(m)
继承
python支持多继承，继承内容与继承顺序相关
所有的类，都会默认继承object类
class A:
def __init__(self):
self.name='A'
def print_test(self):
print('aaaaa')
class B:
def __init__(self):
self.name='b'
class C(A,B):
def __init__(self):
super().__init__()
self.age=20
def print_test(self):
super().print_test()
print('bbbbbb')
c=C()
print(c.name)
print(c.age)
#调用属性或者方法的查找顺序
# print(c.__mro__)
c.print_test()
组合
组合优于继承
class D:
def __init__(self):
self.a=A()
def print_test(self):
self.a.print_test()
print('ddddd')
d=D()
d.print_test()
鸭子类型
叫起来像鸭子，走起来像鸭子，那他就是鸭子
class Programer:
def dowork(self):
print('biancheng')
class Manager:
def dowork(self):
print('guanli')
employer=Manager()
employer.dowork()
使用继承写游戏
class Hero(Sprite):
def bug_attack(self,monster):
monster.minus_blood(monster.blood)
def attack(self,monster):
super().attack(monster)
num=rn.randint(0,3)
if num==1:
print(self.name+'使用了道具')
self.bug_attack(monster)
h=Hero('奥特曼')
m=Sprite('哥斯拉')
while m.has_living() and h.has_living():
m.attack(h)
h.attack(m)
单例模式：一个类只能有一个对象
class S:
instance=None
def __new__(cls, *args, **kwargs):
if S.instance is None:
S.instance=super().__new__(cls) #super().__new__(cls)
return S.instance
s1=S()
print(id(s1))
s2=S()
print(id(s2))
