[已解决]看不懂代码啊兄弟们

黎子卿

class A:
    def __init__(self):
        self.n = 2
    def add(self,m):
        self.n += m

        
class B(A):
    def __init__(self):
        self.n = 3
    def add(self,m):
        super().add(m)
        self.n += 3

输入：      
b = B()
b.add(2)
b.n
输出：8
为什么是8啊？
看不懂继承之后重写的调用函数。

最佳答案

月排行榜 / 总排行榜

ba21

2023-8-26 20:45:50

这里主要涉及了 覆盖 和 继承 2个知识点。只要搞懂 覆盖和继承 ，代码就明白了。

覆盖（也称为 重写）
  覆盖就是指子类和父类中有相同的方法，那么子类的方法会覆盖掉父类的方法，也就是说父类的方法不起作用。
  如本例中的
  A类:

1.    def __init__(self):
   
2.        self.n = 2
   

复制代码

  B类:

1.    def __init__(self):
   
2.         self.n = 3

复制代码

  B类的__init__方法覆盖了A类的__init__方法。



继承
  分2种情况，方法名一样，方法名不一样。
  当方法名一样时，又想使用父类的功能，这时子类中就要用到 父类名.方法名(self, 参数列表)  如: A.add(self, m) 或 super().方法名(参数列表)  如：super().add(m) 来继承父类的方法。

  方法名不一样，子类中就可以直接调用父类的方法

  方法名一样如本例中的
  A类:

1.     def add(self,m):
   
2.         self.n += m     
   

复制代码

  B类:
def add(self,m):
        super().add(m)
        self.n += 3

  这里B类使用super()方法来继承了父类的add方法。拥有父类功能同时还有自己的功能   以上通过继承后，就有了2个功能，继承后方法功能如下：

1. 
   
2. def add(self, m):
   
3.      self.n += m
   
4.      self.n += 3

复制代码

方法名不一样
  class A:
    def __init__(self):
        self.n = 100        
        
    def add_father(self,m):
        self.n += m

        
class B(A):
    def __init__(self):
        self.n = 3        
        
    def add(self,m):         
        self.n += 3

1.   >>> b = B()
   
2.   >>> b.add(2)
   
3.   >>> b.add_father(2) # 可以使用父类的方法。

复制代码

class B(A): B类继承A类，简单点理解就是把A类和B类整合成一个类。

跳转到最佳答案楼层

陶远航

让我帮您解释一下这段代码。

首先，我们有两个类：类A和类B。类B继承自类A，这意味着类B拥有类A的所有属性和方法。

类A中有一个初始化方法__init__(self)，该方法将实例变量n的值设置为2。还有一个名为add(self, m)的方法，它接受一个参数m，并将其加到实例变量n上。

类B也有一个初始化方法__init__(self)，该方法将类A的同名实例变量n的值覆盖为3。类B还重写了名为add(self, m)的方法。在这个方法中，它首先调用父类A的add()方法来执行父类的逻辑。然后，它将参数m加到实例变量n上，并再加上3。

现在让我们来看看具体的操作：

1. b = B()  # 创建类B的实例b
   
2. b.add(2)  # 调用实例方法add，并传入参数2
   
3. print(b.n)  # 打印实例变量n的值
   

复制代码

输出结果为8，这是为什么呢？

1. 首先，通过B()创建了类B的一个实例b。由于类B的__init__()方法覆盖了类A中的同名方法，所以实例变量n被设置为3。
2. 接下来，调用了实例b的add()方法，并传入参数2。在这个方法中，首先调用了父类A的add()方法。因此，实例变量n的值先增加了2，变为5。
3. 接着，子类B的add()方法将参数2再加上3，得到5+3=8。最终，实例变量n的值变成了8。
4. 最后，使用print(b.n)打印实例变量n的值，得到结果8。

所以，根据代码逻辑和运行过程，最后输出的结果是8。

希望这样解释能够帮助您理解这段代码。如有需要，请随时提问！
如果问题已经解决，请设置最佳答案

isdkz

在这段代码中，类B继承自类A，并重写了其中的两个方法。让我们逐步解释代码的执行过程：

1. 创建一个类A，其中的 __init__ 方法初始化了实例变量 n 为2， add 方法将传入的参数m加到实例变量n上。
2. 创建一个类B，它继承了类A。在类B中， __init__ 方法初始化了实例变量 n 为3， add 方法首先调用了父类A的 add 方法，然后将传入的参数m加到实例变量n上，并再加3。

