Java 2程序员考试复习关键点与模拟题

需积分: 3 185 浏览量更新于2024-08-02 收藏 495KB PDF 举报

"Java 2 Exam Notes 是一本针对Java 2程序员考试的学习辅助资料，由Sybex出版社出版。这本书旨在巩固读者对Java 2的理解，并帮助他们准备考试。书中包含样本问题、关键术语和概念的定义，以及全面复习所有必要的基础知识，以通过考试。" 本书的内容结构清晰，首先介绍了是否适合阅读这本书的目标读者群体，以及书本的组织方式。"Critical Information"部分强调了学习者需要特别关注的信息，而"Exam Essentials"则列出考试中的重点内容，帮助考生把握考试的关键点。"Key Terms and Concepts"部分则对重要的术语和概念进行了解析，帮助读者理解并记忆。在第一章“声明与访问控制”中，作者详细讲解了如何声明、构造和初始化各种基本类型的数组，包括不同的声明和初始化形式。这部分内容还涵盖了不同修饰符（如public, final, static, abstract等）的使用，以及它们单独或组合使用时的意义。同时，讨论了包关系如何影响这些由这些修饰符限定的声明项。"Critical Information"提醒读者注意这些要点，"Exam Essentials"列出了考试中可能涉及的关键知识，"Key Terms and Concepts"则提供了相关的问题样本，帮助读者实践和测试自己的理解。后续章节会进一步深入到Java 2的其他核心概念，如类、内部类、方法、实例变量、静态变量以及自动（方法局部）变量的声明和使用。每个章节都会遵循类似的形式，提供关键信息、考试必备知识、术语概念和样题，以便考生全面掌握并熟练应用Java 2语言。获取Java 2认证对于提升职业发展具有重要意义，它能证明你的专业技能和知识水平。书中提供的考试技巧和实际考试经验分享将帮助考生更好地应对考试环境。此外，书中还明确了书中的约定，以及如何联系出版社获取更多支持。《Java 2 Exam Notes》是一本全面、实用的备考指南，不仅覆盖了Java 2的所有基础概念和技术，还提供了丰富的练习题和考试策略，是准备Java 2程序员考试的考生不可或缺的参考资料。

With this syntax, the invocation of new and the size of the array are implicit. The array elements are

initialized to the values given between the brackets, rather than their default initialization values.

Exam Essentials

Know how to declare and construct arrays. The declaration includes one empty pair of square brackets for

each dimension of the array. The square brackets can appear before or after the array name. Arrays are

constructed with the keyword new.

Know the default initialization values for all possible types. The initialization values are zero for numeric

type arrays, false for boolean arrays, and null for object reference type arrays.

Know how to declare, construct, and initialize in a single statement. This notation uses initialization

values in curly brackets; for example, int[] intarr = {1, 2, 3};.

Key Terms and Concepts

Array declaration The square brackets in the declaration can appear before or after the variable name.

Default initialization values An array’s elements are initialized to zero for numeric types and to values that

resemble zero for non−numeric types, as shown in Table 1.1.

Sample Questions

1. Which of the following are legal array declarations?

int[] z[];A.

String[][] z[];B.

char[] z;C.

char z[];D.

float[5] z;E.

2. What are the default initialization values for an array of type char?

3. What are the default initialization values for an array of type boolean?

4. Which of the following are legal ways to declare, construct, and initialize an array in a single line?

char[3] cs = {‘a’, ‘b’, ‘c’};A.

char[] cs = [‘a’, ‘b’, ‘c’];B.

char[] cs = {‘a’, ‘b’, ‘c’, ‘d’};C.

char cs[] = {‘a’, ‘b’, ‘c’,‘d’};D.

Answers

1. All the declarations are legal except E. You cannot specify an array’s size in its declaration.

2. '\u0000' (the null character). Table 1.1 lists initialization values for arrays of all primitive types.

3. false.Table 1.1 lists initialization values for arrays of all primitive types.

4. C and D are both legal. A is illegal because the array size is stated explicitly. B is illegal because it uses

square brackets where curly brackets are required.

Declare classes, inner classes, methods, instance variables,

static variables, and automatic (method local) variables, making

appropriate use of all permitted modifiers (such as public, final,

static, abstract, and so forth). State the significance of each of

these modifiers, both singly and in combination, and state the

effect of package relationships on declared items qualified by

these modifiers.

This objective covers a lot of subject matter (and paper!). The big idea is modifiers. This section reviews

Java’s modifiers, including access modifiers, which relate to the phrase in the objective that mentions "the

effect of package relationships."

It is possible to write Java programs that make little or no use of modifiers. However, appropriate use of

