Java Abstract Method

An Abstract method in java is a method prototype without any implementation. Its implementation is provided by the subclass of the java class in which it is declared. To create an java abstract method, simply specify the modifier abstract followed by the method declaration and replace the method body by a semi-colon.

Syntax of java abstract method:

abstract datatype function name();

Example:

abstract double area();

NOTE:

1. Method must always be defined in a subclass.

2. Method declared with final keyword, can not be redefined in subclass.

Java Abstract Class

The class that contains atleast one abstract method must be declared abstract such a class known as java abstract class. Using abstract classes, we must specify the following conditions:

1. We can not use abstract classes to declare instance object directly.

2. Java Abstract method of abstract class must defined in its sub classes.

3. We can not declare Abstract Constructor.

When we are extending existing classes, we have a choice to redefine the method of super class. A super class has common features that are shared by sub class. In some cases, we find that super class cannot have any object and such of classes are called Abstract classes.

Java Abstract classes usually contain abstract method. Abstract classes are generally used to provide common interface sub classes. We know that a super class is more simple than its sub class.

Example:

	abstract class A
	{
		abstract void call();
	}

	class B extends A
	{
		void call() {

		}
	}

	class absexampleprog
	{
		public static void main(String a[])
		{
			B ob=new B();
			ob.call();
		}
	}

By: Jatin Chawla

Simple Inheritance means heredity from one generation to second; A child inherit many good and bad qualities from his parents such as some identification marks, diseases etc. If we talk about Java Simple Inheritance, there are only one base and derived class. We can define this as a pictorial representation as:

We show a picture as an example of Simple Inheritance

public class square {

	int length, breadth;
	public void get(int x, int y)
	{
		length=x;
		breadth=y;
	}
	int area()
	{
		return(length*breadth);
	}

}

public class cube extends square
{
	int height;
	public void getdata(int x,int y,int z)
	{
		get(x,y);
		height=z;
	}
	int volume()
	{
		return(length*breadth*height);
	}

}

public class RunInheritance {
	public static void main(String a[])
	{
		cube C=new cube();
		C.getdata(10,20,30);

		int b1=C.area();
		System.out.println("Area of Square: "+b1);

		int b2=C.volume();
		System.out.println("Volume of Cube: "+b2);
	}

}

Output

Area of Square: 200
Volume of Cube: 6000

In above example, it is defined that every square has a fixed area and volume; We create two classes i.e. Square and Cube, In first class we define the area of square and in next / derived class we defined the volume of Cube. We can access the area and volume of the Square or Cube by calling the function through Cube class object. As we know that A single Cube has 6 faces of squares that have equal length, breadth and height; In our example, It is shown that A cube can carry 6 square and then it formed in “Cube”. We have just used the functionality of super class (Square Class) in Sub Class (Cube Class).

There are many more examples of Simple Inheritance.

• 1. A student is always a person i.e. A student will contain all attributes and behaviors / features of person class.
• 2. A car is counted in four wheelers so A car will contain about all general features of Four wheelers.
• 3. A multimedia mobile is considered as a simple mobile i.e. a multimedia mobile will adopt all features of General mobile.

By: Pankaj Yadav

Java Control statements in a programming language are very useful as they allow a programmer to change the flow of program execution i.e. altering the normal program flow to jump directly on some statement(s) or to skip a statement(s). In Java control statements are divided into following 3 categories:

Selection/Decision making Statements

Using these statements, a piece of code would be executed only if a certain condition(s) is true. These are of 3 types:

1. if

Statement(s) between the set of curly braces ‘{ }’ will be executed only if the condition(s), between the set of brackets ‘( )’ after ‘if’ keyword, is/are true.

Syntax:

if (Condition) {
	// statements;
}

2. if-else

If the condition(s) between the brackets ‘( )’ after the ‘if’ keyword is/are true then the statement(s) between the immediately following set of curly braces ‘{ }’ will be executed else the statement(s) under, the set of curly braces after the ‘else’ keyword will be executed.

Syntax:

if (condition) {
	// statements;
} else {
	// statements;
}

3. switch

When there is a long list of cases & conditions, then if/if-else is not good choice as the code would become complicated.

Syntax:

		switch (expression)
 		{
			case value1:
			//statement;
			break;
			case value2:
			//statement;
			break;
			default:
			 //statement;
		}

