疯狂Java讲义笔记

一、Java概述

1.java编译产生与平台无关的字节码（*.class文件），再在JVM里面执行。

2.JVM是一个抽象的计算机，具有指令集并使用不同的存储区，负责执行指令，还要管理数据、内存和寄存器。

3.JVM细节：指令集、寄存器、类文件的格式、栈、垃圾回收堆、存储区。

4.只运行java程序可以只安装JRE，若要开发则要JDK

5.bin路径下的绝大部分命令都是包装了tools.jar文件里的工具类。

6.JDK1.5之后可以不用设置CLASSPATH环境变量。

7.main方法的 public 和 static可以交换位置。

8.垃圾回收相关：将对象引用设置为null将加快垃圾回收；可以通过System.gc()来建议系统进行垃圾回收；垃圾回收的精确性主要包括a.精确标记或者的对象b.精确地定位对象之间的引用关系。

二、理解面向对象

1.基本特征：

   a.封装:将对象实现细节隐藏起来，然后通过一些共用方法来暴露该对象的功能

   b.继承:

   c.多态:子类对象可以直接赋给父类变量，运行时依然表现出子类的行为特征，这意味着同一个类型的对象在执行同一个方法时，可能表现出多种行为特征。

三、数据类型和运算符

1.注释，单行注释//  ,多行注释 /* .... */，文档注释/**  ... */

2.注释中常用标记@author指定java程序作者，@version指定源文件的版本，@deprecated不推荐使用的方法，@param方法的参数说明信息，@return方法的返回值说明信息，@see参见，关于指定交叉参考的内容，@exception抛出异常类型，@throws抛出的异常，和exception同意。

类或接口文档中的标记@see、@deprecated、@author、@version；方法或构造器文档中的标记@see、@deprecated、@param、@return、@throws和@exception等；出现在Field文档注释中的有@see、@deprecated等

package yeeku;

/**
 * Description:
 * 
网站: 疯狂Java联盟 
 * 
Copyright (C), 2001-2012, Yeeku.H.Lee
 * 
This program is protected by copyright laws.
 * 
Program Name:
 * 
Date:
 * @author Yeeku.H.Lee [email protected]
 * @version 1.0
 */
public class JavadocTagTest
{
	/**
	 * 一个得到打招呼字符串的方法。
	 * @param name 该参数指定向谁打招呼。
	 * @return 返回打招呼的字符串。
	 */
	public String hello(String name)
	{
		return name + "，你好！";
	}
}

3. 标识符中可以包含$符号

4.Java语言指出的类型，基本类型（primitive type）：int等，引用类型（reference type）：类、接口、数组、null

5.java7中新增了二进制类型。以0b或者0B开头

6.特殊的三个浮点数：正无穷大Double或Float的POSITIVE_INFINITY表示，负无穷大NEGATIVE_INFINITY表示，非数NaN

7.java7中可以在数值中使用下划线。int binVal = 0B1000_0000_0000_0011;double pi = 3.14_15_92;

四、数组

1.数组是一种数据类型，它本身市一中引用类型。 int[]就是一种类型。

2.java数组定义格式  type[] arrayName 和 type arrayName[]; 推荐第一种。这样只定义了一个引用变量，没有分配内存空间。

3.初始化：

    a.静态初始化arrayName= new type[] {element1,element2...},type与element类型相同。也可以arrayName = {element1, element2...}

    b.动态初始化arrayName= new type[length]

4.foreach用于遍历数组和集合,for (type variableName : array | collection) { .................},只提供访问，不提供修改，即修改无效。

5.基本数据类型数组直接在数组引用的内存存储值，而引用类型数组数组元素是引用，需要再次申请堆内存。

6.二维数组的初始化

public class TwoDimensionTest
{
	public static void main(String[] args) 
	{
		//定义一个二维数组
		int[][] a;
		//把a当成一维数组进行初始化，初始化a是一个长度为4的数组
		//a数组的数组元素又是引用类型
		a = new int[4][];
		//把a数组当成一维数组，遍历a数组的每个数组元素
		for (int i = 0 , len = a.length; i < len ; i++ )
		{
			System.out.println(a[i]);
		}
		//初始化a数组的第一个元素
		a[0] = new int[2];
		//访问a数组的第一个元素所指数组的第二个元素
		a[0][1] = 6;
		//a数组的第一个元素是一个一维数组，遍历这个一维数组
		for (int i = 0 , len = a[0].length ; i < len ; i ++ )
		{
			System.out.println(a[0][i]);
		}

		//同时初始化二维数组的2个维数
		int[][] b = new int[3][4];

		//使用静态初始化的语法来初始化一个二维数组
		String[][] str1 = new String[][]{new String[3] 
			, new String[]{"hello"}};
		//使用简化的静态初始化语法来初始化二维数组
		String[][] str2 = {new String[3] 
			, new String[]{"hello"}};
		System.out.println(str1[1][0]);
		System.out.println(str2[1][0]);
	}
}

7.数组操作的工具类Arrays

五、面向对象（上）

1.一个类中常见的三种成员：构造器、Field和方法

2.static修饰的成员不能访问没有static修饰的成员

3.方法传递参数凡是只有一种：值传递。

4.形参个数可变的方法,在最后一个形参的类型后增加三点...，表示该形参可以接受多个参数值，多个参数的值被当成数组传入。

