Java 5 In Action

SCJP Sun Certified Programmer for Java 5 Study Guide(Chapter 4)

2006-11-29T17:02:00.000+02:00

Operators

Relational Operators

Relational operators always result in a boolean value (true or false).
There are six relational operators: >, >=, <, <= , ==, and !=. The last two ( == and ! = ) are sometimes referred to as equality operators.
When comparing characters, Java uses the Unicode value of the character as the numerical value.
Equality operators
- There are two equality operators: == and !=.
- Four types of things can be tested: numbers, characters, booleans, and reference variables.
When comparing reference variables, == returns true only if both references refer to the same object.

Instanceof Operator

instanceof is for reference variables only, and checks for whether the object is of a particular type.
The instanceof operator can be used only to test objects (or null) against class types that are in the same class hierarchy.
For interfaces, an object passes the instanceof test if any of its superclasses implement the interface on the right side of the instanceof operator.

Arithmetic Operators

There are four primary math operators: add, subtract, multiply, and divide.
The remainder operator (%), returns the remainder of a division.
Expressions are evaluated from left to right, unless you add parentheses, or unless some operators in the expression have higher precedence than others.
The *, /, and % operators have higher precedence than + and -.

String Concatenation Operator

If either operand is a string, the + operator concatenates the operands.
If both operands are numeric, the + operator adds the operands.

Increment/Decrement Operators

Prefix operators (++ and --) run before the value is used in the expression.
Postfix operators ( + + and --) run after the value is used in the expression.
In any expression, both operands are fully evaluated before the operator is applied.
Variables marked final cannot be incremented or decremented.

Ternary (Conditional Operator)

Returns one of two values based on whether a boolean expression is true or false.
- Returns the value after the ? if the expression is true.
- Returns the value after the : if the expression is false.

Logical Operators

The exam covers six "logical" operators: &, |, ^, !, &&, and | |.
Logical operators work with two expressions (except for !) that must resolve to boolean values.
The && and & operators return true only if both operands are true.
The | | and | operators return true if either or both operands are true.
The && and | | operators are known as short-circuit operators.
The && operator does not evaluate the right operand if the left operand is false.
The | | does not evaluate the right operand if the left operand is true.
The & and | operators always evaluate both operands.
The ^ operator (called the "logical XOR"), returns true if exactly one operand is true.
The ! operator (called the "inversion" operator), returns the opposite value of the boolean operand it precedes.

It is mostly from the McGraw Hill - SCJP Sun Certified Programmer for Java 5 Study Guide

SCJP Sun Certified Programmer for Java 5 Study Guide(Chapter 3)

2006-11-22T17:10:00.000+02:00

Assignments

Stack and Heap

Local variables (method variables) live on the stack.
Objects and their instance variables live on the heap.

Literals and Primitive Casting

Integer literals can be decimal, octal (e.g. 013), or hexadecimal (e.g. 0x3d).
Literals for longs end in L or 1.
Float literals end in F or f, double literals end in a digit or D or d.
The boolean literals are true and false.
Literals for chars are a single character inside single quotes: 'd'.

Scope

Scope refers to the lifetime of a variable.
There are four basic scopes:

Static variables live basically as long as their class lives.
Instance variables live as long as their object lives.
Local variables live as long as their method is on the stack; however, if their method invokes another method, they are temporarily unavailable.
Block variables (e.g., in a for or an if) live until the block completes.

Basic Assignments

Literal integers are implicitly ints.
Integer expressions always result in an int-sized result, never smaller.
Floating-point numbers are implicitly doubles (64 bits).
Narrowing a primitive truncates the high order bits.
Compound assignments (e.g. +=), perform an automatic cast.
A reference variable holds the bits that are used to refer to an object.
Reference variables can refer to subclasses of the declared type but not to superclasses.
When creating a new object, e.g., Button b = new Button();, three things happen:

Make a reference variable named b, of type Button
Create a new Button object
Assign the Button object to the reference variable b

Using a Variable or Array Element That Is Uninitialized and Unassigned

When an array of objects is instantiated, objects within the array are not instantiated automatically, but all the references get the default value of null.
When an array of primitives is instantiated, elements get default values.
Instance variables are always initialized with a default value.
Local/aufomatic/method variables are never given a default value. If you attempt to use one before initializing it, you'll get a compiler error.