In the above piece of code, the user’s choice (add/sub/mul) will be stored in variable ‘ch’. The moment user enters his choice, it will be matched with the cases’ names & program execution will jump to the matching ‘Case’ & the statement under that case will be executed till the keyword ‘break’ comes. It is very important else the other unwanted cases will also get executed. After the last case there is ‘default’ keyword. Statements between ‘default:’ and the closing bracket of switch-case region will be executed only if the user has entered any wrong value as his choice i.e. other than the cases’ names.

Loop/ Iteration Statements

4. while

while statement continually executes a block of statements while a particular condition is true. Entry controlled

Syntax:

while(conditions)
{
//Loop body
}

5. do-while

It will enter the loop without checking the condition first and checks the condition after the execution of the statements. That is it will execute the statement once and then it will evaluate the result according to the condition. Exit controlled

Syntax:

do
{
//Loop body
}while(condition);

6. for

The concept of Iteration has made our life much easier. Repetition of similar tasks is what Iteration is and that too without making any errors. Until now we have learnt how to use selection statements to perform repetition.

Syntax:

for(initialization;test condition;increment)
{
//Loop body
}

Branching/ Transfer statements

7. break

Sometimes we use Jumping Statements in Java. Using for, while and do-while loops is not always the right idea to use because they are cumbersome to read. . Break statement skips the following code lets the execution jump to point after, where the program execution has jumped from to switch-case region.

Syntax:

		for(initialization;test condition;increment)
		{
			if(condition)
			{
			//statements
			break;
			}
		}

8. continue

Continue statement is just similar to the break statement in the way that a break statement is used to pass program control immediately after the end of a loop and the continue statement is used to force program control back to the top of a loop.

Example

		for(initialization;test condition;increment)
		{
			if(condition)
			{
			//statements
			continue;
			}
		}

By: Pankaj Yadav

It can be used to write the data on file. It provides us methods to perform various tasks on the file. In order to use this class we have to import java.IO package.

Syntax:

import java.io.*;

In this package we have input stream and output stream for read and write in a file.

Input Stream

The java.io.InputStream is the base class of the input streams in java .The input stream read data form a file with the help of read() method. The read() method returns integer type value. If read() method does not have any byte to read returns the -1.

Example:

InputStream inputs = new FileInputStream("c://data//file.txt");
int _idata = inputs.read();
while( _idata> -1 )
{
_idata = inputs.read();
}

Output Stream

The java.io.OutputStream is the base class of the output streams in java. The write() method is used to write the data in the file .

Example:

import java.io.FileOutputStream;
import java.io.OutputStream;

public class OutputStreamExample {

	public static void main(String[] args) {

		try{
			OutputStream out = new FileOutputStream("c://file.txt");
			out.write("testOutputstream".getBytes());
			out.close();
		}
		catch(Exception e)
		{
			e.printStackTrace();
		}
	}

}

We can also use these streams in the sequence to perform the different tasks. This class also provides the buffering techniques for faster performance.

By: Jatin Chawla

Java environment contains a rich set of development tools & thousands of classes and methods. It has mainly two parts:

• 1. Java Development Kit(JDK)
• 2. Java Standard Library(JSL)

Java Development Kit (JDK)

The Java Development Kit is a software package that is provided by the "SUN Microsystem" to public for free of cost. Java Development kit is currently available for most operating systems. It comes with a large collection of rules that are used for developing & running Java programs. It includes all the basic components that makeup the Java Environment. It also includes Utilities documentation and sample code for developing Java Programs. The Java Development Kit(Jdk) contains files and directories that are required to develop Java Applications after installing Java. Some Directories are following:
BIN, INCLUDE, JRE, LIB, DEMO etc.

There are following Java development tools that are used to create programs and applications.

The Java Applet Viewer

It enable us to run Java applets on Appletviewer window. The executable code name is "appletviewer" . It is basically used to execute applets without Java enabled Web Browser.

e.g. appletviewer myapplet.java

The Java Interpreter

This tool enable us to run Java applets and applications by reading and interprating bytecode files. The executable code name is "java".

e.g. java myfile

The Java Compiler

This tool enable us to compile java source code (program) into bytecode. The executable code name is "javac".

e.g. javac myprogram.java

The Java API documentation generator

This tool Creates API documentation in HTML format from Java source code. The executable code name is "javadoc".

e.g. javadoc document.java

The Java header and stub file generator

It Creates C-language header and stub files from a Java class, which allows your Java and C code to interact. It provides header files for use with native method. The executable code name is "javah".

The Java class file Decompiler / Deconstruct

It Disassembles Java files and prints out a representation of Java bytecode. It enables us to convert byte code files into a program description. The executable code name is "javad".

The Java language debugger

This tool helps us to find and fix errors in our program. The executable code name is "jdb".