modifiers—especially access modifiers—is essential for creating classes that are secure, object−oriented, and

maintainable. This objective recognizes the importance of a working knowledge of Java’s identifiers.

Critical Information

A modifier is a Java keyword that affects the behavior of the feature it precedes. (A feature of a class is the

class itself, or a method, variable, or inner class of the class.) Java’s modifiers are listed as follows:

private•

protected•

public•

final•

abstract•

static•

synchronized•

transient•

native•

volatile•

The first three of these modifiers (private, protected, and public) are known as access modifiers. The

remaining modifiers do not fall into any clear−cut categories. (Another modifier, strictfp, is a new addition to

Java 2. It is discussed briefly in Chapter 4, "Language Fundamentals," but does not appear on the exam.)

The Access Modifiers

There are four possible access modes for Java features: public, protected, default, and private. Three of these

modes (public, protected, and private) correspond to access modifiers. The fourth mode (default) is the default

and has no corresponding keyword modifier; a feature is default if it is not marked with private, protected, or

public. Access modifiers generally dictate which classes, and not which instances, have access to features.

You may use one access modifier at most to modify a feature. Automatic variables (that is, variables defined

within the scope of a method or code block) may not take access modifiers.

The most restrictive access modifier is private. Only methods, data, and inner classes may be private; private

classes are not permitted. A private method may only be called within the class that defines the method. A

private variable may only be read and written within the class that defines the variable. A private inner class

may only be accessed by the containing class; subclasses of the containing class may not access a private

inner class. The granularity of private access is the class level, not the instance level: if a class has a private

feature, then an instance of the class may access that private feature of any instance of the class.

“Default” is the default mode in the absence of a private, protected, or public modifier. This mode has no

corresponding Java keyword. Classes, methods, and data may be default. A default class may be accessed by

any class within its class’s package. A default method of a class may be called from anywhere within the

class’s package. A default variable of a class may be read and written from anywhere within the class’s

package. A default inner class may be accessed by a subclass of the containing class, provided the containing

class and the subclass are in the same package.

The protected access mode grants access permission to all members of the owning class’s package, just as

default access does. Moreover, additional access is granted if the class that owns a protected feature has a

subclass in a different package. In this case an instance of the subclass may access protected data and call

protected methods inherited from the parent instance. A protected inner class may be accessed by any subclass

of the containing class, even if the subclass is in a different package from the containing class.

The most accessible access modifier is public. A public class may be accessed by any class. A public method

may be called by any class (provided the calling class may access the class that owns the method in question).

A public variable may be read and written by any class (provided the reading/writing class may access the

class that owns the variable in question). A public inner class, like a protected inner class, may be accessed by

any subclass of the containing class; moreover, public inner classes are a bit more available for manipulation

via Java’s reflection mechanism. The exact details are beyond the scope of the exam.

Table 1.2 summarizes Java’s four access modes.

Table 1.2: Java’s Access Modes

Access Mode Java Keyword Methods and Fields Inner Classes

Private private Accessible only by owning

class

Accessible only by owning

class

Default (no keyword) Accessible by all classes in

package of owning class

Accessible by same−

package subclasses of

enclosing class

Protected protected Accessible by all classes in

package of owning class and by

subclasses of owning class

Accessible by all subclasses

of enclosing class

Public public Universal access Accessible by all subclasses

of enclosing class, plus some

reflection

Table 1.3 shows which access modes are available to which feature types.

Table 1.3: Features and Access Modes

Access Mode Classes Methods Class Variables Inner Classes

Private NO YES YES YES

Default YES YES YES YES

Protected NO YES YES YES

Public YES YES YES YES

Access and Packages

A package defines a namespace for classes: Every class within a package must have a unique name. Packages

are hierarchical: A package may contain other packages. Package naming uses a period (.) to separate the

components of a package hierarchy name. Thus, for example, the java package contains an awt subpackage,

which in turn contains a subpackage called event. The fully qualified name of this last package is

java.awt.event. Within this package is a class called AdjustmentEvent, whose fully qualified name is

java.awt.event. AdjustmentEvent. No other class named AdjustmentEvent may exist in the java.awt.event

package; however, it is legal for a class named AdjustmentEvent to exist in any other package.

One way to create a Java class that resides inside a package is to put a package declaration at the beginning of

your source file. (Further details on package creation are not required knowledge for the Programmer’s Exam

and are beyond the scope of this book.) If you do not explicitly use a package declaration, a package might be

implicitly created for you. At runtime, the Java environment creates a "default package" that contains all

classes in the current working directory that do not explicitly belong to other packages.

