PROGRAMMING IN JAVA

PROGRAMMING IN JAVA
A. SIVASANKARI
ASSISTANT PROFESSOR
DEPARTMENT OF COMPUTER APPLICATION
SHANMUGA INDUSTRIES ARTS AND SCIENCE
COLLEGE,
TIRUVANNAMALAI. 606601.
Email: sivasankaridkm@gmail.com

PROGRAMMING IN JAVA
UNIT - 2
 ARRAY AND ITS TYPES
 INHERITANCE AND ITS TYPES
 THE SUPER KEYWORD
 POLYMORPHISM
 ABSTRACT CLASSES
 INTERFACES
 DECLARING INTERFACES
 IMPLEMENTING INTERFACES
 EXTENDED INTERFACES
 EXTENDING MULTIPLE
INTERFACES
 PACKAGES
 THE IMPORT KEYWORD
 THE DIRECTORY STRUCTURE OF
PACKAGES
 ACCESS SPECIFIER
A. SIVASANKARI - SIASC-TVM UNIT-2

ARRAY AND ITS TYPES
• Group of elements and group of information is called array.
TYPES
• One dimensional Array
• Two dimensional Array
• Multi dimensional Array
• Java provides a data structure, the array, which stores a fixed-size sequential collection of elements
of the same type. An array is used to store a collection of data, but it is often more useful to think of
an array as a collection of variables of the same type.
• Instead of declaring individual variables, such as number0, number1, ..., and number99, you declare
one array variable such as numbers and use numbers[0], numbers[1], and ..., numbers[99] to
represent individual variables
DECLARING ARRAY VARIABLES
• To use an array in a program, We must declare a variable to reference the array, and you must specify
the type of array the variable can reference
• Syntax
• dataType[] arrayRefVar; // preferred way.
CREATING ARRAYS
• We can create an array by using the new operator with the following syntax −
Syntax
• arrayRefVar = new dataType[arraySize];
A. SIVASANKARI - SIASC-TVM
PROGRAMMING IN JAVA

PROGRAMMING IN JAVA
PROCESSING ARRAYS
• When processing array elements, we often use either for loop or for each loop because all of the
elements in an array are of the same type and the size of the array is known.
• public static void main(String[] args)
• { double[] myList = {1.9, 2.9, 3.4, 3.5}; // Print all the array elements
• for (int i = 0; i < myList.length; i++) {
• System.out.println(myList[i] + " ");
• } // Summing all elements
• double total = 0;
• for (int i = 0; i < myList.length; i++)
• { total += myList[i]; }
• System.out.println("Total is " + total); // Finding the largest element
• double max = myList[0];
• for (int i = 1; i < myList.length; i++)
• {
• if (myList[i] > max) max = myList[i];
• } System.out.println("Max is " + max); }}
OUTPUT
• 1.9 2.9 3.4 3.5 Total is 11.7Max is 3.5

PROGRAMMING IN JAVA

INHERITANCE
• Inheritance can be defined as the process where one class acquires the properties (methods
and fields) of another. With the use of inheritance the information is made manageable in a
hierarchical order.
BASE CLASS
• The class whose properties are inherited is known as superclass (base class, parent class).
DERIVED CLASS
• The class which inherits the properties of other is known as subclass (derived class, child
class)
extends Keyword
• extends is the keyword used to inherit the properties of a class. Following is the syntax of
extends keyword.
SYNTAX
• class Super { ..... .....}
• class Sub extends Super { ..... .....}
PROGRAMMING IN JAVA

