cahr a = 'a'; // 必须限定长度为一个字节。等效于 char a = 97; 因为'a'在ASCII码表里对应97.
char b = '中文';
char c = 97;
System.out.println(a == c); // true

void f() {
    int i;
    i++;
}

public class InitialValues {
    private int i;
    public static void main(String[] args) {
        InitialValues initialValues = new InitialValues();
        System.out.println(initialValues.i);  // 0
    }
}

public class ExplicitStatic {
	public static void main(String[] args) {
		System.out.println("Inside main()");
		Cups.c1.f(99);
	}
	static Cups x = new Cups();
	static Cups y = new Cups();
}
class Cup {
	public Cup(int marker) {
		System.out.println("Cup(" + marker + ")");
	}
	void f(int marker) {
		System.out.println("f(" + marker + ")");
	}
}
class Cups {
	static Cup c1;
	static Cup c2;
	static {
		c1 = new Cup(1);
		c2 = new Cup(2);
	}
	public Cups() {
		System.out.println("Cups()");
	}
}

Cup(1)
Cup(2)
Cups()
Cups()
Inside main()
f(99)

Cup(1)
Cup(2)
Cups()
Cup(1)
Cup(2)
Cups()
Inside main()
f(99)

class A {
	void play(int i) {}
}
class C {
	C() {}
}
class B extends A {
	void play(C c) {}
}

import java.util.*;
interface CanFight {
	void fight();
}
interface CanSwim {
	void swim();
}
interface CanFly {
	void fly();
}
class ActionCharacter {
	public void fight() {}
}
class Hero extends ActionCharacter implements CanFight, CanSwim, CanFly {
	public void swim() {}
	public void fly() {}
}
public class Adventure {
	static void t(CanFight x) { x.fight(); }
	static void u(CanSwim x) { x.swim(); }
	static void v(CanFly x) { x.fly(); }
	static void w(ActionCharacter x) { x.fight(); }
	public static void main(String[] args) {
		Hero i = new Hero();
 		t(i); // Treat it as a CanFight
 		u(i); // Treat it as a CanSwim
 		v(i); // Treat it as a CanFly
 		w(i); // Treat it as an ActionCharacter
 	}
}

void foo(String str);
void foo(int num);

class Parent {
	void foo() {
		System.out.println("Parent foo()");
	}
}
class Child extends Parent {
	void foo() {
		System.out.println("Child foo()");
	}
}

Parent instance = new Child();
instance.foo(); // 此处其实调用的是 Child 类里面的 foo()

class Animal {
	int num = 10;
	static int age = 20;
	public void eat() {
		System.out.println("动物吃饭");
	}
	public static void sleep() {
		System.out.println("动物在睡觉");
	}
	public void run() {
		System.out.println("动物在奔跑");
	}
}
class Cat extends Animal {
	int num = 80;
	static int age = 90;
	String name = "tomCat";
	public void eat() {
		System.out.println("猫吃饭");
	}
	public static void sleep() {
		System.out.println("猫在睡觉");
	}
	public void catchMouse() {
		System.out.println("猫在抓老鼠");
	}
}

class Demo_Test1 {
	public static void main(String[] args) {
		Animal am = new Cat();
		am.eat();
		am.sleep();
		am.run();
//		am.catchMouse();  报错,Animal类里没有这个方法。
//		System.out.println(am.name);  报错
		System.out.println(am.num);
		System.out.println(am.age);
	}
}
// 打印输出
猫吃饭
动物在睡觉
动物在奔跑
10
20

Cat ct = (Cat)am;
ct.catchMouse();
System.out.println(ct.name);

