1. Classes, Interfaces and Packages

2. Objectives After completing this chapter, the student will be able to:
Explain Java classes
Explain Java objects
Declare and define simple Java classes
Create objects of Java classes and do manipulation on those objects by invoking class methods
Explain class constructors and finalizers
Explain access modifiers and the difference between different access modifiers

3. Objectives contd..
Explain class inheritance
Explain the difference between method overloading and method overriding
Explain abstract classes, interfaces and interface implementation
Explain Java packages
Explain CLASSPATH environment variable and set it to suit his/her requirement
Write programs to create Java packages
Explain the usage of import and package statements
Write Java programs using previously created packages
Explain the important packages in Java API

4. Introduction Java is an object oriented programming language.
Object oriented programming revolves around the concept of objects.
Objects are software bundles of data abstractions and procedures that act on the data.
These procedures are also known as methods.
Two powerful benefits of encapsulation are implementation hiding and modularity.

5. Classes
A class is a template or a prototype that defines a type of object.
A class is to an object what a blue print is to a house.
A class outlines the properties of an object.
Objects created from the same class show similar characteristics.

6. Declaring Classes
The syntax for declaring classes in Java is as follows:
class identifier {
classBody }
ClassBody consists of data declarations and method definitions.
Curly braces surround the classBody.

7. The new Operator
Here is how you create instances of classes or object variables and invoke methods or member functions in Java.
ExampleClass ec;
ec = new ExampleClass();
ec.exampleMethod1();
ec.exampleMethod2();
The declaration “ExampleClass ec:” simply states what type of object variable ec will be.
The object is actually created when the new operator is called.

8. Constructors
Constructors are special methods you can implement in your classes.
Constructors are always given the same name as that of the class.
It do not have return type.
Used to initialize the member variables.

9. Finalize Method
Finalizer methods are automatically called when an object is destroyed.
Java objects are destroyed during garbage collection.
Finalizers are thus called when Java performs garbage collection.
void finalize() {
// do clean u job }

10. Java Objects as Class Member Variables
Java class member variables are of two types.
One is the built in type like char, int, float, double, etc.
Class member variables can be Java objects as well.
Ex: String msg;

11. Method Overloading
If two or more methods of a class have the same name but different signatures, then the method name is said to be overloaded.
The signature of a method consists of the name of the method and the number and types of formal parameters in particular order.
Only the method name is reused in overloading, so method overloading is actually method name overloading.
Overloaded methods may have arguments with different types and order of the arguments may be different.

12. Method Overloading contd..
Overloaded methods are not required to have the same return type or the list of thrown exceptions.
Overloading is used while implementing several methods that implement similar behavior but for different data types.
Overloaded methods are independent methods of a class and can call each other just like any other method.

13. Constructor Overloading
Constructors can also be overloaded as they are also methods.
Java has some classes with overloaded constructors.
Ex: Integer i =new Integer(3);
Integer j =new Integer(“2012”);
One constructor can call another overloaded constructor of the same class by using this keyword.
One constructor can call constructor of it’s super class by using the super keyword.

14. Deriving Classes
A Class can be built on another class that is already defined and is existing. This already existing class is called the base class or the parent class. The newly built class is called the derived class or child class. extends is the keyword used for inheritance.
The Child class inherits all the properties of the parent class.
The child class inherits all the member variables and methods of the parent class.
The child class can have its own member variables and methods.

15. Method Overriding
When a class defines a method with same method name ,argument types, argument order and return type as a method in its super class, it’s called method overriding.
The method in the super class is said to be overridden by the method in the subclass.
Overriding method actually replaces the behavior in super class for a subclass.
The call super.method() will invoke the method of immediate super class.

16. Rules for Method Overriding
Methods overriding cannot be declared more private than the super class method.
Any exceptions declared in overriding method must be of the same type as those thrown by the super class or a subclass of that type.
Methods declared as final cannot be overridden.
An overriding method can be declared as final as the keyword final only suggests that this method cannot be further overridden.
Methods declared as private cannot be overridden.

17. Access Modifiers
Access to member variables and methods in a Java class is accomplished through access modifiers.
Access modifiers define the varying levels of access between class members and outside world.
Access modifiers are declared immediately before the data type of a member variable or the return type of a method.
There are four access modifiers: default, private, protected and public.

18. Access Modifiers
Access modifiers on class member declarations are listed here.
Modifier
Same Class
Same Package
Subclass
Universe
private
Yes
default
protected
public

19. The static Modifier
The static modifier specifies that a variable or a method is the same for all objects of a particular class.
static variables memory is allocated only once i.e. the first time when we create the object.
static method can be accessed without having to create an object of the class.
Static method has access to static variables only.

20. The final Modifier
The final modifier with variable specifies that the variable has a constant value.
The final modifier with method specifies that the method can not be overridden in a subclass or child class.
The final modifier with class specifies that the class can not be inherited.

21. The native Modifier
The native modifier informs the Java compiler that a method’s implementation is in an external C file.
Syntax:
native void classMethod();

22. Abstract Classes and Methods
Abstract classes are classes that are partially implemented.
Abstract methods are methods that are declared, but not implemented.
Abstract classes are used as base classes for deriving subclasses.
In the child class, all the abstract methods of the base class will be overridden.
Constructors, static methods and private methods cannot be abstract.

23. Interfaces An interface is a prototype for a class.
The syntax for creating interfaces is shown below:
interface identifier {
interface Body }
Here interface is a keyword.
identifier is the name of the interface.
interface body consists of static final variables and abstract methods.

24. Naming Conflicts
A Java program consists of a collection of classes. When a Java program is compiled, each class in it is compiled into a byte code file with the class name as file name and extension .class. This creates a potential naming conflict.
You should not have a second Java program in your working directory in which classes, with names the same as that of the classes in your first program, are appearing.
It is always safe to have unique class names in every program in the same directory.

25. Points to note
Any method in a class can happily reference another class or class method even if that class does not occur immediately above.
You can not define a second class when you are already in the middle of defining another class.
You cannot have class declaration in one file and class method implementation in a different file.

26. Large Programs
Large program means a program consisting of more than one file.
The Java programs we have seen so far consisted of one single compilation unit or file.
The class you are compiling makes references to other classes in other files.
Javac compiler will compile all these classes.
If a class is modified after the previous compilation, Java compiler detects that and that class alone will be compiled in the next run.

27. Packages and Imports
A package provides a means to group together related classes and reference them as a whole.
To create a package you need to label each file in which the classes are defined with the name of the package.
This is done through a statement
package packname;
as the very first statement of the file concerned.
The import statement is used to import the classes in the named package into the file concerned.
Syntax :
import packagename.*;
import packagename.Classname;

28. Classpath
You will find some relationship between the CLASSPATH, package name and the directory path in which the file is located.
The package name is the difference between the directory path and CLASSPATH.
The package name bridges the gap in the directory path name between the CLASSPATH and the file name.
CLASSPATH + packagename = DirectoryPath

29. javac -d option
It is possible to segregate the .class files into different directories with –d option in javac command.
Ex:
Example1.java is in the package mypack.pack1.
Compile as
d:\user\javac –d c:\cmc Example1.java
* c:\cmc directory should exist
* The directory c:\cmc\mypack\pack1 will be created if it does not already exist.
* Example1.class will be found in
c:\cmc\mypack\pack1\Example1.class