现在来看一下代码的执行过程：

1. 创建一个类B的实例b。
2. 调用b的 add 方法，并传入参数2。这会首先调用类B中的 add 方法，该方法首先调用了父类A中的 add 方法，将参数2加到实例变量n上，此时n的值为5。然后， add 方法再将实例变量n加3，此时n的值为8。
3. 输出b的实例变量n，即输出8。

因此，最终输出的结果是8。

liuhongrun2022

根据给出的代码，当创建类B的实例b时，它会调用类B的构造函数__init__。在类B的构造函数中，self.n = 3将实例变量n设置为3。

然后，调用了实例方法add(2)。这里使用了继承和重写。在类B中的add方法中，通过super().add(m)调用了父类A的add方法。父类A的add方法使实例变量n增加了传入的参数m，即self.n += m。因此，在调用super().add(m)之后，实例变量n的值变为了5（3 + 2）。

接着，类B的add方法又执行了self.n += 3，将实例变量n再次增加了3。所以最终实例变量n的值为8。

因此，输出的结果是8。

此内容为ChatGPT回答，如果对你有帮助，请设置一个最佳答案！

ba21

这里主要涉及了 覆盖 和 继承 2个知识点。只要搞懂 覆盖和继承 ，代码就明白了。

覆盖（也称为 重写）
  覆盖就是指子类和父类中有相同的方法，那么子类的方法会覆盖掉父类的方法，也就是说父类的方法不起作用。
  如本例中的
  A类:

1.    def __init__(self):
   
2.        self.n = 2
   

复制代码

  B类:

1.    def __init__(self):
   
2.         self.n = 3

复制代码

  B类的__init__方法覆盖了A类的__init__方法。



继承
  分2种情况，方法名一样，方法名不一样。
  当方法名一样时，又想使用父类的功能，这时子类中就要用到 父类名.方法名(self, 参数列表)  如: A.add(self, m) 或 super().方法名(参数列表)  如：super().add(m) 来继承父类的方法。

  方法名不一样，子类中就可以直接调用父类的方法

  方法名一样如本例中的
  A类:

1.     def add(self,m):
   
2.         self.n += m     
   

复制代码

  B类:
def add(self,m):
        super().add(m)
        self.n += 3

  这里B类使用super()方法来继承了父类的add方法。拥有父类功能同时还有自己的功能   以上通过继承后，就有了2个功能，继承后方法功能如下：

1. 
   
2. def add(self, m):
   
3.      self.n += m
   
4.      self.n += 3

复制代码

方法名不一样
  class A:
    def __init__(self):
        self.n = 100        
        
    def add_father(self,m):
        self.n += m

        
class B(A):
    def __init__(self):
        self.n = 3        
        
    def add(self,m):         
        self.n += 3

1.   >>> b = B()
   
2.   >>> b.add(2)
   
3.   >>> b.add_father(2) # 可以使用父类的方法。

复制代码

class B(A): B类继承A类，简单点理解就是把A类和B类整合成一个类。

ba21

这鱼C的富文本，真的是搞死人。就这么看吧。

ww185912

自己看看，以后可以用这种方式，看程序是怎么运行的

1. >>> class A:
   
2. ...     def __init__(self):
   
3. ...             self.n = 2
   
4. ...             print(self,self.n)
   
5. ...     def add(self,m):
   
6. ...             self.n += m
   
7. ...             print(self,self.n,m)
   
8. ...
   
9. >>> class B(A):
   
10. ...     def __init__(self):
    
11. ...             self.n = 3
    
12. ...             print("B",self,self.n)
    
13. ...     def add(self,m):
    
14. ...             super().add(m)
    
15. ...             self.n += 3
    
16. ...             print("B",self,self.n,m)
    
17. ...
    
18. >>> b = B()
    
19. B <__main__.B object at 0x000002C14D286E50> 3
    
20. >>> b.add(2)
    
21. <__main__.B object at 0x000002C14D286E50> 5 2
    
22. B <__main__.B object at 0x000002C14D286E50> 8 2
    
23. >>> b.n
    
24. 8

复制代码

注意，__init__函数只有在实例化时候才会执行