Java笔试题

System.out.println(3+5+"a"+6+7);    输出：8a67

interface只能用public 和 默认修饰符 修饰

static域的执行时间（第一次用类的时候执行一次，以后就不执行了） 

class A {   
  
    public static void pri() {   
        System.out.println("A");   
    }   
}   
  
public class B extends A {   
  
    public static void pri() {   
        System.out.println("B");   
    }   
  
    public static void main(String[] args) {   
        A a = new B();   
        a.pri();   
  
    }   
}  

输出：A

class A {   
  
    public  void pri() {   
        System.out.println("A");   
    }   
}   
  
public class B extends A {   
  
    public  void pri() {   
        System.out.println("B");   
    }   
  
    public static void main(String[] args) {   
        A a = new B();   
        a.pri();   
  
    }   
}  

输出：B

---------------------------

静态变量定义位置

public class B { 
public int aMethod() { 
static int i = 0; 
i++; 
return i; 
}  

上边这个代码的错误就是：类的实例方法中不能定义静态变量。看看下面这面的

public class B { 
public static int aMethod() { 
static int i = 0; 
i++; 
return i; 
}  这个还是错误的。

所以大家要记住：在类的实例方法和静态方法中都不能定义静态变量。那么只能能定义静态变量呢？

下面说一下具体原理：

只有类才存在静态的变量 方法只能对静态变量的操作 不能在方法内试图定义静态变量
否则的话会抛出编译错误
静态变量的本意是为了让所有的对象共享这个变量,如果在方法里面定义静态变量的话就存在逻辑错误了,也达不到你想要目的. 因为在方法定义静态变量根本没有他的任何意义. 任何对象都有自己的方法,即使是静态方法,方法内的变量也是在方法调用时候才开始分配内存,所以想给成静态的在逻辑上存在问题

--------------------------------------

new()具体执行过程

class TestA { 
 private int id=9;
 public TestA(){ 
 a1(); 
 } 
 public void a1() { 
 System.out.println("this is A"); 
 } 
}

public class TestB extends TestA{ 
 private int id=8;
 int bb=0; 
 public TestB() { 
 bb=1000; 
 super.a1();

 a1();
 } 
 public void a1() { 
 System.out.println("bb is "+bb); 
 System.out.println("B-a1"); 
 } 
 public static void main(String[] args) { 
  new TestB(); 
 }  
}

结果是：

bb is 0
B-a1
this is A
bb is 1000
B-a1

 

以上结果表明：在new()的具体过程是这样的，当new testB(); 的时候首先执行父类的构造方法，父类的构造方法调用了a1();此时编译器又检查到testB重写了a1()这个方法;所以执行的是子类的a1()方法。由于此时还没有执行testB()的构造方法，所以bb=0;所以才有上面的结果。

------父类的私有方法不能被覆盖

class Base {
	private  String showMe(){
		return "Base";
	}
	
	public void print(){
		System.out.println(showMe());//到底是掉用Base类的showMe还是Sub类的showMe
	}
}
public class Sub extends Base {
	public String showMe() {
		return "Sub";
	}
	
	public static void main(String args[]) {
		Sub sub = new Sub();
		sub.print();
	}
}

输出：Base

class Base {
	public  String showMe(){
		return "Base";
	}
	
	public void print(){
		System.out.println(showMe());//到底是掉用Base类的showMe还是Sub类的showMe
	}
}
public class Sub extends Base {
	public String showMe() {
		return "Sub";
	}
	
	public static void main(String args[]) {
		Sub sub = new Sub();
		sub.print();
	}
}

输出：Sub

将showMe方法改为public类型，有覆盖，Java虚拟机会调用当前sub实例的方法
-------

初始化顺序：this()或super()——>初始化语句块——>构造函数内语句

public class MyClass {
	
	private static String msg(String msg) {
		System.out.println(msg);
		return msg;
	}
		static String m = msg("1");
	static {
		m = msg("3");
	}
	
	{
		m = msg("2");
	}
	public static void main(String[] args) {
		//Object obj = new MyClass();
	}
}

输出：1  3

去掉注释后为 132

class A1 {
	public int i = 10;
	
}
class B2 extends A1 {
	public int i = 20;
}
public class Test {
	public static void main(String[] args) throws Exception {
		B2 b = new B2();
		A1 a = b;
		System.out.print(b.i);
		System.out.print(a.i);
	}
}

输出：20
10

public class ThreadRunnable implements Runnable {  
    public void run() {  
    	System.out.print("run");
    }     
      
    public static void main(String[] args) {  
    	ThreadRunnable td1 = new ThreadRunnable();  
        Thread t = new Thread(td1);
        td1.run();
        td1.run();
        t.start();
    }  
}  

输出：runrunrun