public class Varargs
{
	//定义了形参个数可变的方法
	public static void test(int a , String... books)
	{
		//books被当成数组处理
		for (String tmp : books)
		{
			System.out.println(tmp);
		}
		//输出整数变量a的值
		System.out.println(a);
	}
	public static void main(String[] args) 
	{
		//调用test方法
		test(5 , "疯狂Java讲义" , "轻量级Java EE企业应用实战");
	}
}

5.重载：同一个类中包含了两个或两个以上方法的方法名相同，但是形参列表不同。方法返回值类型、修饰符等，与方法重载没有任何关系。可变参数方法重载时，优先选择不可变参数的方法。

6.虽然类实例可以访问static Field，但是建议用类.StaticField来访问。

7.访问控制权限。

8.希望子类重写的方法，可以用protected修饰符

9.父包中要使用子包中的类需要写成完整包路径加类名，使用import后可以直接使用类名。

10.Java默认为所有源文件导入java.lang包下的所有类。

11.import static 可以导入类的static Field

import static java.lang.System.*;
import static java.lang.Math.*;

public class StaticImportTest
{
	public static void main(String[] args) 
	{
		//out是java.lang.System类的静态Field，代表标准输出
		//PI是java.lang.Math类的静态Field，表示π常量
		out.println(PI);
		//直接调用Math类的sqrt静态方法
		out.println(sqrt(256));
	}
}

12. 一旦提供了构造器，则不再使用默认的构造器，通常在提供构造器后要提供一个无参构造器

13.几个构造器中与重叠代码时，可以用一个构造器通过this（x,y)调用另一个构造器

public class Apple
{
	public String name;
	public String color;
	public double weight;
	public Apple()
	{
	}
	//两个参数的构造器
	public Apple(String name , String color)
	{
		this.name = name;
		this.color = color;
	}
	//三个参数的构造器
	public Apple(String name , String color , double weight)
	{
		//通过this调用另一个重载的构造器的初始化代码
		this(name , color);
		//下面this引用该构造器正在初始化的Java对象
		this.weight = weight;
	}
}

14.子类包含与父类同名方法的现象被称为方法重写，重写要遵循“两同两小一大”规则，“两同”即方法名相同、形参列表相同；“两小”指的是子类方法返回值类型应比父类方法返回值类型更小或者相等，子类方法声明抛出的异常类应比父类方法声明抛出的异常类更小或相等；"一大“，子类方法的访问权限应比父类方法更大或者相等

15.父类中的private方法对子类是隐藏的，因此其子类无法访问该方法，也就是无法重写该方法，即使子类中有相同的private方法，也不是重写

16.子类Field定义了与父类Field同名成员变量，那么子类成员变量会覆盖父类成员变量，但是子类对象初始化时也会为父类成员变量分配存储空间，必须通过super访问

17.子类构造器总会调用一次父类构造器，如果没有显示调用父类构造器，则调用默认的父类构造器，super显示调用父类构造器，必须放在子类构造器的第一行

18.创建任何java对象总是先调用object类的构造器，自顶向下调用构造器

19.Java引用变量有编译时类型和运行时类型两类，编译时类型由定义该变量时使用的类型决定，运行时类型由实际赋给该变量的对象决定。编译时类型和运行时类型不一致，就可能出现所谓的多态性

20.对象的Field并不具有多态性，总是访问它编译时类型所定义的Field，而不是它运行时类型所定义的Field

21.将父类引用强制转换成子类引用时，需要先用instanceof进行预判

22.设计父类的原则：a.尽量隐藏父类的内部数据，多用private，不让子类直接访问父类；b.不要让子类可以随意访问、修改父类的方法，辅助方法用private，不希望改写用final，希望重写，不希望其他类访问，可以用protected。c.尽量不要在构造器中调用将要被子类重写的方法。

class Base
{
	public Base()
	{
		test();
	}
	public void test()           //①号test方法
	{
		System.out.println("将被子类重写的方法");
	}
}
public class Sub extends Base
{
	private String name;
	public void test()        //②号test方法
	{
		System.out.println("子类重写父类的方法，"
			+ "其name字符串长度" + name.length());
	}
	public static void main(String[] args)
	{
		//下面代码会引发空指针异常
		Sub s = new Sub();
	}
}

当创建Sub对象时，先执行父类构造器，父类构造器调用了被子类重写方法，则变成调用被子类重写后的方法。即执行2号test方法，此时name Field是null

23.使用final或者将构造器设置为private，则该类无法成为父类，对于后者可以提供静态方法以创建该类的实例

24.当子类需要增加额外属性或者行为方式时，就使用继承

25.初始化块是Java类的第四种成员（Field、方法和构造器），先定义的初始化块先执行，后定义的后执行，用｛｝表示，初始化块在构造器之前执行

26.创建Java对象时，先为该对象的所有实例Field分配内存（前提是该类已经被加载过）接着成语开始对这些实例变量执行初始化，先执行初始化块或者声明Field时指定的初始值，在执行构造器里指定的初始值。

public class InstanceInitTest
{
	//为a分配内存，再执行初始化块将a Field赋值为6
	{
		a = 6;
	}
	//再执行将a Field赋值为9
	int a = 9;
	public static void main(String[] args) 
	{
		//下面代码将输出9。
		System.out.println(new InstanceInitTest().a);
	}
}

