JavaSJCP Exam Preparation: Language Fundamentals, Part 1

SJCP Exam Preparation: Language Fundamentals, Part 1 content and product recommendations are editorially independent. We may make money when you click on links to our partners. Learn More.


You are going to be asked to answer questions in the exam regarding the following subjects.
So be sure that you understand everything. After reading each article
I suggest you write and compile small Java programs.
I believe that practice is always better than theory. At the exam, you will be
asked to address the following topics[2]. 

  • Identify correctly the construction of a java source file

  • package declaration
  • Importing classes, and the declaration of
  • class declarations
  • interface declarations
  • Constructor declarations
  • Method declarations
  • main() method and correspondence between the index values and arguments passed to the
    main() method

If you have any questions after studying this
document, do not hesitate to drop me an e-mail, and I will
try to clarify things as best as I can.

You can read more information about SJCP certification from the
Web page
[2] and you can download the .pdf file called Sun
Certified Programmer for Java 2 Platform Success

Koray Guclu

The Structure of Java Source Files

A java source file consists of class or interface declarations. Every 
source file has a .java extension and a file
name in the form After compilation, a valid java byte code
file has a .class extension and a file name in the
form filename.class. A Java source file
can be compiled by the javac
executable utililty,
to compile a java source file you must use “javac
  command. If there are no compile time errors then
a java executable file will be created. The name of this newly created file will
be filename.class. This is a Java
executable file. We can run this file by typing “java
in the command prompt. The extension of the source
file changes after compilation of a source file but the filename remains the same.

There is a correlation between the file name and class names inside the
java source file. If there is a class or interface declared as public, then the
name of the java source file must match the class or the interface name which
has been declared as public.

