Welcome ShouJun's Blog

Wrapper Classes and Their Constructor Arguments

2011-04-16T22:36:00.000-04:00

Primitive	Wrapper Class	Constructor Arguments
boolean	Boolean	boolean or String
char	Character	char
byte	Byte	byte or String
short	Short	short or String
int	Integer	int or String
long	Long	long or String
float	Float	float, double, or String
double	Double	double or String

Default Values for Primitives and Refrence Types in Java

2011-04-16T22:15:00.003-04:00

Variable Type	Default Value
Object reference	null (not referencing any object)
byte, short, int, long	0
float, double	0.0
boolean	false
char	'\u0000'

SCJP Exam Watch 11 - Access instance variable/method from static mathod

2011-04-16T21:50:00.002-04:00

One of the mistakes most often made by new Java programmers is attempting to access an instance variable (which means nonstatic variable) from the static main() method (which doesn't know anything about any instances, so it can't access the variable). The following code is an example of illegal access of a nonstatic variable from a static method:

class Foo {
    int x = 3;
    public static void main(String[] args) {
        system.out.println("x is " + x);
    }
}

Understand that this code will never compile, because you can't access a nonstatic (instance) variable from a static method. Just think of the compiler saying, "Hey, I have no idea which Foo object's x variable you're trying to print!". Remember, it's the class running the main() method, not an instance of the class.

Of course, the tricky part for the exam is that the question won't look as obvious as the preceding code. The problem you're being tested for accessing a nonstatic variable from a static method will be buried in code that might appear to be testing something else. For example, the preceding code would be more likely to appear as

class Foo {
    int x = 3;
    float y = 4.3f;
    public static void main(String[] args) {
        for (int z - x; z < ++x; z--, y = y + z) {
            // complicated looping and branching code
        }
    }
}

So, while you're trying to follow the logic, the real issue is that x and y can't be used within main(), because x and y are instance, not static, variables! The same applies for accessing nonstatic methods from a static method. The rule is, a static method of a class can't access a nonstatic (instance) method or variable of its own class.

Refrence: SCJP Sun® Certified Programmer for Java™ 6 Study Guide Exam (310-065)

Compiler generated constractor code

2011-04-10T23:52:00.001-04:00

class Foo {}

======>

class Foo {
    Foo() {
        super();
    }
}

class Foo {
    Foo() {}
}

======>

class Foo {
    Foo() {
        super();
    }
}

public class Foo {}

======>

public class Foo {
    public Foo() {
        super();
    }
}

class Foo {
    Foo(String s) {}
}

======>

class Foo {
    Foo(String s) {
        super();
    }
}

class Foo {
    Foo(String s) {
        super();
    }
}

======>

Nothing, compiler doesn't need to insert anything.

class Foo {
    void Foo() {}
}

======>

class Foo {
    void Foo() {}
    Foo() {
        super();
    }
}

(void Foo() is a method, not a constructor.)

Refrence: SCJP Sun® Certified Programmer for Java™ 6 Study Guide Exam (310-065)

SCJP Exam Watch 10 - Methods return an abstract class or interface

2011-04-10T23:20:00.000-04:00

Watch for methods that declare an abstract class or interface return type, and know that any object that passes the IS-A test (in other words, would test true using the instanceof operator) can be returned from that method - for example:

public abstract class Animal {}
public class Bear extends Animal {}
public class Test {
    public Animal go () {
        return new Bear();    // OK, Bear "is-a" Animal
    }
}

This code will compile, the return value is a subtype.

Refrence: SCJP Sun® Certified Programmer for Java™ 6 Study Guide Exam (310-065)

SCJP Exam Watch 9 - Class and Interface Declaration

2010-08-28T20:09:00.001-04:00

Look for illegal uses of extends and implements. The following shows examples of legal and illegal class and interface declarations:

class Foo {}                        // OK
class Bar implements Foo {}         // No! Can't implement a class
interface Baz {}                    // OK
interface Fi {}                     // OK
interface Fee implements Baz {}     // No! Interface can't implement an interface
interface Zee implements Foo {}     // No! Interface can't implement a class
interface Zoo extends Foo {}        // No! Interface can't extend a class
interface Boo extends Fi {}         // OK
class Toon extends Foo, Button {}   // No! Class can't extend multiple classes
class Zoom implements Fi, Baz {}    // OK
interface Vroom extends Fi, Baz {}  // OK
class Yow extends Foo implements Fi {}    // OK

Burn these in, and watch for abuses in the questions you get on the exam. Regardless of what the question appears to be testing, the real problem might be the class or interface declaration. Before you get caught up in, say, tracing a complex threading flow, check to see if the code will even compile.

Refrence: SCJP Sun® Certified Programmer for Java™ 6 Study Guide Exam (310-065)

My sons

2010-08-26T22:06:00.003-04:00

My sons picture!

Great!

They are in China now, I miss them and my wife.

SCJP Exam Watch 8 - Obfuscate

2010-08-26T21:14:00.001-04:00

The exam creators will tell you that they're forced to jam tons of code into little spaces "because of the exam engine." While that's partially true, they ALSO like to obfuscate.

The following code:

Animal a = new Dog();
Dog d = (Dog)a;
d.doDogStuff();

Can be replaced with this easy-to-read bit of fun:

Animal a = new Dog();
((Dog)a).doDogStuff();

In this case the compiler needs all of those parentheses, otherwise it thinks it's been handed an incomplete statement.

Refrence: SCJP Sun® Certified Programmer for Java™ 6 Study Guide Exam (310-065)

SCJP Exam Watch 7 - Object Orientation (3)

2010-05-18T15:40:00.001-04:00

Don't be fooled by a method that's overloaded but not overridden by a subclass. It's perfectly legal to do the following:

public class Foo {
    void doStuff() {}
}

class Bar extends Foo {
    void doStuff(String s) {}
}

The Bar class has two doStuff() methods: the no-arg version it inherits from Foo (and does not override), and the overloaded doStuff(String s) defined in the Bar class. Code with a refrence to a Foo can invoke only the no-arg version. but code with a reference to a Bar can invoke either of the overloaded versions.

Refrence: SCJP Sun® Certified Programmer for Java™ 6 Study Guide Exam (310-065)

SCJP Exam Watch 6 - Object Orientation (2)

2010-05-18T15:31:00.006-04:00

Be careful to recognize when a method is overloaded rather than overridden. You might see a method that appears to be violating a rule for overriding, but that is actually a legal overload, as follows:

public class Foo {
    public void doStuff(int y, String s) {}
    public void moreThings(int x) {}
}

class Bar extends Foo {
    public void doStuff(int y, long s) throws IOException {}
}

It's tempting to see the IOException as the problem, because the overridden doStuff() method doesn't declare an exception, and IOException is checked by the compiler.

But the doStuff() method is not overridden! Subclass Bar overloads the doStuff() method, by varying the argument list, so the IOException is fine.

Refrence: SCJP Sun® Certified Programmer for Java™ 6 Study Guide Exam (310-065)

SCJP Exam Watch 5 - Object Orientation (1)

2010-05-18T15:20:00.005-04:00

If a method is overridden but you use a polymorphic (supertype) reference to refer to the subtype object with the overriding method, the compiler assumes you're calling the supertype version of the method.

If the supertype version declares a checked exception, but the overriding subtype method does not, the compiler still thinks you are calling a method that declares an exception.

Let's take a look at an example:

class Animal {
    public void eat() throws Exception {
        // throws an Exception
    }
}

class Dog extends Animal {
    public void eat() {
        /*no Exceptions*/
    }

    public static void main(String[] args) {
        Animal a = new Dog();
        Dog d = new Dog();
        d.eat();        // OK
        a.eat();        // Compiler error - unreported exception
    }
}

This code will not compile because of the exception declared on the Animal eat() method. This happens even though, at runtime, the eat() method used would be the Dog version, which does not declare the exception.