27.将多个构造器中相同的代码提取到初始化块中定义，能更好地提高初始化代码的复用，提高整个应用的可维护性

28.在存在继承关系中，先执行父类的初始化块，父类的构造器，再执行子类的初始化块和子类构造器

29.静态初始化代码块使用static，系统将在类初始化阶段执行静态初始化块，而不是在创建对象时才执行，静态初始化块总是比普通初始化块先执行。通常用于对类Field执行初始化处理，而不能对实例Field进行初始化处理。不能访问非静态的Field。静态初始化块也要上溯父类。

class Root
{
	static{
		System.out.println("Root的静态初始化块");
	}
	{
		System.out.println("Root的普通初始化块");
	}
	public Root()
	{
		System.out.println("Root的无参数的构造器");
	}
}
class Mid extends Root
{
	static{
		System.out.println("Mid的静态初始化块");
	}
	{
		System.out.println("Mid的普通初始化块");
	}
	public Mid()
	{
		System.out.println("Mid的无参数的构造器");
	}
	public Mid(String msg)
	{
		//通过this调用同一类中重载的构造器
		this();
		System.out.println("Mid的带参数构造器，其参数值："
			+ msg);
	}
}
class Leaf extends Mid
{
	static{
		System.out.println("Leaf的静态初始化块");
	}
	{
		System.out.println("Leaf的普通初始化块");
	}	
	public Leaf()
	{
		//通过super调用父类中有一个字符串参数的构造器
		super("疯狂Java讲义");
		System.out.println("执行Leaf的构造器");
	}
}
public class Test
{
	public static void main(String[] args) 
	{
		new Leaf();
		new Leaf();
	}
}

30.当JVM第一次主动使用某个类时，系统为在类准备阶段为该类的所有静态Field分配内存；在初始化阶段则负责初始化这些静态Field，初始化静态Field就是执行类初始化代码或者声明类Field时指定的初始值，他们的执行顺去与源代码中的排列顺序相同。

public class StaticInitTest
{
	//先执行静态初始化块将a静态Field赋值为6
	static
	{
		a = 6;
	}
	//再执行将a静态Field赋值为9
	static int a = 9;
	public static void main(String[] args) 
	{
		//下面代码将输出9。
		System.out.println(StaticInitTest.a);
	}
}

即先分配空间，再按排列顺序执行赋值。

六、面向对象（下）

1.==和equals，==用来判断两个对象是否相等（基本类型时，只要值相等，引用类型时，必须指向同一个对象），equals用于判断引用对象值是否相等，通常需要重写，默认的是比较对象的地址，String已经重写了

2.final修饰的类、变量和实例变量不可改变。final修饰的类Field必须在静态初始化块中或声明该Field时指定初始值；实例Field必须在非静态初始化块、声明该Field或构造器中指定初始值。final变量必须初始化后才可以访问。final局部变量，只能初始化一次

3.当final修饰基本类型变量，不能对基本类型变量重新赋值，但对于引用类型变量，只保证这个引用类型变量所引用的地址不会改变，即一直引用同意对象，但这个对象完全可以发生改变

4.当类Field、实例Field或者局部变量使用了final修饰符，并且在定义该变量时指定了初始值，该初始值在编译时就被确定下来，那么就相当于是一个直接量（宏替换）

public class FinalLocalTest
{
	public static void main(String[] args) 
	{
		//定义一个普通局部变量
		final int a = 5;
		System.out.println(a);
	}
}

变量a其实并不存在，执行System.out.println(a)时转换为System.out.println(5)

5.final修饰的方法不可被重写（不希望子类重写父类的某个方法），final修饰的类不能有子类

6.创建不可变类的规则（类似与String，Double）：使用private和final修饰符来修饰该类的Field；提供带参数构造器，用于根据传入参数来初始化类里的Field；仅为该类的Field提供Getter方法，不提供Setter方法；如果有必要，重写Object类的hashCode和equals方法，还要保证用equals判断相等的对象的hashCode也相等。

public class Address
{
	private final String detail;
	private final String postCode;
	//在构造器里初始化两个实例Field
	public Address()
	{
		this.detail = "";
		this.postCode = "";
	}
	public Address(String detail , String postCode)
	{
		this.detail = detail;
		this.postCode = postCode;
	}
	//仅为两个实例Field提供getter方法
	public String getDetail()
	{
		return this.detail;
	}
	public String getPostCode()
	{
		return this.postCode;
	}
	//重写equals方法，判断两个对象是否相等。
	public boolean equals(Object obj)
	{
		if (this == obj)
		{
			return true;
		}
		if(obj != null && obj.getClass() == Address.class)
		{
			Address ad = (Address)obj;
			// 当detail和postCode相等时，可认为两个Address对象相等。
			if (this.getDetail().equals(ad.getDetail()) 
				&& this.getPostCode().equals(ad.getPostCode()))
			{
				return true;
			}
		}
		return false;
	}
	public int hashCode()
	{
		return detail.hashCode() + postCode.hashCode() * 31;
	}
}

7.通过引用新的实例对象，就可以避免不可变类的引用类型的Field域被修改