SAMPLE CODE
class Calculation
• {
• int z;
• public void addition(int x, int y)
• {
• z = x + y;
• System.out.println("The sum of the given numbers:"+z);
• }
• public void Subtraction(int x, int y)
• { z = x - y;
• System.out.println("The difference between the given
numbers:"+z);
• }}
• public class My_Calculation extends Calculation
• {
• public void multiplication(int x, int y)
• {
• z = x * y;
• System.out.println("The product of the given numbers:"+z);
• }
PROGRAMMING IN JAVA

public static void main(String args[])
• {
• int a = 20, b = 10;
• My_Calculation demo = new My_Calculation();
• demo.addition(a, b);
• demo.Subtraction(a, b);
• demo.multiplication(a, b); }}
Compile and execute the above code as shown below.
• javac My_Calculation.java
• java My_Calculation
After executing the program, it will produce the following result
OUTPUT
• The sum of the given numbers:30
• The difference between the given numbers:10
• The product of the given numbers:200
• Note − A subclass inherits all the members (fields, methods, and nested classes) from its
superclass. Constructors are not members, so they are not inherited by subclasses, but the
constructor of the superclass can be invoked from the subclass.
PROGRAMMING IN JAVA

TYPES OF INHERITANCE
Note: Java does not support multiple inheritance
PROGRAMMING IN JAVA

DIAGRAM REPRESENTATION
PROGRAMMING IN JAVA

TYPES OF INHERITANCE
• A very important fact to remember is that Java does not support multiple inheritance. This
means that a class cannot extend more than one class. Therefore following is illegal
Example
• public class extends Animal, Mammal{}
• However, a class can implement one or more interfaces, which has helped Java get rid of the
impossibility of multiple inheritance.
PROGRAMMING IN JAVA

THE SUPER KEYWORD
• The super keyword is similar to this keyword. Following are the scenarios where the super
keyword is used.
• It is used to differentiate the members of superclass from the members of subclass, if they
have same names.
• It is used to invoke the superclass constructor from subclass.
Differentiating the Members
• If a class is inheriting the properties of another class. And if the members of the superclass
have the names same as the sub class, to differentiate these variables we use super keyword as
shown below.
• super.variable super.method();
SAMPLE CODE
• In the given program, you have two classes namely Sub_class and Super_class, both have a
method named display() with different implementations, and a variable named num with
different values. We are invoking display() method of both classes and printing the value of
the variable num of both classes. Here you can observe that we have used super keyword to
differentiate the members of superclass from subclass.
• Copy and paste the program in a file with name Sub_class.java.
PROGRAMMING IN JAVA

• class Super_class
• { int num = 20; // display method of superclass
• public void display() {
• System.out.println("This is the display method of superclass"); }}
• public class Sub_class extends Super_class {
• int num = 10; // display method of sub class public void display() {
• System.out.println("This is the display method of subclass"); }
• public void my_method() { // Instantiating subclass
• Sub_class sub = new Sub_class(); // Invoking the display() method of sub class
• sub.display(); // Invoking the display() method of superclass
• super.display(); // printing the value of variable num of subclass
• System.out.println("value of the variable named num in sub class:"+ sub.num);
• // printing the value of variable num of superclass
• System.out.println("value of the variable named num in super class:"+ super.num); }
• public static void main(String args[]) { Sub_class obj = new Sub_class(); obj.my_method(); }}
Compile and execute the above code using the following syntax.
• javac Super_Demo
• java Super
OUTPUT
• This is the display method of subclass
• This is the display method of superclass
• value of the variable named num in sub class:10
• value of the variable named num in super class:20
PROGRAMMING IN JAVA