Java Standard Library(JSL)

It is also known as Java Application Program Interface. The main and essential part of a human body is Heart; Same like this The main part (heart) of any programming language is Package. It includes hundreds of classes and methods grouped into Several functioned package. These packages provide everything that we need to create a powerful application. There are following packages in Java Standard Library:

Langauage Support Package

It is the core set of classes for the Java language that provide basic functions, such as string and array handling. This collection of classes and methods required for implementating basic features of Java.


Package Name: "java.lang"

Utility Package

It is the collection of classes to provide utility function such as date and time function, encoding/decoding, hash tables, and stacks.

Package Name:"java.util"

Input / Output Package

A set of classes provide the standard input / outputs and file I / O manipulation.

Package Name: "java.io"

Network Package

A set of classes that provide tools for accessing / communicating with other networks by protocols, such as FTP, Telnet, and HTTP (Internet Means).

Package Name: "java.net"

AWT Package

AWT (Abstract Window Toolkit) Package contains classes that implements platform independent graphical user interface such as buttons, labels, frames etc.

Package Name: "java.awt".

It also include other package like "java.awt.image", "java.awt.peer" etc.

Applet Package

This includes a set of classes that allows us to create java applets; This relate to the applet environment and are generally used when viewing applets.

Package Name: "java.applet"

SQL Package

It enables us to create and develop java application that access database.

Package Name: "java.sql"

By: Jatin Chawla

Java Inheritance is one of the key concept of OOP language that enables us to arrange the classes in hierarchical form / tree structure just like a child / baby inherit the characteristics of his parents and develop new characteristics of his / her own. In similar way, in Java a programmer can write a new class that can adopt / inherit the accessible (type modifier) fields and methods of existing class and can include new attributes. It allows us to easily reuse code and extend the functionality of existing class.

Definition: The inclusion of members of the existing class in a new class so that they are accessible in the new class is known as INHERITANCE.

Using this aspect of OOP, we can create a new class from the already existing class. We can extends the functionality of the old class in the way that suit our current need. The television class can contain the subclasses such as B/W Television, Color Television and Home Theater style television. The new class is called Derived Class, Sub Class, Child Class; The existing (OLD) class that is being inherited is called as Super, Base, Parent Class. Once the super class has been written, tested and debugged; Its functionality can be reused by the sub class rather than being rewrite from the screen.

In Java, One class can be inherited from another by using "extends" keyword. A new class cannot be inherited from more than two class means one class cannot be a sub class of more than two classes

	class sub_class_name extends super_class
	{
		Member 1;
		Member 2;
	}

There are three types of Inheritance:

• 1. Simple Inheritance: In this type of Inheritance, a single class is inherited all attributes from super class. e.g. Every person has a name and age, some persons may be student that have a roll no. and class i.e. Every student has a name ,age, roll no. and class.
• 2. Multilevel Inheritance: In this type of Inheritance, a single class is inherited all attributes from super class and the derived class further derive a new class and adopt all the features of that class. e.g. Every person has a name and age, some persons may be student that have a roll no. and class. Every student contain some subjects and their results then we organise all of them in a simple manner i.e. Every student has a name, age, roll no., class, subjects and their results.
• 3. Hierarchical Inheritance: In this type of Inheritance, a single class derives more than two classes. e.g. Every person has a name and age, some persons may be student that have a roll no. and class; And In other way every employee has a unique ID in his / her organisation and designation. Then we can say that every student has a name, age, roll no. and class and every employee has a name, age, ID, Designation.

Java Strings

By: Pankaj Yadav

It represents a sequence of characters. In java, Strings are class object and implements using the three classes as following

*.String

*.StringBuffer

*.StringBuilder

String: It is an object of the String class. It can be created as follows:

Syntax:

String  StringName;
String name = new String("string");

Example:

  String name;

  name = new String("Panakj");
  //And it can be same done as follows:

  String name= new String ("Pankaj");

String Array

String array can be created as follows:

String  nameArray[]= new String[3];

Java String Methods

String class has a number of methods that allows us to accomplish a variety of string manipulations. And the methods of java string class as follows:

toLowerCase() Convert the whole string to lower case

toUpperCase() Convert the string to upper case

replace(”x”,”y”) replaces the x with y

trim() removes the white spaces from beginning and end of string

equals() True if the first string is equal to the other string

equalsIgnoreCase() Ignore String letters A=a are equals and Returns if firststr=secondstr

length() gives length of the string

charAt(n) returns the nth character of the string

compareTo() Returns negative if s1s2, and zero on s1=s2

concat() Concatenates string first with second

