前言

大家好，我是BoBo仔吖，上3节课我们学习了类的基础知识。这节课，我们要讲一些深入的东西。
是什么呢？看看就知道！

一、类定义语法

其实，我们学习的class类都可以看做我们定义的功能语法
之前我讲解type函数的时候也说到了我们的牢大class
这是我们的文章
https://blog.csdn.net/m0_69481332/article/details/138410028?spm=1001.2014.3001.5501
这里有一个内容要注意：

这幅图片我给大家扣过来了，大家会发现：这里我们通过type函数判断类型后（其实，list等等也是一个类哦），下面的输出是<class'类型'>
大家是不是也看看让自己的类的语法形式？使用type方法即可！

还是有栗子：

这是我们上次的例子
我们都知道，我们把类GameB赋予了变量game_begin
所以，我们用type来检验它的时候便反映了它的类语法形式，也就是GameB
这里还有一个main

<class '__main__.GameB'>

这里出现了__main__方法，因为这是我们自己定义的类语法空间

这就是类定义语法，非常简单似不似？
接下来，我们学习一些更加深入的内容

二、私有方法和私有属性

1.私有属性

我们还是把我们之前的例子拿出来

class GameB:
    def __init__(self,exp,grade):
        self.exp = exp
        self.grade = grade
    
    def print_message(self):
        print('经验值',self.exp)
        print('等级',self.grade)

game_begin = GameB('0',1)
game_begin.print_message()
print(type(game_begin))

这里我们把class GameB的设定叫做定义类，而其中的函数则称为方法
为什么要扯概念？因为这个东东非常重要

接下来，我们来讲一个和上文一点不搭噶的东西

class Dog:
    def __init__(self,name):
        self.__name = name
        self.__age = None
        print(self.__name,'生成成功！')
    def set_age(self,age):
        if not isinstance(age,int):#这里的函数isinstance是判断它括号内的两个参数中，参数1是否是参数2的类型，如果不是就执行下面的操作，通常作为条件使用
            print('输入的年龄必须是数字！')
            return False
        if age <= 0:
            print('年龄必须大于0！')
            return False
        self.__age = age
    def play(self):
        print('汪汪汪！我今年',self.__age)

dog =Dog('旺财')
dog.set_age('hello!')
dog.set_age(-20)
dog.set_age(3)
dog.play()

这是一个生成dog角色的函数，这里我们发现有一个非常眼生的东西：私有属性
私有属性的属性呢和他的本身命名的特性差不多，是一个“私有”属性
大家可以把私有属性看做一件事情：
我们在家里可能穿睡衣，穿拖鞋；但是，我们在外面就不会穿的这么奇怪
我们就可以把家里看做class类里，外面看做class类外的代码，这样大家是不是就理解多了呢？

