看了子父类，想到一个问题

class Fu
{

public void person()
{
  
}
  
}
class Zi extends Fu
{
public void person()
{
  
}
}
class Zi1 extends Fu
{
public void person()
{
  
}
}
我想问的是，当Zi复写Fu的方法之后，Zi1继承Fu，当Zi1调用Fu的方法的时候是调用的Fu的方法，还是调用的被Zi复写后的方法
最好能详细的说一下为什么，谢谢大家

我想问的是父类的一个方法被覆盖之后，被其他的子类再次调用的时候，被调用的是已经覆盖的过方法还是父类原有的方法

像2楼那样直接复制视频中的东西就不用回答了吧，那些我也有，请大家看清楚问题，再回答

2,子父类中的函数。

当子类出现和父类一模一样的函数时，
当子类对象调用该函数，会运行子类函数的内容。
如同父类的函数被覆盖一样。

这种情况是函数的另一个特性：重写(覆盖)


当子类继承父类，沿袭了父类的功能，到子类中，
但是子类虽具备该功能，但是功能的内容却和父类不一致，
这时，没有必要定义新功能，而是使用覆盖特殊，保留父类的功能定义，并重写功能内容。


覆盖：
1，子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则编译失败。

2，静态只能覆盖静态。


记住大家：
重载：只看同名函数的参数列表。
重写：子父类方法要一模一样。
*/

class Fu
{
        void show()
        {
                System.out.println("fu show");
        }
        void speak()
        {
                System.out.println("vb");
        }
}

class Zi extends Fu
{
        void speak()
        {
                System.out.println("java");
        }
        void show()
        {
                System.out.println("zi show");
        }
}


class ExtendsDemo3
{
        public static void main(String[] args)
        {
                Zi z = new Zi();
                z.speak();

        }
}


class Tel
{
        void show()
        {
                System.out.println("number");
        }
       
}

class NewTel extends Tel
{
        void show()
        {
                //System.out.println("number");
                super.show();
                System.out.println("name");
                System.out.println("pic");
        }
}

2,子父类中的函数。

当子类出现和父类一模一样的函数时，
当子类对象调用该函数，会运行子类函数的内容。
如同父类的函数被覆盖一样。

这种情况是函数的另一个特性：重写(覆盖)


当子类继承父类，沿袭了父类的功能，到子类中，
但是子类虽具备该功能，但是功能的内容却和父类不一致，
这时，没有必要定义新功能，而是使用覆盖特殊，保留父类的功能定义，并重写功能内容。


覆盖：
1，子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则编译失败。

2，静态只能覆盖静态。


记住大家：
重载：只看同名函数的参数列表。
重写：子父类方法要一模一样。
*/

class Fu
{
        void show()
        {
                System.out.println("fu show");
        }
        void speak()
        {
                System.out.println("vb");
        }
}

class Zi extends Fu
{
        void speak()
        {
                System.out.println("java");
        }
        void show()
        {
                System.out.println("zi show");
        }
}


class ExtendsDemo3
{
        public static void main(String[] args)
        {
                Zi z = new Zi();
                z.speak();

        }
}


class Tel
{
        void show()
        {
                System.out.println("number");
        }
       
}

class NewTel extends Tel
{
        void show()
        {
                //System.out.println("number");
                super.show();
                System.out.println("name");
                System.out.println("pic");
        }
}

子类和父类有同名变量或者同名功能时，子类创建的对象在调用该变量或者方法时应用的是子类的，
所以子类调用的是被复写后的方法,即this.xx。
只有当子类中没有这个方法或者变量时，才调用父类的，即super.x

当Zi复写Fu的方法之后，Zi1继承Fu，当Zi1调用Fu的方法的时候是调用的Fu的方法，还是调用的被Zi复写后的方法？
答：如果Zi1中没有复写父类的该方法，他会调用父类的方法，如果复写了该方法，则调用自己的方法
子类复写父类方法后如果想调用父类方法，可以用super.method();来调用

class Fu
{
        public void person()
        {
                System.out.println("fu");
        }
}
class Zi extends Fu
{
        public void person()
        {
                System.out.println("zi");
        }
}
class Zi1 extends Fu
{
        public void person()
        {
                System.out.println("zi1");
        }
}
class Demo
{
        public static void main(String[] args)
        {
                Zi z =new Zi();
                z.person();
                Zi1 z1=new Zi1();
                z1.person();
        }
}
Zi覆写父类方法，调用的是Zi覆写之后的方法，同理Zi1也是一样的，楼主可以用上面的代码运行下，可以很直观的发现子类覆写父类方法后，调用的都是各自覆写后的方法。

1. package p719;
   
2. class Fu
   
3. {
   
4. 
   
5. public void person()
   
6. {
   
7.   System.out.println("这是你爸爸");
   
8. }
   
9.   
   
10. }
    
11. class Zi extends Fu
    
12. {
    
13. public void person()
    
14. {
    
15.   System.out.println("这是你");
    
16. }
    
17. }
    
18. class Zi1 extends Fu
    
19. {
    
20. public void person()
    
21. {
    
22.   System.out.println("这是你儿子");
    
23. }
    
24. }

复制代码

1、Fu-Zi-Zi1：
      ①继承：子类继承父类，就是把父类的(除了构造函数外的)所有成员都拷贝一份过来了，成了自己的了。
      ②覆盖：子类把父类的成员都拿过来后，发现有些成员自己已经有了，不需要了，就把父类继承过来的重复成员丢掉了。
2、你这个类里面，person（）方法，由于父亲-子-孙都给子有，不需要继承了。
       当调用的时候，各人用各人的，互不相关的。

