面试题1

原创
2019/08/11 14:39
阅读数 79
package com.liuyuan.test02;

public class Test02 {
	public static void main(String[] args) {
		Father f = new Father();
		Son s = new Son();
		System.out.println(f.getInfo());
		System.out.println(s.getInfo());
		s.test();
		System.out.println("-----------------");
		s.setInfo("大源源");
		System.out.println(f.getInfo());
		System.out.println(s.getInfo());
		s.test();
	}
}
class Father{
	private String info = "liuyuanyuan";
	public void setInfo(String info){
		this.info = info;
	}
	public String getInfo(){
		return info;
	}
}
class Son extends Father{
	private String info = "刘源源";
	public void test(){
		System.out.println(this.getInfo());
		System.out.println(super.getInfo());
	}
}

liuyuanyuan
liuyuanyuan
liuyuanyuan
liuyuanyuan
-----------------
liuyuanyuan
大源源
大源源
大源源
 

package com.liuyuan.test06;

/*
 * 实例初始化的过程:
 * (1)父类的实例初始化
 * <init>(){
 * 		x = 10;//父类的x
 * 		this.print();//子类的print,因为this代表的是正在创建的子类对象,而子类重写了print,所以是子类的print'
 * 				System.out.println("Son.x = " + x);//子类的x  没有赋值x=0
		x = 20;//父类的x
 * }
 * (2)子类的实例初始化
 * <init>(){
 * 		x = 30;//子类的x
 * 		this.print();//子类的print
 * 			System.out.println("Son.x = " + x);//子类的x  已经赋值x=30
		x = 40;//子类的x
 * }
 */
public class Test06 {
	public static void main(String[] args) {
		Father f = new Son();
		System.out.println(f.x);//编译时是Father类型,访问Father中的x   x=20
	}
}
class Father{
	int x = 10;
	public Father(){
		this.print();
		x = 20;
	}
	public void print(){
		System.out.println("Father.x = " + x);
	}
}
class Son extends Father{
	int x = 30;
	public Son(){
		this.print();
		x = 40;
	}
	public void print(){
		System.out.println("Son.x = " + x);
	}
}

Son.x = 0
Son.x = 30
20
 

package com.liuyuan.test07;

/*
 * (1)类的初始化
 * <clinit>(){
 * 		int x = 5;//局部变量
		x--;//局部变量		x=4
 * 		Test07.x--;//静态变量      x = -1
 * }
 * (2)执行main方法
 * System.out.println("x=" + x);//静态变量   -1
 * z--;//静态变量   z=-1
 * method();
 * 		y = z++ + ++z;//静态变量   
 * 			①先加载z的值“-1”②z自增,z=0③z自增 z =1④加载z的值“1” ⑤求和  “-1” + “1” = 0⑥把0赋值给y   y=0
 * System.out.println("result:" + (z + y + ++z));
 * 			①加载z的值“1”  ②加载y的值"0" ③z自增  z=2 ④加载z的值“2”  ⑤求和  “1” + “0” + “2”
 * 
 */
public class Test07 {
	static int x, y, z;//类变量,静态变量,成员变量   默认值0

	static {
		int x = 5;//局部变量
		x--;//局部变量
	}

	static {
		x--;//静态变量
	}

	public static void main(String[] args) {
		System.out.println("x=" + x);//静态变量
		z--;//静态变量
		method();
		System.out.println("result:" + (z + y + ++z));//静态变量
	}

	public static void method() {
		y = z++ + ++z;//静态变量
	}
}

x=-1
result:3
 

package com.test07;

/*
 * new A(new B());
 * (1)new B()
 * <init>(){
 * 		System.out.println("B");
 * }
 * (2)new A(B的对象)
 * <init>(B b){
 * 		this();
 * 				System.out.println("A");
 * 		System.out.println("AB");
 * }
 */
public class Test07 {

	public static void main(String[] args) {
		new A(new B());
	}
}

class A {
	public A() {
		System.out.println("A");
	}

	public A(B b) {
		this();
		System.out.println("AB");
	}
}

class B {
	public B() {
		System.out.println("B");
	}
}

B
A
AB
 

package com.test08;

/*
 * 1、Base b1 = new Base();
 * 父类的实例初始化,和子类无关
 * 
 * <init>(){
 * 		method(100);
 * 			System.out.println("base : " + i);  base:100
 * }
 * 
 * 2、Base b2 = new Sub();
 * (1) 父类的实例初始化
 * 
 * <init>(){
 * 		method(100);//执行了子类重写的method()
 * 			System.out.println("sub : " + j);  sub:100
 * }
 * 
 * (2)子类的实例初始化
 * <init>(){
 * 		super.method(70);
 * 			System.out.println("base : " + i);	base:70
 * }
 */
public class Test08 {
	public static void main(String[] args) {
		Base b1 = new Base();
		Base b2 = new Sub();
	}
}

class Base {
	Base() {
		method(100);
	}

	public void method(int i) {
		System.out.println("base : " + i);
	}
}

class Sub extends Base {
	Sub() {
		super.method(70);
	}

	public void method(int j) {
		System.out.println("sub : " + j);
	}
}

base : 100
sub : 100
base : 70
 

package com.liuyuan.test08;

/*
 * (1)父类的实例初始化
 * <init>(){
 * 		System.out.println("base");
 * 		method(100);  //子类重写了,执行子类的method
 * 				System.out.println("sub : " + j);  sub:100
 * }
 * (2)子类实例初始化
 * <init>(){
 * 		System.out.println("sub");   sub
 * 		super.method(70);  //父类的method
 * 				System.out.println("base : " + i);  base 70
 * }
 */