// File name:
public class
Employee {
// class body
/* File name must be 

Employee because we have 
*  a public class called 

Since this
*  a source file the extension 
*  must be
.java   */

What you should bear in mind is the public
accessibility modifier. If the source file doesn’t contain any public
class or interface then the compiler
will not
complain. In this case, the file can be given a name which is different from the
class or interface name declared inside the source file. Please note, the file
name given should have some relevance to whatever the classes function is.

// File name:
class PendingOrders {

// class body
/* File name can be any 

because we don’t have a 
*  public accessibility 

modifier. Since this is 
*  a source file the extension 

must be java. */

We have seen two possible cases for source code declaration. What if we have two or more class declarations in a source file? How should we
name the source file in this case? Lets remember the previous rule. If a class
declaration has a public accessibility modifier then the name of the source file
must match the public class name. This is the only
rule that we must bear in
mind. The file name of the source code can be anything, if there is no public
class declaration at all. This means that we can have more than one class
defined in a source file. Because they are not declared as public,
we don’t care about the class name and the file name. So what if we have a source
file which has
more than one public class declaration?
According to the rule, the file name must match the name of the
public class declaration. Because
there are more than one
public class declarations, the compiler will complain and throw
up a compile time
exception. There can only be at the most one public
class declaration in a source file.

// File name:
public class

PendingOrders { // ERROR !
// class body
Order {
// class body
More than one public class 
*  declaration will cause a
*  time error.
*  In that case the compiler
*  complain about PendingOrders() class

because Order{} class has the same 
*  name as the source
*  We can solve this problem 
*  by
deleting "public"  
*  in front of the
*  class   */

A source file cannot have more then one public class declaration. At most
only one
public class declaration is allowed per source file and the name of the source
file must match this public class
declaration name.

If the accessibility modifier is not declared, which means default accessibility,
then any number of classes can be declared in a source file. In this case there
is no relation between the name of the source file and the name of the

// File name:
class PendingOrders {

// class body
class Orders {
// class body

/* More than one class can

*  be declared in a source file

*  and the filename
can be anything.
*  Because, there is no public

*  classes declared. */


Besides that, it is not allowed to define more than one class, which has the
same name, in a source file. The
names must be unique or else each class must be declared in a different package.

// File name:
public class

Order { //

       // class body
class Order {
// class

/* There can not be more 

than one class declaration

the same name.*/

There can be at the most only one public class declaration in a source file. If there is
a public class declaration inside the source file then the name of
class  must match the name of the source file. 

// File name:

public class Order { // OK

          // class body


class PendingOrder { //OK

          // class body


/* The name of the source
*  file and public class 

declaration is the same.*/

A valid Java source code, compilation unit, can have three basic elements. None of
these elements
are mandatory. The compiler will not complain even if there is an empty source file. But if they are present
they must be in the following order.

  • A package declaration (you can
    only have one package declaration)
  • import declarations
  • class or interface declarations


import java.util.*;

public class Flower {

        // class body


The compiler will complain if the order is not correct. For example, for the
following code snippet the compiler will throw a compile time error
because the package and
import statements are present, but they
are not in the correct order thus – package->import(s)->class(es)/interface(s).

public class Flower {

        // class body


package; //ERROR!

import java.util.*; // ERROR!

Declaration of package  

Packages are used as a naming organization unit.
They don’t have any relationship to the scope of the variables in the source code.
If a package statement is used in a source file, compilation of that source file will
create a directory structure that is similar to the package structure. For example,
compilation of the following code will create the Flower.class
file at the end of the directory structure “com/earthweb/certification. As we can see
the directory structure is the same as the package naming structure.

package com.earthweb.certification;

public class Flower {

         // class body


There can be at most only one package declaration per source file and if a package name is used it must be the first statement in
the source code.

Importing classes, and declaration of import

An import declaration is the first declaration following the
package declaration. Contrary to
packages, there can be more than one import statement. If there is no package declaration
then the import statements can be the first
statement(s) in a source file.

import javax.servlet.*;

import java.util.*;

public class Flower {

        // class body


The compiler ignores duplicate imports. If we import java.util.Date twice
the compiler will simply import one and ignore any others.

The Java compiler imports java.lang.* package by default. For
this reason, there is no
need to declare the statement in order to use java.lang.System,
java.lang.Math, java.lang.Thread
classes which are included in the java.lang.* package. Any classes
which fall under the java.lang.*
package can be used without
declaring the import statement.

Note, importing a package does not import sub packages recursively. Importing java.* does not
mean that we also import java.util.*.

Declaration of class or interface

They are called as a top-level class or interface.
A top-level class is a class whose declaration is not enclosed by another class.

public class Car {
// Top-level class

       // class body


The file name of this source code must be
because, as I am sure you remember from the rule, it is declared as public and
the class name
must match the file name. Inside of a class we have member methods and member
variables. The following code snippets show the use of member variables and member

public class Lamp {

 // Member variables 

    int voltage; 

 // Member Method  

    void turnOn() {


    void turnOff() {



Interfaces only have method names without any implementation of those methods.
The following code shows a simple interface declaration.

public interface
Engine {  

       void start();



When does a compiler error occur?

The compiler will throw a compile time error if a class is imported twice by
using its exact name with its package structure.

import java.util.Date;

import com.earthweb.certification.Date; // ERROR!

To get rid of this problem, the whole package can be imported instead of
the exact
class name. The following code snippet shows the solution to the problem.

import java.util.*;

import com.earthweb.certification.Date; // OK!

Declaration of a class, which has the same name as the imported class, will cause a
compile time error. 

import com.earthweb.certification.Date;
// OK!

public class Date { // ERROR!

         // class body


It is not allowed to use the same class name as the name of the imported

Declaration of a Class/Interface

In a class declaration, there can be member variables, 
constructors, method declarations & implementations. Multiple inheritance is
not allowed in java. For that reason, you can not extend multiple classes. You can only implement multiple interfaces.
The general syntax for a class declaration is as follows.

[modifiers] class ClassName






           // Class body


A simple example for a sports car
class which extends the car class is shown below. Multiple inheritance is not allowed in Java. 

SportsCar extends Car {
// OK

         //Class body


Since multiple inheritance is not allowed in java, doing so will cause the compiler
to throw a compile time error.

SportsCar extends Car, Engine {
// Error !

         //Class body


Contrary to that, Java allows for the implementation of multiple interfaces. As shown in
the following code snippet car class implements engine and sports wheels

SportsCar extends Car implements Engine,
{ // Ok !

         //Class body


It is not mandatory to declare an access modifier. If we do not define any
access modifier, this means the default access will be applied. The modifiers are shown below.

public protected private  
abstract static final strictfp

These modifiers don’t suit every case. There are some special conditions for use
of these modifiers. As an  example, you can not use private,
as a top-level class modifier. You can only use the public modifier or no
modifier (default access) for this top-level class declaration.
The private and the public modifiers can only be used by the member classes.
You can read the SCJPE Preparation series
Top-level and Inner Classes
section to learn more about this topic.

An interface declaration may seem like a class
declaration. The difference being, an interface can
not have a method implementation. They can only have method names and member variables. An interface can
extend multiple interfaces. The general syntax of an interface is shown below.

[modifiers] interface InterfaceName





               // Interface body


I will mention the details of a class, an abstract class and an  interface in the following chapters. Here is an example
of an interface declaration

interface Player

   void run(); 


Method declarations

The general structure of a method inside a class is as follows.

class ClassName {

      [modifiers] returnType MethodName( [Arguments]

      // Method body



Methods defined inside classes may have implementations. For example, we have an
for the move method of the Car class as follows

Car {

      public int move(int


      // Method body



For interfaces, we can not define method bodies. Interfaces are only to
define method signatures as shown below

Car {

      public int move(int


Constructor declarations

Inside of the class body we have constructors, variables and method declarations.
The syntax of a constructor declaration is like this.

class ClassName

     [ContructorModifiers] ClassName(

     // Constructor body



As you can see from the above syntax a constructor can never have a return
type.  Besides that, only the following modifiers can be used as a valid
modifier for constructors.

public protected private

The following code snippet shows a class with a valid constructor.

class Car

   int velocity;



    velocity = 0;



   Car(int initial)

    velocity = initial;



An interface can not have
a constructor because an interface does not provide the facility for implementations. For
that reason, trying to compile the following will cause an error.

interface Player




The main() method

Every Java application must have a main() method. The structure of Applets and
Servlets are different, for this reason they have special mechanisms to execute
the code and they don’t need a main()
method in order to do this. The structure of the main()
method is shown below 

class Game {

      public static void main(

      // Method body



We can define the argument in various different ways and they are all acceptable
with the exception of the last.

// OK!
public static void main(String args[]){ }

// OK!
public static void main(String[] args){ }

// OK!
public static void main(String [] args){

// OK!
public static void main(String args []){

// OK!
public static void main(String s []){ }


public static void main(String args) {}
// No error at compile time but when
// you try to execute JVM will throw an error
// java.lang.NoSuchMethodError: main

The signature of the main() method
must be the same. Basically the main() method
must have a string array argument, must return void
, it must be static and have a public
modifier. Since main() is a
method, you can inherit the main() method.
It acts like other methods. The following examples illustrates valid and invalid definitions of
the main() method.

// OK!
public static void main(String args[]){ }

// OK!
static public void main(String args[]){ }

// OK!
final public static void main(String args[]){ }

// OK!
final static public void main(String args[]){ }


static void public main(String args[]){ }

The main() method can take a string array as an argument. This argument gives us
commands entered at the command prompt. For example, we have the given arguments to
the Game application at command prompt.

Game.class param1 param2

We can get the number of arguments by args.length.
The first arguments is the first element of the args[]
array, which is args[0]. For the
previous example args[0] will return param1.
It will not return the program name or something else. It will return the first
parameter param1.


1.)    Which of the following are legal Java programs. Select all the correct answer.
a.)// The comments come before the package
      package com.gamelan.certification;
      import java.util.*;

      class Game();

      import java.util.*;
      import java.util.*;
      class Game();

      class Game{};

      class Game{};

2.) Which of the following statements are correct. Select all correct answers. 
        a.) A Java program must have a package statement. 
        b.) A package statement if present must be the first statement of the program 
        c.) An empty file is a valid source file. 
        d.) A Java file without any class or interface definitions can also be compiled. 
        e.) If an import statement is present, it must appear before any class or interface definitions. 

3.) Which of these are valid declarations for the main method? Select all correct answers. 
        a.) public
static void main(); 

        b.) public static void main(String
        c.) static public void

        d.) public static
char main(String args[]); 

4.) What gets printed on the standard output when the class below is compiled and executed by entering
"gamelan is the best java source". 
    public class test {
        public static void main(String args[]) {
System.out.println(args.length+" “+args[0]+” “+args[args.length-1]);

        a.) The program will print "5
gamelan java" 
        b.) The program will print "6
gamelan java"  
        c.) The program will throw an exception.
        d.) The program will print "5
gamelan source"  
        e.) The program will print "6
gamelan source"  
        f.) The program will compile without
an exception and will not print anything.  


I suggest you compile and try other possible combinations by yourself.
Practical work is important for the exam. Instead of just looking at the answers try to
compile code and learn from the results you receive.

1.) a,c,e,f

2.) b,c,d,e

3.) b

4.) e


[ 1 ]. Java
Language Specification (Second
Edition) by James Gosling, Bill
Joy, Guy Steele

[ 2 ]. Information

about SCJP Certification

[ 3 ]. Sun

Certified Programmer for Java 2
Platform Success Guide

[ 4 ]. SJCP

Exam Preparation: Top-level and Inner Classes

Previous Articles

[ 1 ].
Top-level and Inner Classes


I would like to thank to Francis
Hutchings for his valuable
efforts for the review of this

About the Author

Koray Guclu works as a freelance writer and software developer. You can reach
him at His Web
site is

Get the Free Newsletter!

Subscribe to Developer Insider for top news, trends & analysis

Latest Posts

Related Stories