class Name
{
	private String firstName;
	private String lastName;
	public Name(){}
	public Name(String firstName , String lastName)
	{
		this.firstName = firstName;
		this.lastName = lastName;
	}
	public void setFirstName(String firstName)
	{
		this.firstName = firstName;
	}
	public String getFirstName()
	{
		return this.firstName;
	}
	public void setLastName(String lastName)
	{
		this.lastName = lastName;
	}
	public String getLastName()
	{
		return this.lastName;
	}
}
public class Person
{
	private final Name name;
	public Person(Name name)
	{
		this.name = name;
	}
	public Name getName()
	{
		return name;
	}
	public static void main(String[] args)
	{
		Name n = new Name("悟空", "孙");
		Person p = new Person(n);
		// Person对象的name的firstName值为"悟空"
		System.out.println(p.getName().getFirstName());
		// 改变Person对象name的firstName值
		n.setFirstName("八戒");
		// Person对象的name的firstName值被改为"八戒"
		System.out.println(p.getName().getFirstName());
	}
}

修改代码为：

public class Person
{
	private final Name name;
	public Person(Name name)
	{
    

		this.name =new Name(name.getFirstName()name.getLastName());

	}
	public Name getName()
	{
		return newName(name.getFirstName()name.getLastName());
	}
	public static void main(String[] args)
	{
		Name n = new Name("悟空", "孙");
		Person p = new Person(n);
		// Person对象的name的firstName值为"悟空"
		System.out.println(p.getName().getFirstName());
		// 改变Person对象name的firstName值
		n.setFirstName("八戒");
		// Person对象的name的firstName值被改为"八戒"
		System.out.println(p.getName().getFirstName());
	}
}

8.含有抽象方法的类只能被定义成抽象类（直接定义一个抽象方法；继承了一个抽象父类没有完全实现父类包含的抽象方法，以及实现了一个接口，但没有完全实现接口包含的抽象方法），final和abstract不能同时使用，static不能和abstract同时使用

9.接口中不能包含普通方法，接口中所有方法都是抽象方法。一个接口可以有多个直接父接口，但接口只能继承接口，不能继承类。接口里可以包含Field（只能是常量）、方法（只能是抽象实例方法）、内部类（包括内部接口、枚举）定义。接口中的成员（包括常量、方法、内部类和枚举）都是public访问权限，可以省略public，如果指定访问修饰则只能用public。接口中的Field会自动添加static 和 final修饰符，即自动添加public static final，而且接口中没有构造器和初始化块，必须在定义时指定默认值。接口里的方法总是public abstract来修饰。接口里定义的内部类、接口、枚举类默认都采用public static 两个修饰符

10.一个类可以继承一个父类，实现多个接口

11.内部类成员可以直接访问外部类的私有数据，因为内部类被当成其外部类成员，同一个类成员之间可以相互访问，但外部类不能访问内部类的实现细节

12.内部类的文件形式，B是A的内部类，则会生成A.class和A$B.class

13.外部类成员变量、内部类成员变量与内部类里方法的局部变量同名，则可通过使用this,外部类类名.this作为限定来区分。同过OutterClass.this.propName的形式访问外部类的实例Field，通过this.propName的形式访问非静态内部类的实例Field

public class DiscernVariable
{
	private String prop = "外部类的实例变量";
	private class InClass
	{
		private String prop = "内部类的实例变量";
		public void info()
		{
			String prop = "局部变量";
			//通过 外部类类名.this.varName 访问外部类实例Field
			System.out.println("外部类的Field值：" 
				+ DiscernVariable.this.prop);
			//通过 this.varName 访问内部类实例的Field
			System.out.println("内部类的Field值：" + this.prop);
			//直接访问局部变量
			System.out.println("局部变量的值：" + prop);
		}
	}
	public void test()
	{
		InClass in = new InClass();
		in.info();
	}
	public static void main(String[] args) 
	{
		new DiscernVariable().test();
	}
}

14.内部类也满足静态关系，即静态成员不能访问非静态成员，不允许在非静态内部类里定义静态成员

15.static修饰的内部类，属于外部类本身，称为静态内部类。外部类不能直接访问静态内部类的成员，但可以使用静态内部类的类名作为调用者来访问静态内部类的类成员，也可以使用静态内部类对象作为调用者来访问静态内部类的实例成员。

public class AccessStaticInnerClass
{
	static class StaticInnerClass
	{
		private static int prop1 = 5;
		private int prop2 = 9;
	}
	public void accessInnerProp()
	{
		//System.out.println(prop1);
		//上面代码出现错误，应改为如下形式：
		//通过类名访问静态内部类的类成员
		System.out.println(StaticInnerClass.prop1);
		//System.out.println(prop2);
		//上面代码出现错误，应改为如下形式：
		//通过实例访问静态内部类的实例成员
		System.out.println(new StaticInnerClass().prop2);
	}
}

16.接口中定义的内部类，默认使用public static 修饰

17.在外部类以外使用非静态内部类：如果在外部类以外的地方访问内部类（包括静态和非静态），则内部类不能使用private访问控制权限，private修饰的内部类只能在外部类内部使用，对于使用其他访问控制符修饰的内部类，则能在访问控制符对应的访问权限内使用。

OuterClass.InnerClass varName //在外部类意外定义内部类变量

在外部类以外的地方创建非静态内部类实例

OuterInstance.new InnerConstructor();