public class Test08 {
	public static void main(String[] args) {
		Sub s = new Sub();
	}
}
class Base{
	Base(){
		method(100);
	}
	{
		System.out.println("base");
	}
	public void method(int i){
		System.out.println("base : " + i);
	}
}
class Sub extends Base{
	Sub(){
		//隐含了:super()
		super.method(70);
	}
	{
		System.out.println("sub");
	}
	public void method(int j){
		System.out.println("sub : " + j);
	}
}

base
sub : 100
sub
base : 70
 

package com.atguigu.homewok.test09;

/*
 * final
 * 方法的参数传递机制
 */
public class Test09 {
	public static void main(String[] args) {
		Other o = new Other();
		new Test09().addOne(o);
		System.out.println(o.i);
	}
	
	//o是引用数据类型,实参给形参的是地址值,那么形参修改了属性,实参也会修改
	//o变量的值不能修改,不是说i的值不能修改
	public void addOne(final Other o){
		o.i++;
	}
}
class Other{
	public int i;//默认值0
}

1

package com.test01;

/*
 * 考核点:多态,重载,重写
 * 1、分析每个类都有什么方法
 * A类:
 *   public String show(D obj)
 *   public String show(A obj)
 * B类:
 * 	 public String show(D obj)
 *   public String show(A obj)重写
 *   public String show(B obj)
 * C类和D类,因为这里没有用它们的对象去调用方法,暂时不分析。
 * 
 * 2、继承关系
 * C-->B-->A
 * D-->B-->A
 * 
 * 3、如果出现重载的多个方法,会找其中类型最合适的
 * 
 * 4、分析代码
 * (1)a1.show(b),因为这里a1没有多态引用,编译时类型和运行时类型都是A类,只看A类的方法。
 * 此时b对象是B类型,那么public String show(A obj)这个方法最合适,因为b不能赋值给D子类的形参,只能自动向上转型为A类
 *
 * (2)a2.show(d),因为这里a2有多态,编译时类型是从A类型中寻找最合适的方法,运行时执行的B类的重写的方法,如果B类没有重写,还是执行的是A类的
 * 此时d对象是D类型,在A类中public String show(D obj)这个方法最合适。
 * 
 * (3)b.show(c),因为b没有多态,编译时类型和运行时类型都是B类,从B类中选择最合适的方法
 * 此时c对象是C类型,在B类中public String show(B obj)最合适的,因为C与B最近,比与A近
 * 
 * (4)b.show(d),因为b没有多态,编译时类型和运行时类型都是B类,从B类中选择最合适的方法
 * 此时d对象是D类型,在B类中public String show(D obj)最合适
 */
public class Test01 {
	public static void main(String[] args) {
		A a1 = new A();
		A a2 = new B();
		B b = new B();
		C c = new C();
		D d = new D();
		System.out.println("(1)" + a1.show(b));//A and A
		System.out.println("(2)" + a2.show(d));//A and D
		System.out.println("(3)" + b.show(c));//B and B
		System.out.println("(4)" + b.show(d));//A and D
	}
}
class A{
	public String show(D obj){
		return ("A and D");
	}
	public String show(A obj){
		return "A and A";
	}
}
class B extends A{
	public String show(B obj){
		return "B and B";
	}
	public String show(A obj){
		return "B and A";
	}
}
class C extends B{
	
}
class D extends B{
	
}

(1)A and A
(2)A and D
(3)B and B
(4)A and D
 

package com.test02;

/*
 * 考核点:多态,重载,重写
 * 1、分析每个类都有什么方法
 * A类:
 *   public String show(C obj)
 *   public String show(A obj)
 * B类:
 * 	 public String show(C obj)
 *   public String show(A obj)重写
 *   public String show(B obj)
 * C类和D类,因为这里没有用它们的对象去调用方法,暂时不分析。
 * 
 * 2、继承关系
 * C-->B-->A
 * D-->B-->A
 * 
 * 3、如果出现重载的多个方法,会找其中类型最合适的
 * 
 * 4、分析代码
 * (1)a1.show(b),a1没有多态,从A类找,public String show(A obj)
 * (2)a2.show(d),a2有多态,编译时看A类,在A类中找最合适public String show(A obj)
 * 		执行时,看运行时类型,看B类,B类中有重写的方法  
 * (3)b.show(c),b没有多态,从B类中找public String show(C obj) 
 * (4)b.show(d),b没有多态,从B类中找public String show(B obj)
 */
public class Test02 {
	public static void main(String[] args) {
		A a1 = new A();
		A a2 = new B();
		B b = new B();
		C c = new C();
		D d = new D();
		System.out.println("(1)" + a1.show(b));//A and A
		System.out.println("(2)" + a2.show(d));//B and A
		System.out.println("(3)" + b.show(c));//A and C
		System.out.println("(4)" + b.show(d));//B and B
	}
}

class A {
	public String show(C obj) {
		return ("A and C");
	}

	public String show(A obj) {
		return "A and A";
	}
}

class B extends A {
	public String show(B obj) {
		return "B and B";
	}

	public String show(A obj) {
		return "B and A";
	}
}

class C extends B {

}

class D extends B {

}

(1)A and A
(2)B and A
(3)A and C
(4)B and B
 

展开阅读全文
打赏
0
0 收藏
分享
加载中
更多评论
打赏
0 评论
0 收藏
0
分享
返回顶部
顶部