Passing Variables into Methods

Methods can take primitives and/or object references as arguments.
Method arguments are always copies.
Method arguments are never actual objects (they can be references to objects).
A primitive argument is an unattached copy of the original primitive.
A reference argument is another copy of a reference to the original object.
Shadowing occurs when two variables with different scopes share the same name. This leads to hard-to-find bugs, and hard-to-answer exam questions.

Array Declaration, Construction, and Initialization

Arrays can hold primitives or objects, but the array itself is always an object.
When you declare an array, the brackets can be left or right of the name.
It is never legal to include the size of an array in the declaration.
You must include the size of an array when you construct it (using new) unless you are creating an anonymous array.
Elements in an array of objects are not automatically created, although primitive array elements are given default values.
You'll get a NullPointerException if you try to use an array element in an object array, if that element does not refer to a real object.
Arrays are indexed beginning with zero.
An ArraylndexOutOfBoundsException occurs if you use a bad index value.
Arrays have a length variable whose value is the number of array elements.
The last index you can access is always one less than the length of the array.
Multidimensional arrays are just arrays of arrays.
The dimensions in a multidimensional array can have different lengths.
An array of primitives can accept any value that can be promoted implicitly to the array's declared type;. e.g., a byte variable can go in an int array.
An array of objects can hold any object that passes the IS-A (or instanceof) test for the declared type of the array. For example, if Horse extends Animal, then a Horse object can go into an Animal array.
If you assign an array to a previously declared array reference, the array you're assigning must be the same dimension as the reference you're assigning it to.
You can assign an array of one type to a previously declared array reference of one of its supertypes. For example, a Honda array can be assigned to an array declared as type Car (assuming Honda extends Car).

Initialization Blocks

Static initialization blocks run once, when the class is first loaded.
Instance initialization blocks run every time a new instance is created. They run after all super-constructors and before the constructor's code has run.
If multiple init blocks exist in a class, they follow the rules stated above, AND they run in the order in which they appear in the source file.

Using Wrappers (Objective 3.1)

The wrapper classes correlate to the primitive types.
Wrappers have two main functions:

To wrap primitives so that they can be handled like objects
To provide utility methods for primitives (usually conversions)

The three most important method families are

xxxValue() Takes no arguments, returns a primitive
parseXxx() Takes a String, returns a primitive, throws NFE
valueOf() Takes a String, returns a wrapped object, throws NFE

Wrapper constructors can take a String or a primitive, except for Character, which can only take a char.
Radix refers to bases (typically) other than 10; octal is radix = 8, hex = 16.

Boxing

As of Java 5, boxing allows you to convert primitives to wrappers or to convert wrappers to primitives automatically.
Using = = with wrappers is tricky; wrappers with the same small values (typically lower than 127), will be = =, larger values will not be = =.

Advanced Overloading

Primitive widening uses the "smallest" method argument possible.
Used individually, boxing and var-args are compatible with overloading.
You CANNOT widen from one wrapper type to another. (IS-A fails.)
You CANNOT widen and then box. (An int can't become a Long.)
You can box and then widen. (An int can become an Object, via an Integer.)
You can combine var-args with either widening or boxing.

Garbage Collection

In Java, garbage collection (GC) provides automated memory management.
The purpose of GC is to delete objects that can't be reached.
Only the JVM decides when to run the GC, you can only suggest it.
You can't know the GC algorithm for sure.
Objects must be considered eligible before they can be garbage collected.
An object is eligible when no live thread can reach it.
To reach an object, you must have a live, reachable reference to that object.
Java applications can run out of memory.
Islands of objects can be GCed, even though they refer to each other.
Request garbage collection with System.gc(); (recommended).
Class Object has a finalize() method.
The finalize() method is guaranteed to run once and only once before the garbage collector deletes an object.
The garbage collector makes no guarantees, finalize() may never run.
You can uneligibilize an object for GC from within finalize().

It is mostly from the McGraw Hill - SCJP Sun Certified Programmer for Java 5 Study Guide

SCJP Sun Certified Programmer for Java 5 Study Guide(Chapter 2)

2006-11-10T22:01:00.001+02:00

Object Orientation

Encapsulation, IS-A, HAS-A

Encapsulation helps hide implementation behind an interface (or API).
Encapsulated code has two features:

Instance variables are kept protected (usually with the private modifier).
Getter and setter methods provide access to instance variables.

IS-A refers to inheritance.
IS-A is expressed with the keyword extends.
IS-A, "inherits from," and "is a subtype of" are all equivalent expressions.
HAS-A means an instance of one class "has a" reference to an instance of another class or another instance of the same class.

Inheritance

Inheritance allows a class to be a subclass of a superclass, and thereby inherit public and protected variables and methods of the superclass.
Inheritance is a key concept that underlies IS-A, polymorphism, overriding, overloading, and casting.
All classes (except class object), are subclasses of type object, and therefore they inherit object's methods.

Polymorphism

Polymorphism means "many forms."
A reference variable is always of a single, unchangeable type, but it can refer to a subtype object.
A single object can be referred to by reference variables of many different types—as long as they are the same type or a supertype of the object.
The reference variable's type (not the object's type), determines which methods can be called!
Polymorphic method invocations apply only to overridden instance methods.