Refrence: SCJP Sun® Certified Programmer for Java™ 6 Study Guide Exam (310-065)

SCJP Exam Watch 4 - Encapsulation

2010-05-14T11:52:00.000-04:00

Look out for code that appears to be asking about the behavior of a method, when the problem is actually a lack of encapsulation. Look at the following example, and see if you can figure out what's going on:

class Foo {
    public int left = 9;
    public int right = 3;

    public void setLeft(int leftNum) {
        left = leftNum;
        right = leftNum/3;
    }

    // lots of complex test code here
}

Now consider this question: Is the value of right always going to be one-third the value of left? It looks like it will, until you realize that users of the Foo class don't need to use the setLeft() method! Thay can simply go straight to the instance variables and change them to any arbitrary int value.

Refrence: SCJP Sun® Certified Programmer for Java™ 6 Study Guide Exam (310-065)

SCJP Exam Watch 3 - Array Declaration

2010-05-14T11:23:00.002-04:00

It is never legal to include the size of the array in your declaration. Yes, we know you can do that in some other language, which is why you might see a question or two that include code similar to the following:

int[5] scores;

The preceding code won't compile. Remember, the JVM doesn't allocate space until you actually instantiate the array object. That's when size matters.

Refrence: SCJP Sun® Certified Programmer for Java™ 6 Study Guide Exam (310-065)

SCJP Exam Watch 2 - Interface Definition

2010-05-14T11:08:00.002-04:00

Look for interface difinitions that define constants, but without explicitly using the required modifiers. For example, the following are all identical:

// Looks non-static and non-final, but isn't!
public int x = 1;
// Looks default, non-static, non-final, but isn't!
int x = 1;
// Does't show public or final
static int x = 1;
// Doesn't show public or static
final int x = 1;
// Doesn't show final
public static int x = 1;
// Doesn't show static
public final int x = 1;
// Doesn't show public 
static final int x = 1;
// What you get implicitly
public static final int x = 1;

Any combination of the required (but implicit) modifiers is legal, as is using no moddifiers at all! On the exam, you can expect to see questions you won't be able to answer correctly unless you know, for example, that an interface variable is final and can never be given a value by implementing (or any other) class.

Refrence: SCJP Sun® Certified Programmer for Java™ 6 Study Guide Exam (310-065)

SCJP Exam Watch 1 - Identifier

2010-05-14T10:58:00.001-04:00

The objective says you have to know legal identifiers only for variable names, but the rules are the same for ALL Java components. So remember that a legal identifier for a variable is also a legal identifier for a method or a class. However, you need to distinguish between legal identifiers and naming conventions, such as the JavaBeans standards, that indicate how a Java component should be names. In other words, you must be able to recognize that an identifier is legal even if it does't confirm to naming standards.

If the exam question is asking about naming conventions - not just whether an identifier will compile - JavaBeans will be mentioned explicitly.

Refrence: SCJP Sun® Certified Programmer for Java™ 6 Study Guide Exam (310-065)

Coding Guidelines - Java Programming Fundamentals

2010-04-05T08:54:00.017-04:00

Your Java programs should always end with the .java extension.
Filenames should match the name of your public class. So for example, if the name of your public class is Hello, you should save it in a file called Hello.java.
You should write comments in your code explaining what a certain class does, or what a certain method do.

In creating blocks, you can place the opening curly brace in line with the statement, like for example,