class Out
{
	//定义一个内部类，不使用访问控制符，
	//即只有同一个包中其他类可访问该内部类
	class In
	{
		public In(String msg)
		{
			System.out.println(msg);
		}
	}
}
public class CreateInnerInstance
{
	public static void main(String[] args) 
	{
		Out.In in = new Out().new In("测试信息");
		/*
		上面代码可改为如下三行代码：
		使用OutterClass.InnerClass的形式定义内部类变量
		Out.In in;
		创建外部类实例，非静态内部类实例将寄存在该实例中
		Out out = new Out();
		通过外部类实例和new来调用内部类构造器创建非静态内部类实例
		in = out.new In("测试信息");
		*/
	}
}

非静态内部类构造器必须使用外部类对象来调用。

18.在外部类以外使用静态内部类

class StaticOut
{
	//定义一个静态内部类，不使用访问控制符，
	//即同一个包中其他类可访问该内部类
	static class StaticIn
	{
		public StaticIn()
		{
			System.out.println("静态内部类的构造器");
		}
	}
}
public class CreateStaticInnerInstance
{
	public static void main(String[] args) 
	{
		StaticOut.StaticIn in = new StaticOut.StaticIn();
		/*
		上面代码可改为如下两行代码：
		使用OutterClass.InnerClass的形式定义内部类变量
		StaticOut.StaticIn in;
		通过new来调用内部类构造器创建静态内部类实例
		in = new StaticOut.StaticIn();
		*/
	}
}

静态内部类只需使用外部类即可调用构造器，而非静态内部类必须使用外部类对象来调用构造器

使用静态内部类只要把外部类当成静态内部类的包空间即可。
19.匿名内部类适合创建那种只使用一次的类，匿名内部类会立即创建一个该类的实例，匿名内部类必须继承一个父类，或（最多）实现一个接口。匿名内部类不能是抽象类（需要对象实例），匿名内部类不能定义构造器（无类名），可以定义实例初始化块

new 父类构造器(实参列表) | (实现接口)｛ 匿名内部类的类体｝

interface Product

{
	public double getPrice();
	public String getName();
}
public class AnonymousTest
{
	public void test(Product p)
	{
		System.out.println("购买了一个" + p.getName() 
			+ "，花掉了" + p.getPrice());
	}
	public static void main(String[] args) 
	{
		AnonymousTest ta = new AnonymousTest();
		//调用test方法时，需要传入一个Product参数，
		//此处传入其匿名实现类的实例
		ta.test(new Product()
		{
			public double getPrice()
			{
				return 567.8;
			}
			public String getName()
			{
				return "AGP显卡";
			}
		});
	}
}

20.通过接口创建匿名内部类时，不能显示创建构造器，只有一个隐式的无参构造器，new 接口名后的括号里不能传入参数值；通过继承父类来创建匿名内部类时，匿名内部类自动拥有和父类相似（相同的形参列表）的构造器。

abstract class Device
{
	private String name;
	public abstract double getPrice();
	public Device(){}
	public Device(String name)
	{
		this.name = name;
	}
	//此处省略了name的setter和getter方法
	public void setName(String name)
	{
		this.name = name;
	}
	public String getName()
	{
		return this.name;
	}
}
public class AnonymousInner
{
	public void test(Device d)
	{
	System.out.println("购买了一个" + d.getName()
		+ "，花掉了" + d.getPrice());
	}
	public static void main(String[] args) 
	{
		AnonymousInner ai = new AnonymousInner();
		//调用有参数的构造器创建Device匿名实现类的对象
		ai.test(new Device("电子示波器")
		{
			public double getPrice()
			{
				return 67.8;
			}
		});
		//调用无参数的构造器创建Device匿名实现类的对象
		Device d = new Device()
		{
			//初始化块
			{
				System.out.println("匿名内部类的初始化块...");
			}
			//实现抽象方法
			public double getPrice()
			{
				return 56.2;
			}
			//重写父类的实例方法
			public String getName()
			{
				return "键盘";
			}
		};
		ai.test(d);
	}
}

21. 匿名内部类内部只能访问外部类的final变量

22.回调就是某一个方法一旦获得了内部类对象的引用后，就可以在合适的时候反过来去调用外部类实例的方法。所谓回调，就是允许客户类通过内部类引用来调用其外部类的方法

public class TeachableProgrammer extends Programmer
{
	public TeachableProgrammer(){}
	public TeachableProgrammer(String name)
	{
		super(name);
	}
	//教学工作依然由TeachableProgrammer类定义
	private void teach()
	{
		System.out.println(getName() + "教师在讲台上讲解...");
	}
	private class Closure implements Teachable
	{
		/*
		非静态内部类回调外部类实现work方法，非静态内部类引用的作用仅仅是
		向客户类提供一个回调外部类的途径
		*/
		public void work()
		{
			teach();
		}
	}
	//返回一个非静态内部类引用，允许外部类通过该非静态内部类引用来回调外部类的方法
	public Teachable getCallbackReference()
	{
		return new Closure();
	}
}

public class TeachableProgrammerTest
{
	public static void main(String[] args) 
	{
		TeachableProgrammer tp = new TeachableProgrammer("李刚");
		//直接调用TeachableProgrammer类从Programmer类继承到的work方法
		tp.work();
		//表面上调用的是Closure的work方法，
		//实际上是回调TeachableProgrammer的teach方法
		tp.getCallbackReference().work();
	}
}