这里的结构是__(下划线×2）对象名
这个私有属性呢与我们普通的属性有一个显著的特点就是他不能直接改动，而是需要在某个特定的函数中再次修改，且不能再类以外的地方调用
例如这里，我们构造了两个私有属性，它们是__age和__name
属性age只能通过类中的set_age修改，不能再外部直接改动，否则会发生错误
就像这样：

当然，有私有属性就有私有方法

2.私有方法

这里的方法概念上面提到了，就是我们所封装的函数
私有方法的理解也可以向上文那样：你在家里休息日时可能9点起，12点睡，打游戏，吃KFC；但是，你上学或是工作时就必须早起，调整作息。
我们还是把家看做类代码，把外面看做类以外的代码

我们还是以类Dog为例，构造私有方法__say(self,name)
代码如下：

class Dog:
    def __say(self,name):
        print(name)

    def play(self):
        print('汪汪汪！')


dog = Dog()
dog.play()

这里我们的私有方法没有起任何作用
而且，这里不能通过类以外区域来修改这个函数，否则会出现错误

大家学会私有概念了吗？如果学会，那么你的类使用就更加灵活咯！！！

三、类“继承”

继承呢我们往往会联想到一些时间：老父亲的特征往往会继承给儿女，这就是生理继承（DNA继承）
这种广义上的继承想必大家都知道，那么，在类里，继承是什么一种概念呢？
还是甩出刚刚的示例，就是那个生成doggy的模型
这里我们看源代码，看看有什么相同和不同

1.初识继承

class Animal:
    def __init__(self,name):
        self.name = name 
    
    def play(self):
        print('我是',self.name)

class Dog(Animal):#注意看，这就是继承的格式！！
    pass#这里我们没有私有方法，所以这里我们在下面调用的时候调整就可以了

dog = Dog('旺财')#这里继承了Animal类中的方法，赋给dog之后，就可以转而通过Dog类调用Animal的内容
dog.play()

这里我们的继承类采用的是这样的格式:

class 类名【子类】(主类名【或者叫父类】):

我们通过继承的手法可以更加灵活地使用父类里的东西，而且还能修改（私有属性或私有方法除外，不可继承），更加灵活。这里我们的父类Animal受了Dog的调用，如果我们在dog里修改animal类，那么效果会更加良好

2.使用super函数调用父类中构造的东西

class Animal:
    def __init__(self,name):
        self.name = name

    def play(self):
        print('我是',self.name)
    
class Dog(Animal):
    def __init__(self):
        print('旺财')
    
dog = Dog()

在这个例子里，我们在dog类中继承了Animal，但是由于没有调用play，所以只能输出旺财

但是，我们如果直接使用方法play，那么就会出错，因为我们使用的是类Dog里的构造方法，而不是类Animal的构造方法，尽管我们继承了Animal类
如果我们要实现animal类的构造方法，那么我们就要用到super() 内置函数

就像这样：

class Animal:
    def __init__(self, name):
        self.name = name

    def play(self):
        print('我是', self.name)


class Dog(Animal):
    def __init__(self):
        super(Dog,self).__init__('旺财')


dog = Dog()
dog.play()

我们使用super函数来调用我们在Animal类中所继承的__init__构造方法，完之后就可以直接使用play来运行Animal类中的内容了
怎么样，是不是很神奇？

四、类“多态”

多态是基于继承上的一种形式，我们可以把它大致理解为“父类的多个子类”
还是以类Animal为例，来看看使用多态后结果如何

1.多态基础

还是这个例子

class Animal:
    def say(self):
        print('Animal')
    
class Dog(Animal):
    pass

class Cat(Animal):
    pass

dog = Dog()
dog.say()

cat = Cat()
cat.say()

这里我们用两个形式来继承Animal，它们分别是类Dog和类Cat
我们的两个子类继承父类Animal之后，使用了父类中的方法say，这个大家应该能理解
接下来，我们来看点深层的内容

2.子类不同形态

这里我们的目标是使用2个不同的子类来通过共同继承父类Animal来输出不同的内容

其实也不难，只要在类Dog与Cat中分别加入自己的内容即可

具体代码如下：

class Animal:
    def say(self):
        print('Animal')
    
class Dog(Animal):
    def say(self):
        print('Dog')

class Cat(Animal):
    def say(self):
        print('Cat')

dog = Dog()
dog.say()

cat = Cat()
cat.say()

这里我们的输出就是Dog与Cat了，我们共同使用了自己所继承的方法来创造自己不同的结果，这就是多态的体现

3.使用isinstance函数与多态结合判断类型

这个isinstance函数呢大家不陌生，之前的一个章节中我就用它判断过类型：对，就是实战的那一章，我用这个来判断输入类型（构造旺财的那一课，大家可以翻翻我之前的文章找一找）
具体格式我就不说了，大家可以自己根据我使用的方法自己练练手
接下来我们直接上代码
我们的isinstance函数和我们的多态是有关系的，所以我把他放在这里节里讲解

首先，我们像刚刚那样使用dog变量与cat变量分别迭代类Dog与类Cat

class Animal:
    def say(self):
        print('Animal')
    
class Dog(Animal):
    def say(self):
        print('Dog')

class Cat(Animal):
    def say(self):
        print('Cat')

dog = Dog()
cat = Cat()

好，不要眨眼，接下来就是重头戏！

我们这里其实也能把cat与dog变量看做一种调用继承的形式。根据这个逻辑，我们可以用isinstance来判断继承的正误，简称来说就是看是不是亲生的

OK，我们先上代码

class Animal:
    def say(self):
        print('Animal')
    
class Dog(Animal):
    def say(self):
        print('Dog')

class Cat(Animal):
    def say(self):
        print('Cat')

dog = Dog()
cat = Cat()

print(isinstance(dog,Dog))
print(isinstance(dog,Animal))
print(isinstance(cat,Cat))
print(isinstance(cat,Animal))

这里我们的输出是：

True
True
True
True

好，现在我们知道了，dog和cat都是自己的祖宗亲生的了

接下来，我们就要好好琢磨琢磨
首先，我们把后面几行单独剔出来检查

dog = Dog()
cat = Cat()

print(isinstance(dog,Dog))
print(isinstance(dog,Animal))
print(isinstance(cat,Cat))
print(isinstance(cat,Animal))

我们这里使用dog和cat两个变量“继承”了类Dog，Cat与Animal
所以，我们的这里的输出是正确的

我之前讲过，其实我们的数据类型，像int，float，str，list等等，其实都是一个类，我们只要使用isinstance函数就能看出，逗号“，”前的是不是逗号“，”后的类型。所以，大家现在懂数据类型与类的关联性原理了吧

总结

好了，今天的内容到此结束。实在是写不动了，下次再努力吧
下节课，我们将学习类的最后一讲：拓展篇，大家敬请期待！如有不懂，别忘了问我哟！下期见~~~

【制作不易，别忘了一圈三连，点个关注！！！】