JAVA source file structure

by
S.Santhosh
1721041
• JAVA SOURCE FILE STRUCTURE:
1. A java program can contain any number of classes.
2. At most one class can be declared as public.
3. If there is a public class then name of the program and
name of the public class must be matched. Otherwise, we
will get compile time error.

Example:
class One
{
}
class Two
{
}
class C
{
}
• Case 1:
Example:
Class One
{
}
Class Two
{
}
Class C
{
}
– If there is no public class then we can use any name and there
is no restrictions.
• One.java
• Two.java
• C.java
• Santhosh.java
• Case 2:
• Example:
Class One
{
}
public Class Two
{
}
Class C
{
}

If class Two is public then name of the program should be

Two.java.
Otherwise, we will get compile time error saying,
Class Two is public, should be declared in a file named Two.java
• Case 3:
• Example:
Class One
{
}
public Class Two
{
}
public Class C
{
}

If class Two and C is declared as public and name of the program is

Two.java then we will get compile time error saying,

Class C is public, should be declared in a file named C.java

• Whenever we are compiling a java program for every class
present in the program a separate .class file will be generated.
Example:
class A
{
public static void main(String[] args)
{
System.out.println(“A class main”);
}
}
class B
{
public static void main(String[] args)
{
System.out.println(“B class main”);
}
}
class C
{
}

javac One.java

A.class B.class C.class One.java

1) Whenever we are executing a java class, the corresponding
class main method will be executed.
2) If the class doesn’t contain main method then we will get
runtime exception saying,
noSuchMethodError:main
3) If the corresponding .class file not available then we will get
runtime exception saying
noClassDefFoundError

java A --- java B ---

output: A class main output: B class main
java C --- java One --
RE :noSuchMethodError:main RE:noClassDefFoundError
Import statement:
class One
{
public static void main(String[] args)
{
Scanner s=new Scanner(System.in);
}
}

CE: cannot find symbol

symbol: class Scanner
location: class One
We can solve this problem by using fully-qualified name

java.util.Scanner s=new Scanner(System.in);

• The problem with usage of fully-qualified name everytime, it
increases the length of the code and reduces readability.
• We can solve this problem by using import statement.
• Whenever we are writing import statement, it is not required
to use fully-qualified name everytime. We can use short
name directly.
Example:
import java.util.Scanner;
class one
{
public static void main(String[] args)
{
Scanner s=new Scanner(System.in);
}
}
There are two types of import statements

 Explicit class import

Eg: import java.util.Scanner;
 Implicit class import
Eg: import java.util.*;
Case 1:
import java.util.*;
import java.util.*;
class Test
{
public static void main(String[] args)
{
Date d=new Date();
}
}

CE: reference to Date is ambiguous

Because both the package(util and sql) contain Date class.

while resolving class name compiler will always gives
precedence in the following order.
» Explicit class import
» Classes present in current working directory
» Implicit class import
Example:
import java.util.Date;
import java.sql.*;
class Test
{
public static void main(String[] args)
{
Date d=new Date();
System.out.println(d.getClass().getName());
}
}

Output:
java.util.Date
• Packages:
• It is an encapsulation mechanisms group related classes and
interfaces into a single unit, which is nothing but package.
• Example:
– All classes and interfaces which are required for database
operation are grouped into a single package which is
nothing but java.sql package
The main advantages of package are:-
1. To resolve naming conflict( that is unique identification
of our components).
2. It improves maintainability of the application.
3. It proves security for our components.
Example:
Package com.cricket;
Public class Test
{
public static void main(String[] args)
{
System.out.println(“package demo”);
}
}
Compile – 2 ways:
javac Test.java ---
Generated .class file will be placed in current working
directory.
javac –d . Test.java ---
Generated .class file will be placed in corresponding package
structure.
As destination instead of . We can take any valid directory
name.
javac – d F: Test.java ---
If the corresponding package structure not already
available then this command itself will create
corresponding package structure.
If the specified directory not available then
We will get compile time error.
Example:
javac – d Z: Test.java ---

directory not found: Z:

At the time of execution we have to use fully-qualified name

java com.cricket.Test ---

Output:
package demo
Conclusion:
1) In any java source file, there can be at most one package statement. That is
more than one package is not allowed. Otherwise, we will get compile time error.
Example:

package pack1;
package pack2;
public class A
{
}

CE: class,interface or enum expected

2) If any java program, the first non-comment statement
should be package statement( if it is available). Otherwise,
we will get compile time error.
Example:

import java.util.*;
package pack;
public class A
{
}

CE: class,interface or enum expected

The following is valid java source file structure.

package statement;
import statements;
class / interface / enum declarations
Thank you