public static void main(String[] args){

public static void main(String[] args)
{

You should indent the next statements after the start of a block, for example,

public static void main(String[] args){
    System.out.println("Hello ");
    System.out.println("world");
}

For names of classes, capitalize the first letter of the class name. For names of methods and variables, the first letter of the word should start with a small letter. For example:

In case of multi-word identifiers, use capital letters to indicate the start of the word except the first word. For example, charArray, fileName,ClassName.
Avoid using underscores at the start of the identifier such as _read or _write.

In defining a long value, a lowercase L is not recommended because it is hard to distinguish from the digit 1.

It always good to initialize your variables as you declare them.
Use descriptive names for your variables. Like for example, if you want to have a variable that contains a grade for a student, name it as, grade and not just some random letters you choose.
Declare one variable per line of code. For example, the variable declarations,

double exam = 0;
double quiz = 10;
double grade = 0;

double exam = 0, quiz = 10, grade = 0;

Comparing Loop Constrcts

2010-03-30T15:38:00.005-04:00

Use the while loop to iterate indefinitely through statements and to perform the statements zero or more times.
Use the do/while loop to iterate indefinitely through statements and to perform the statements one or more times.
Use the for loop to step through statements a predefined number of times.

Enum in Java

2010-03-18T19:35:00.007-04:00

The basic using of Enum should be like following:

public enum SimpleColor {
    RED,
    GREEN,
    BLUE
}

public static void main(String[] args) {
    for (SimpleColor sc : SimpleColor.values()) {
        System.out.println(sc);
    }
}

In addition, you may also using it as following:

public enum ComplexColor {
    RED ("Red", "0XFF0000"),
    GREEN ("Green", "0X00FF00"),
    BLUE ("Blue", "0X0000FF");

    private String title;
    private String rgb;

    ComplexColor(String title, String rgb) {
        this.title = title;
        this.rgb = rgb;
    }

    public String title() {
        return title;
    }

    public String rgb() {
        return rgb;
    }
}

public static void main(String[] args) {
    for (ComplexColor cc : ComplexColor.values()) {
        System.out.println(cc.title() + " - " + cc.rgb());
    }
}

so, you can have more information on it.

Best Practice of Java Array Declaration

2010-02-25T15:50:00.001-05:00

To declare a array in Java, you have following options:

dataType[] variableName;
dataType variableName[];
dataType []variableName;

The 1st is clearly related to how Java actually works, and you can read it as "dataType array variableName".

The conclusion is:

dataType[] variableName;
dataType[][]...[] arrayName;

IE8 user agent string

2010-02-03T16:44:00.001-05:00

IE8 have 3 kinds of browser mode, but give different user agent string

IE7 mode give you Mozilla/4.0 (compatible; MSIE 7.0; ...;)
IE8 mode give you Mozilla/4.0 (compatible; MSIE 8.0; ...; Trident/4.0; ...;)
IE8 compat view mode give you Mozilla/4.0 (compatible; MSIE 7.0; ...; Trident/4.0; ...;)

Trident/4.0 is the important string to determine the real mode and version of IE8.

Java Operators

2010-01-23T00:55:00.010-05:00

.         []           ()
++        --           !            ~
*          /           %
+         -
<<        >>           >>>         <<<
<         >            <=           >=
==        !=
&         |
^
&&
||
?:
=

Java Data Types

2010-01-23T00:33:00.000-05:00

Primitive Data Types

boolean (true, false)
char (8 bits)
byte (8 bits)
short (16 bits)
int (32 bits)
long (64 bits)
float (32 bits)
double (64 bits)

Reference Variables vs. Primitive Variables

Primitive variables are variables with primitive data types. They store data in the actual memory location of the variable is.
Reference variables are variables that stores the address in the memory location. It points to another memory location of the actual data is.

My First Java Program

2010-01-19T04:03:00.001-05:00

public class Hello {
    /**
     * My first Java program
     */
    public static void main(String[] args) {
        //prints the string "Hello world!" on screen
        System.out.println("Hello world!");
    }
}

Error Types

Syntax errors
Run-time errors

Java Comments

C++ Style Comments
C-Style Comments
Special Javadoc Comments

About Java

2010-01-19T03:51:00.000-05:00

What is Java Technology?

A programming language
A development environment
An application environment
A deployment environment

Some Features of Java

The Java Virtual Machine (JVM)
Garbage Collection
Code Security

My new year's resolution

2010-01-17T23:42:00.000-05:00

My new year's resolution is learning Java and using Java in my next project.

Go for it!