substring(n) it returns the part of string between from nth place

substring(n,m) returns string between n and m characters

Java String Examples:

class StringJavaExample
{
	static String name[]={"Pankaj","Amit","Jon","Marry","Vinita"};

	public static void main(String args[])
	{
		int size=name.length;
		String temp=null;
		for(int i=0;i<size;i++)
		{
			for(int j=i+1;j<size;j++)
			{
				if (name[j].compareTo(name[i])<0)
				{
					//swaping string
					temp=name[i];
					name[i]=name[j];
					name[j]=temp;
				}
			}
		}
		for (int i=0;i<size;i++)
		{
			System.out.println(name[i]);
		}
	}
}

Output

Java StringBuffer Class:

String creates a fixed length. Where StringBuffer creates strings of flexible length and can be modified.

The methods of the StringBuffer class as follows:

setChartAt(n,’x’) Modifies nth character to x

append() it appends stri1 to str2

insert(n,str2) inserts str2 at nth positon str1

setLength(n) Set the length of the string to n.

Data Types in Java

By: Pankaj Yadav

It is a classification in programming languages which indicates the type of value a variable can store. Different types of values are there & different operations are there for every data type. e.g.

Following statements declares 2 variables of datatypes int and char & also initializes

int  _iVar = 4;       //'_iVar' can store only numbers
char  _cVar = 'c';   //'_cVar' can store both numbers & characters

There are 2 groups of data types in Java Primitive and Non- Primitive.

Primitive Data Types

Variables of these data types store the actual data or the primitive value. They are passed by value. There are 8 primitive datatypes in Java:- int, char, byte, short, long, float, double and boolean.

To get minimum & maximum values of a datatype:

Datatype_Name.MIN_VALUE				// lower limit
Datatype_Name.MAX_VALUE				// upper limit

Primitive datatypes have a limit of values (range) & also they have a default values till programmer assigns which are described in the following table along with their size & format.

Example of Primitive Dat Type

int a = 8;                      //a contains value 3
int b = a;                      //b contains copy of a
    b = 5;                      // Changing b

                                // Now, b = 5 and a = 8
                                // no change in a

Non-Primitive Data Types

Variables of non-primitive datatypes or object references stores reference to the actual value stored in the primitive variable.

Objects (Classes & Interfaces) and Arrays are the reference or non-primitive data types in Java. They are so called because they are handled “by reference” i.e. variables of their type store the address of the object or array is stored in a variable. They are passed by reference. For Ex:

char[]  arr = { 'a', 'b', 'c', 'd' };		//'arr' stores the references for the 4 values

Example of Non-Primitive Dat Type

Button a, b;                  //Objects of type Button
a = new Button();              //a object created
b = a;                         //b object created
                               //& filled with a
a.var = 8;
b.var = 5;                //Assign values
                          // Now, b = a = 5
                         //a is changed

By: Pankaj Yadav

Exceptions are the error those may lead to incorrect output or may terminate the execution of program and may even cause system crash.

Types of Exceptions

• 1. Compile time Exception
• 2. Run Time Exception

Compile time Exception

These exceptions may rise during compilation of program. And these errors may be raised by the compiler. There may be the following reasons for exception:

We can declare fields as follows:

• 1. Due to missing of semi colon.
• 2. Due to missing class and method bracket
• 3. Misspelling of the identifiers and keywords
• 4. Missing double quotation in strings
• 5. Used of undeclared variables
• 6. Incomplete types in assignment/initialization
• 7. Use of Bad reference object

Run-time Exception

These exceptions may rise during run of program. Most of the common exceptions may rise due to:

• 1. Dividing by zero
• 2. Accessing element out of the index of the array
• 3. Trying to insert values of the variable not of the type

Steps for Exception Handling

• 1. Find the problem (Hit exception)
• 2. Inform about the exception(Throw exception)
• 3. Receive the exception(Catch exception)
• 4. Correct the exception(Handling exception)

Syntax of Exception Handling

try
{
statements			//generates an exception
}
catch (Exception e)
{
statement			//process the exception
}

Multiple catch Statements

It is possible to have more than one catch statement in the catch block

Syntax for method:

Using finally

Java supports finally statement that can be used to handle exception that is not caught by any previous catch statement. Finally block is used to handle any error generated in the try block.

Syntax

	try
		{
			//		statement
		}
		catch(ExceptionSubClass1 ex1)
		{
			//		statements
		}
		catch(ExceptionSubClass2 ex2)
		{
			//		statements
		}
		finally
		{
			//		statements
		}

User Defined Exception