package com.lizz.finalize;
public class Frog extends Amphibian {
	Frog() {
		System.out.println("Frog()");
	}
	protected void finalize() {
		System.out.println("Frog finalize");
		if(DoBaseFinalization.flag) {
			try {
				super.finalize();
			} catch (Throwable e) {
			}
		}
	}
	public static void main(String[] args) {
		if(args.length != 0 && args[0].equals("finalize")) {
			DoBaseFinalization.flag = true;
		} else {
			System.out.println("not finalizing bases");
		}
		new Frog();
		System.out.println("bye!");
		System.runFinalizersOnExit(true);
	}
}
class DoBaseFinalization {
	public static boolean flag = false;
}
class Characteristic {
	String s;
	Characteristic(String c) {
		s = c;
		System.out.println("Creating Character " + s);
	}
	protected void finalize() {
		System.out.println("finalizing Characteristic " + s);
	}
}
class LivingCreature {
	Characteristic p = new Characteristic("is alive");
	LivingCreature() {
		System.out.println("LivingCreature()");
	}
	protected void finalize() {
		System.out.println("LivingCreature finalize");
		if(DoBaseFinalization.flag) {
			try {
				super.finalize();
			} catch (Throwable e) {
			}
		}
	}
}
class Animal extends LivingCreature {
	Characteristic p = new Characteristic("has heart");
	Animal() {
		System.out.println("Animal()");
	}
	protected void finalize() {
		System.out.println("Animal finalize");
		if(DoBaseFinalization.flag) {
			try {
				super.finalize();
			} catch (Throwable e) {
			}
		}
	}
}
class Amphibian extends Animal {
	Characteristic p = new Characteristic("can live in water");
	Amphibian() {
		System.out.println("Amphibian()");
	}
	protected void finalize() {
		System.out.println("Amphibian finalize");
		if(DoBaseFinalization.flag) {
			try {
				super.finalize();
			} catch (Throwable e) {
			}
		}
	}
}
// 打印输出：
not finalizing bases
Creating Character is alive
LivingCreature()
Creating Character has heart
Animal()
Creating Character can live in water
Amphibian()
Frog()
bye!
finalizing Characteristic can live in water
finalizing Characteristic has heart
finalizing Characteristic is alive
Frog finalize

package com.lizz.polymorphism;
public class PolyConstructors {
	public static void main(String[] args) {
		new RoundGlyph(5);
	}
}
abstract class Glyph {
	abstract void draw();
	Glyph() {
		System.out.println("Glyph() before draw()");
		draw();
		System.out.println("Glyph() after draw()");
	}
}
class RoundGlyph extends Glyph {
	int radius = 1;
	RoundGlyph(int i) {
		radius = i;
		System.out.println("RoundGlyph.RoundGlyph(), radius = " + radius);
	}
	void draw() {
		System.out.println("RoundGlyph.drwa(), radius = " + radius);
	}
}
// 打印输出：
Glyph() before draw()
RoundGlyph.drwa(), radius = 0
Glyph() after draw()
RoundGlyph.RoundGlyph(), radius = 5

package com.lizz.set;
import java.util.Vector;
public class CatsAndDogs {
	public static void main(String[] args) {
		Vector cats = new Vector();
		for(int i = 0; i < 7; i++) {
			cats.addElement(new Cat(i));
		}
		cats.addElement(new Dog(7));
		for(int i = 0; i < cats.size(); i++) {
			((Cat)cats.elementAt(i)).print();;
		}
	}
}
class Cat {
	private int catNumber;
	Cat(int i) {
		catNumber = i;
	}
	void print() {
		System.out.println("Cat #" + catNumber);
	}
}
class Dog {
	private int dogNumber;
	Dog(int i) {
		dogNumber = i;
	}
	void print() {
		System.out.println("Dog #" + dogNumber);
	}
}

