Day40面试题：子类父类题

方法重载@Overload

• （1）什么是方法重载
  Java允许在同一个类中，定义多个名字相同的方法 ，但是这些相同名字的方法必须具有不同的参数列表
  案例：比较两个数是否相等

• （2）重载方法有什么意义？
  为了减少程序员对功能相同的方法的记忆负担

• （3）JVM如何调用重载的方法
  》根据方法名查找
  》再找参数类型

• （4）如何判断方法重载
  》与什么有关?
  参数列表不同：参数类型,参数个数,顺序必须不同
  》与什么无关?
  1)参数列表名字无关
  2)返回值类型无关
  3)public static

练习题

public static void open(){}
public static void open(int a){}
static void open(int a,int b){}
public static void open(double a,int b){}
public static void open(int a,double b){}
public void open(int i,double d){}
public static void OPEN(){}
public static void open(int i,int j){}

案例:

class MyDemo{
    //定义一个方法判断两个数是否相等
    public boolean isSame(int a,int b){//JVM: isSame(int,int)
        System.out.println(" isSame(int a,int b)");
        return a == b;
    }
//    public boolean isSame(int x,int y){//JVM: (int,int)
//        System.out.println(" isSame(int x,int x)");
//        return x == y;
//    }
    public boolean isSame(int a,int b,int c){//JVM: isSame(int,int,int) 个数不一样
        System.out.println(" isSame(int a,int b,int c)");
        return a == b;
    }
    public boolean isSame(int a,double b){//类型不一样JVM: isSame(int,double)
        System.out.println(" isSame(int a,double b)");
        return a == b;
    }
    public boolean isSame(double a,int b){//顺序不一样isSame(double,int)
        System.out.println(" isSame(int a,double b)");
        return a == b;
    }
    public boolean isSame(double a,double b){
        System.out.println(" isSame(double a,double b)");
        return a == b;
    }
    public boolean isSame(long a,long b){
        System.out.println(" isSame(long a,long b)");
        return a == b;
    }
    public boolean isSame(byte a,byte b){
        System.out.println(" isSame(byte a,byte b)");
        return a == b;
    }
}
class Ex{
    static void open(int a,int b){}
    public static void open(double a,int b){}
    public static void open(int a,double b){}
    //public void open(int i,double d){}
    //public static void OPEN(){}
    //public static void open(int i,int j){}
}
public class Test04重载 {
    @Test
    public void test01(){
        int a = 10;
        int m = 10;
        MyDemo md=new MyDemo();
        System.out.println(md.isSame(10,10));
        System.out.println(md.isSame(10.0,10.0));
        // System.out.println是个典型的重载
        //好处是大在的减少了记忆负担
    }
}

方法重写@Override

• （1）什么是重写
  在子类中出现和父类 一模一样的方法。
  可以使用@Override的检验，但不是必须加
• （2）重写有什么特点
  子类重写父类的方法，子类对象调用该方法，执行是子类的方法
• （3）重写有什么意义?
  功能增强

class Fu{
    public void  eat(){
        System.out.println("父类的eat方法");
    }
    public void  run(){
        System.out.println("父类的run方法");
    }
}
class Zi extends Fu{
    //重写
    //@Override 报告算不上重写
    public void  study(){
        System.out.println("子类的study方法");
    }
    @Override  //重写 子类出现跟父类一样的方法（除方法体外）
    public void  run(){
        System.out.println("子类的run方法");
    }
}
class Phone{ //以前的手机
    public void send(){
        System.out.println("文字");
    }
}
class SmartPhone extends Phone{ //新一代的手机
    //子类重写父类的方法的意义是增加原方法
    public void send(){
        System.out.println("文字");
        System.out.println("视频");
        System.out.println("语音");
        System.out.println("图片");
    }
}
public class Test05重写 {
    @Test
    public void test01(){
        //子类重写父类的方法，子类对象调用该方法，执行是子类的方法
        SmartPhone sp = new SmartPhone();
        sp.send();
    }
}

孔子的爹

class Father{
    public String name="孔子他爹";
    public int age = 50;
    public void teach(){
        System.out.println("教四书五经");
    }
}
class Son extends Father{
    public String name="孔子";
    public int age = 30;
    public void teach(){
        System.out.println("教论语");
    }
}
public class Test06重写Ex {
    @Test
    public void test01(){
        Son son = new Son();
        System.out.println(son.name);
        System.out.println(son.age);
//        son.teach();

    }
    @Test
    public void test02(){
        Father son = new Son();
        System.out.println(son.name);
        System.out.println(son.age);
       // son.teach();

        //只要是子类对象 ，等号左边不管是Father,还是Son，执行的都子类的方法
        //变量没有覆盖重写一说，子类继承父类，子就有父类成员变量。
        //想调父类的变量，等号左边写父类
        //想调子类的变量,等号左边就写子类
    }
}