8-1，文档注释

文档注释其实就是将自己写的程序根据这些注释生成文档保存在硬盘上，与Java的API长的一样。

1，格式：

/**
	注释内容...
*/

2，在命令行中通过javadoc命令生成文档注释，在工作开发中必须加文档注释。

例如：

/**
建立一个用于操作数组的工具类，其中包含常见的对数组操作的函数，如最值，排序等。
@author 张三   作者
@version 1.0   当前程序的版本号
*/
class ArrayTool {
	/**
	获取整形数组的最大值。
	@param arr 接收一个元素为int类型的数组
	@return 该数组中最大的元素值
	*/
	public static int getMax(int[] arr) {......}
}

3，用javadoc命令可以查看这个命令的用法。

-d : 输出目录（生成的文档放到指定目录）

例如：

4，加入文件夹目录：javadoc d myhelp author versionArrayTool.java

在当前目录下创建一个myhelp文件，把生成的文档都放进去。

会生成一些html文件，打开index.html文件查看即可。

5，文档注释能提取的只有共有的和受保护的，不能提取私有的，将私有的加到普通多行注释中就可以。

文件的路径修改后要编译需要重新设定classpath，设置了classpath就不在当前目录找了。

8-2，单例设计模式-概述-体现

1，设计模式：对问题进行行之有效的解决方式，其实就是一种思想。

2，单例设计模式：

能解决的问题：可以保证一个类在内存中的对象唯一性。

必须对多个程序使用同一个配置信息对象时，就需要保证该对象的唯一性。

如何保证唯一性？

(1)不允许其他程序用new的方式创建该类对象。

(2)在该类创建一个本类实例。

(3)对外提供一个方法让其他程序可以获取该对象。

步骤：

(1)私有化该类的构造函数。

(2)通过new在本类中创建一个本类的对象。

(3)定义一个公有的方法，将创建的对象返回。

例如：

class Test {
	private int num;
	private static Test t = new Test();
	private Test() {}
	public static Test getInstance() {
		return t;
	}
	public void setNum(int num) {
		this.num = num;
	}
	public int getNum() {
		return num;
	}
}
class SingleDemo {
	public static void main(String[] args) {
		Test t1 = Test.getInstance();
		Test t2 = Test.getInstance();
		System.out.println(t1 == t2);  // true
		t1.setNum(10);
		t2.setNum(20);
		System.out.println(t1.getNum());//20
		System.out.println(t2.getNum());//20
	}
}

单例的通用写法：（饿汉式）

class Single {
	private static Single s = new Single();//new一个本类对象并静态私有化
	private Single(){}//构造函数私有化
	public static Single getInstance() { //提供公共访问方式
		return s;
	}
}

8-5，单例设计模式内存图解

class Single {
	private static Single s = new Single();//new一个本类对象并静态私有化
	private Single(){}//构造函数私有化
	public static Single getInstance() { //提供公共访问方式
		return s;
	}
}
class SingleDemo {
	public static void main(String[] args) {
		Single s1 = Single.getInstance();
		Single s2 = Single.getInstance();
		System.out.println(s1 == s2);
	}
}

步骤：

(1)main函数所在的类加载，将方法加载到方法区，main函数进栈，局部变量s1进栈。

(2) Single s1，这时Single加载，将方法加载到方法区。private static Single s = new Single();这一句在堆中创建了一个对象，分配地址为0X0056。并赋给静态方法区的变量s。

(3)调用getInstance方法，进栈。

(4)获取到静态区中变量s的值，并返回，这个getInstance方法弹栈。

(5)将s的值赋给s1，main中的s1指向堆中的对象。

(6)局部变量s2进栈。

(7)调用getInstance方法，再次直接将s的值赋给s2。

(8)getInstance方法执行完毕弹栈。

(9)s2指向堆中的实体。

8-6，单例-懒汉式

1，写法：

class Single2{
	private static Single2 s = null;
	private Single2(){}
	public static Single2 getInstance() {
		if(s == null) {
			s = new Single2();
		}
		return s;
	}
}

Single2类加载的时候不创建对象，只有调用getInstance方法的时候才创建对象。

2，与饿汉式的区别

懒汉式只有当用到getInstance()方法的时候才建立对象，饿汉式只要类一加载就建立对象。

3，懒汉式缺点

懒汉式在处理多线程问题的时候可能保证不了对象的唯一性。

8-7，继承-概述

1，类之间可以继承，接口之间也可以继承，子类继承父类，子类继承了父类后，拥有父类非私有的成员，不用再在子类中定义，子类可以定义一些自己私有的内容。

父类是由子类不断向上抽取共性内容而来的。

继承的形式如：

class Person {
	String name;
	int age;
}
class Student extends Person {
	void study(){...}
}
class Worker extends Person {
	void work(){...}
}

Student和Worker继承了Person类中的成员，可在Student和Worker中直接使用name和age。

2，继承的好处

(1)提高了代码的复用性

(2)让类与类之间产生了关系，给多态提供了前提。

8-8，单继承和多重继承

1，Java中支持单继承，不直接支持多重继承，但对C++中的多继承机制进行了改良。

2，单继承：一个子类中只能有一个直接父类。

多继承：一个子类可以有多个直接父类（Java不允许，进行改良）。

3，Java更注重多继承的问题

问题如：

class A {
	void show() {
		System.out.println("a")