java继承中成员变量的访问特点、多态中成员变量的访问特点、多态中成员方法的访问特点。

继承中成员变量的访问特点：
在父子类的继承关系当中，如果成员变量重名，则创建子类对象时，
访问成员变量有两种方式：

1. 直接通过子类对象访问成员变量：
   等号左边是谁，就优先用谁，没有则向上找。
2. 间接通过成员方法访问成员变量：
   该方法属于谁，就优先用谁，没有则向上找。



package cn.itcast.day09.demo02;

public class Demo01ExtendsField {
    public static void main(String[] args) {
        Fu fu=new Fu();//创建父类对象
        System.out.println(fu.numFu);//只能使用父类的东西，没有任何子类内容
        System.out.println("=================");


        Zi zi=new Zi();
        System.out.println(zi.numFu);//10
        System.out.println(zi.numZi);//20
        System.out.println("=================");


        //等号左边是谁，就优先用谁
        System.out.println(zi.num);//优先子类，200
     // System.out.println(zi.num);//先优先找子类，子类没有，又向上找父类，父类也没有，编译报错！
        System.out.println("=================");

        //这个方法是在子类中定义的，优先用子类的，没有再向上找
        zi.methodZi();//200
        //这个方法是在父类中定义的，优先用父类的，没有再向上找
        zi.methodFu();//100

    }
}



package cn.itcast.day09.demo02;

public class Fu {
    int numFu=10;
    int num=100;

    public void methodFu(){
    //使用的是本类当中的，不会向下找子类的
        System.out.println(num);
    }
}


package cn.itcast.day09.demo02;

public class Zi  extends Fu {
    int numZi=20;
    int num=200;


    public void methodZi(){
        //因为本类当中有num，所以这里用的是本类的num
        System.out.println(num);
    }
}

多态中成员变量的访问特点：

多态中访问成员变量的两种方式：
1.直接通过对象名称访问成员变量：看等号左边是谁，优先用谁，
没有则向上找(注意：编译和运行都仅看等号左边，与多态中访问
成员方法不同)。
2.间接通过成员方法访问成员变量：看该方法属于谁，优先用谁，
没有则向上找。


package cn.itcast.day10.demo05;

public class Demo01MultiField {
    public static void main(String[] args) {
    //使用多态的写法，父类引用指向子类对象

    Fu obj=new Zi();
    System.out.println(obj.num);//父：10，直接通过对象名称访问成员变量。
  //  System.out.println(obj.age);//错误写法，Fu类中没有age,向上找，Object中也没有age。


     System.out.println("=============");
     obj.showNum();//子类没有覆盖重写，就是父：10，间接通过成员方法访问成员变量。
     //若子类覆盖重写了，则该方法就是属于子类的：20。即看该方法属于谁，则优先用谁。


    }
}



package cn.itcast.day10.demo05;

public class Fu /*extends Object */ {
//@Override，只有方法能覆盖重写，成员变量不能覆盖重写。
    int num=10;

  public void showNum(){
      System.out.println(num);
  }
  
}



package cn.itcast.day10.demo05;

public class Zi extends Fu {
    //@Override，只有方法能覆盖重写，成员变量不能覆盖重写。
    int num=20;

    int age=16;

    @Override
    public void showNum(){
        System.out.println(num);
    }
}

多态中成员方法的访问特点:

在多态的代码当中，成员方法的访问规则是：
 看new的是谁，就优先用谁，没有则向上找。
口诀:编译看左边，运行看右边（左父右子，即编译看父，运行看子）。
即使用多态方式调用成员方法时，编译看父类，首先检查父类
是否有该方法，如果没有，则编译报错；如果有，则运行时再去检查
子类是否有此方法，若子类有此方法，则运行时优先调用子类的该方法，
若子类没有该方法，则运行时调用父类的该方法。


package cn.itcast.day10.demo05;


public class Demo02MultiMethod {
    public static void main(String[] args) {

        Fu obj=new Zi();//多态

       obj.method();//父子都有，优先用子（编译看左边，左边的父类中有method，然后运行看右边，右边的子类中也有该方法，运行用子类）
       obj.methodFu();//子类没有，父类有，向上找到父类（编译看左边，左边的父类中有methodFu，然后运行看右边，右边的子类中没有该方法，
        // 向上找到父类，父类中有该方法，所以该运行用父类。）

     //编译看左边，左边是Fu，Fu当中没有methodZi方法，所以编译报错。

    // obj.methodZi();//错误写法


    }
}




package cn.itcast.day10.demo05;

public class Fu /*extends Object */ {
//@Override，只有方法能覆盖重写，成员变量不能覆盖重写。
    int num=10;

  public void showNum(){
      System.out.println(num);
  }


  public void method(){
      System.out.println("父类方法");
  }


    public void methodFu(){
        System.out.println("父类特有方法");
    }


}




package cn.itcast.day10.demo05;

public class Zi extends Fu {
    //@Override，只有方法能覆盖重写，成员变量不能覆盖重写。
    int num=20;

    int age=16;

    @Override
    public void showNum(){
        System.out.println(num);
    }


   @Override
    public void method(){
        System.out.println("子类方法");
    }



    public void methodZi(){
        System.out.println("子类特有方法");
    }
}