Thinking In Java琐碎知识点摘要(二)

class Art {
	Art(int a) {
		print("Art constructor "+a );
	}
	Art() {
		print("Art constructor " );
	}
}

class Drawing extends Art {
	Drawing(String aa) {
		super(1);
		print("Drawing constructor "+ aa);
	}
	Drawing() {
		print("Drawing constructor ");
	}
}


public class Cartoon extends Drawing {
	public Cartoon() {
		//super("zpc");//没有这句话则是一层一层调用默认的无参构造器，取消注释则调用指定的父类构造器
		print("Cartoon constructor");
	}

	public static void main(String[] args) {
		Cartoon x = new Cartoon();
	}
}

public class WithFinal extends MyFinal {
	private final void test(){
		print("WithFinal.test");
	} 
	/*上面之所以能够"覆盖"test()方法只是因为private修饰的成员对子类是隐藏的，
	这里不是覆盖，而是子类中创建的一个新的方法*/
	
	/*public final void test2(){
		print("WithFinal.test2");
	} final修饰的方法不能被子类覆盖
	*/
	public void test3(){
		print("WithFinal.test3");
	}//这里是方法覆盖,子类的修饰符要大于等于父类
}


class MyFinal{
	private final void test(){
		print("MyFinal.test");
	} 
	public final void test2(){
		print("MyFinal.test2");
	}
	protected void test3(){
		print("MyFinal.test3");
	}
}

//下面的代码引起空指针异常，因为先执行父类构造器，父类构造器中调用test方法实际却是调的子类覆盖的test方法，此时
//子类还没初始化，name值为null,把父类test方法改成private就行了，此时没有构成方法重写，父类构造器中test()直接调用Base类的test方法
public class Sub extends Base {
	String name="zpc";
	public void test(){
		System.out.println("子类重写父类的方法，name字符串的长度"+name.length());
	}
	public static void main(String[] args){
		Sub s=new Sub();
	}
}
class Base{
	public Base(){
		test();
	}
	public void test(){
		System.out.println("将被子类覆盖的方法");
	}
}

//下面这个例子可以清晰展示初始化顺序，能更好地理解上面那个例子的过程
public class Sub extends Base {
	{
		System.out.println("Sub的普通初始化块");
	}
	static {
		System.out.println("Sub的静态初始化块");
	}
	String name="zpc";
	public Sub(){
		System.out.println("Sub()的构造函数");
	}


	public static void main(String[] args){
		Sub s=new Sub();
		System.out.println("**************");
		Sub s2=new Sub();
	}
}
class Base{
	static {
		System.out.println("Base的静态初始化块");
	}
	{
		System.out.println("Base的普通初始化块");
	}
	public Base(){
		System.out.println("Base()的构造函数");
		test();
		
	}
	public void test(){
		System.out.println("将被子类覆盖的方法");
	}
}

 class  Singleton{
	//使用一个变量来缓存曾经创建的实例
	private static Singleton instance;
	//隐藏构造器
	private Singleton(){}
	//提供一个静态方法返回Singleton的实例
	public static Singleton getInstance(){
		if(instance==null){
			instance=new Singleton();
		}
		return instance;
	}
}
public class TestSingleton {
	public static void main(String[] args) {
		Singleton s1=Singleton.getInstance();
		Singleton s2=Singleton.getInstance();
		System.out.println("s1=s2?"+(s1==s2));//s1、s2指向同一个对象
	}
}

   public void fuzhi(final int d){
		d=9;//非法,由调用方法时传入的参数完成初始化，不能再赋值
	}

Thinking In Java琐碎知识点摘要(二),布布扣,bubuko.com

Thinking In Java琐碎知识点摘要(二)

原文：http://blog.csdn.net/hellozpc/article/details/23793401