package com.lizz.set;
import java.util.Enumeration;
import java.util.Vector;
public class CatsAndDogs2 {
	public static void main(String[] args) {
		Vector cats = new Vector();
		for(int i = 0; i < 7; i++)
			cats.addElement(new Cat2(i));
		 // Not a problem to add a dog to cats:
		cats.addElement(new Dog2(7));
		Enumeration e = cats.elements();
		while(e.hasMoreElements())
			((Cat2)e.nextElement()).print();
		 // Dog is detected only at run-time
	}
}
class Cat2 {
	private int catNumber;
	Cat2(int i) {
		catNumber = i;
	}
	void print() {
		System.out.println("Cat number " +catNumber);
	}
}
class Dog2 {
	private int dogNumber;
	Dog2(int i) {
		dogNumber = i;
	}
	void print() {
		System.out.println("Dog number " +dogNumber);
	}
}

public class Stack<E> extends Vector<E> {
    /**
     * Creates an empty Stack.
     */
    public Stack() {
    }
    public E push(E item) {
        addElement(item);
        return item;
    }
    public synchronized E pop() {
        E       obj;
        int     len = size();
        obj = peek();
        removeElementAt(len - 1);
        return obj;
    }
    public synchronized E peek() {
        int  len = size();
        if (len == 0)
            throw new EmptyStackException();
        return elementAt(len - 1);
    }
    public boolean empty() {
        return size() == 0;
    }
    public synchronized int search(Object o) {
        int i = lastIndexOf(o);
        if (i >= 0) {
            return size() - i;
        }
        return -1;
    }
    /** use serialVersionUID from JDK 1.0.2 for interoperability */
    private static final long serialVersionUID = 1224463164541339165L;
}

package com.lizz.set;
import java.util.Dictionary;
import java.util.Enumeration;
import java.util.Vector;
public class AssocArray extends Dictionary {
	private Vector keys = new Vector();
	private Vector values = new Vector();
	public int size(){
		return keys.size();
	}
	public boolean isEmpty() {
		return keys.isEmpty();
	}
	public Object put(Object key, Object value) {
		keys.addElement(key);
		values.addElement(value);
		return key;
	}
	public Object get(Object key) {
		int index = keys.indexOf(key);
		if(index == -1) {
			return null;
		}
		return values.elementAt(index);
	}
	public Object remove(Object key) {
		int index = keys.indexOf(key);
		if(index == -1) {
			return null;
		}
		keys.removeElementAt(index);
		Object returnvalue = values.elementAt(index);
		values.removeElementAt(index);
		return returnvalue;
	}
	public Enumeration keys() {
		return keys.elements();
	}
	public Enumeration elements() {
		return values.elements();
	}
	public static void main(String[] args) {
		AssocArray aa = new AssocArray();
		for(char c = 'a'; c < 'z'; c++) {
			aa.put(String.valueOf(c), String.valueOf(c).toUpperCase());
		}
		char[] ca = {'a', 'e', 'i', 'o', 'u'};
		for(int i = 0; i < ca.length; i++) {
			System.out.println("Uppercase: " + aa.get(String.valueOf(ca[i])));
		}
	}
}

package com.lizz.set;
import java.util.Hashtable;
public class SpringDetector {
	public static void main(String[] args) {
		Hashtable hashtable = new Hashtable();
		for(int i = 0; i < 10; i++) {
			hashtable.put(new Groundhog(i), new Prediction());
		}
		System.out.println("hashtable = " + hashtable + "\n");
		System.out.println("Looking up prediction for groundhog #3:");
		Groundhog groundhog = new Groundhog(3);
		/*
		 * Groundhog 是从通用的 Object 根类继承的（若当初未指定基础类，则所有类最终都是从Object 继承的）。
		 * 事实上是用 Object 的 hashCode()方法生成每个对象的散列码，而且默认情况下只使用它的对象的地址。
		 * 所以，Groundhog(3)的第一个实例并不会产生与Groundhog(3)第二个实例相等的散列码，而我们用第二个实例进行检索。
		 * 大家或许认为此时要做的全部事情就是正确地覆盖 hashCode()。但这样做依然行不能，除非再做另一件事情：覆盖也属于Object 一部分的 equals()。
		 * 当散列表试图判断我们的键是否等于表内的某个键时，就会用到这个方法。同样地，默认的 Object.equals()只是简单地比较对象地址，
		 * 所以一个 Groundhog(3)并不等于另一个 Groundhog(3)。因此，为了在散列表中将自己的类作为键使用，必须同时覆盖 hashCode()和equals()，
		 * 看示例 SpringDetector2
		 */
		if(hashtable.containsKey(groundhog)) {
			System.out.println((Prediction)hashtable.get(groundhog));
		}
	}
}
class Groundhog {
	int ghNumber;
	Groundhog(int n) { 
		ghNumber = n; 
	}
}
class Prediction {
	boolean shadow = Math.random() > 0.5;
	public String toString() {
		if(shadow)
			return "Six more weeks of Winter!";
		else
			return "Early Spring!";
	}
}