23.用enum定义枚举类，默认继承了Enum类，Enum类实现了Serializable和Comparable两个接口。使用enum定义、 非抽象的枚举类默认会使用final修饰，构造器只能使用private访问控制符；枚举类的所有实例必须在枚举类第一行显示列出，系统自动添加public static final修饰；枚举类提供了一个values方法。

public enum SeasonEnum
{
	// 在第一行列出4个枚举实例
	SPRING,SUMMER,FALL,WINTER;
}

public class EnumTest
{
	public void judge(SeasonEnum s)
	{
		//switch语句里的表达式可以是枚举值
		switch (s)
		{
			case SPRING:
				System.out.println("春暖花开，正好踏青");
				break;
			case SUMMER:
				System.out.println("夏日炎炎，适合游泳");
				break;
			case FALL:
				System.out.println("秋高气爽，进补及时");
				break;
			case WINTER:
				System.out.println("冬日雪飘，围炉赏雪");
				break;
		}
	}
	public static void main(String[] args)
	{
		//所有枚举类都有一个values方法，返回该枚举类的所有实例
		for (SeasonEnum s : SeasonEnum.values())
		{
			System.out.println(s);
		}
		//平常使用枚举实例时，
		//总是通过EnumClass.variable形式来访问
		new EnumTest().judge(SeasonEnum.SPRING);
	}
}

23.枚举类的实例只能是枚举值，而不是随意通过new来创建枚举对象。每一个实例拥有一套定义的Field

better

public enum Gender 
{
	MALE,FEMALE;
	private String name;
	public void setName(String name)
	{
		switch (this)
		{
			case MALE:
				if (name.equals("男"))
				{
					this.name = name;
				}
				else
				{
					System.out.println("参数错误");
					return;
				}
				break;
			case FEMALE:
			if (name.equals("女"))
			{
				this.name = name;
			}
			else
			{
				System.out.println("参数错误");
				return;
			}
			break;
		}
	}
	public String getName()
	{
		return this.name;
	}
}

public class GenderTest
{
	public static void main(String[] args) 
	{
		Gender g = Enum.valueOf(Gender.class , "FEMALE");
		g.setName("女");
		System.out.println(g + "代表:" + g.getName());
		//此时设置name值时将会提示参数错误。
		g.setName("男");
		System.out.println(g + "代表:" + g.getName());
	}
}

best

public enum Gender
{
	//此处的枚举值必须调用对应构造器来创建
	MALE("男"),FEMALE("女");
	private final String name;
	//枚举类的构造器只能使用private修饰
	private Gender(String name)
	{
		this.name = name;
	}
	public String getName()
	{
		return this.name;
	}
}

24. 枚举类实现接口与普通类一样。这样每个实例都有同样的方法。如果要实现实例方法的差异化，需要让每个枚举值分别来实现该方法

public interface GenderDesc
{
	void info();
}

public enum Gender implements GenderDesc
{

	//此处的枚举值必须调用对应构造器来创建
	MALE("男")
	//花括号部分实际上是一个类体部分
	{
		public void info()
		{
			System.out.println("这个枚举值代表男性");
		}
	},
	FEMALE("女")
	{
		public void info()
		{
			System.out.println("这个枚举值代表女性");
		}
	};
	//其他部分与codes\06\6.8\best\Gender.java中的Gender类完全相同
}

匿名内部类的原理，创建的是Gender的子类实例
25.在枚举类里定义抽象方法，为不同枚举值提供不同实现，也是匿名内部类的原理

public enum Operation2
{
	PLUS
	{
		public double eval(double x , double y)
		{
			return x + y;
		}
	},
	MINUS
	{
		public double eval(double x , double y)
		{
			return x - y;
		}
	},
	TIMES
	{
		public double eval(double x , double y)
		{
			return x * y;
		}
	},
	DIVIDE
	{
		public double eval(double x , double y)
		{
			return x / y;
		}
	};
	//为枚举类定义一个抽象方法，
	//这个抽象方法由不同枚举值提供不同的实现
	public abstract double eval(double x, double y);
	public static void main(String[] args)
	{
		System.out.println(Operation2.PLUS.eval(3, 4));
		System.out.println(Operation2.MINUS.eval(5, 4));
		System.out.println(Operation2.TIMES.eval(5, 4));
		System.out.println(Operation2.DIVIDE.eval(5, 4));
	}
}

6.9 垃圾回收机制回收对象前，会先调用它的finalize方法，该方法可能使该对象重新复活。不要主动调用某个对象的finalize方法；finalize方法何时被调用是否被调用具有不确定性，不一定会执行；finalize方法出现异常时，垃圾回收机制不会报告异常；finalize方法可能使该对象或系统中的其他对象重新可达。

七、与运行环境交互

1.Scanner类是一个基于正则表达式的文本扫描器；System类和Runtime类与程序的运行平台进行交互

2.StringBuilder和StringBuffer是可变字符串，不同的是StringBuffer是线程安全的，而StringBuilder没有实现线程安全，性能更高

3.Random类专门用于生成一个伪随机数，一个构造器使用默认的种子（当前时间），另一个构造器需要显示传入long型整数种子。ThreadLocalRandom是Random的增强版，在并发环境下，使用ThreadLocalRandom来代替Random可以减少多线程资源竞争，保证更好的线程安全性

4.Random产生的是伪随机数，相同的种子，会产生相同的随机数，推荐使用当前时间作为Random对象的种子

5.BigDecimal用于避免精度丢失

