面试题与答案

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.Date;

public class Logon implements Serializable {
	private Date date = new Date();
	private String username;
	private transient String password;
	
	public Logon(String name, String pwd) {
		username = name;
		password = pwd;
	}
	public String toString() {
		String pwd = (password == null) ? "(n/a)" : password;
		return "logon info: n username: " + username + "n date: " + date
		+ "n password: " + pwd;
	}

	public static void main(String[] args) throws Exception {
		Logon a = new Logon("Hulk", "myLittlePony");
		System.out.println("logon a = " + a);
		ObjectOutputStream o = new ObjectOutputStream(new FileOutputStream(
		"Logon.out"));
		o.writeObject(a);
		o.close();
		Thread.sleep(1000); // Delay for 1 second
		// Now get them back:
		ObjectInputStream in = new ObjectInputStream(new FileInputStream(
		"Logon.out"));
		System.out.println("Recovering object at " + new Date());
		a = (Logon) in.readObject();
		System.out.println("logon a = " + a);
	}
}

Object a; Customer b; b = (Customer) a;

abstract class Instrument { 
	int i; // storage allocated for each 
	public abstract void play(); 
	public String what() { 
		return "Instrument";
	}	
	public abstract void adjust(); 
} 

class Wind extends Instrument { 
	public void play() { 
		System.out.println("Wind.play()"); 
	} 
	public String what() { 
		return "Wind"; 
	} 
	public void adjust() {}
}

public abstract class Container extends Component {

public abstract float price();

abstract class testAbstractClass {
	protected String myString; 
	public String getMyString() { 
		return myString; 
	} 
	public abstract string anyAbstractFunction();
}

import java.util.*; 
interface Instrument { 
	int i = 5; // static & final 
	// Cannot have method definitions: 
	void play(); // Automatically public 
	String what(); 
	void adjust(); 
}
 
class Wind implements Instrument { 
	public void play() { 
		System.out.println("Wind.play()"); 
	}
	public String what() { return "Wind"; } 
	public void adjust() {} 
}

public interface abc{		
	static int i=0; 
	void dd();		
	class a1{			
		a1(){
			int j;
			System.out.println("inside");
		};
		public static void main(String a1[])
		{
			System.out.println("in interfia");
		}
	}	
}

public interface sampleInterface {
	public void functionOne();
	public long CONSTANT_ONE = 1000; 
}

• As per Java 8, interface can have method body as well.
  

interface A { 
	void methodA();
} 

class AImpl implements A { 
	void methodA() { //do stuff }
}
 
interface B { 
	void methodB();
} 

class BImpl implements B { 
	void methodB() { //do stuff }
}
 
class Multiple implements A, B { 
	private A a = new A();
	private B b = new B();
	void methodA() { 
		a.methodA(); 
	}
	void methodB() { 
		b.methodB(); 
	}
}

class Multiple implements A, B { 
	private A a = new AImpl();
	private B b = new BImpl();
	void methodA() { 
		a.methodA(); 
	}
	void methodB() { 
		b.methodB(); 
	}
}

class RunnableThread implements Runnable {
	Thread runner;
	
	public RunnableThread() {
	}
	
	public RunnableThread(String threadName) {
		runner = new Thread(this, threadName); // (1) Create a new thread.
		System.out.println(runner.getName());
		runner.start(); // (2) Start the thread.
	}

	public void run() {
		//Display info about this particular thread
		System.out.println(Thread.currentThread());
	}
}

• NEW
  A thread that has not yet started is in this state.
• RUNNABLE
  A thread executing in the Java virtual machine is in this state.
• BLOCKED
  A thread that is blocked waiting for a monitor lock is in this state.
• WAITING
  A thread that is waiting indefinitely for another thread to perform a particular action is in this state.
• TIMED_WAITING
  A thread that is waiting for another thread to perform an action for up to a specified waiting time is in this state.
• TERMINATED
  A thread that has exited is in this state.

A thread can be in only one state at a given point in time. These states are virtual machine states which do not reflect any operating system thread states.

//Synchronized block
class A { 
 public void method1() {...} 
}


class B
{
 public static void main(String s[])
 { 
  A objecta=new A();
  A objectb=new A();
  synchronized(objecta) {
   objecta.method1();
  }
  objectb.method1(); //not synchronized
 }
}

//synchronized method
class A { 
 public synchronized void method1() { ...}
}

class B {
 public static void main(String s[]) {
  A objecta=new A();
  A objectb =new A();
  objecta.method1(); objectb.method2();
 }
}

import java.util.Vector;

public class GarbageCollector{
	public static void main(String[] args) {
		int SIZE = 200;
		StringBuffer s;
		for (int i = 0; i < SIZE; i++) {
		}
		System.out.println("Garbage Collection started explicitly.");
		long time = System.currentTimeMillis();
		System.gc();
		System.out.println("It took " +(System.currentTimeMillis()-time) + " ms");
	}
}

file = new File("c:/newfile.txt");
fop = new FileOutputStream(file);
if (!file.exists()) {
	file.createNewFile();
} 
// get the content in bytes
byte[] contentInBytes = content.getBytes(); 
fop.write(contentInBytes);
fop.flush();
fop.close();