Java编程基础详解-优快云博客

目标一包，引入，内部类，接口

正确识别结构化的包声明，引入子句，类声明（包含内部类在内的所有形式），接口声明，方法声明（包括类运行入口的main方法），变量声明和标识符。

目标的注解

这是一个奇怪的使用短语表达的目标。它似乎在要求你理解何时，如何以及为何使用引入子句和包子句，以及应该将接口子句和变量子句放在什么地方。

包

名称package意味着类的集合，有点类似于类库。使用包也有点像使用目录。如果你在一个文件中放置一个包子句，此文件只对同一个包中的其他类可见。包有助于解决命名冲突问题。因为你只能使用这么多有意义的名字作为类名，最终，你可能需要使用或创建相同名称的类。通过在类之前附加一个完整的包名，你可以多次使用相同的名字。包名的使用惯例是用组织的internet域名来创建类。因此，当创建一个叫做Question的类来表示一个虚拟的测试题时，我使用我的网站域名www.jchq.net来创建目录结构。

WWW部分无法唯一标识网站的任何信息，所以使用的域名将是net.jchq。为了在我唯一的包中创建类，我创建了目录net，并在此之下创建一个叫做jchq的目录。接着，在那个目录中我可以创建叫做Question的类，类的开头为如下包定义：

package net.jchq.*;

这将赋予你访问此包/目录中任何类的权利。可选地，你可以仅仅指定一个需要获取访问权限的类，使用如下行：

package net.jchq.Question;

引入

import子句必须出现在任何package子句之后和任何代码之前。引入子句不能出现在类中，类声明之后或其他任何地方。

import子句允许你直接使用类名，而不必使用完整的包名来限定它。一个例子就是类名java.awt.Button通常被简写为Button，只要你已经将如下子句放在文件的起始位置：

import java.awt.*;

如果我随后想要创建我的Question类的实例，我只需要引入包或指定此类的完整包名。为了引入其他包中的类，我将需要如下行：

import net.jchq.*;

为了指定类的完整包名，我需要使用如下风格的语法。

jchq.net.Question question = new net.jchq.Question();

你可以想象，经常性地输入完全限定的包名显得不够灵活，所以引入类通常是首选的方案。

请注意，使用引入子句对性能没有影响。这类似于在DOS（或Unix）环境中设定一个路径声明。这只是简单的为类设定有效性或路径，并不是直接将代码引入程序中。仅仅在程序中实际地使用类才会影响性能。

你可以在包自己之前放置一段注释，但不能是其他任何内容。你可能会遇到将引入子句放于包子句前面的考试题。

//你可以在包子句之前放置一段注释

package MyPack;

public class MyPack {}

下面的代码会导致错误

import java.awt.*;

//错误：将引入子句放于包子句前面

//语句会导致编译时错误

package MyPack;

public class MyPack {}

package子句可能会包含点号来指定包层次。因此如下代码将不会导致编译错误

package myprogs.MyPack;

public class MyPack {}

记住，如果你没有在源文件中放置包子句，这将被认为有一个相当于当前目录的缺省包。这与在“1.2节定义和访问控制”中提到的可见性有关。

类和内部类声明

一个文件只能包含一个外部public类。如果你试图创建一个包含多个public类的文件，编译器将会报告特定的错误。一个文件可以包含多个非公共类，但是记住这将为每个类生成单独的.class输出文件。公共类在文件中的放置位置是没有关系的，只要在文件中仅有一个公共类。

内部类是在JDK1.1中提出的。这个想法是为了允许一个类在另一个类中定义，在一个方法中定义，以及创建匿名内部类。这会带来一些有趣的影响，特别是对于可见性。

这是一个简单的内部类的例子：

class Outer {

class inner{}

}

这会导致生成如下名称的类文件

Outer.class

Outer$Inner.class

内部类的定义仅仅在现有的Outer类的上下文中可见。因此，如下代码会导致编译时错误

class Outer {

class Inner{}

}