package com.lizz.set;
import java.util.Hashtable;
public class SpringDetector2 {
	public static void main(String[] args) {
		Hashtable hashtable = new Hashtable();
		for(int i = 0; i < 10; i++) {
			hashtable.put(new Groundhog2(i), new Prediction());
		}
		System.out.println("hashtable = " + hashtable + "\n");
		System.out.println("Looking up prediction for groundhog #3:");
		Groundhog2 groundhog2 = new Groundhog2(3);
		if(hashtable.containsKey(groundhog2)) {
			System.out.println((Prediction)hashtable.get(groundhog2));
		}
	}
}
class Groundhog2 {
	int ghNumber;
	Groundhog2(int n) { 
		ghNumber = n;
	}
	public int hashCode() { 
		return ghNumber; 
	}
	public boolean equals(Object o) {
		return (o instanceof Groundhog2) && (ghNumber == ((Groundhog2)o).ghNumber);
	}
}

private final char value[];
public String(String original) {
        this.value = original.value;
        this.hash = original.hash;
}
public int compareTo(String anotherString) {
        int len1 = value.length;
        int len2 = anotherString.value.length;
        int lim = Math.min(len1, len2);
        char v1[] = value;
        char v2[] = anotherString.value;
        int k = 0;
        while (k < lim) {
            char c1 = v1[k];
            char c2 = v2[k];
            if (c1 != c2) {
                return c1 - c2;
            }
            k++;
        }
        return len1 - len2;
}

package com.lizz.set;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class SimpleCollection {
	public static void main(String[] args) {
		Collection c = new ArrayList();
		for(int i = 0; i < 10; i++) {
			c.add(Integer.toString(i));
		}
		Iterator it = c.iterator();
		while (it.hasNext()) {
			System.out.println(it.next());
		}
	}	
}

public Iterator<E> iterator() {
	return new Itr();
}
private class Itr implements Iterator<E> {
	int cursor;       // index of next element to return
    int lastRet = -1; // index of last element returned; -1 if no such
    int expectedModCount = modCount;
    public boolean hasNext() {
        return cursor != size;
    }
	...

public class Collection1 {
	public static Collection fill(Collection c, int start, int size) {
		for(int i = start; i < start + size; i++) {
			c.add(Integer.toString(i));
		}
		return c;
	}
	public static Collection fill(Collection c) {
		return fill(c, 0, 10);
	}
	public static Collection newCollection() {
		return fill(new ArrayList());
	}
	public static Collection newCollection(int start, int size) {
		return fill(new ArrayList(), start, size);
	}
	public static void print(Collection c) {
		for(Iterator x = c.iterator(); x.hasNext();) {
			System.out.println(x.next() + " ");
		}
		System.out.println();
	}
	public static void main(String[] args) {
		Collection c = newCollection();
		c.add("ten");
		c.add("eleven");
		c.addAll(newCollection());
		print(c);
		Collection c2 = newCollection(5, 3);
		c.retainAll(c2);
		print(c);
		c.removeAll(c2);
	}
}

private static final int DEFAULT_CAPACITY = 10;
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
transient Object[] elementData;
private int size;
protected transient int modCount = 0; // 这里是继承自AbstractList,并不是ArrayList内定义的
public ArrayList() {
       this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
   }
public boolean add(E e) {
       ensureCapacityInternal(size + 1);  // Increments modCount!!
       elementData[size++] = e;
       return true;
   }
private void ensureCapacityInternal(int minCapacity) {
       if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
           minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
       }
       ensureExplicitCapacity(minCapacity);
   }
   private void ensureExplicitCapacity(int minCapacity) {
       modCount++;
       // overflow-conscious code
       if (minCapacity - elementData.length > 0)
           grow(minCapacity);
   }
