一、抽象类与抽象方法
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类)。