3、举个例子：
   ①爸爸：一辆车、一栋房、一个存折
   ②儿子：一辆车、一个存折
   ③孙子：一个存折
当他们都继承了后
  ①爸爸：一辆车、一栋房、一个存折
   ②儿子：一辆车、一栋房(爸爸的)一个存折
   ③孙子：一辆车(儿子的)、一栋房(爸爸的)、一个存折

  儿子把爸爸的东西都拿来过来，一看，我有车，有存折，从爸爸那里拿来的就甩掉了，只把爸爸的房子拷贝一份拿过来了。
孙子看到儿子的，只把儿子的车和房子拷贝后，拿了过来。

4、继续过来的就成了自己的，虽然口上面说，这房子是我爸爸的，其实现在属于你了。他们三个人都各自用各自的东西了，
   互不干扰的，虽然说有些东西一样，不过不是一个东西。

      

一个子类覆盖了父类中的方法后，另一个子类调用或者重新覆盖的还是父类中原先的方法；
以你的代码为例：

1. class Fu
   
2. {
   
3. public void person()
   
4. {
   
5.                 System.out.println("fu person");
   
6. }
   
7.   
   
8. }
   
9. class Zi extends Fu
   
10. {
    
11.         public void person()
    
12.         {
    
13.                 System.out.println("zi person");
    
14.         }
    
15. }
    
16. class Zi1 extends Fu
    
17. {
    
18.         /*
    
19.         这里注释掉，不覆写父类中的person方法，以便于观察打印结果
    
20.         public void person()
    
21.         {
    
22.                 System.out.println("zi1 person");
    
23.         }
    
24.         */
    
25. }
    
26. 
    
27. class Test
    
28. {
    
29.         public static void main(String[] args)
    
30.         {
    
31.                 Zi z=new Zi();
    
32.                 z.person();
    
33.                 Zi1 z1=new Zi1();
    
34.                 z1.person();
    
35. 
    
36.         }
    
37. }

复制代码

在子类Zi覆写了父类中的person方法后，
新创建一个Zi1对象，再次调用person方法，可以发现调用的是父类中原先的person方法；
结果如下：

“我想问的是，当Zi复写Fu的方法之后，Zi1继承Fu，当Zi1调用Fu的方法的时候是调用的Fu的方法，还是调用的被Zi复写后的方法”
当子类从写了父类的方法后，创建子类对象调用从写的方法，都是调用子类自己的。多个类继承某一个类。用子类调用从写的方法都是调用子类自己从写的方法。

class Fu
{
        public void person()
        {
                System.out.println("fu");
        }
}
class Zi extends Fu
{
        public void person()
        {
                System.out.println("zi");
        }
}
class Zi1 extends Fu
{
        public void person()
        {
                System.out.println("zi1");
        }
}
class Demo
{
        public static void main(String[] args)
        {
                Zi z =new Zi();
                z.person();
                Zi1 z1=new Zi1();
                z1.person();
        }
}

父类的一个方法被覆盖之后，被其他的子类再次调用的时候，被调用的是已经覆盖的过方法还是父类原有的方法
答案是子类的，用毕老师的话，自己没有再找外面的，有了就不找了。

补充一点：
当子类成员变量和父类中的变量同名时，这时要调用子类的成员变量，在变量前就要加上this了，父类加super

答案很短，但希望你能理解呀。

Zi继承父类，就相当于把父类的内容全部复制到子类中，由于子类中有跟父类一模一样的方法，如果不覆盖方法，调用该方法时会不知道该调用哪个方法，所以子类就将父类中一模一样的方法的内容覆盖，而父类中的内容原来是什么样还是什么样，子类覆盖方法只是在子类的内容中进行，不会改变父类中的内容。也就是说，父类被其子类继承，只是将自己中的成员复制给其子类，而自己并没有随着子类的变化而变化。
举个例子，复制文件的时候，源文件不会因为复制文件的独立操作而改变其内容。

Zi1继承Fu， 调用的是fu的方法， 与zi 无关，你可以分析他们的内存

首先：子类继承父类，如果子类没有覆盖父类的方法，则调用父类的方法；如果覆盖了父类的方法，则调用子类自己复写后的方法；
多个子类继承同一父类，各子类间关系独立，如果子类（zi zi1）之间没有调用，两个子类是没有任何联系的；
回到本题：
zi复写父类中的方法，调用时为本身（zi中的方法）
zi1如果没有复写父类的方法，调用时还是父类的方法！zi1如果复写父类中的方法，调用时为本身（zi1中的方法）
所以，父类的一个方法被(zi)覆盖之后，被其他的子类(zi1)再次调用的时候，被调用的还是父类原有的方法;
zi和zi1两个子类是独立的，他们都继承了父类，根据需要分别去实现和覆盖父类的方法；
zi1的继承父类调用仍是父类的方法，与zi是否复写父类的方法没有任何关系！

package day002;

public class FuDemo {

        public static void main(String[] args) {
               
                Zi1 f = new Zi1();
                f.person();
               
        }
}
class Fu
{

public void person()
{
   System.out.println("1111111111");
}
  
}
class Zi extends Fu
{
public void person()
{
   System.out.println("22222222222");
}
}
class Zi1 extends Fu
{
    public void person1(){
            System.out.println("4444444444");
    }
}

你的意思是这样吧，  Zi1里面没有复写fu的方法，zi里面复写了fu的方法， 然后拿Zi1调用fu类方法是吧？

这样当然是执行父类的啊，zi1 是zi1 是的啊， 和zi没关系啊，    zi1里面并没有重写父类方法啊，所以调用fu类方法，当然要执行父类方法啊，
哪个类重写就跟哪个类有关系，别的类重写了，你用不是重写的调用父类，肯定不会走重写那个类的方法啊。