6.Date类在设计上存在缺陷，Calender类能更好的处理日期和时间，其中add会进退位，而roll不会，setLenient(false)关闭容错性，Month设置13时不会进位。lenient模式可接受超出范围的值，而non-lenient模式则不能，否则将抛出异常。set方法会延迟修改，到真正访问时才更新。TimeZone类用于设置时区。

7.Java国际化与格式化

八、Java集合

1.Java集合类主要由两个接口派生：Collection和Map

2.使用Iterator接口遍历集合元素，Iterator对象依附于Collection对象。使用Iterator迭代访问Collection集合元素时，集合里的元素不能被改变

3.foreach，也不能修改迭代变量的值

public class ForeachTest
{
	public static void main(String[] args) 
	{
		//创建一个集合
		Collection books = new HashSet();
		books.add(new String("轻量级Java EE企业应用实战"));
		books.add(new String("疯狂Java讲义"));
		books.add(new String("疯狂Android讲义"));
		for (Object obj : books)
		{
			//此处的book变量也不是集合元素本身
			String book = (String)obj;
			System.out.println(book);
			if (book.equals("疯狂Android讲义"))
			{
				//下面代码会引发ConcurrentModificationException异常
				books.remove(book);     //①
			}
		}
		System.out.println(books);
	}
}

4.Set集合中判断两个对象是否相同不是使用==运算，而是根据equals

5.HashSet需要通过代码来保证同步性，集合元素值可以是null，HashSet是通过equals和hashCode中的一个或者全部来判断元素相同,如果需要把某个类的对象保存到HashSet集合中，重写这个类的equals方法和hashCode方法时，应尽量保证两个对象通过equals方法比较是返回true时，它们的hashCode方法返回值也相等

6.hashCode方法基本规则：同一个对象多次调用hashCode方法应该返回相同的值；equals方法比较返回true时，这两个对象的hashCode方法应该返回相等的值；equals方法比较标准的Field，都应该用来计算hashCode值

将对象内每个有意义的Field计算出一个int类型的hashCode；组合之前计算的多个hashCode值计算出一个hashCode值返回（可以通过为各Field乘以任意一个质数后再相加来避免直接想家产生偶然相等。当向hashSet中添加可变对象时可能导致该独享与集合中的其他对象相等，从而导致HashSet无法准确访问该对象

class R
{
	int count;
	public R(int count)
	{
		this.count = count;
	}
	public String toString()
	{
		return "R[count:" + count + "]";
	}
	public boolean equals(Object obj)
	{
		if(this == obj)
			return true;
		if (obj != null && obj.getClass() == R.class)
		{
			R r = (R)obj;
			if (r.count == this.count)
			{
				return true;
			}
		}
		return false;
	}
	public int hashCode()
	{
		return this.count;
	}
}
public class HashSetTest2
{
	public static void main(String[] args) 
	{
		HashSet hs = new HashSet();
		hs.add(new R(5));
		hs.add(new R(-3));
		hs.add(new R(9));
		hs.add(new R(-2));
		//打印HashSet集合，集合元素没有重复
		System.out.println(hs);
		//取出第一个元素
		Iterator it = hs.iterator();
		R first = (R)it.next();
		//为第一个元素的count实例变量赋值
		first.count = -3;     //①
		//再次输出HashSet集合，集合元素有重复元素
		System.out.println(hs);
		//删除count为-3的R对象
		hs.remove(new R(-3));   //
		//可以看到被删除了一个R元素
		System.out.println(hs);
		//输出false
		System.out.println("hs是否包含count为-3的R对象？"
			+ hs.contains(new R(-3)));
		//输出false
		System.out.println("hs是否包含count为5的R对象？"
			+ hs.contains(new R(5)));
	}
}

先计算hashcode找到桶，再按照equals来判断是否相等，hs.remove(new R(-3));计算该对象的hashcode后与第三个元素所在桶一致，equals也相等则包含。hs.contains(new R(5))计算hashcode与第一个元素所在桶一直，equals则不想等，所以不包含

7.LinkedHashSet是HashSet子类，需要使用链表维护元素的次序；TreeSet是SortedSet接口的实现类，可以确保集合元素处于排序状态；通过实现Comparable接口，来实现对该类对象的比较，在TreeSet中插入元素时，会自动调用元素的compareTo方法，如果添加到TreeSet中的类对象没有compareTo方法，会抛出异常。equals方法返回true时，comparaTo应该返回0

8.可以通过Comparator接口实现定制排序

class M
{
	int age;
	public M(int age)
	{
		this.age = age;
	}
	public String toString()
	{
		return "M[age:" + age + "]";
	}
}
public class TreeSetTest4
{
	public static void main(String[] args) 
	{
		TreeSet ts = new TreeSet(new Comparator()
		{
			//根据M对象的age属性来决定大小
			public int compare(Object o1, Object o2)
			{
				M m1 = (M)o1;
				M m2 = (M)o2;
				return m1.age > m2.age ? -1
					: m1.age < m2.age ? 1 : 0;
			}
		});	
		ts.add(new M(5));
		ts.add(new M(-3));
		ts.add(new M(9));
		System.out.println(ts);
	}
}

创建了一个Comparator接口的匿名内部类对象，该对象负责ts集合的排序，可以无需实现Comparable接口，由TreeSet关联的Comparator对象负责集合元素的排序