class Another {

public void amethod () {

Inner I = new Inner();

}

涉及到类Another的时候，类Inner是不存在的。它只能存在于Outer类实例的上下文中。因此如下代码运行良好，因为在创建Inner实例的时候，有一个指向外部类的this实例。

class Outer {

public void mymethod () {

Inner I = new Inner();

}

public class Inner {}

}

但是，如果Outer类的this实例不存在时会发生什么呢。为了弄清楚为此提供的相当古怪的语法的含义，试着将如上例子中的new关键字看作属于this实例当前的上下文。

这样，你可以改变创建实例的代码行，如下

Inner i = this.new Inner ();

这样，如果你需要从一个static方法或其他没有this对象的地方创建Inner的实例，你可以把new当作属于外部类的一个方法来使用

class Outer {

public class Inner {}

}

class another {

public void amethod () {

Outer.Inner i = new Outer ().new Inner ();

}

尽管有了我口齿伶俐的解释，我发现这个语法不够直观，并在学完5分钟后就忘记了。你很有可能会在考试中遇到这个问题，所以请给予额外的注意。

内部类的一个好处是内部类一般可以访问它的嵌套类（或外部类）的域。不像外部类，内部类可以是private或static。主考者似乎有可能问一些归结为“一个内部类可以是static或private”的问题。

静态内部类的方法当然可以访问其嵌套类的任何静态域，因为那些域将只会有一个实例。

声明在方法中的内部类

内部类可以在方法中创建。这是像Borland JBuilder那样的GUI生成工具在创建事件处理器时花很多功夫做的事情。

这是一个这种自动生成的代码的例子

buttonControl1.addMouseListener (new java.awt.event.MouseAdapter () {

public void mouseClicked (MouseEvent e) {

buttonControl1_mouseClicked (e);

}

});

请注意第一个圆括号之后的new关键字。它指出在方法addMouseListener中一个匿名内部类正在被定义。通常地，这个类可以使用一个名字定义，这可能会使它更容易被人们读懂，但是由于在其他地方不需要对其进行处理，取名字不会有太多帮助。

如果你手动创建这些代码，很容易会被数字以及花括号和圆括号的层次弄糊涂。请注意完整的结构为何是以分号结束的，因为这实际上是一个方法调用的结束。

正如你猜的那样，一个匿名内部类不能由程序员给定构造函数。考虑一下，构造函数是一个没有返回值，并且名字与类名相同的方法。咄！我们在谈论没有名字的类。一个匿名类可以继承其他类或实现单一接口。这个特别的限制似乎不会在考试中考到。

在方法中定义的类的域可见性

定义在方法中的类只能访问嵌套方法中的域，如果他们是被定义为final的。这是因为定义在方法中的变量通常被认为是自治的（automatic），例如他们仅当方法执行时才存在。在创建在方法中的类中定义的域可能比嵌套方法的生命周期长。

因为final变量不能被修改，JVM可以确保它的值保持恒定，甚至在外部方法运行终止之后。你很可能在考试中遇到这方面的问题，包括考察作为参数传递给方法的变量状态的问题（是的，他们也必须是final的）。

创建接口

接口是Java用来解决缺少多继承的方式。有趣的是，Visual Basic使用关键字interface并以与Java相似的方式来使用此概念。有时候接口方法被认为面向契约编程。通过关键字“implements”来使用接口。因此，类可以被声明为

class Malvern implements Hill, Well {

public

}

主方法

因为java中的所有代码必须存在于类中，必须有一个特别的或“有魔力的”的方法来引导程序开始运行。这个方法具有如下署名

public static void main (String argv[])

从声明中的每一项来分析，关键字public意味着方法到处可见。static部分意味着方法属于类本身，而不是属于任何特定的实例。这意味着不需要创建类的实例就可以调用它。单词void意味着方法没有返回值。注意单词main都是小写的。在圆括号中的部分指出方法接受一个String数组的参数。当然，单词String必须以大写S开头。参数arg的名字没有关系，你可以叫它bicycle或trousers或任何正确的变量名称，它都可以正确运行。但是参数命名为arg是一个值得坚持的惯例。因为数组的方括号可以跟在名字或类型之后，将参数声明为String [] arg也是可以接受的。

请注意，为了Sun Certified Java Programmers，这是正确的署名。你可能发现其他类似的署名在现实中也可以运行，但是为了考试（以及未来兼容性的目的）你应该使用这种署名。因为这个方法是静态的，所以它被调用（或被Java环境有效跟踪）的时候不需要创建类的实例。同样，因为它是静态的，你不可以操作非静态的方法或数据。因为这样，main方法经常包含极少的代码，典型地，它包含代码来创建嵌套类的实例，然后调用真正使程序完成工作的非静态方法。

由系统传递给main方法的String数组包含任何在程序开始时从命令行传入的参数。当然，有了现代图形用户界面环境，更普通的方法是通过点击图标来启动程序，这些都不会给传递参数带来变化。

考试的目标4.2明确地要求你理解命令行参数是如何传递给main方法的，以及如何访问它们。这就是说……

陈述传递给main方法的参数数组的下标值与命令行参数的对应关系。

课后测试题

问题1）假设有如下代码

public class FinAc {

static int l = 4;

private int k = 2;

public static void main (String argv [] ) {

FinAc a = new FinAc();

a.amethod();

}

public void amethod () {

final int i = 99;

int j = 6;

class CInMet {

public void mymethod (int q) {

// Here

}// end of mymethod

}// End of CInMet

CInMet c = new CInMet ();

c.mymethod (i);

}// End of amethod

}

如下变量中，哪些在由注释//Here标记的行上是可见的？

1. 1. l
  2. k
  3. i
  4. j

问题 2）下面哪个选项可以正确编译？

1）

// A Comment

import java.awt.*;

class Base {}

2）

import java.awt.*;

package Spot;

class Base ();

3）

// Another comment

package myprogs.MyPack;

public class MyPack {}

4）

class Base {}

import java.awt.*;

public class Tiny {}

问题 3）如下论述哪些是正确的？

An inner class may be defined as static
An inner class may NOT be define as private
An anonymous class may have only one constructor
An inner class may extend another class

问题 4）从不存在当前this引用的代码中如何创建内部类的实例？

Outer.Inner i = new Outer ().new Inner ();
Without a this reference an inner class cannot be created
Outer.Inner i = Outer ().new new Inner ();
Outer i = Outer.new ().Inner ();

问题 5）如下哪些是开始执行Java程序的main方法的正确形式？

public static void main (String[] bicycle);
public void main (String argv[]);
public static int main (String args[])
public static void main (String args[]);

问题 6）试图编译如下代码时会发生什么？

abstract class Base {

abstract public void getValue (Base b);

}

public class Robinwood extends Base {

public static void main (String argv[]) {

Robinwood rw = new Robinwood();

rw.main();

}

public void main () {

getValue (this);

}

public void getValue (Base b) {

}

Compile error, only methods can be marked as abstract
Compile error, the name “main” is reserved for the startup method
Compile error, the parameter to the getValue call is of the wrong type
Compilation without error

问题 7）

// located in the East end

package spital;

abstract class Spital {

public Spital (int i) {}

}

public class Mudchute extends Spital {

public static void main (String argv[]) {

Mudchute ms = new Mudchute ();

ms.go ();

}

public Mudchute () {

super (10);

}

public void go () {

island();

}

public void island () {

System.out.println (“island”);

}

Compile time error, any package declaration must appear before anything else
Output of 10 followed by island
Output of 10 followed by “spital island”
Compile time error

问题 8）对于定义在方法中的类，什么规则管理对于嵌套类中变量的访问？

The class can access any variable
The class can only access static variables
The class can only access transient variables
The class can only access final variables

答案

答案1）

定义在方法中的类只能看到来自嵌套方法中的final域。但是它可以看到嵌套类中包括私有域在内的域。域j没有被定义为final。

答案 2）

1）

//A Comment

import java.awt.*;

class Base {};

//Another comment

package myprogs.MyPack;

public class MyPack {}

任何包子句必须是文件中的第一个条目（除去注释）。引入子句必须在任何包子句之后和代码之前。

答案 3）

An inner class may be defined as static
An inner class may extend another class

一个匿名类怎么能有构造函数呢？内部类可以被定义为私有的。

答案 4）

Outer.Inner i = new Outer ().new Inner ();

答案 5）

public static void main (String[] bicycle);
public static void main (String args[]);

选项2可以编译，但是不能成为程序的启动方法，因为它没有声明为static。选项3不能编译，因为它被声明为返回int值。

答案 6）

4）Compilation without error

为一个非启动方法取名为“main”在语法上是正确的，但这是很糟糕的风格。因为类Robinwood继承自类Base，所以可以将其作为参数传递给一个期望得到Base类型参数的方法。

答案 7）

2）Output of 10 followed by island

包声明必须出现在除注释外的任何内容之前，注释可以出现在任何地方。

答案 8）

4）The class can only access final variables

注意这一限制适用于嵌套方法中的变量，而不是嵌套类中的变量。

目标二使用接口

识别正确实现了接口的类，这些接口既可以是java.lang.Runnable，也可以是试题中完整指定的接口。

接口——面向契约编程

接口是总所周知的“面向契约编程”的一部分。这意味着一个程序员创造了一些东西来迫使其他程序员遵循一组条件。接口同样也被认为是Java用来无缺点获取一些多继承好处的方式。C++语言具有多继承，这意味这一个类可以有多个父类。多继承与单继承的优缺点是编程理论家之间广泛争论的话题。

Runnable接口

Runnable接口是线程机制的一部分，线程机制将在其他的考试目标中进行明确地陈述。Runnable接口指定实现了它的类必须定义一个具有如下署名的方法

public void run ()

使用接口的关键字是implements，因此，如果你打算创建一个实现Runnable接口的类，代码类似于

public class MyClass implements Runnable {

public void run () {}

}

当然，为了做一些有用的事，你需要在run方法体中添加一些代码，但是仅仅创建一个具有合适署名的run方法已经足够完成Runnable接口要求的契约了。除非你具有一个完全正确署名的方法，否则你会得到一个编译时错误。

目标三从命令行传递值

陈述传递给main方法的参数数组的下标值与命令行参数的对应关系。

注意：这似乎是一个微小的主题，几乎不值得使之成为一个目标。

这个主题可以找出更具经验的C/C++程序员，因为argv []的第一个元素是命令行中程序名称后面的第一个字符串。因此，如果程序运行如下。

java myprog myparm

元素argv [0]将包含“myparm”。如果你具有C/C++背景，你可能认为它包含“java”。Java不包含与Visual Basic中的Option Base等价的元素（译者注：VB中可以使用Option Base来限定下标的缺省下界），并且所有的数组都是从元素0开始。

以如下程序为例

public class MyParm {

public static vooid main (String argv []) {

String s1 = argv [1];

System.out.println (s1);

}

为了强调argv是一个String数组，我将参数1传给一个String。如果你使用如下命令运行程序

java MyParm hello there

输出结果将是there，而不是MyParm或hello。

课后测试题

问题 1）假设类Cycle中有如下主方法，并且有命令行

java Cycle one two

输出是什么？

public static void main (String bicycle []) {

System.out.println (bicycle [0]);

}

None of these options
Cycle
one
two

问题 2）如何从命令行中获取传递给主方法的值？

Use the System.getParms () method
Assign an element of the argument to a string
Assign an element of the argument to a char array
None of these options

答案

答案 1）

答案2）

Assign an element of the argument to a string

目标四识别关键字

识别所有Java程序设计语言的关键字。注意：不会出现关于关键字与描述常量之间的深层次区别的问题。

目标的注解：你可能希望在学习较少使用的关键字的基础上解决这个目标，确保你没有延续来自其他你所知道的语言中的“坏朋友”，特别是C/C++。考试特别强调识别关键字。此目标的第二部分提到的深层次区别是在JDK1.4版本的考试中加入的目标。似乎越来越多的人担心true/false和null是不是关键字。我想你可以从评论中断定你不会被询问关于true/false 和null的问题。

Java关键字

abstract	boolean	break	byte	case	catch
char	class	const *	continue	default	do
double	else	extends	final	finally	float
for	goto *	if	implements	import	instanceof
int	interface	long	native	new	package
private	protected	public	return	short	static
strictfp	super	switch	synchronized	this	throw
throws	transient	try	void	volatile	while

通过使用语言，你将会逐渐认识大部分的Java关键字，但是，在考试中可能会出现极少使用的例外和保留词。

一些极少使用的词（当然是对于初学者而言）的例子

volatile

transient

native

strictfp

带星号的词是保留的，现在并没有被使用。注意所有的关键字都是小写的，所以for是关键字而FOR不是。

课后测试题

问题 1）下面哪些是Java关键字？

double
Switch
then
instanceof

问题 2）下面哪些不是Java关键字？

volatile
sizeOf
goto
try

答案

答案 1）

double

4）instanceof

注意，switch中的大写字母S意味着它不是关键字，单词then是Visual Basic中的一部分而不是Java。

答案 2）

sizeOf

这是C/C++中用来决定一个原始数据在某个特定平台上的大小的关键字。因为Java中原始数据在所有平台上都具有相同大小，所以这个关键字没有被使用。

目标五未赋值的变量

陈述当没有显式赋值时，使用任何类型的变量或数组元素的影响。

1. 1. 变量

你可以学习使用Java编程而不必真正理解这个目标背后的议程，但是它确实代表着有价值的实际知识。本质上，类级别的变量总是会被赋予一个缺省值，而一个成员变量（包含在方法中）将不会被赋予任何缺省值。如果你试图访问一个未赋值的变量会发生错误。例如

class MyClass {

public static void main (String argv[]) {

int p;

int j = 10;

j = p;

}

这段代码将会导致如下错误：

“error variable p might not have been assigned”

从C/C++给你足够的自由给p留下一个任意值的倾向来看，这被认为是一个很受欢迎的改变。如果p定义在类级别，它就会被赋予其缺省值，而不会有错误产生。

class MyClass {

static int p;

public static void main (String argv []) {

int j = 10;

j = p; System.out.println (j);

}

整型数的缺省值是0，所以这将会打印出0。

数字类型的缺省值是0，布尔型为false，对象引用唯一的缺省值类型是null。

数组

学习这部分目标需要理解一个简单的规则。任何基本类型的数组元素的值将总是被初始化为缺省值，无论数组是否被定义。无论数组定义为类级别还是方法级别，元素值都会被设定为缺省值。你可能会遇到询问一个数组的某个特定元素包含什么值的问题。除非是对象数组，否则答案都不会是null（或者如果它们被特别的设定为NULL）。

课后测试题

问题 1）假设有如下代码，元素b [5]包含什么？

public class MyVal {

public static void main (String argv []) {

MyVal m = new MyVal ();

m.amethod ();

}

public void amethod () {

boolean b [] = new Boolean [5];

}

1）1

2）null

3）＂＂

4）none of these options

问题 2) 假设有如下构造函数，mycon的元素1包含什么？

MyCon () {

int [] mycon = new int [5];

}

1）0

2）null

3）＂＂

4）None of these options

问题 3）试图编译和运行如下代码时会发生什么？

public class MyField {

int i = 99;

public static void main (String argv []) {

MyField m = new MyField ();

m.amethod ();

}

void amethod () {

int i;

System.out.println (i);

}

1. The value 99 will be output
2. The value 0 will be output
3. Compile time error
4. Run time error

问题 4）试图编译和运行如下代码时会发生什么？

public class MyField {

String s;

public static void main (String argv []) {

MyField m = new MyFeild ();

m.amethod ();

}

void amethod () {

System.out.println (s);

}

Compile time error s has not been initialized
Runtime error s has not been initialized
Blank output
Output of null

答案

答案 1）

4）none of these options

数组元素从0开始编号，因此数组没有元素5。如果你试图运行

System.out.println (b [5])

你会得到一个异常。

答案 2）

1）0

这种情况下，构造函数产生的效果与其他方法没有什么不同。无论在哪里创建，一个整型数组的所有元素都将被初始化为0。

答案 3）

Compile time error

你会得到一个编译时错误，指出变量i没有被初始化。类级别的变量i会转移你的注意力，因为它会被方法级别版本所覆盖。方法级别的变量不会被初始化为缺省值。

答案 4）

Output of null

创建在类级别的变量总是会被赋予一个缺省值。对象引用的缺省值是null，并且使用System.out.println隐式调用toString方法时会打印出null。

目标六数据类型的范围和格式

陈述所有原始数据类型的范围，声明String文字以及使用所有允许的格式，基数和表示法来声明原始数据类型。

目标的注解

这是一个有点令人烦恼但又很容易遇到的目标。你可以书写大量Java代码而不需要了解原始数据类型的范围，但是要记住这些细节也不会花很多时间。对能使用所有格式的要求要小心，不要忽略了八进制格式。

整数原始数据类型的大小

当这个目标要求原始数据类型的范围时，我假定它只要求以2的幂次表示，而不是确实表示的数值。由于byte的大小很直观，基于我对PC的基本经验，是8比特，在我的记忆中只有三种整型类型需要学习，

整型数据类型的范围

Name	Size	Range
byte	8 bit	-2⁷ to 2 ⁷-1
short	16 bit	-2¹⁵ to 2¹⁵-1
int	32 bit	-2³¹ to 2³¹-1
long	64 bit	-2 ⁶³ to 2 ⁶³-1

声明整型数

有三种方式声明整型数。缺省的，如你所期望的是十进制。这里是一些选项

声明18为整型数

Decimal	18
Octal	022 (Zero not letter O)
Hexadecimal	0x12

如果你编译并运行这个小类，你每次都会得到18的输出。

public class Lit {

public static void main (String [] argv) {

int i = 18;

int j = 022; //Octal version: Two eights plus two

int k = 0x12; //Hex version: One sixteen plus two

System.out.println (i);

System.out.println (j);

System.out.println (k);

}

Roberts和Heller描述了6种声明整型数的方法，因为对于Java来说是很少见，字母X不是大小写敏感的，16进制符号中的字母A到F也是这样。我觉得仅仅记住有三种方式以及字母是非大小写敏感的要更容易一点。

浮点原始数据类型的大小

浮点数是有点奇怪的“野兽”，因为在计算的时候会出现意想不到的结果。引用Peter Van Der Linden的话“The exact accuracy depends on the number being represented”。为补偿变量的精确度，你确实会接触到巨大得超出想象的数据。因此，最大的double可以存储达到17后面跟307个0的数。所以你甚至可以存储经济报刊上说的Bill Gates所拥有的价值那么大的数值（直到Linux得到了全世界的控制权，那么整数就能很好的完成任务了）。

浮点类型的范围

float	32 bit
double	64 bit

记住，一个具有小数部分的数据的缺省类型是double而不是float。这会有点让人困惑，因为你可能会认为“浮点数”的缺省类型是float。你可能会在考试中遇到类似于如下形式的题目。

如下能通过编译吗？

float i = 1.0;

直觉会告诉你这是可以编译成功的。不幸地是考试不是为考察你的直觉而设计的。这会导致编译时错误，因为它试图将double值赋给一个float类型。你可以这样修改代码

float i = 1.0F;

或者甚至是

float i = (float) 1.0;

使用后缀字母指定数据类型

如上一节中演示的那样，你可以通过一个后缀字母告诉Java一段数字文字的类型。如下那些是可用的

指定数据类型的后缀

float	F
long	L
double	D

布尔值和字符值

布尔和字符原始数据类型有点古怪。如果你有C/C++的背景，请特别注意boolean并确保没有从其他语言中带来任何“坏朋友”。boolean数不能被赋予除true或false以外的其他的值。true或false的值不等价于0，-1或其他任何数字。

char是Java中唯一的未赋值的原始数据类型，它是16位长的。char类型可以用来表示一个Unicode字符。Unicode是ASCII码的替代方案，它使用2个字节来存储字符而不是ASCII码中的1个字节。这提供了65K个字符，尽管不足以覆盖所有文本，但已经是对255字符的ASCII码的很大的改进了。国际化是一个完全属于其本身的话题，而且仅仅因为你能够在中文或越南语中表示字符，并不能表示他们可以在标准的英文风格的操作系统上正常显示。