There are many times when we have to throw exceptions .This we can do with the help of throw as follows:

throw new ArithmaticException();
throw new NumberFormatException();

Note: Mainly all user defined classes are subclass of Throwable.

Example

import java.lang. Exception;

class MyException extends Exception
{

	MyException(String message)
	{
		super(message);
	}

}

class TestmMyException
{

	public  static void main(String args[])
	{

		int x=5,y=1000;
		try
		{
			float z=(float)x/(float)y;
			if(z<0.01)
			{
				throw new MyException("number is small");
			}
		}
		catch(MyException e)
		{
			System.out.println("Exception caught");
		}
		finally
		{
			System.out.println("Finally bloc Always executes");
		}
	}

}

output

Exception caught
Finally bloc Always executes
Press any key to continue…

By: Jatin Chawla

Object Oriented Programming is an approach to organize and develop the program, which attempts to eliminate some of the drawbacks of Conventional Programming methods . All the languages are not suitable with OOP concept. Language that support OOP concept / features include C++, ADA, Object Pascal, Java. C++ is basically a procedural language that follow only some features of OOP. Java is a core Object Oriented Programming Language.

There are following features of OOP followed by Java:

Objects and Classes

Object is similar like an entity such as table, chair, pen etc. Every entity has some its behavior and attributes.

A person is also an object that has some behaviours (methods) such as To walk, To breathe, To listen, To talk, To see etc. that are accomplished by some of its attributes i.e. Nose, Eye, Ear, Legs etc.

They may represent any living or non living entity like a person, a place, a bank account, a record of student etc. Program objects should be chosen in a manner they match closely with real word objects.

When a program is executed, the objects interact by sending message from one to another. To create an object in Java, we use following syntax.

class <Class name>
{
	…………………	//Class body
 	…………………	//Class body
	…………………	//Class body
}

e.g. Student s;

Class is a building block of Java. It is a logical way to group together Fields that hold values and associated methods that operate on these fields into a single unit. To create a class in Java, we use following syntax.

<Class name> <Object name>;

example

class Student
{
		int roll;
		String name;

		public void get()
		{
			roll=20;
			name="Jatin";
		}
}

Data Abstraction and Encapsulation

The process of linking / binding data and associated code / procedures to make them a compound unit, is called data encapsulation. When data and code is associated with one another, they create objects. These objects support the Encapsulation mechanism. In this process, the data OR code may be public / private / protected / friendly etc. Private code is only accessible by the particular part of that object, whereas public code is accessible by any other object.

Abstraction is a very classic feature that defines only fundamental / vital information without involving the Source code information or elaboration. When we use the social networking sites such as facebook, orkut etc. OR any other sites; we only complete the particular task. We does not check the source code of that webpage. Let we talk about our daily life, when we have softdrink; we only enjoy the taste of that, we does not try to know which type of chemicals are used for preparing this.

Inheritance

Inheritance means Heredity i.e. Transfer some qualities and attributes of parents to their children. Inheritance is a process to derive new classes from already existing classes. Existing class is called Super / Base / Parent class and new class is known as Sub / Derived / child class. This process defines the characteristics hold by Super class, inherited by the sub class. The basic way to adopt this concept is that work again with the same qualities / standards.

e.g. If we talk about persons, every person has a name; If we talk about students, every student is a person and it acquire the attributes of person class.

There are three type of inheritance:

• 1. Simple Inheritance
  
• 2. Multilevel Inheritance
  
• 3. Hierarchical Inheritance
  

Polymorphism

Polymorphism is very striking concept. In formal way Polymorphism means having or passing through many stages of development. In technical language, Poly means many and morphism means the process to change e.g. when we change one image to another image using computer animation tools, it means we are changing the form of one image to further (Basic image to Advanced).

e.g. In our family and in our social network, usually we are known as different-different name.

We can use this concept to create and define multiple level of interface.

If we talk about Method Overloading, There is a group of methods having same name but differ in argument / parameter list. Method overloading does not depend on return type of method. This is the type of Multiple Polymorphism.

Method overriding is the type of Single Polymorphism.

Dynamic Binding

In our daily life, Binding means something that link together to any other thing. In java, Binding refers to the linking of procedures call to the code to be executed in response to the call. In other words, Binding is a process that links / connects the objects to procedures / methods / functions in a single unit called class.

Message Communication

This is a process through which objects can interact / communicate with one another. People pass / send messages to one another through many means such as Mobile, Letter etc. In the similar way Object communicate with one another by sending and receiving information through requesting their procedures / methods.

Figure: Passing message