一般来说，类由属性和行为（方法）组成

属性表示了这个类的特点，行为（方法）规定了这个类的功能
程序（类）=数据结构（属性）+算法（行为、方法）

类->实例：实例是类的具体化

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))

面向对象的编程