Overriding and Overloading

Methods can be overridden or overloaded; constructors can be overloaded but not overridden.
Abstract methods must be overridden by the first concrete (non-abstract) Subclass.
With respect to the method it overrides, the overriding method

Must have the same argument list.
Must have the same return type, except that as of Java 5, the return type can be a subclass—this is known as a covariant return.
Must not have a more restrictive access modifier.
May have a less restrictive access modifier.
Must not throw new or broader checked exceptions.
May throw fewer or narrower checked exceptions, or any unchecked exception.

final methods cannot be overridden.
Only inherited methods may be overridden, and remember that private methods are not inherited.
A subclass uses super.overriddenMethodName() to call the superclass version of an overridden method.
Overloading means reusing a method name, but with different arguments.
Overloaded methods

Must have different argument lists
May have different return types, if argument lists are also different
May have different access modifiers
May throw different exceptions

Methods from a superclass can be overloaded in a subclass.
Polymorphism applies to overriding, not to overloading.
Object type (not the reference variable's type), determines which overridden method is used at runtime.
Reference type determines which overloaded method will be used at compile time.

Reference Variable Casting

There are two types of reference variable casting: downcasting and upcasting.
Downcasting: If you have a reference variable that refers to a subtype object, you can assign it to a reference variable of the subtype. You must make an explicit cast to do this, and the result is that you can access the subtype's members with this new reference variable.
Upcasting: You can assign a reference variable to a supertype reference variable explicitly or implicitly. This is an inherently safe operation because the assignment restricts the access capabilities of the new variable.

Implementing an Interface

When you implement an interface, you are fulfilling its contract.
You implement an interface by properly and concretely overriding all of the methods defined by the interface.
A single class can implement many interfaces.

Return Types

Overloaded methods can change return types; overridden methods cannot, except in the case of covariant returns.
Object reference return types can accept null as a return value.
An array is a legal return type, both to declare and return as a value.
For methods with primitive return types, any value that can be implicitly converted to the return type can be returned.
Nothing can be returned from a void, but you can return nothing. You're allowed to simply say return, in any method with a void return type, to bust out of a method early. But you can't return nothing from a method with a non-void return type.
Methods with an object reference return type, can return a subtype.
Methods with an interface return type, can return any implementer.

Constructors and Instantiation

A constructor is always invoked when a new object is created.
Each superclass in an object's inheritance tree will have a constructor called.
Every class, even an abstract class, has at least one constructor.
Constructors must have the same name as the class.
Constructors don't have a return type. If you see code with a return type, it's a method with the same name as the class, it's not a constructor.
Typical constructor execution occurs as follows:

The constructor calls its superclass constructor, which calls its superclass constructor, and so on all the way up to the Object constructor.
The Object constructor executes and then returns to the calling constructor, which runs to completion and then returns to its calling constructor, and so on back down to the completion of the constructor of the actual instance being created.

Constructors can use any access modifier (even private!).
The compiler will create a default constructor if you don't create any constructors in your class.
The default constructor is a no-arg constructor with a no-arg call to super().
The first statement of every constructor must be a call to either this() (an overloaded constructor) or super().
The compiler will add a call to super() unless you have already put in a call to this() or super().
Instance members are accessible only after the super constructor runs.
Abstract classes have constructors that are called when a concrete subclass is instantiated.
Interfaces do not have constructors.
If your superclass does not have a no-arg constructor, you must create a constructor and insert a call to super() with arguments matching those of the superclass constructor.
Constructors are never inherited, thus they cannot be overridden.
A constructor can be directly invoked only by another constructor (using acall to super() or this()).
Issues with calls to this()

May appear only as the first statement in a constructor.
The argument list determines which overloaded constructor is called.
Constructors can call constructors can call constructors, and so on, but sooner or later one of them better call super() or the stack will explode.
Calls to this() and super() cannot be in the same constructor. You can have one or the other, but never both.

Statics

Use static methods to implement behaviors that are not affected by the state of any instances.
Use static variables to hold data that is class specific as opposed to instance specific—there will be only one copy of a static variable.
All static members belong to the class, not to any instance.
A static method can't access an instance variable directly.
Use the dot operator to access static members, but remember that using a reference variable with the dot operator is really a syntax trick, and the compiler will substitute the class name for the reference variable, for instance d.doStuff(); becomes: Dog.doStuff();
static methods can't be overridden, but they can be redefined.

Coupling and Cohesion

Coupling refers to the degree to which one class knows about or uses members of another class.
Loose coupling is the desirable state of having classes that are well encapsulated, minimize references to each other, and limit the breadth of API usage.
Tight coupling is the undesirable state of having classes that break the rules of loose coupling.
Cohesion refers to the degree in which a class has a single, well-defined role or responsibility.
High cohesion is the desirable state of a class whose members support a single, well-focused role or responsibility.
Low cohesion is the undesirable state of a class whose members support multiple, unfocused roles or responsibilities.

It is mostly from the McGraw Hill - SCJP Sun Certified Programmer for Java 5 Study Guide

SCJP Sun Certified Programmer for Java 5 Study Guide(Chapter 1)

2006-11-10T19:30:00.000+02:00

So, now I'm preparing for the SCJP5. I've got a perfect book for this – "McGraw Hill - SCJP Sun Certified Programmer for Java 5 Study Guide". There is a Short Drill in the end of every chapter. I post them (drills) with some additional information/comments. I hope it will be helpful for you guys.

Declarations and Access Control

Identifiers

Identifiers can begin with a letter, an underscore, or a currency character.
After the first character, identifiers can also include digits.
Identifiers can be of any length.
JavaBeans methods must be named using camelCase, and depending on the method's purpose, must start with set, get, is, add, or remove.
Java Keywords: 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, assert, enum

Declaration Rules

A source code file can have only one public class.
If the source file contains a public class, the filename must match the public class name.
A file can have only one package statement, but multiple imports.
The package statement (if any) must be the first (non-comment) line in a source file.
The import statements (if any) must come after the package and before the class declaration.
If there is no package statement, import statements must be the first (non-comment) statements in the source file.
package and import statements apply to all classes in the file.
A file can have more than one nonpublic class.
Files with no public classes have no naming restrictions.

Class Access Modifiers

There are three access modifiers: public, protected, and private.
There are four access levels: public, protected, default, and private.
Classes can have only public or default access.
A class with default access can be seen only by classes within the same package.
A class with public access can be seen by all classes from all packages.
Class visibility revolves around whether code in one class can:

Create an instance of another class
Extend (or subclass), another class
Access methods and variables of another class

Class Modifiers (Nonaccess)

Classes can also be modified with final, abstract, or strictfp.
A class cannot be both final and abstract.
A final class cannot be subclassed.
An abstract class cannot be instantiated.
A single abstract method in a class means the whole class must be abstract.
An abstract class can have both abstract and nonabstract methods.
The first concrete class to extend an abstract class must implement all of its abstract methods.

Interface Implementation

Interfaces are contracts for what a class can do, but they say nothing about the way in which the class must do it.
Interfaces can be implemented by any class, from any inheritance tree.
An interface is like a 100-percent abstract class, and is implicitly abstract whether you type the abstract modifier in the declaration or not.
An interface can have only abstract methods, no concrete methods allowed.
Interface methods are by default public and abstract—explicit declaration of these modifiers is optional.
Interfaces can have constants, which are always implicitly public, static, and final.
Interface constant declarations of public, static, and final are optional in any combination.
A legal nonabstract implementing class has the following properties:

It provides concrete implementations for the interface's methods.
It must follow all legal override rules for the methods it implements.
It must not declare any new checked exceptions for an implementation method.
It must not declare any checked exceptions that are broader than the exceptions declared in the interface method.
It may declare runtime exceptions on any interface method implementation regardless of the interface declaration.
It must maintain the exact signature (allowing for covariant returns) and return type of the methods it implements (but does not have to declare the exceptions of the interface).

A class implementing an interface can itself be abstract.
An abstract, implementing class docs not have to implement the interface methods (but the first concrete subclass must).
A class can extend only one class (no multiple inheritance), but it can implement many interfaces.
Interfaces can extend one or more other interfaces.
Interfaces cannot extend a class, or implement a class or interface.

Member Access Modifiers

Methods and instance (nonlocal) variables are known as "members. "
Members can use all four access levels: public, protected, default, private.
Member access comes in two forms:

Code in one class can access a member of another class.
A subclass can inherit a member of its superclass.

If a class cannot be accessed, its members cannot be accessed.
Determine class visibility before determining member visibility.
public members can be accessed by all other classes, even in other packages.
If a superclass member is public, the subclass inherits it—regardless of package.
Members accessed without the dot operator (.) must belong to the same class.
this. always refers to the currently executing object.
this.aMethod() is the same as just invoking aMethod().
private members can be accessed only by code in the same class.
private members are not visible to subclasses, so private members can not be inherited.

default and protected members differ only when subclasses are involved:
default members can be accessed only by classes in the same package.
protected members can be accessed by other classes in the same package, plus subclasses regardless of package.
protected = package plus kids (kids meaning subclasses).
For subclasses outside the package, the protected member can be accessed only through inheritance; a subclass outside the package cannot access a protected member by using a reference to a superclass instance (in other words, inheritance is the only mechanism for a subclass outside the package to access a protected member of its superclass).
A protected member inherited by a subclass from another package is not accessible to any other class in the subclass package, except for the subclass' own subclasses.

Local Variables

Local (method, automatic, or stack) variable declarations cannot have access modifiers.
final is the only modifier available to local variables.
Local variables don't get default values, so they must be initialized before use.

Other Modifiers—Members

final methods cannot be overridden in a subclass.
abstract methods are declared, with a signature, a return type, and an optional throws clause, but are not implemented.
abstract methods end in a semicolon—no curly braces.
Three ways to spot a non-abstract method:

The method is not marked abstract.
The method has curly braces.
The method has code between the curly braces.

The first nonabstract (concrete) class to extend an abstract class must implement all of the abstract class' abstract methods.
The synchronized modifier applies only to methods and code blocks.
synchronized methods can have any access control and can also be marked final.
abstract methods must be implemented by a subclass, so they must be inheritable. For that reason:

abstract methods cannot be private.
abstract methods cannot be final.

The native modifier applies only to methods.
The strictfp modifier applies only to classes and methods.

Methods with Var-args ^*NEW

As of Java 5, methods can declare a parameter that accepts from zero to many arguments, a so-called var-arg method.
A var-arg parameter is declared with the syntax type... name; for instance: doStuff(int... x) { }
A var-arg method can have only one var-arg parameter.
In methods with normal parameters and a var-arg, the var-arg must come last.

Variable Declarations

Instance variables can

Have any access control
Be marked final or transient

Instance variables can't be abstract, synchronized, native, or strictfp.
It is legal to declare a local variable with the same name as an instance variable; this is called "shadowing."
final variables have the following properties:

final variables cannot be reinitialized once assigned a value.
final reference variables cannot refer to a different object once the object has been assigned to the final variable.
final reference variables must be initialized before the constructor completes.

There is no such thing as a final object. An object reference marked final does not mean the object itself is immutable.
The transient modifier applies only to instance variables.
The volatile modifier applies only to instance variables.
Ranges of Numeric Primitives
- byte - has 8 bit. It range from -2⁷to 2⁷-1
- short - has 16 bit. It range from -2¹⁵to 2¹⁵-1
- int - has 32 bit. It range from -2³¹to 2³¹-1
- long - has 64 bit. It range from -2⁶³to 2⁶³-1
- float - has 32 bit. It range n/a
- double - has 64 bit. It range n/a

Array Declarations

Arrays can hold primitives or objects, but the array itself is always an object.
When you declare an array, the brackets can be to the left or right of the variable name.
It is never legal to include the size of an array in the declaration.
An array of objects can hold any object that passes the IS-A (or instanceof) test for the declared type of the array. For example, if Horse extends Animal, then a Horse object: can go into an Animal array.

Static Variables and Methods

They are not tied to any particular instance of a class.
No classes instances are needed in order to use static members of the class.
There is only one copy of a static variable / class and all instances share it.
static methods do not have direct access to non-static members.

Enums ^*NEW

An enum specifies a list of constant values that can be assigned to a particular type.
An enum is NOT a String or an int; an enum constant's type is the enum type. For example, WINTER, SPRING, SUMMER, and FALL are of the enum type Season.
Think of an enum as a kind of class, that looks something (but not exactly) like this:
// conceptual example of how you can think // about enums class CoffeeSize { public static final CoffeeSize BIG = new CoffeeSize("BIG", 0); public static final CoffeeSize HUGE = new CoffeeSize("HUGE", 1); public static final CoffeeSize OVERWHELMING = new CoffeeSize("OVERWHELMING", 2); public CoffeeSize(String enumName, int index) { // stuff here } public static void main(String[] args) { System.out.println(CoffeeSize.BIG); } }
An enum can be declared outside or inside a class, but NOT in a method.
An enum declared outside a class must NOT be marked static, final, abstract, protected, or private.
Enums can contain constructors, methods, variables, and constant class bodies.
enum constants can send arguments to the enum constructor, using the syntax BIG(8), where the int literal 8 is passed to the enum constructor.
enum constructors can have arguments, and can be overloaded:
enum CoffeeSize { BIG(8), HUGE(10), VERWHELMING(16) { public String getLidCode() { // override the method return "A"; } }; // the semicolon is REQUIRED when you have a body CoffeeSize(int ounces) { this.ounces = ounces; } private int ounces; public int getOunces() { return ounces; } public String getLidCode() { return "B"; } }
enum constructors can NEVER be invoked directly in code. They are always called automatically when an enum is initialized.
The semicolon at the end of an enum declaration is optional. These are legal:

enum Foo { ONE, TWO, THREE}
enum Foo { ONE, TWO, THREE}

Java 5 In Action

SCJP Sun Certified Programmer for Java 5 Study Guide(Chapter 4)

Operators

Relational Operators

Instanceof Operator

Arithmetic Operators

String Concatenation Operator

Increment/Decrement Operators

Ternary (Conditional Operator)

Logical Operators

SCJP Sun Certified Programmer for Java 5 Study Guide(Chapter 3)

Assignments

Stack and Heap

Literals and Primitive Casting

Scope

Basic Assignments

Using a Variable or Array Element That Is Uninitialized and Unassigned

Passing Variables into Methods

Array Declaration, Construction, and Initialization

Initialization Blocks

Using Wrappers (Objective 3.1)

Boxing

Advanced Overloading

Garbage Collection

SCJP Sun Certified Programmer for Java 5 Study Guide(Chapter 2)

Object Orientation

Encapsulation, IS-A, HAS-A

Inheritance

Polymorphism

Overriding and Overloading

Reference Variable Casting

Implementing an Interface

Return Types

Constructors and Instantiation

Statics

Coupling and Cohesion

SCJP Sun Certified Programmer for Java 5 Study Guide(Chapter 1)

Declarations and Access Control

Identifiers

Declaration Rules

Class Access Modifiers

Class Modifiers (Nonaccess)

Interface Implementation

Member Access Modifiers

Local Variables

Other Modifiers—Members

Methods with Var-args *NEW

Variable Declarations

Array Declarations

Static Variables and Methods

Enums *NEW

Methods with Var-args ^*NEW

Enums ^*NEW