![](images/null_1x1.gif) |
![](images/null_1x1.gif) |
Here is the article in a print-friendly format. Click the button above to print this page. |
![](images/null_1x1.gif) |
The AP Java Subset: Language Features
|
|
- The primitive types int, double, and boolean are part of the AP Java subset.
The other primitive types short, long, byte, char, and float are not in the subset. In particular, students need not be aware that strings are composed of char values. Introducing char does not increase the expressiveness of the subset. Students already need to understand string concatenation, String.substring, and String.equals. Not introducing char avoids complexities with the char/int conversions and confusion between "x" and 'x'.
- Arithmetic operators: +, -, *, /, % are part of the AP Java subset.
- The increment/decrement operators ++ and --
are part of the AP Java subset. These operators are used only for their
side effect, not for their value. That is, the postfix form (for
example, x++) is always used, and the operators are not used inside other expressions. For example, a[x++] is not used.
- The assignment operator = is part of the AP Java subset. The combined arithmetic/assignment operators +=, -=, *=, /=, %= are part of the AP Java subset although they are used simply as a shorthand and will not be used in the adjustment part of a for loop.
- Relational operators ==, !=, <, <=, >, >= are part of the AP Java subset.
- Logical operations &&, ||, ! are part of the AP Java subset. Students need to understand the "short circuit" evaluation of the && and || operators. The logical &, | and ^ and the bit operators <<, >>, >>>, &, ~, |, ^ are not in the subset.
- The ternary ?: operator is not in the subset.
- The numeric casts (int) and (double) are part of the AP Java subset. Since the only primitive types in the subset are int, double, and boolean, the only required numeric casts are the cast (int) and the cast (double).
Students are expected to understand "truncation towards 0" behavior as
well as the fact that positive floating-point numbers can be rounded to
the nearest integer as (int)(x + 0.5), negative numbers as (int)(x - 0.5).
- String concatenation + is part of the AP Java subset. Students are expected to know that concatenation converts numbers to strings and invokes toString on objects. String concatenation can be less efficient than using the StringBuffer class. However, for greater simplicity and conceptual clarity, the StringBuffer class is not in the subset.
- The escape sequences inside strings \\, \", \n are part of the AP Java subset. The \t escape and Unicode \uxxxx escapes are not in the subset. The \' escape is only necessary inside character literals and is not in the subset.
- User input is not part of the AP Java subset. There are many possible ways for supplying user input; e.g., by reading from a BufferedReader that is wrapped around System.in,
reading from a stream (such as a file or an URL), or from a dialog box.
There are advantages and disadvantages to the various approaches. In
particular, reading from System.in is
both fraught with complexities (two nested readers and the handling of
checked exceptions) and considered old fashioned by some instructors.
The exam does not prescribe any one approach. Instead, if reading input
is necessary, it will be indicated in a way similar to the following:
double x = call to a method that reads a floating-point number;
or
double x = IO.readDouble(); // read user input
Processing string input (e.g., with StringTokenizer) and converting strings to numeric values (e.g., with Integer.parseInt) is not in the subset.
- Testing of output is restricted to System.out.print and System.out.println. As with user input, there are many possible ways for directing the output of a program, for example to System.out, to a file, or to a text area in a graphical user interface. The AP Java subset includes the ability to print output to System.out, because it makes it easy to formulate questions. Since most graphical environments allow printing of debug messages to System.out
(with output being collected in a special window, e.g. the "Java
console" in a browser), students are usually familiar with this method
of producing output. Formatted output (e.g., with NumberFormat) is not in the subset.
- The main method and
command-line arguments are not in the subset. The AP Computer Science
Committee does not prescribe any particular approach for program
invocation. In free-response questions, students are not expected to
invoke programs. In case studies, program invocation with main may occur, but the main method will be kept very simple.
- Arrays: one-dimensional arrays and two-dimensional
rectangular arrays are part of the AP Java subset. Both arrays of
primitive types (e.g., int[]) and arrays of objects (e.g., Student[] ) are in the subset. Initialization of named arrays (int[] arr = { 1, 2, 3 };)
is part of the AP Java subset. Two-dimensional arrays will only be
tested on the AB exam. Arrays with more than two dimensions (e.g., rubik = new Color[3][3][3]) are not in the subset. "Ragged" arrays (e.g., new int[3][]) are not in the subset. In particular, students do not need to know that an int[3][3] really is an "array of arrays" whose rows can be replaced with other int[] arrays. However, students are expected to know that arr[0].length is the number of columns in a rectangular two-dimensional array arr. Anonymous arrays (e.g., new int[] { 1, 2, 3 }) are not in the subset.
- The control structures if, if/else, while, for, return are part of the AP Java subset. The do/while, switch, plain and labeled break and continue statements are not in the subset.
- Method overloading (e.g. MyClass.method(String str) and MyClass.method(int num))
is part of the AP Java subset. Students are expected to know that the
signature of a method depends only on the number, types, and order of
the parameters, and not on its return type.
- Classes: Students are expected to construct objects with the new
operator, to supply construction parameters, and to invoke accessor and
modifier methods. Students are expected to modify existing classes (by
adding or modifying methods and instance variables). Students are
expected to design their own classes.
- Visibility: In the AP Java subset, all classes are public. All instance variables are private. Methods, constructors, and constants (static final variables) are either public, or private.
The AP Java subset does not use protected and package (default) visibility.
- The AP Java subset uses /* */, and // comments. Javadoc comments are not part of the subset.
- The final keyword is only used for final block scope constants and static final class scope constants.final parameters or instance variables, final methods and final classes are not in the subset.
- The concept of static methods is a part of the subset. Students are required to understand when the use of static methods is appropriate. In the exam, static methods are always invoked through a class, never an object (i.e., ClassName.method(), not obj.method()).
- static final variables are part of the subset, other static variables are not.
- The null reference is part of the AP Java subset.
- The use of this is restricted to passing the implicit parameter in its entirety to another method (e.g., obj.method(this)) and to descriptions such as "the implicit parameter this". Using this.var or this.method(args) is not in the subset. In particular, students are not required to know the idiom "this.var = var", where var is both the name of an instance variable and a parameter variable. Calling other constructors from a constructor with the this(args) notation is not in the subset.
- The use of super to invoke a superclass constructor (super(args)) or to invoke a superclass method (i.e., super.method(args)) is part of the AP Java subset.
- Students are expected to implement constructors that
initialize all instance variables. Class constants are initialized with
an initializer:
public static final int MAX_SCORE = 5;
The rules for default initialization (with 0, false or null)
are not in the subset. Initializing instance variables with an
initializer is not in the subset. Initialization blocks are not in the
subset. - Students are expected to extend classes and implement
interfaces. Students are also expected to have a knowledge of
inheritance that includes understanding the concepts of method
overriding and polymorphism. Students are expected to implement their
own subclasses.
- Students are expected to read the definitions of interfaces
and abstract classes and understand that the abstract methods need to
be redefined in non-abstract classes. Students are expected to write
interfaces or class declarations when given a general description of
the interface or class. On the AB exam, students are expected to define
their own interfaces and abstract classes.
- Students are expected to understand the difference between object equality (equals) and identity (==). The implementation of equals and hashCode methods is not in the subset.
- Cloning is not in the subset, because of the complexities of implementing the clone method correctly and the fact that clone is rarely required in Java programs.
- The finalize method is not in the subset.
- Students are expected to understand that conversion from a
subclass reference to a superclass reference is legal and does not
require a cast. Class casts (generally from Object to another class) are part of the AP Java subset, to enable the use of generic collections, for example:
Person p = (Person)people.get(i);
The instanceof operator is not in the subset. Array type compatibility and casts between array types are not in the subset.
- Students are expected to have a basic understanding of packages and a reading knowledge of import statements of the form
import packageName.subpackageName.ClassName;
import statements with a trailing *, packages and methods for locating class files (e.g., through a class path) are not in the subset.
- Nested and inner classes are not in the subset.
- Threads are not in the subset.
- Students are expected to understand the exceptions that occur when their programs contain errors (in particular, NullPointerException, ArrayIndexOutOfBoundsException, ArithmeticException, ClassCastException, IllegalArgumentException). On the AB exam, students are expected to be able to throw the unchecked IllegalStateException and NoSuchElementException
in their own methods (principally when implementing collection ADTs).
Checked exceptions are not in the subset. In particular, the try/catch/finally statements and the throws modifier are not in the subset.
|
|
|