一、抽象类与抽象方法
Java提供抽象类，它只能作为父类，不能实例化。定义抽象类的作用是将一类对象的共同特点抽象出来，成为代表该类共同特性的抽象概念，其后在描述某一具体对象时，只要添加与其他子类对象的不同之处，而不需要重复类的共同特性。这样就使得程序概念层次分明，开发更高效。与抽象类紧密相连的是抽象方法——它总是用在抽象类或接口中。
1.抽象方法的声明
抽象方法只有方法声明而没有方法体。
通用的形式：
abstract 访问权限 返回类型 方法名([参数列表]);
注意最后以“;”结尾，而没有方法体的括号“{ }”。
声明抽象方法的几个限制：
- 构造方法不能声明abstract
- 静态方法不能声明abstract
- private不能方法不能声明为abstract
- final方法不能声明为abstract
- 抽象方法只能出现在抽象类或接口中
2.抽象类的定义
abstract class ClassName{
类体
}
抽象类中可以有0个或多个抽象方法，也可以有普通的实例方法和静态方法，还可以有其他成员变量和构造方法。如果类中没有任何形式的抽象方法，程序员可以自主决定是否将类声明为abstract类型。但是如果有以下情况之一，类必然是抽象类，要加abstract修饰
- 类中声明有abstract方法
- 类是从抽象类继承下来的，而且没有实现父类中的全部抽象方法
- 类实现了一个接口，但没有将其中所有的抽象方法实现
注意：抽象类可以声明一个变量 类名 变量名; 但是不能将变量实例化 变量名= new 类名();
使用抽象类的唯一途径是派生一个子类，如果这个子类实现了抽象类中的所有抽象方法，那么这个子类就是一个普通的类，它可以用来创建对象。
3.回调函数
例：
//----------------文件名 HasRecall.java--------------
public abstract class HasRecall{
abstract public void alert();
public void doSomething(){
alert();
}
}
该程序是正确的。由于doSomething()是一个实例方法，它执行时必须创建对象。而要创建对象，类必须是普通的实例化类，也就意味着HasRecall这个抽象类中所有的方法都已经实现，自然也就包括了alert()方法。
但是要考虑的一个问题是这样设计的实际作用。因为在HasRecall中调用alert()方法时，并不知道这个方法在子类中是如何实现的，如果不做任何规定，这种调用是没有任何现实意义的。所以，父类的设计者需要规定这个抽象方法的基本用途，而子类设计者需要按照这个规定来实现该方法，才能保证逻辑上的准确性。
例如：在此规定alert方法必须用于输出一条警告信息，向下面这个程序就可以正常运行。
//-------------文件名 ImpRecall.java---------------
public class ImpRecall extends HasRecall{
public void alert(){
System.out.println("Warning!");
}
public static void main(String args[]){
HasRecall oa = new ImpRecall();//父类变量，引用了子类对象
oa.doSomething();
}
}
Java中这种机制，弥补了Java中没有类似于C/C++中的函数指针，因而无法实现回调函数这一缺陷。
所谓回调函数，是指函数f1调用函数f2，函数f2又调用函数f3，但是函数f3的函数体并不是确定的，它是由函数f1在调用f2时作为参数传递给f2的，f3就称为回调函数。
二、最终类与最终方法
如果一个类不希望被其他类继承，则可以声明成final类，这样可以防止其他类以它为父类。最终类通常是有某个固定作用的类，系统中也提供了这样的类，如System、String和Socket类等。
最终类显然不可能是抽象类。由于最终类不能有子类，那么它所拥有的所有方法都不可能被覆盖，因此它其中所有的方法都是最终方法。
1.一般形式
[ 访问权限 ] final class 类名{
类体
}
最终类可以从其他类派生出来，由于它没有子类，所以声明成最终类的变量一定不会引用它的子类对象，因此它的变量不存在运行时的多态问题。编译器可以在编译时确定每个方法的调用，加快执行速度。
如果一个类允许被其他类继承，只是其中的某些方法不允许被子类覆盖，那么可以将这些方法声明为最终方法。一般形式如下：
[ 访问权限 ] final 返回类型 方法名([参数列表])
注意：
- 最终方法不能被覆盖，但是可以被重载
- 最终方法可以出现在任何类中，但是不能和abstract修饰符同时使用。
三、内部类
前面介绍的类都是定义在包中的，可以说是顶层类。而内部类则是可以定义在另外一个类的里面。为了方便，将包含了内部类的这个类称为外部类。
Java通过内部类加上接口，可以更好的实现多重继承的效果。
1.内部类的定义
内部类分为三种：嵌入类，内部成员类，和本地类。当类前面有static修饰符时，他就是嵌入类，嵌入类只能和外部类的成员并列，不能定义在方法中。如果类和外部类的成员是并列定义的，且没有static修饰，则称为内部成员类。如果类是定义在某个方法中，则称为本地类。
-
嵌入类的定义
当内部类的前面用static修饰时，它就是一个嵌入类。它与外部类的其他成员属性和方法处于同一层次上。它的一般形式如下：
[ 访问权限修饰符 ] static class 类名 [ extends 父类名 ] [ implements 接口列表 ] { 类体 }
嵌入类可以定义任何类型的成员属性和方法，这一点与顶层类完全相同。它本身可以是final类型或者是abstract类型，也可以被其他类所继承。但在实际使用过程中，很少会这样做。
嵌入类不能和包含它的外部类同名，也不能和其他的成员同名。
包含一个嵌入类的类编译以后，会生成两个class文件，一个是外部类名.class，另一个是外部类名$内部类名.class。
- 内部成员类的定义
如果内部类前面不能用static修饰，他就是一个内部成员类。它的地位与类的实例成员相当，所以也叫做内部实例成员类。一般形式如下：
[访问权限修饰符] class 类名 [extends 父类名] [implements 接口列表]{
类体
}
内部类与嵌入类最大的不同在于，它的类体不允许存在静态成员，包含静态成员变量和静态方法，但是可以定义静态常量。但是内部类可以继承父类的静态成员。
- 本地类的定义
内部类也可以定义在方法或语句块之中，这时候它成为本地类。无论是静态方法还是实例方法，本地类都不能用static来修饰。它的类体和内部成员类一样，除了静态成员常量，不允许定义任何静态成员，但可以通过继承来拥有静态成员
本地类的作用域是定义它的方法（或语句块），所以它没有访问类型。地位相当于定义了一个局部数据类型。
| 嵌入类 | 内部成员类 | 本地类 | |
|---|---|---|---|
| 静态常量 | √ | √ | √ |
| 静态变量 | √ | ||
| 静态方法 | √ | ||
| 实例变量 | √ | √ | √ |
| 实例常量 | √ | √ | √ |
| 实例方法 | √ | √ | √ |
2.内部类访问外部类的成员
| 嵌入类 | 内部成员类 | 实例方法中的本地类 | 静态方法中的本地类 | |
|---|---|---|---|---|
| 静态常量 | √ | √ | √ | √ |
| 静态变量 | √ | √ | √ | √ |
| 静态方法 | √ | √ | √ | √ |
| 实例变量 | √ | √ | ||
| 实例常量 | √ | √ | ||
| 实例方法 | √ | √ |
注意：如果位于实例方法中的本地类，可以访问实例方法中定义的局部常量，不能访问实例方法中定义的局部变量。
（eg：final int a = 1; int b = 2; a可以访问，b是局部变量，不可以访问 ）
3.内部类之间的相互使用
| 嵌入类 | 内部成员类 | 实例方法中的本地类 | 静态方法中的本地类 | |
|---|---|---|---|---|
| 嵌入类 | √ | √ | √ | √ |
| 内部成员类 | √ | √ | ||
| 实例方法中的本地类 | √ | |||
| 静态方法中的本地类 | √ |
4.在外部使用内部类
对于嵌入类和内部成员类，只要它们的访问权限不是private，可以在外部使用这些类。对于本地类，在外部是无法使用的。
如果是嵌入类，可以像使用静态成员一样，通过"外部类名.嵌入类名"的方式来使用。
由于内部类是非静态的，必须通过外部类的实例来引用。
5.匿名内部类
有时候程序定义一个内部类之后只要创建这个类的一个对象，就不必为这个类命名，这种类称为匿名内部类。语法形式如下：
new InterfaceName( ){
类体
}
或
new SuperClassName([ 实际参数 ]){
类体
}
匿名类是没有名字的，InterfaceName 和SuperClassName是它要继承的接口或类的名字。括号中的参数是用来传递给父类构造方法的。
由于构造方法必须与类名相同，而匿名类没有类名，所以匿名类没有构造方法。取而代之的是将参数传递给父类的构造方法。如果是实现接口，则不能有任何参数。
使用一个匿名内部类通常按照下面的形式：
SuperClassName oa = new SuperClassName( 参数 ) { 类体 }; //注意是大括号
由于匿名类在定义的同时必须要创建对象，所以不能用static修饰。如果它与类的其他成员并列，那么它与内部成员类的定义没有什么区别。如果它是写在一个成员方法中，那么与本地类的规则相同。
注意：如果需要将由匿名类创建的对象作为实际参数传递给某个方法，对象也可以没有名字，所以它的形式如下：
function(newsuperClass() { 类体 }; );
大量使用匿名类会使程序组织变得混乱，使程序流程难于理解，建议限制它的使用。另外，所有的匿名内部类都不是必需的，它一定可以被前面介绍的其他内部类所代替。
四、包
包是一组由类和接口所组成的集合，Java程序可以由若干个包组成，每一个包拥有独有的名字。包的引入，体现了封装特性，它将类与接口封装在一个包内，每个包中可以有若干类和接口，同一个包中不允许有同名的类和接口，但不同包中的类和接口不受此限制。包的引入，解决了类命名冲突问题。
包提供了一种命名机制和可见性控制机制，起到了既可以划分类名空间，又可以控制类之间的访问的作用。由于同一个包中的类默认可以互相访问，所以在一般情况下，总是将具有相似功能和具有共用性质的类放在同一个包中。使用包的另一个好处是有利于实现不同程序间类的复用。
1.包的创建
Java中有两种包，命名包（package 包名;）和未命名包。
2.包的使用
| 在引用类(或接口)名前面加上它所在的包名 | eg: 包名.方法名 |
|---|---|
| 使用关键字import引入指定类 | import 包名.类名; |
| 使用import引入包中所有类 | import 包名.*; |
| 使用import引入静态类 | 从JDK1.5开始，引入Math类时， import static java.lang.Math.*; |
Math类里面的方法全是静态方法。
3.JAR文件的创建和使用
在一个包中，会有很多个 *.class文件。为了方便这些文件的管理，以及减少传输这些文件所需的时间，Java允许把所有的类文件打包成一个文件，这就是JAR文件。JAR文件是压缩的，其压缩格式是ZIP。JAR文件中除了可以包含 *.class文件之外，还像ZIP文件一样可以包含其他类型的文件。
JDK提供了jar工具来创建JAR文件，jar默认位于bin目录下。构建JAR文件最常用的命令如下：
jar cvf JAR 文件名 文件1 文件2
jar命令完整的形式如下
jar { ctxu } [vfm0Mi] [jar - 文件] [manifest - 文件] [- C 目录] 文件名...
jar命令选项说明
| 选项 | 说明 |
|---|---|
| -c | 创建新的存档 |
| -t | 列出存档内容的列表 |
| -x | 展开存档中的命名的（或所有的）文件 |
| -u | 更新已存在的存档 |
| -v | 生成详细输出到标准输出上 |
| -f | 指定存档文件名 |
| -m | 包含指定清单文件中的清单信息 |
| -0 | 只存储方式，未用ZIP压缩格式 |
| -M | 不产生所有项的清单（mainfest）文件 |
| -i | 为指定的jar文件产生索引信息 |
| -C | 改变到指定的目录，并且包含下列文件：如果一个文件名是一个目录，它将被递归处理。清单（mainfest）文件名和存档文件名都需要指定，按‘m’和‘f’标志指定的相同顺序 |
清单（mainfest）文件是一个文本文件，它**默认以.MF为扩展名，**用户可以任意更改这个扩展名，它的主文件名也可以任意指定。jar命令在创建JAR存档文件时，如果指定了-m选项，则可从清单文件中提取一些关于存档文件的附加信息，如指定存档文件中的主类(拥有main方法的类)。清单文件是一个ASCII文件，必须以一个空行作为结尾。
4.JDK中的常用包
- java.lang：语言包。
- java.util：实用包。
- java.awt：抽象窗口工具包。
- java.swing：轻量级的窗口工具包，这是目前使用最广泛的GUI程序设计包。
- java.io：输入输出包。
- java.net：网络函数包。
- java.applet：编制 applet 须用到的包（目前编制 applet 程序时，更多是使用 swing 中的JApplet类）。
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