Invoking Superclass Constructor
• If a class is inheriting the properties of another class, the subclass automatically acquires the
default constructor of the superclass. But if you want to call a parameterized constructor of
the superclass, we need to use the super keyword as shown below.
• super(values);
Sample Code
• The program given in this section demonstrates how to use the super keyword to invoke the
parametrized constructor of the superclass. This program contains a superclass and a subclass,
where the superclass contains a parameterized constructor which accepts a integer value, and
we used the super keyword to invoke the parameterized constructor of the superclass.
Copy and paste the following program in a file with the name Subclass.java
• Example
• class Superclass
• {
• int age;
• Superclass(int age)
• { this.age = age;
• }
PROGRAMMING IN JAVA

• public void getAge()
• {
• System.out.println("The value of the variable named
age in super class is: " +age); }}
• public class Subclass extends Superclass {
• Subclass(int age) {
• super(age);
• }
• public static void main(String args[])
• { Subclass s = new Subclass(24);
• s.getAge();
• }}
Compile and execute the above code using the following
syntax.
• javac Subclass
• java Subclass
Output
• The value of the variable named age in super class is:
24
PROGRAMMING IN JAVA

POLYMORPHISM
• Polymorphism is the ability of an object to take on many forms. The most common use of
polymorphism in OOP occurs when a parent class reference is used to refer to a child class
object.
• Any Java object that can pass more than one IS-A test is considered to be polymorphic. In
Java, all Java objects are polymorphic since any object will pass the IS-A test for their own
type and for the class Object.
• It is important to know that the only possible way to access an object is through a reference
variable. A reference variable can be of only one type. Once declared, the type of a reference
variable cannot be changed.
• The reference variable can be reassigned to other objects provided that it is not declared final.
The type of the reference variable would determine the methods that it can invoke on the
object.
• A reference variable can refer to any object of its declared type or any subtype of its declared
type. A reference variable can be declared as a class or interface type
Example
• Let us look at an example.
• public interface Vegetarian{}
• public class Animal{}
• public class Deer extends Animal implements Vegetarian{}
PROGRAMMING IN JAVA

• Now, the Deer class is considered to be polymorphic
since this has multiple inheritance.
Following are true for the above examples −
• A Deer IS-AAnimal
• A Deer IS-A Vegetarian
• A Deer IS-A Deer
• A Deer IS-A Object
When we apply the reference variable facts to a Deer
object reference, the following declarations are legal −
Example
• Deer d = new Deer();
• Animal a = d;
• Vegetarian v = d;
• Object o = d;
• All the reference variables d, a, v, o refer to the same
Deer object in the heap.
PROGRAMMING IN JAVA

ABSTRACT CLASSES
• A class which contains the abstract keyword in its declaration is known as abstract class.
• Abstract classes may or may not contain abstract methods, i.e., methods without body ( public
void get(); )
• But, if a class has at least one abstract method, then the class must be declared abstract.
• If a class is declared abstract, it cannot be instantiated.
• To use an abstract class, you have to inherit it from another class, provide implementations to
the abstract methods in it.
• If you inherit an abstract class, you have to provide implementations to all the abstract
methods in it.
• Example
• This section provides you an example of the abstract class. To create an abstract class, just use
the abstract keyword before the class keyword, in the class declaration.
SAMPLE PROGRAM
• /* File name : Employee.java */
• public abstract class Employee {
• private String name;
• private String address;
• private int number;
• public Employee(String name, String address, int number)
• { System.out.println("Constructing an Employee");
• this.name = name;
PROGRAMMING IN JAVA

• this.address = address;
• this.number = number; }
• public double computePay() {
• System.out.println("Inside Employee computePay");
• return 0.0; }
• public void mailCheck() {
• System.out.println("Mailing a check to " + this.name +
• " " + this.address); }
• public String toString() { return name + " " +
• address + " " + number; }
• public String getName() { return name; }
• public String getAddress() { return address; }
• public void setAddress(String newAddress)
• { address = newAddress; }
• public int getNumber() {
• return number; }}
You can observe that except abstract methods the Employee class
is same as normal class in Java. The class is now abstract, but it
still has three fields, seven methods, and one constructor.
PROGRAMMING IN JAVA

ABSTRACT METHODS
• If you want a class to contain a particular method but you want the actual implementation of
that method to be determined by child classes, you can declare the method in the parent class
as an abstract.
• abstract keyword is used to declare the method as abstract.
• You have to place the abstract keyword before the method name in the method declaration.
• An abstract method contains a method signature, but no method body.
• Instead of curly braces, an abstract method will have a semi colon (;) at the end.
Example
• public abstract class Employee {
• private String name;
• private String address;
• private int number;
• public abstract double computePay(); // Remainder of class definition
• }
Declaring a method as abstract has two consequences
• The class containing it must be declared as abstract.
• Any class inheriting the current class must either override the abstract method or declare itself
as abstract
PROGRAMMING IN JAVA

• Note − Eventually, a descendant class has to implement the
abstract method; otherwise, you would have a hierarchy of
abstract classes that cannot be instantiated.
• Suppose Salary class inherits the Employee class, then it
should implement the computePay() method as shown
below −
• /* File name : Salary.java */
• public class Salary extends Employee
• { private double salary; // Annual salary
• public double computePay() {
• System.out.println("Computing salary pay for " +
getName());
• return salary/52; } // Remainder of class definition}
PROGRAMMING IN JAVA

INTERFACES
• An interface is a reference type in Java. It is similar to class. It is a collection of abstract
methods. A class implements an interface, thereby inheriting the abstract methods of the
interface.
• Along with abstract methods, an interface may also contain constants, default methods, static
methods, and nested types. Method bodies exist only for default methods and static methods.
• Writing an interface is similar to writing a class. But a class describes the attributes and
behaviors of an object. And an interface contains behaviors that a class implements.
• Unless the class that implements the interface is abstract, all the methods of the interface need
to be defined in the class.
An interface is similar to a class in the following ways −
• An interface can contain any number of methods.
• An interface is written in a file with a .java extension, with the name of the interface
matching the name of the file.
• The byte code of an interface appears in a .class file.
• Interfaces appear in packages, and their corresponding bytecode file must be in a directory
structure that matches the package name.
However, an interface is different from a class in several ways, including −
• You cannot instantiate an interface.
• An interface does not contain any constructors.
• All of the methods in an interface are abstract.
• An interface cannot contain instance fields. The only fields that can appear in an interface
must be declared both static and final.
• An interface is not extended by a class; it is implemented by a class.
• An interface can extend multiple interfaces.
PROGRAMMING IN JAVA

DECLARING INTERFACES
• The interface keyword is used to declare an interface. Here is a simple example to declare an
interface
Example
/* File name : NameOfInterface.java */
• import java.lang.*;// Any number of import statements
• public interface NameOfInterface {
• // Any number of final, static fields
• // Any number of abstract method declarations
• }
Interfaces have the following properties
• An interface is implicitly abstract. You do not need to use the abstract keyword while
declaring an interface.
• Each method in an interface is also implicitly abstract, so the abstract keyword is not needed.
• Methods in an interface are implicitly public.
Example
• /* File name : Animal.java */
• interface Animal {
• public void eat();
• public void travel();}
PROGRAMMING IN JAVA

PROGRAMMING IN JAVA
IMPLEMENTING INTERFACES
• When a class implements an interface, you can think of the class as signing a contract, agreeing to
perform the specific behaviors of the interface. If a class does not perform all the behaviors of the
interface, the class must declare itself as abstract.
• A class uses the implements keyword to implement an interface. The implements keyword appears
in the class declaration following the extends portion of the declaration Example
/* File name : MammalInt.java */
• public class MammalInt implements Animal {
• public void eat() {
• System.out.println("Mammal eats"); }
• public void travel() {
• System.out.println("Mammal travels"); }
• public int noOfLegs() {
• return 0; }
• public static void main(String args[]) {
• MammalInt m = new MammalInt();
• m.eat();
• m.travel(); }}
OUTPUT
• Mammal eats
• Mammal travels

EXTENDING INTERFACES
• An interface can extend another interface in the same way that a class can extend another
class. The extends keyword is used to extend an interface, and the child interface inherits the
methods of the parent interface.
• The following Sports interface is extended by Hockey and Football interfaces.
Example
• // Filename: Sports.java
• public interface Sports {
• public void setHomeTeam(String name);
• public void setVisitingTeam(String name);} // Filename: Football.java
• public interface Football extends Sports {
• public void homeTeamScored(int points);
• public void visitingTeamScored(int points);
• public void endOfQuarter(int quarter);} // Filename: Hockey.java
• public interface Hockey extends Sports {
• public void homeGoalScored();
• public void visitingGoalScored();
• public void endOfPeriod(int period);
• public void overtimePeriod(int ot);}
The Hockey interface has four methods, but it inherits two from Sports; thus, a class
that implements Hockey needs to implement all six methods. Similarly, a class that implements
Football needs to define the three methods from Football and the two methods from Sports.
PROGRAMMING IN JAVA

EXTENDING MULTIPLE INTERFACES
• A Java class can only extend one parent
class. Multiple inheritance is not allowed.
Interfaces are not classes, however, and
an interface can extend more than one
parent interface.
• The extends keyword is used once, and
the parent interfaces are declared in a
comma-separated list.
• For example, if the Hockey interface
extended both Sports and Event, it would
be declared as
Example
public interface Hockey extends Sports,
Event
PROGRAMMING IN JAVA

PROGRAMMING IN JAVA
PACKAGES
• Packages are used in Java in order to prevent naming conflicts, to control access, to make
searching/locating and usage of classes, interfaces, enumerations and annotations easier, etc.
• A Package can be defined as a grouping of related types (classes, interfaces, enumerations
and annotations ) providing access protection and namespace management.
Some of the existing packages in Java are −
• java.lang − bundles the fundamental classes
• java.io − classes for input , output functions are bundled in this package
• Programmers can define their own packages to bundle group of classes/interfaces, etc. It is a
good practice to group related classes implemented by you so that a programmer can easily
determine that the classes, interfaces, enumerations, and annotations are related.
• Since the package creates a new namespace there won't be any name conflicts with names in
other packages. Using packages, it is easier to provide access control and it is also easier to
locate the related classes.
Creating a Package
• While creating a package, you should choose a name for the package and include
a package statement along with that name at the top of every source file that contains the
classes, interfaces, enumerations, and annotation types that you want to include in the
package.
• The package statement should be the first line in the source file. There can be only one
package statement in each source file, and it applies to all types in the file.

• If a package statement is not used then the class, interfaces, enumerations, and annotation types will
be placed in the current default package.
To compile the Java programs with package statements, you have to use -d option as shown below.
• javac -d Destination folder file_name.java
Then a folder with the given package name is created in the specified destination, and the compiled class
files will be placed in that folder.
Example
• Let us look at an example that creates a package called animals. It is a good practice to use names of
packages with lower case letters to avoid any conflicts with the names of classes and interfaces.
Following package example contains interface named animals −
• /* File name : Animal.java */
• package animals; interface Animal {
• public void eat();
• public void travel();}
Now, let us implement the above interface in the same package animals −
• package animals;/* File name : MammalInt.java */
• public class MammalInt implements Animal {
• public void eat() {
• System.out.println("Mammal eats");
• }
PROGRAMMING IN JAVA

PROGRAMMING IN JAVA
• public void travel() {
• System.out.println("Mammal travels"); }
• public int noOfLegs() {
• return 0; }
• public static void main(String args[]) {
• MammalInt m = new MammalInt();
• m.eat();
• m.travel(); }}
Now compile the java files as shown below −
• $ javac -d . Animal.java
• $ javac -d . MammalInt.java
We can execute the class file within the package and get
the result as shown below.
• Mammal eats
• Mammal travels
Now a package/folder with the name animals will be
created in the current directory and these class files will be
placed in it as shown right

THE IMPORT KEYWORD
• If a class wants to use another class in the same package, the package name need not be used.
Classes in the same package find each other without any special syntax.
Example
• Here, a class named Boss is added to the payroll package that already contains Employee. The
Boss can then refer to the Employee class without using the payroll prefix, as demonstrated
by the following Boss class.
• package payroll;
• public class Boss {
• public void payEmployee(Employee e) {
• e.mailCheck();
• }
• }
The fully qualified name of the class can be used. For example
• payroll.Employee
The package can be imported using the import keyword and the wild card (*).
• import payroll.*;
The class itself can be imported using the import keyword. For example
• import payroll.Employee;
Note − A class file can contain any number of import statements. The import statements must
appear after the package statement and before the class declaration.
PROGRAMMING IN JAVA

THE DIRECTORY STRUCTURE OF PACKAGES
Two major results occur when a class is placed in a package
• The name of the package becomes a part of the name of the class, as we just discussed in the
previous section.
• The name of the package must match the directory structure where the corresponding
bytecode resides.
Here is simple way of managing your files in Java
• Put the source code for a class, interface, enumeration, or annotation type in a text file whose
name is the simple name of the type and whose extension is .java.
For example
• // File Name : Car.java
• package vehicle;
• public class Car { // Class implementation. }
• Now, put the source file in a directory whose name reflects the name of the package to which
the class belongs −
• ....vehicleCar.java Now, the qualified class name and pathname would be as follows −
• Class name → vehicle.Car
• Path name → vehicleCar.java (in windows)
• import com.apple.computers.*;
PROGRAMMING IN JAVA

ACCESS SPECIFIER
PROGRAMMING IN JAVA

PROGRAMMING IN JAVA

More Related Content

What's hot (20)

Similar to PROGRAMMING IN JAVA (20)

More from SivaSankari36 (7)

Recently uploaded (20)

PROGRAMMING IN JAVA