5问明白多态(深挖笔试题)

5问明白多态(深挖笔试题)

请问运行结果是啥?

public class InterviewTest1 {

	public static void main(String[] args) {
		Base1 base = new Sub1();
		base.add(1, 2, 3);

		Sub1 s = (Sub1) base;
		s.add(1, 2, 3);
	}
}

class Base1 {
	public void add(int a, int... arr) {
		System.out.println("base1");
	}
}

class Sub1 extends Base1 {

	public void add(int a, int[] arr) {
		System.out.println("sub_1");
	}

	public void add(int a, int b, int c) {
		System.out.println("sub_2");
	}

}

//答案
sub_1
sub_2

• 第一个解答: base.add(1, 2, 3); 时候这个参数是否合法,看的是Base1中是否有能满足该种类型的参数,明显有,会把 2 3 点的工作参数传递给…arr,这时候2 3被变成了数组类型,执行方法的时候看的是子类,然后1 arr[2,3]肯定对应Sub1的第一个方法,执行结果是sub_1.
• 第二个解答:base向下转型为Sub1,此时的add(1,2,3)当然要走Sub1中的方法,那么类型刚好对应第二个add,输出sub_2

把Sub1中的第一add方法改后,请问运行结果是啥?

//考查多态的笔试题目：
public class InterviewTest1 {

	public static void main(String[] args) {
		Base1 base = new Sub1();
		base.add(1, 2, 3);

		Sub1 s = (Sub1) base;
		s.add(1, 2, 3);
	}
}

class Base1 {
	public void add(int a, int... arr) {
		System.out.println("base1");
	}
//	public void add(int a, int b,int c) {
//		System.out.println("base11");
//	}
}

class Sub1 extends Base1 {

	public void add(int a, int... arr) {
		System.out.println("sub_1");
	}

	public void add(int a, int b, int c) {
		System.out.println("sub_2");
	}

}

//答案:
sub_1
sub_2

• 结果没变, 第一个解释不用解释,看第二个,在同一个类(Sub1)中方法重载时候要满足重载的规则(百度查你就知道了)不能参数类型相同,两个方法按理说都可以接受int a,int b, int c,但是为了满足重载接受3个整形参数的时候走的是第二个add方法,当把第二个add方法注释掉的时候结果就都是sub_1了.

//考查多态的笔试题目：
public class InterviewTest1 {

	public static void main(String[] args) {
		Base1 base = new Sub1();
		base.add(1, 2, 3);

		Sub1 s = (Sub1) base;
		s.add(1, 2, 3);
	}
}

class Base1 {
	public void add(int a, int... arr) {
		System.out.println("base1");
	}
//	public void add(int a, int b,int c) {
//		System.out.println("base11");
//	}
}

class Sub1 extends Base1 {

	public void add(int a, int... arr) {
		System.out.println("sub_1");
	}

//	public void add(int a, int b, int c) {
//		System.out.println("sub_2");
//	}

}

结果

sub_1
sub_1

那么改成如下你知道结果是什么了么

public class InterviewTest1 {

	public static void main(String[] args) {
		Base1 base = new Sub1();
		base.add(1, 2, 3);

		Sub1 s = (Sub1) base;
		s.add(1, 2, 3);
	}
}

class Base1 {
	public void add(int a, int... arr) {
		System.out.println("base1");
	}
	public void add(int a, int b,int c) {
		System.out.println("base11");
	}
}

class Sub1 extends Base1 {



}

base11
base11

• 答案都是base11,子类没有重写父类方法的时候走的是父类方法,所以上面走得是父类的方法,根据参数走的是第二个add方法.第二个答案中走的是子类继承的父类的方法,也是第二个add方法.

4个参数的时候呢?

public class InterviewTest1 {

	public static void main(String[] args) {
		Base1 base = new Sub1();
		base.add(1, 2, 3,4);

		Sub1 s = (Sub1) base;
		s.add(1, 2, 3);
	}
}

class Base1 {
	public void add(int a, int... arr) {
		System.out.println("base1");
	}
//	public void add(int a, int b,int c) {
//		System.out.println("base11");
//	}
}

class Sub1 extends Base1 {

	public void add(int a, int... arr) {
		System.out.println("sub_1");
	}

	public void add(int a, int b, int c) {
		System.out.println("sub_2");
	}

}

答案
sub_1
sub_2

• 第一个答案:编译前看的是父类是否有这种方法,且参数类型是否在父类有,没有就会爆错,这里明显满足父类第一个add方法,然后运行走的是子类,自然而然走的就是子类的第一个add方法,这个方法是对应父类第一个add方法的重写,

注意这两个方法不可以同时出现在子类,也不能同时出现在父类中,他们不满足重载的规定. 他俩可以分别出现在子父类中,算作重写.(知识点有点偏,但是是重写出现在子父类中)

	public void add(int a, int... arr) {
		System.out.println("sub_1");
	}
	public void add(int a, int [] arr) {
		System.out.println("sub_1");
	}

当两个参数的时候,下面结果是啥

public class InterviewTest1 {

	public static void main(String[] args) {
		Base1 base = new Sub1();
		base.add(1, 2, 3,4);

		Sub1 s = (Sub1) base;
		s.add(1, 2);
	}
}

class Base1 {
	public void add(int a, int... arr) {
		System.out.println("base1");
	}

	public void add(int a, int b,int c) {
		System.out.println("base11");
	}
}

class Sub1 extends Base1 {

	public void add(int a, int... arr) {
		System.out.println("sub_1");
	}


	public void add(int a, int b) {
		System.out.println("sub_222");
	}

}

sub_1
sub_222

• Sub1中第二add方法是重载,Sub1类型的类调用这个方法.

下面的时候答案是什么呢?

package duotai;

public class Interverl1 {

    public static void main(String[] args) {
        Base1 base = new Sub1();
        base.add(1, 2, 3);

//        Sub1 s = (Sub1) base;
//        s.add(1, 2, 3);
    }
}

class Base1 {
    public void add(int a, int... arr) {
        System.out.println("base1");
    }
}

class Sub1 extends Base1 {

//    public void add(int a, int[] arr) {
//        System.out.println("sub_1");
//    }

    public void add(int a, int b, int c) {
        System.out.println("sub_2");
    }

}
结果:base1

子类中并没有重写下面这个方法,所以走的是父类的方法,怎么也不能是sub_2;如果int a,int[] arr注释打开的话那么答案就是sub_1了.

 public void add(int a, int... arr) {
        System.out.println("base1");
    }