Figure 1.1 shows a superclass, Parent, which is part of the packageA package. The Parent superclass has two

subclasses. One subclass, childA, is also in the packageA package. The other subclass, childB, is in a different

package, called packageB.

Figure 1.1: Package and subclass relationships

The childB subclass has access to all features of the Parent superclass that are public or protected. The childA

subclass also has access to the public and protected features of Parent. In addition, since childA and Parent are

in the same package, childA has access to all default features of Parent; this access would be the same if

childA were not a subclass of Parent.

Default Access in Interfaces

In a class definition, the default access mode for a method is, of course, “default.” This is not the case for a

method in an interface. All interface methods are inherently public, so the default access mode for a method in

an interface is public. Thus the following two interface versions are functionally identical:

Interface Inter { // no access modifier

double getWeight(Animal theAnimal);

}

Interface Inter { // explicitly public

public double getWeight(Animal theAnimal);

}

You are not allowed to apply any access modifier other than public to a method in an interface. The following

interface generates a compiler error.

Interface BadAccess {

protected double x(); // Compiler error

}

Access Examples

This section presents several examples of the use of access modifiers. All the examples refer to a simple class

called packageA.Parent, which is listed below:

1. package packageA;

3. public class Parent {

4. private int iPrivate;

5. int iDefault;

6. protected int iProtected;

7. public int iPublic;

8. }

The class definitions that follow illustrate each of the four Java access modes. All the code compiles; lines

that illustrate illegal access attempts have been commented out.

The first example illustrates the private access mode. Since only the Parent class may access a private feature

of the Parent class, our example is an expansion of Parent.

1. package packageA;

3. public class Parent {

4. private int iPrivate;

5. int iDefault;

6. protected int iProtected;

7. public int iPublic;

9. void xxx() {

10. iPrivate = 10; // My own

11. Parent other = new Parent();

12. other.iPrivate = 20; // Someone else’s

13. }

14. }

Line 10 is an obvious use of the private access mode. The current instance of the Parent class is modifying its

own version of iPrivate. Line 12 is less obvious: the current instance is modifying the iPrivate of a different

instance of Parent. This example illustrates the principle that access modifiers grant access to classes, and not

to instances.

The next example illustrates the default access mode, which grants access permission to all classes in the same

package as the class that owns the default feature. Here we will create a second class in the packageA

package.

1. package packageA;

3. public class InSamePackage {

4. void makeItSo() {

5. Parent parent = new Parent();

6. // parent.iPrivate = 10;

7. parent.iDefault = 20;

8. parent.iProtected = 30;

9. parent.iPublic = 40;

10. }

11. }

Line 6 has to be commented out, because the attempted access to iPrivate in another class would not be

allowed. Line 7 is legal because iDefault is a default variable in a class in the current package. Line 8 is legal

because iProtected is a protected variable in a class in the current package. Line 9 is legal because iPublic is a

public variable.

The next example illustrates the protected access mode, which grants access permission to all classes in the

same package as the class that owns the protected feature, as well as to subclasses of the class that owns the

feature. Here we will create a class in a second package, called packageB.

1. package packageB;

3. public class InDifferentPackage

4. extends packageA.Parent {

5. void aMethod() {

6. packageA.Parent parent =

new packageA.Parent();

7. // parent.iPrivate = 10;

8. // parent.iDefault = 20;

9. // parent.iProtected = 30;

10. iProtected = 40;

11. parent.iPublic = 50;

12. }

13. }

Lines 7 and 8 have to be commented out for reasons that were illustrated in the previous examples. It may be

surprising that line 9 does not compile and also must be commented out. The iProtected variable is protected;

an instance of a subclass in a different package (such as the current instance of packageB.InDifferentPackage

here) does not have access to the iProtected of every instance of packageA .Parent. Rather, an instance of the

剩余117页未读，继续阅读

kennstorm

粉丝: 1
资源: 7

Java 2程序员考试复习关键点与模拟题

SCWCD Exam Notes.doc

Java Certificate Notes

初级java笔试题-DB_Exam_Notes:DB_Exam_Notes

sommatlab代码-Test_Exam_notes:Test_Exam_notes

worldwindjava源码-SANS_FOR572_GNFA_Exam_Notes:SANS_FOR572_GNFA_Exam_Notes

cpp-java-code:我的C ++和Java代码

java笔试题2015-CSstudy:自己收集的一些计算机/数学/Linux/分布式的资料，收藏夹不够用了！

网络取证分析：世界风Java源码的TTP识别与攻击者停留时间

数据分析高级培训：客户体验分析-课件

【微电网潮流】分布式电源微电网潮流【Matlab仿真 7357期】.zip

最新资源