private void grow(int minCapacity) {
       // overflow-conscious code
       int oldCapacity = elementData.length;
       int newCapacity = oldCapacity + (oldCapacity >> 1);
       if (newCapacity - minCapacity < 0)
           newCapacity = minCapacity;
       if (newCapacity - MAX_ARRAY_SIZE > 0)
           newCapacity = hugeCapacity(minCapacity);
       // minCapacity is usually close to size, so this is a win:
       elementData = Arrays.copyOf(elementData, newCapacity);
   }
   private boolean batchRemove(Collection<?> c, boolean complement) {
       final Object[] elementData = this.elementData;
       int r = 0, w = 0;
       boolean modified = false;
       try {
           for (; r < size; r++)
               if (c.contains(elementData[r]) == complement)
                   elementData[w++] = elementData[r];
       } finally {
           // Preserve behavioral compatibility with AbstractCollection,
           // even if c.contains() throws.
           if (r != size) {
               System.arraycopy(elementData, r,
                                elementData, w,
                                size - r);
               w += size - r;
           }
           if (w != size) {
               // clear to let GC do its work
               for (int i = w; i < size; i++)
                   elementData[i] = null;
               modCount += size - w;
               size = w;
               modified = true;
           }
       }
       return modified;
   }

public static int binarySearch(byte[] a, byte key) {
    return binarySearch0(a, 0, a.length, key);
}
private static int binarySearch0(byte[] a, int fromIndex, int toIndex, byte key) {
    int low = fromIndex;
    int high = toIndex - 1;
    while (low <= high) {
        int mid = (low + high) >>> 1;
        byte midVal = a[mid];
        if (midVal < key)
        	low = mid + 1;
        else if (midVal > key)
            high = mid - 1;
        else
            return mid; // key found
    }
    return -(low + 1);  // key not found.
}

public class Array1 {
	static Random r = new Random();
	static String ssource = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" + "abcdefghijklmnopqrstuvwxyz";
	static char[] src = ssource.toCharArray();
	public static String randString(int length) {
		char[] buf = new char[length];
		int rnd;
		for(int i = 0; i < length; i++) {
			rnd = Math.abs(r.nextInt()) % src.length;
			buf[i] = src[rnd];
		}
		return new String(buf);
	}
	public static String[] randStrings(int length, int size) {
		String[] s = new String[size];
		for(int i = 0; i < size; i++) {
			s[i] = randString(length);
		}
		return s;
	}
	public static void print(byte[] b) {
		for(int i = 0; i < b.length; i++) {
			System.out.println(b[i] + " ");
		}
		System.out.println();
	}
	public static void print(String[] s) {
		for(int i = 0; i < s.length; i++) {
			System.out.print(s[i] + " ");
		}	
		System.out.println();
	}
	public static void main(String[] args) {
		byte[] b = new byte[15];
		r.nextBytes(b);
		print(b);
		Arrays.sort(b);
		print(b);
		int loc = Arrays.binarySearch(b, b[10]);
		System.out.println("Location of " + b[10] + " = " + loc);
		String[] s = randStrings(4, 10);
		print(s);
		Arrays.sort(s);
		print(s);
		loc = Arrays.binarySearch(s, s[4]);
		System.out.println("Location of " + s[4] + " = " + loc);
	}
}