9.EnumSet是专为枚举类设计的集合类，其中的元素必须是指定枚举类型的枚举值，其中的元素是有序的，以枚举值在Enum类内的定义顺序来决定集合元素的顺序。不允许加入null

10.HashSet、TreeSet和EnumSet都是线程不安全的，必须手动保证该Set集合的线程安全，通常可以通过Collections工具类sysnchronizedSortedSet方法来“包装”该Set集合

SortedSet s = Collections.synchronizedSortedSet(new TreeSet(...))

11.List是Collection接口的子接口，List提供了额外的listIterator（）方法，返回一个ListIterator对象，在Iterator基础上增加了一些用于List的方法

12.ArrayList和Vector是List类的两个典型实现，initialCapacity控制内部数组的长度，会自增长，如果知道要保存多少元素可以指定initialCapacity大小。ArrayList是线程不安全的，而Vector是线程安全的，Vector性能较低，使用Collections工具类可以将ArrayList编程线程安全的

13.Arrays.ArrayList是固定长度的List集合，只能访问，不可增加、删除该集合里的元素

14.Queue接口有一个PriorityQueue实现类，元素按大小进行排序，可以通过插入元素实现Comparable接口实现自然排序，也可以创建PriorityQueue队列时传入一个Comparator对象实现定制排序；Queue还有一个Deque接口（双端队列，可以当队列和栈使用），有ArrayDeque和LinkedList两个实现类

15.HashMap和Hashtable实现了Map接口，Hashtable线程安全，且不能使用null作为key和value，HashMap可以使用null作为key或value，HashMap和Hashtable通过key的equals返回true判断两个key是否相等

16.LinkedHashMap链表维护Map的迭代顺序，与插入顺序保持一致

17.EnumMap是一个与枚举类一起使用的Map实现，所有key都必须是单个枚举类的枚举值。根据key的自然顺序来维护key-value对的顺序。创建EnumMap时必须指定一个枚举类

enum Season
{
	SPRING,SUMMER,FALL,WINTER
}
public class EnumMapTest
{
	public static void main(String[] args) 
	{
		//创建一个EnumMap对象，该EnumMap的所有key
		//必须是Season枚举类的枚举值
		EnumMap enumMap = new EnumMap(Season.class);
		enumMap.put(Season.SUMMER , "夏日炎炎");
		enumMap.put(Season.SPRING , "春暖花开");
		System.out.println(enumMap);
	}
}

18.HashSet与HashMap的性能选项：容量-capacity，初始化容量-initial capacity，尺寸-size，负载因子-load factor

19.Collections工具类，提供了排序、查找、替换操作和同步控制（通过synchronizedXxx()方法将指定集合包装成线程同步的集合，解决多线程并发访问集合时的线程安全问题）

public class SynchronizedTest
{
	public static void main(String[] args)
	{
		//下面程序创建了四个同步的集合对象
		Collection c = Collections
			.synchronizedCollection(new ArrayList());
		List list = Collections.synchronizedList(new ArrayList()); 
		Set s = Collections.synchronizedSet(new HashSet()); 
		Map m = Collections.synchronizedMap(new HashMap()); 
	}
}

返回不可变集合：emptyXxx()、singletonXxx()、unmodifiableXxx()

public class UnmodifiableTest
{
	public static void main(String[] args)
	{
		//创建一个空的、不可改变的List对象
		List unmodifiableList = Collections.emptyList();
		//创建一个只有一个元素，且不可改变的Set对象
		Set unmodifiableSet = Collections.singleton("疯狂Java讲义");
		//创建一个普通Map对象
		Map scores = new HashMap();
		scores.put("语文" , 80);
		scores.put("Java" , 82);
		//返回普通Map对象对应的不可变版本
		Map unmodifiableMap = Collections.unmodifiableMap(scores);
		//下面任意一行代码都将引发UnsupportedOperationException异常
		unmodifiableList.add("测试元素");   //①
		unmodifiableSet.add("测试元素");   //②
		unmodifiableMap.put("语文" , 90);   //③
	}
}

九、泛型

1.创建了带泛型声明的接口、父类之后，可以为该接口创建实现类，或从该父类派生子类，父类不能再包含类型形参，必须指定

public class A extends Apple {...}  \\错误

public class A extends Apple {...}  \\正确

子类重写父类方法时需要将T换成具体的类型

public class A1 extends Apple
{
	// 正确重写了父类的方法，返回值
	// 与父类Apple的返回值完全相同
	public String getInfo()
	{
		return "子类" + super.getInfo();
	}
	/*
	// 下面方法是错误的，重写父类方法时返回值类型不一致
	public Object getInfo()
	{
		return "子类";
	}
	*/
}

如果使用Apple时没有传入实际的类型参数，将默认使用Object

2.不管为泛型类传入哪一种类型实参，对于Java来说，他们依然被当成同一个类处理，在内存中也只占用一块内存空间，因此在静态方法、静态初始化块或者静态变量的声明和初始化中不允许使用类型形参

List l1 = new ArrayList<>();
List l2 = new ArrayList<>();
System.out.println(l1.getClass() == l2.getClass()); //实际输出为true

由于系统并不会真正生成泛型类，所以instanceof运算符后不能使用泛型类

3.如果Foo是Bar的一个子类型，而G是具有泛型声明的类或接口， G并不是G的子类，即List不是List