Java

8:29 pm  Dragon Booster  

Introduction to Java Programming

Introduction to Computer Science using Java

Java is a simple and yet powerful object oriented programming language and it is in many respects similar to C++. Java originated at Sun Microsystems, Inc. in 1991. It was conceived by James Gosling, Patrick Naughton, Chris Warth, Ed Frank, and Mike Sheridan at Sun Microsystems, Inc. It was developed to provide a platform-independent programming language. This site gives you an Introduction to Java Programming accompanied with many java examples. Its a complete course in java programming for beginners to advanced java.

Platform independent

Unlike many other programming languages including C and C++ when Java is compiled, it is not compiled into platform specific machine, rather into platform independent byte code. This byte code is distributed over the web and interpreted by virtual Machine (JVM) on whichever platform it is being run.

Java Virtual Machine

What is the Java Virtual Machine? What  is its role?


Java was designed with a concept of ‘write once and run everywhere’. Java Virtual Machine plays the central role in this concept. The JVM is the environment in which Java programs execute. It is a software that is implemented on top of real hardware and operating system. When the source code (.java files) is compiled, it is translated into byte codes and then placed into (.class) files. The JVM executes these bytecodes. So Java byte codes can be thought of as the machine language of the JVM. A JVM can either interpret the bytecode one instruction at a time or the bytecode can be compiled further for the real microprocessor using what is called a just-in-time compiler. The JVM must be implemented on a particular platform before compiled programs can run on that platform.

Object Oriented Programming

Since Java is an object oriented programming language it has following features:
  • Reusability of Code
  • Emphasis on data rather than procedure
  • Data is hidden and cannot be accessed by external functions
  • Objects can communicate with each other through functions
  • New data and functions can be easily addedJava has powerful features. The following are some of them:-

    Simple
    Reusable
    Portable (Platform Independent)
    Distributed
    Robust
    Secure
    High Performance
    Dynamic
    Threaded
    Interpreted
Object Oriented Programming is a method of implementation in which programs are organized as cooperative collection of objects, each of which represents an instance of a class, and whose classes are all members of a hierarchy of classes united via inheritance relationships.
OOP Concepts
Four principles of Object Oriented Programming are
Abstraction
Encapsulation
Inheritance
Polymorphism
Abstraction
Abstraction denotes the essential characteristics of an object that distinguish it from all other kinds of objects and thus provide crisply defined conceptual boundaries, relative to the perspective of the viewer.
Encapsulation

Encapsulation is the process of compartmentalizing the elements of an abstraction that constitute its structure and behavior ; encapsulation serves to separate the contractual interface of an abstraction and its implementation.
Encapsulation
* Hides the implementation details of a class.
* Forces the user to use an interface to access data
* Makes the code more maintainable.
Inheritance
Inheritance is the process by which one object acquires the properties of another object.
Polymorphism
Polymorphism is the existence of the classes or methods in different forms or single name denoting different
implementations.

Java is Distributed

With extensive set of routines to handle TCP/IP protocols like HTTP and FTP java can open and access the objects across net via URLs.


Java is Multithreaded

One of the powerful aspects of the Java language is that it allows multiple threads of execution to run concurrently within the same program A single Java program can have many different threads executing independently and continuously. Multiple Java applets can run on the browser at the same time sharing the CPU time.

Java is Secure

Java was designed to allow secure execution of code across network. To make Java secure many of the features of C and C++ were eliminated. Java does not use Pointers. Java programs cannot access arbitrary addresses in memory.

Garbage collection

Automatic garbage collection is another great feature of Java with which it prevents inadvertent corruption of memory. Similar to C++, Java has a new operator to allocate memory on the heap for a new object. But it does not use delete operator to free the memory as it is done in C++ to free the memory if the object is no longer needed. It is done automatically with garbage collector.

Java Applications

Java has evolved from a simple language providing interactive dynamic content for web pages to a predominant enterprise-enabled programming language suitable for developing significant and critical applications. Today, It is used for many types of applications including Web based applications, Financial applications, Gaming applications, embedded systems, Distributed enterprise applications, mobile applications, Image processors, desktop applications and many more. This site outlines the building blocks of java by stating few java examples along with some java tutorials.

 

Basic Language Elements


(Identifiers, keywords, literals, white spaces and comments)
This part of the java tutorial teaches you the basic language elements and syntax for the java programming language. Once you get these basic language concepts you can continue with the other object oriented programming language concepts.

Keywords

There are certain words with a specific meaning in java which tell (help) the compiler what the program is supposed to do. These Keywords cannot be used as variable names, class names, or method names. Keywords in java are case sensitive, all characters being lower case.


Keywords are reserved words that are predefined in the language; see the table below (Taken from Sun Java Site). All the keywords are in lowercase.
	abstract    default    if            private      this
	boolean     do         implements    protected    throw
	break       double     import        public       throws
	byte        else       instanceof    return       transient
	case        extends    int           short        try
	catch       final      interface     static       void
	char        finally    long          strictfp     volatile
	class       float      native        super        while
	const       for        new           switch
	continue    goto       package       synchronized
Keywords are marked in yellow as shown in the sample code below
/** This class is a Hello World Program used to introduce
the Java Language*/
public class HelloWorld {
public static void main(String[] args) {
System.out.println(“Hello World”); //Prints output to console
}
}
For more information on different Keywords – Java Keywords
Some Tricky Observations: The words virtual, ifdef, typedef, friend, struct and union are all words related to
the C programming language. const and goto are Java keywords. The word finalize is the name of a method
of the Object class and hence not a keyword. enum and label are not keywords.

Comments

Comments are descriptions that are added to a program to make code easier to understand. The compiler ignores comments and hence its only for documentation of the program.
Java supports three comment styles.
Block style comments begin with /* and terminate with */ that spans multiple lines.
Line style comments begin with // and terminate at the end of the line. (Shown in the above program)
Documentation style comments begin with /** and terminate with */ that spans multiple lines. They are generally created using the automatic documentation generation tool, such as javadoc. (Shown in the above program)
name of this compiled file is comprised of the name of the class with .class as an extension.

Variable, Identifiers and Data Types

Variables are used for data that change during program execution. All variables have a name, a type, and a scope. The programmer assigns the names to variables, known as identifiers. An Identifier must be unique within a scope of the Java program. Variables have a data type, that indicates the kind of value they can store. Variables declared inside of a block or method are called local variables; They are not automatically initialized. The compiler will generate an error as a result of the attempt to access the local variables before a value has been assigned.
public class localVariableEx {
  public static int a;
  public static void main(String[] args) {
    int b;
    System.out.println("a : "+a);
    System.out.println("b : "+b); 	//Compilation error
}}
Note in the above example, a compilation error results in where the variable is tried to be accessed and not at the place where its declared without any value.
The data type indicates the attributes of the variable, such as the range of values that can be stored and the operators that can be used to manipulate the variable. Java has four main primitive data types built into the language. You can also create your own composite data types.
Java has four main primitive data types built into the language. We can also create our own data types.

  • Integer: byte, short, int, and long.

  • Floating Point: float and double

  • Character: char

  • Boolean: variable with a value of true or false.

    • The following chart (Taken from Sun Java Site) summarizes the default values for the java built in data types. Since I thought Mentioning the size was not important as part of learning Java, I have not mentioned it in the below table. The size for each Java type can be obtained by a simple Google search.
    Data Type Default Value (for fields) Range
    byte 0 -127 to +128
    short 0 -32768 to +32767
    int 0
    long 0L
    float 0.0f
    double 0.0d
    char ‘\u0000′ 0 to 65535
    String (object) null
    boolean false
    When we declare a variable we assign it an identifier and a data type.
    For Example
    String message = “hello world”
    In the above statement, String is the data type for the identifier message. If you don’t specify a value when the variable is declared, it will be assigned the default value for its data type.
    Identifier Naming Rules
    • Can consist of upper and lower case letters, digits, dollar sign ($) and the underscore ( _ ) character.
    • Must begin with a letter, dollar sign, or an underscore
    • Are case sensitive
    • Keywords cannot be used as identifiers
    • Within a given section of your program or scope, each user defined item must have a unique identifier
    • Can be of any length.

    Classes

    A class is nothing but a blueprint for creating different objects which defines its properties and behaviors. An object exhibits the properties and behaviors defined by its class. A class can contain fields and methods to describe the behavior of an object. Methods are nothing but members of a class that provide a service for an object or perform some business logic.


    Objects

    An object is an instance of a class created using a new operator. The new operator returns a reference to a new instance of a class. This reference can be assigned to a reference variable of the class. The process of creating objects from a class is called instantiation. An object reference provides a handle to an object that is created and stored in memory. In Java, objects can only be manipulated via references, which can be stored in variables.

    Interface

    An Interface is a contract in the form of collection of method and constant declarations. When a class implements an interface, it promises to implement all of the methods declared in that interface.

    Instance Members

    Each object created will have its own copies of the fields defined in its class called instance variables which represent an object’s state. The methods of an object define its behaviour called instance methods. Instance variables and instance methods, which belong to objects, are collectively called instance members. The dot ‘.’ notation with a object reference is used to access Instance Members.

    Static Members

    Static members are those that belong to a class as a whole and not to a particular instance (object). A static variable is initialized when the class is loaded. Similarly, a class can have static methods. Static variables and static methods are collectively known as static members, and are declared with a keyword static. Static members in the class can be accessed either by using the class name or by using the object reference, but instance members can only be accessed via object references.
    Below is a program showing the various parts of the basic language syntax that were discussed above.
    /** Comment
 * Displays "Hello World!" to the standard output. 

 */
public class HelloWorld {
      String output = "";
      static HelloWorld helloObj;  //Line 1 

      public HelloWorld(){
            output = "Hello World";
      } 

      public String printMessage(){
            return output;
      } 

      public static void main (String args[]) {
            helloObj = new HelloWorld();  //Line 2
            System.out.println(helloObj.printMessage());
  }

}
    Class Name: HelloWorld
    Object Reference: helloObj (in Line 1)
    Object Created: helloObj (In Line 2)
    Member Function: printMessage
    Field: output (String)
    Static Member: helloObj
    Instance Member : output (String)

    Java Operators

    They are used to manipulate primitive data types. Java operators can be classified as unary, binary, or ternary—meaning taking one, two, or three arguments, respectively. A unary operator may appear
    before (prefix) its argument or after (postfix) its argument. A binary or ternary operator appears between its arguments.
    Operators in java fall into 8 different categories:
    Java operators fall into eight different categories: assignment, arithmetic, relational, logical, bitwise, compound assignment, conditional, and type.
     Assignment Operators    = 
 Arithmetic Operators     -    +   *   /   %   ++   --

     Relational Operators    >  <   >=      <=    ==   != 
 Logical Operators      &&    ||    &  |  !   ^ 
 Bit wise Operator      &   |   ^  >>   >>> 
 Compound Assignment Operators    +=     -=    *=    /=    %=   

                                                  <<=  >>=  >>>=   
 Conditional Operator          ?:
    Java has eight different operator types: assignment, arithmetic, relational, logical, bitwise, compound assignment, conditional, and type.


    Assignment operators

    The java assignment operator statement has the following syntax:
    <variable> = <expression>
    If the value already exists in the variable it is overwritten by the assignment operator (=).
    public class AssignmentOperatorsDemo {

	public AssignmentOperatorsDemo() {
		//	        Assigning Primitive Values
		int j, k;
		j = 10; // j gets the value 10.
		j = 5; // j gets the value 5. Previous value is overwritten.
		k = j; // k gets the value 5.
		System.out.println("j is : " + j);
		System.out.println("k is : " + k);
		//	        Assigning References
		Integer i1 = new Integer("1");
		Integer i2 = new Integer("2");
		System.out.println("i1 is : " + i1);
		System.out.println("i2 is : " + i2);
		i1 = i2;
		System.out.println("i1 is : " + i1);
		System.out.println("i2 is : " + i2);
		//	        Multiple Assignments
		k = j = 10; // (k = (j = 10))
		System.out.println("j is : " + j);
		System.out.println("k is : " + k);
	}
	public static void main(String args[]) {
		new AssignmentOperatorsDemo();
	}
}
    Download AssignmentOperatorsDemoSource code

    Arithmetic operators

    Java provides eight Arithmetic operators. They are for addition, subtraction, multiplication, division, modulo (or remainder), increment (or add 1), decrement (or subtract 1), and negation. An example program is shown below that demonstrates the different arithmetic operators in java.
    The binary operator + is overloaded in the sense that the operation performed is determined by the type of the operands. When one of the operands is a String object, the other operand is implicitly converted to its string representation and string concatenation is performed.
    String message = 100 + "Messages"; //"100 Messages"
    public class ArithmeticOperatorsDemo {

	public ArithmeticOperatorsDemo() {
		int x, y = 10, z = 5;
		x = y + z;
		System.out.println("+ operator resulted in " + x);
		x = y - z;
		System.out.println("- operator resulted in " + x);
		x = y * z;
		System.out.println("* operator resulted in " + x);
		x = y / z;
		System.out.println("/ operator resulted in " + x);
		x = y % z;
		System.out.println("% operator resulted in " + x);
		x = y++;
		System.out.println("Postfix ++ operator resulted in " + x);
		x = ++z;
		System.out.println("Prefix ++ operator resulted in " + x);
		x = -y;
		System.out.println("Unary operator resulted in " + x);
		// Some examples of special Cases
		int tooBig = Integer.MAX_VALUE + 1; // -2147483648 which is
		// Integer.MIN_VALUE.
		int tooSmall = Integer.MIN_VALUE - 1; // 2147483647 which is
		// Integer.MAX_VALUE.
		System.out.println("tooBig becomes " + tooBig);
		System.out.println("tooSmall becomes " + tooSmall);
		System.out.println(4.0 / 0.0); // Prints: Infinity
		System.out.println(-4.0 / 0.0); // Prints: -Infinity
		System.out.println(0.0 / 0.0); // Prints: NaN
		double d1 = 12 / 8; // result: 1 by integer division. d1 gets the value
		// 1.0.
		double d2 = 12.0F / 8; // result: 1.5
		System.out.println("d1 is " + d1);
		System.out.println("d2 iss " + d2);
	}
	public static void main(String args[]) {
		new ArithmeticOperatorsDemo();
	}
}
    Download ArithmeticOperatorsDemo Source code

    Relational operators

    Relational operators in Java are used to compare 2 or more objects. Java provides six relational operators:
    greater than (>), less than (<), greater than or equal (>=), less than or equal (<=), equal (==), and not equal (!=).
    All relational operators are binary operators, and their operands are numeric expressions.
    Binary numeric promotion is applied to the operands of these operators. The evaluation results in a boolean value. Relational operators have precedence lower than arithmetic operators, but higher than that of the assignment operators. An example program is shown below that demonstrates the different relational operators in java.
    
public class RelationalOperatorsDemo {
   public RelationalOperatorsDemo( ) { 

     int x = 10, y = 5;
     System.out.println("x > y : "+(x > y));
     System.out.println("x < y : "+(x < y));
     System.out.println("x >= y : "+(x >= y));
     System.out.println("x <= y : "+(x <= y));
     System.out.println("x == y : "+(x == y));
     System.out.println("x != y : "+(x != y));
     } 

     public static void main(String args[]){
             new RelationalOperatorsDemo();
     }
    }
    Download RelationalOperatorsDemo Source code

    Logical operators

    Logical operators return a true or false value based on the state of the Variables. There are six logical, or boolean, operators. They are AND, conditional AND, OR, conditional OR, exclusive OR, and NOT. Each argument to a logical operator must be a boolean data type, and the result is always a boolean data type. An example program is shown below that demonstrates the different Logical operators in java.
    public class LogicalOperatorsDemo {

	public LogicalOperatorsDemo() {
		boolean x = true;
		boolean y = false;
		System.out.println("x & y : " + (x & y));
		System.out.println("x && y : " + (x && y));
		System.out.println("x | y : " + (x | y));
		System.out.println("x || y: " + (x || y));
		System.out.println("x ^ y : " + (x ^ y));
		System.out.println("!x : " + (!x));
	}
	public static void main(String args[]) {
		new LogicalOperatorsDemo();
	}
}
    Download LogicalOperatorsDemo Source code
    Given that x and y represent boolean expressions, the boolean logical operators are defined in the Table below.
    x
    y
    !x
    x & y
    x && y
    x | y
    x || y
    x ^ y
    true
    true
    false
    true
    true
    false
    true
    false
    false
    false
    true
    true
    false
    true
    true
    false
    true
    true
    false
    false
    true
    false
    false
    false




    Bitwise operators

    Java provides Bit wise operators to manipulate the contents of variables at the bit level.
    These variables must be of numeric data type ( char, short, int, or long). Java provides seven bitwise
    operators. They are AND, OR, Exclusive-OR, Complement, Left-shift, Signed Right-shift, and Unsigned Right-shift. An example program is shown below that demonstrates the different Bit wise operators in java.
    
 public class BitwiseOperatorsDemo {
  public BitwiseOperatorsDemo() {
    int x = 0xFAEF; //1 1 1 1 1 0 1 0 1 1 1 0 1 1 1 1
    int y = 0xF8E9; //1 1 1 1 1 0 0 0 1 1 1 0 1 0 0 1
    int z; System.out.println("x & y : " + (x & y));
    System.out.println("x | y : " + (x | y));
    System.out.println("x ^ y : " + (x ^ y));
    System.out.println("~x : " + (~x));
    System.out.println("x << y : " + (x << y));
    System.out.println("x >> y : " + (x >> y));
    System.out.println("x >>> y : " + (x >>> y));
    //There is no unsigned left shift operator
    } 

  public static void main(String args[])
     new BitwiseOperatorsDemo(); 

   }
    Download BitwiseOperatorsDemo Source code
    The result of applying bitwise operators between two corresponding bits in the operands is shown in the Table below.
    A
    B
    ~A
    A & B
    A | B
    A ^ B
    1
    1
    0
    1
    1
    0
    1
    0
    0
    0
    1
    1
    0
    1
    1
    0
    1
    1
    0
    0
    1
    0
    0
    0
    Output
    3,0,3
    /*
 * The below program demonstrates bitwise operators keeping in mind operator precedence
 * Operator Precedence starting with the highest is -> |, ^, &
 */

public class BitwisePrecedenceEx {

	public static void main(String[] args) {
		int a = 1 | 2 ^ 3 & 5;
		int b = ((1 | 2) ^ 3) & 5;
		int c = 1 | (2 ^ (3 & 5));
		System.out.print(a + "," + b + "," + c);
	}
}
    Downloadad BitwiseOperatorsDemo2 Source code

    Compound operators

    The compound operators perform shortcuts in common programming operations. Java has eleven compound assignment operators.
    Syntax:
    argument1 operator = argument2.
    The above statement is the same as, argument1 = argument1 operator argument2. An example program is shown below that demonstrates the different Compound operators in java.
    public class CompoundOperatorsDemo {

	public CompoundOperatorsDemo() {
		int x = 0, y = 5;
		x += 3;
		System.out.println("x : " + x);
		y *= x;
		System.out.println("y :  " + y);
		/*Similarly other operators can be applied as shortcuts. Other 

		 compound assignment operators include boolean logical 

		 , bitwiseand shift operators*/
	}
	public static void main(String args[]) {
		new CompoundOperatorsDemo();
	}
}
    Download CompoundOperatorsDemo Source code

    Conditional operators

    The Conditional operator is the only ternary (operator takes three arguments) operator in Java. The operator evaluates the first argument and, if true, evaluates the second argument. If the first argument evaluates to false, then the third argument is evaluated. The conditional operator is the expression equivalent of the if-else statement. The conditional expression can be nested and the conditional operator associates from right to left: (a?b?c?d:e:f:g) evaluates as (a?(b?(c?d:e):f):g)
    An example program is shown below that demonstrates the Ternary operator in java.
    public class TernaryOperatorsDemo {

	public TernaryOperatorsDemo() {
		int x = 10, y = 12, z = 0;
		z = x > y ? x : y;
		System.out.println("z : " + z);
	}
	public static void main(String args[]) {
		new TernaryOperatorsDemo();
	}
}
    Download TernaryOperatorsDemo Source code
    /*
 * The following programs shows that when no explicit parenthesis is used then the
 conditional operator
 * evaluation is from right to left
 */

public class BooleanEx1 {

	static String m1(boolean b) {
		return b ? "T" : "F";
	}
	public static void main(String[] args) {
		boolean t1 = false ? false : true ? false : true ? false : true;
		boolean t2 = false ? false
				: (true ? false : (true ? false : true));
		boolean t3 = ((false ? false : true) ? false : true) ? false
				: true;
		System.out.println(m1(t1) + m1(t2) + m1(t3));
	}
}
    Output
    FFT
    Download TernaryOperatorsDemo2 Source code
    Type conversion allows a value to be changed from one primitive data type to another. Conversion can occur explicitly, as specified in
    the program, or implicitly, by Java itself. Java allows both type widening and type narrowing conversions.
    In java Conversions can occur by the following ways:
    • Using a cast operator (explicit promotion)
    • Using an arithmetic operator is used with arguments of different data types (arithmetic promotion)
    • A value of one type is assigned to a variable of a different type (assignment promotion)

    Operator Precedence

    The order in which operators are applied is known as precedence. Operators with a higher precedence are applied before operators with a lower precedence. The operator precedence order of Java is shown below. Operators at the top of the table are applied before operators lower down in the table. If two operators have the same precedence, they are applied in the order they appear in a statement.
    That is, from left to right. You can use parentheses to override the default precedence.
    postfix [] . () expr++ expr--
    unary ++expr --expr +expr -expr ! ~
    creation/caste new (type)expr
    multiplicative * / %
    additive + -
    shift >> >>>
    relational < <= > >= instanceof
    equality == !=
    bitwise AND &
    bitwise exclusive OR ^
    bitwise inclusive OR |
    logical AND &&
    logical OR ||
    ternary ?:
    assignment = "op="


    Example
    In an operation such as,
    result = 4 + 5 * 3
    First (5 * 3) is evaluated and the result is added to 4 giving the Final Result value as 19. Note that '*' takes higher precedence than '+' according to chart shown above. This kind of precedence of one operator over another applies to all the operators.
    QUIZ
    1. How to generate a random number between 1 to x, x being a whole number greater than 1
    Ans: double result = x * Math.random();

    Java Control Flow Statements

    Java Control statements control the order of execution in a java program, based on data values and conditional logic. There are three main categories of control flow statements;
    · Selection statements: if, if-else and switch.
    · Loop statements: while, do-while and for.
    · Transfer statements: break, continue, return, try-catch-finally and assert.
    We use control statements when we want to change the default sequential order of execution

    Selection Statements



    The If Statement
    The if statement executes a block of code only if the specified expression is true. If the value is false, then the if block is skipped and execution continues with the rest of the program. You can either have a single statement or a block of code within an if statement. Note that the conditional expression must be a Boolean expression.
    The simple if statement has the following syntax:
    if (<conditional expression>)
    <statement action>
    Below is an example that demonstrates conditional execution based on if statement condition.
    public class IfStatementDemo {

	public static void main(String[] args) {
		int a = 10, b = 20;
		if (a > b)
			System.out.println("a > b");
		if (a < b)
			System.out.println("b > a");
	}
}
    Output
    b > a
    Download IfStatementDemo.java
    The If-else Statement
    The if/else statement is an extension of the if statement. If the statements in the if statement fails, the statements in the else block are executed. You can either have a single statement or a block of code within if-else blocks. Note that the conditional expression must be a Boolean expression.
    The if-else statement has the following syntax:
    if (<conditional expression>)
    <statement action>
    else
    <statement action>
    Below is an example that demonstrates conditional execution based on if else statement condition.

    public class IfElseStatementDemo {

	public static void main(String[] args) {
		int a = 10, b = 20;
		if (a > b) {
			System.out.println("a > b");
		} else {
			System.out.println("b > a");
		}
	}
}
    Output
    b > a
    Download IfElseStatementDemo.java


    Switch Case Statement The switch case statement, also called a case statement is a multi-way branch with several choices. A switch is easier to implement than a series of if/else statements. The switch statement begins with a keyword, followed by an expression that equates to a no long integral value. Following the controlling expression is a code block that contains zero or more labeled cases. Each label must equate to an integer constant and each must be unique. When the switch statement executes, it compares the value of the controlling expression to the values of each case label. The program will select the value of the case label that equals the value of the controlling expression and branch down that path to the end of the code block. If none of the case label values match, then none of the codes within the switch statement code block will be executed. Java includes a default label to use in cases where there are no matches. We can have a nested switch within a case block of an outer switch. Its general form is as follows:
    switch (<non-long integral expression>) {
    case label1: <statement1>
    case label2: <statement2>
    …
    case labeln: <statementn>
    default: <statement>
    } // end switch
    When executing a switch statement, the program falls through to the next case. Therefore, if you want to exit in the middle of the switch statement code block, you must insert a break statement, which causes the program to continue executing after the current code block.
    Below is a java example that demonstrates conditional execution based on nested if else statement condition to find the greatest of 3 numbers.
    public class SwitchCaseStatementDemo {

	public static void main(String[] args) {
		int a = 10, b = 20, c = 30;
		int status = -1;
		if (a > b && a > c) {
			status = 1;
		} else if (b > c) {
			status = 2;
		} else {
			status = 3;
		}
		switch (status) {
		case 1:
			System.out.println("a is the greatest");
			break;
		case 2:
			System.out.println("b is the greatest");
			break;
		case 3:
			System.out.println("c is the greatest");
			break;
		default:
			System.out.println("Cannot be determined");
		}
	}
}
    Output
    c is the greatest
    Download SwitchCaseStatementDemo.java

    Introduction to Java Access Modifiers

    Java Access Specifiers

    The access to classes, constructors, methods and fields are regulated using access modifiers i.e. a class can control what information or data can be accessible by other classes. To take advantage of encapsulation, you should minimize access whenever possible.
    Java provides a number of access modifiers to help you set the level of access you want for classes as well as the fields, methods and constructors in your classes. A member has package or default accessibility when no accessibility modifier is specified.
    Access Modifiers
    1. private
    2. protected
    3. default
    4. public


    public access modifier
    Fields, methods and constructors declared public (least restrictive) within a public class are visible to any class in the Java program, whether these classes are in the same package or in another package.
    private access modifier
    The private (most restrictive) fields or methods cannot be used for classes and Interfaces. It also cannot be used for fields and methods within an interface. Fields, methods or constructors declared private are strictly controlled, which means they cannot be accesses by anywhere outside the enclosing class. A standard design strategy is to make all fields private and provide public getter methods for them.
    protected access modifier
    The protected fields or methods cannot be used for classes and Interfaces. It also cannot be used for fields and methods within an interface. Fields, methods and constructors declared protected in a superclass can be accessed only by subclasses in other packages. Classes in the same package can also access protected fields, methods and constructors as well, even if they are not a subclass of the protected member’s class.
    default access modifier
    Java provides a default specifier which is used when no access modifier is present. Any class, field, method or constructor that has no declared access modifier is accessible only by classes in the same package. The default modifier is not used for fields and methods within an interface.


    Below is a program to demonstrate the use of public, private, protected and default access modifiers while accessing fields and methods. The output of each of these java files depict the Java access specifiers.
    The first class is SubclassInSamePackage.java which is present in pckage1 package. This java file contains the Base class and a subclass within the enclosing class that belongs to the same class as shown below.
    package pckage1;

class BaseClass {

	public int x = 10;
	private int y = 10;
	protected int z = 10;
	int a = 10; //Implicit Default Access Modifier
	public int getX() {
		return x;
	}
	public void setX(int x) {
		this.x = x;
	}
	private int getY() {
		return y;
	}
	private void setY(int y) {
		this.y = y;
	}
	protected int getZ() {
		return z;
	}
	protected void setZ(int z) {
		this.z = z;
	}
	int getA() {
		return a;
	}
	void setA(int a) {
		this.a = a;
	}
}

public class SubclassInSamePackage extends BaseClass {

	public static void main(String args[]) {
		BaseClass rr = new BaseClass();
		rr.z = 0;
		SubclassInSamePackage subClassObj = new SubclassInSamePackage();
		//Access Modifiers - Public
		System.out.println("Value of x is : " + subClassObj.x);
		subClassObj.setX(20);
		System.out.println("Value of x is : " + subClassObj.x);
		//Access Modifiers - Public
		//    	If we remove the comments it would result in a compilaton
		//    	error as the fields and methods being accessed are private
		/*    	System.out.println("Value of y is : "+subClassObj.y);

		 subClassObj.setY(20);

		 System.out.println("Value of y is : "+subClassObj.y);*/
		//Access Modifiers - Protected
		System.out.println("Value of z is : " + subClassObj.z);
		subClassObj.setZ(30);
		System.out.println("Value of z is : " + subClassObj.z);
		//Access Modifiers - Default
		System.out.println("Value of x is : " + subClassObj.a);
		subClassObj.setA(20);
		System.out.println("Value of x is : " + subClassObj.a);
	}
}
    Output
    Value of x is : 10
    Value of x is : 20
    Value of z is : 10
    Value of z is : 30
    Value of x is : 10
    Value of x is : 20
    The second class is SubClassInDifferentPackage.java which is present in a different package then the first one. This java class extends First class (SubclassInSamePackage.java).
    import pckage1.*;

public class SubClassInDifferentPackage extends SubclassInSamePackage {

	public int getZZZ() {
		return z;
	}

	public static void main(String args[]) {
		SubClassInDifferentPackage subClassDiffObj = new SubClassInDifferentPackage();
		SubclassInSamePackage subClassObj = new SubclassInSamePackage();
		//Access specifiers - Public
		System.out.println("Value of x is : " + subClassObj.x);
		subClassObj.setX(30);
		System.out.println("Value of x is : " + subClassObj.x);
		//Access specifiers - Private
		//      if we remove the comments it would result in a compilaton
		//      error as the fields and methods being accessed are private
		/*      System.out.println("Value of y is : "+subClassObj.y);

		 subClassObj.setY(20);

		 System.out.println("Value of y is : "+subClassObj.y);*/
		//Access specifiers - Protected
		//      If we remove the comments it would result in a compilaton
		//      error as the fields and methods being accessed are protected.
		/*      System.out.println("Value of z is : "+subClassObj.z);

		 subClassObj.setZ(30);

		 System.out.println("Value of z is : "+subClassObj.z);*/
		System.out.println("Value of z is : " + subClassDiffObj.getZZZ());
		//Access Modifiers - Default
		//      If we remove the comments it would result in a compilaton
		//      error as the fields and methods being accessed are default.
		/*

		 System.out.println("Value of a is : "+subClassObj.a);

		 subClassObj.setA(20);

		 System.out.println("Value of a is : "+subClassObj.a);*/
	}
}
    Output
    Value of x is : 10
    Value of x is : 30
    Value of z is : 10
    The third class is ClassInDifferentPackage.java which is present in a different package then the first one.
    import pckage1.*;

public class ClassInDifferentPackage {

	public static void main(String args[]) {
		SubclassInSamePackage subClassObj = new SubclassInSamePackage();
		//Access Modifiers - Public
		System.out.println("Value of x is : " + subClassObj.x);
		subClassObj.setX(30);
		System.out.println("Value of x is : " + subClassObj.x);
		//Access Modifiers - Private
		//      If we remove the comments it would result in a compilaton
		//      error as the fields and methods being accessed are private
		/*      System.out.println("Value of y is : "+subClassObj.y);

		 subClassObj.setY(20);

		 System.out.println("Value of y is : "+subClassObj.y);*/
		//Access Modifiers - Protected
		//      If we remove the comments it would result in a compilaton
		//      error as the fields and methods being accessed are protected.
		/*      System.out.println("Value of z is : "+subClassObj.z);

		 subClassObj.setZ(30);

		 System.out.println("Value of z is : "+subClassObj.z);*/
		//Access Modifiers - Default
		//      If we remove the comments it would result in a compilaton
		//      error as the fields and methods being accessed are default.
		/*      System.out.println("Value of a is : "+subClassObj.a);

		 subClassObj.setA(20);

		 System.out.println("Value of a is : "+subClassObj.a);*/
	}
}
    Output
    Value of x is : 10
    Value of x is : 30
    Download all the 3 source files

    Java Classes and Objects

    Introduction to Java Classes

    A class is nothing but a blueprint or a template for creating different objects which defines its properties and behaviors. Java class objects exhibit the properties and behaviors defined by its class. A class can contain fields and methods to describe the behavior of an object.
    Methods are nothing but members of a class that provide a service for an object or perform some business logic. Java fields and member functions names are case sensitive. Current states of a class’s corresponding object are stored in the object’s instance variables. Methods define the operations that can be performed in java programming.
    A class has the following general syntax:
    <class modifiers>class<class name>
    <extends clause> <implements clause>    {
    // Dealing with Classes (Class body)
    <field declarations (Static and Non-Static)>
    <method declarations (Static and Non-Static)>
    <Inner class declarations>
    <nested interface declarations>
    <constructor declarations>
    <Static initializer blocks>
    }
    Below is an example showing the Objects and Classes of the Cube class that defines 3 fields namely length, breadth and height. Also the class contains a member function getVolume().


    public class Cube {

	int length;
	int breadth;
	int height;
	public int getVolume() {
		return (length * breadth * height);
	}
}
    How do you reference a data member/function?
    This is accomplished by stating the name of the object reference, followed by a period (dot), followed by the name of the member inside the object.
    ( objectReference.member ). You call a method for an object by naming the object followed by a period (dot), followed by the name of the method and its argument list, like this: objectName.methodName(arg1, arg2, arg3).
    For example:
    cubeObject.length = 4;
    cubeObject.breadth = 4;
    cubeObject.height = 4;
    cubeObject.getvolume()

    Class Variables – Static Fields

    We use class variables also know as Static fields when we want to share characteristics across all objects within a class. When you declare a field to be static, only a single instance of the associated variable is created common to all the objects of that class. Hence when one object changes the value of a class variable, it affects all objects of the class. We can access a class variable by using the name of the class, and not necessarily using a reference to an individual object within the class. Static variables can be accessed even though no objects of that class exist. It is declared using static keyword.

    Class Methods – Static Methods

    Class methods, similar to Class variables can be invoked without having an instance of the class. Class methods are often used to provide global functions for Java programs. For example, methods in the java.lang.Math package are class methods. You cannot call non-static methods from inside a static method.

    Instance Variables

    Instance variables stores the state of the object. Each class would have its own copy of the variable. Every object has a state that is determined by the values stored in the object. An object is said to have changed its state when one or more data values stored in the object have been modified. When an object responds to a message, it will usually perform an action, change its state etc. An object that has the ability to store values is often said to have persistence.
    Consider this simple Java program showing the use of static fields and static methods
    // Class and Object initialization showing the Object Oriented concepts in Java
class Cube {

	int length = 10;
	int breadth = 10;
	int height = 10;
	public static int numOfCubes = 0; // static variable
	public static int getNoOfCubes() { //static method
		return numOfCubes;
	}
	public Cube() {
		numOfCubes++; //
	}
}

public class CubeStaticTest {

	public static void main(String args[]) {
		System.out.println("Number of Cube objects = " + Cube.numOfCubes);
		System.out.println("Number of Cube objects = "
				+ Cube.getNoOfCubes());
	}
}
    Download CubeStaticTest.java
    Output
    Number of Cube objects = 0
    Number of Cube objects = 0

    Final Variable, Methods and Classes

    In Java we can mark fields, methods and classes as final. Once marked as final, these items cannot be changed.
    Variables defined in an interface are implicitly final. You can’t change value of a final variable (is a constant). A final class can’t be extended i.e., final class may not be subclassed. This is done for security reasons with basic classes like String and Integer. It also allows the compiler to make some optimizations, and makes thread safety a little easier to achieve. A final method can’t be overridden when its class is inherited. Any attempt to override or hide a final method will result in a compiler error.

    Introduction to Java Objects

    The Object Class is the super class for all classes in Java.
    Some of the object class methods are

    equals
    toString()
    wait()
    notify()
    notifyAll()
    hashcode()
    clone()
    An object is an instance of a class created using a new operator. The new operator returns a reference to a new instance of a class. This reference can be assigned to a reference variable of the class. The process of creating objects from a class is called instantiation. An object encapsulates state and behavior.
    An object reference provides a handle to an object that is created and stored in memory. In Java, objects can only be manipulated via references, which can be stored in variables.
    Creating variables of your class type is similar to creating variables of primitive data types, such as integer or float. Each time you create an object, a new set of instance variables comes into existence which defines the characteristics of that object. If you want to create an object of the class and have the reference variable associated with this object, you must also allocate memory for the object by using the new operator. This process is called instantiating an object or creating an object instance.
    When you create a new object, you use the new operator to instantiate the object. The new operator returns the location of the object which you assign o a reference type.
    Below is an example showing the creation of Cube objects by using the new operator.
    public class Cube {

	int length = 10;
	int breadth = 10;
	int height = 10;
	public int getVolume() {
		return (length * breadth * height);
	}
	public static void main(String[] args) {
		Cube cubeObj; // Creates a Cube Reference
		cubeObj = new Cube(); // Creates an Object of Cube
		System.out.println("Volume of Cube is : " + cubeObj.getVolume());
	}
}
    Download Cube.java

    Method Overloading

    Method overloading results when two or more methods in the same class have the same name but different parameters. Methods with the same name must differ in their types or number of parameters. This allows the compiler to match parameters and choose the correct method when a number of choices exist. Changing just the return type is not enough to overload a method, and will be a compile-time error. They must have a different signature. When no method matching the input parameters is found, the compiler attempts to convert the input parameters to types of greater precision. A match may then be found without error. At compile time, the right implementation is chosen based on the signature of the method call
    Below is an example of a class demonstrating Method Overloading
    
public class MethodOverloadDemo {

	void sumOfParams() { // First Version
		System.out.println("No parameters");
	}
	void sumOfParams(int a) { // Second Version
		System.out.println("One parameter: " + a);
	}
	int sumOfParams(int a, int b) { // Third Version
		System.out.println("Two parameters: " + a + " , " + b);
		return a + b;
	}
	double sumOfParams(double a, double b) { // Fourth Version
		System.out.println("Two double parameters: " + a + " , " + b);
		return a + b;
	}
	public static void main(String args[]) {
		MethodOverloadDemo moDemo = new MethodOverloadDemo();
		int intResult;
		double doubleResult;
		moDemo.sumOfParams();
		System.out.println();
		moDemo.sumOfParams(2);
		System.out.println();
		intResult = moDemo.sumOfParams(10, 20);
		System.out.println("Sum is  " + intResult);
		System.out.println();
		doubleResult = moDemo.sumOfParams(1.1, 2.2);
		System.out.println("Sum is  " + doubleResult);
		System.out.println();
	}
}
    Download MethodOverloadDemo.java
    Output
    No parameters
    One parameter: 2
    Two parameters: 10 , 20
    Sum is 30
    Two double parameters: 1.1 , 2.2
    Sum is 3.3000000000000003
    Below is a code snippet to shows the interfaces that a Class Implements:
    Class cls = java.lang.String.class;
Class[] intfs = cls.getInterfaces();
// [java.lang.Comparable, java.lang.CharSequence, java.io.Serializable]
// The interfaces for a primitive type is an empty array
cls = int.class;
intfs = cls.getInterfaces(); // []
    Below is a code snippet to show whether a Class Object Represents a Class or Interface:
    Class cls = java.lang.String.class;
boolean isClass = !cls.isInterface(); // true
cls = java.lang.Cloneable.class;
isClass = !cls.isInterface(); // false


    Java Constructors

    A java constructor has the same name as the name of the class to which it belongs. Constructor’s syntax does not include a return type, since constructors never return a value.
    Constructors may include parameters of various types. When the constructor is invoked using the new operator, the types must match those that are specified in the constructor definition.
    Java provides a default constructor which takes no arguments and performs no special actions or initializations, when no explicit constructors are provided.
    The only action taken by the implicit default constructor is to call the superclass constructor using the super() call. Constructor arguments provide you with a way to provide parameters for the initialization of an object.
    Below is an example of a cube class containing 2 constructors. (one default and one parameterized constructor).
    public class Cube1 {

	int length;
	int breadth;
	int height;
	public int getVolume() {
		return (length * breadth * height);
	}
	Cube1() {
		length = 10;
		breadth = 10;
		height = 10;
	}
	Cube1(int l, int b, int h) {
		length = l;
		breadth = b;
		height = h;
	}
	public static void main(String[] args) {
		Cube1 cubeObj1, cubeObj2;
		cubeObj1 = new Cube1();
		cubeObj2 = new Cube1(10, 20, 30);
		System.out.println("Volume of Cube1 is : " + cubeObj1.getVolume());
		System.out.println("Volume of Cube1 is : " + cubeObj2.getVolume());
	}
}

    Download Cube1.java
    Note: If a class defines an explicit constructor, it no longer has a default constructor to set the state of the objects.
    If such a class requires a default constructor, its implementation must be provided. Any attempt to call the default constructor will be a compile time error if an explicit default constructor is not provided in such a case.

    Java Overloaded Constructors

    >


    Like methods, constructors can also be overloaded. Since the constructors in a class all have the same name as the class, />their signatures are differentiated by their parameter lists. The above example shows that the Cube1 constructor is overloaded one being the default constructor and the other being a parameterized constructor.
    It is possible to use this() construct, to implement local chaining of constructors in a class. The this() call in a constructorinvokes the an other constructor with the corresponding parameter list within the same class. Calling the default constructor to create a Cube object results in the second and third parameterized constructors being called as well. Java requires that any this() call must occur as the first statement in a constructor.
    Below is an example of a cube class containing 3 constructors which demostrates the this() method in Constructors context
    public class Cube2 {

	int length;
	int breadth;
	int height;
	public int getVolume() {
		return (length * breadth * height);
	}
	Cube2() {
		this(10, 10);
		System.out.println("Finished with Default Constructor");
	}
	Cube2(int l, int b) {
		this(l, b, 10);
		System.out.println("Finished with Parameterized Constructor having 2 params");
	}
	Cube2(int l, int b, int h) {
		length = l;
		breadth = b;
		height = h;
		System.out.println("Finished with Parameterized Constructor having 3 params");
	}
	public static void main(String[] args) {
		Cube2 cubeObj1, cubeObj2;
		cubeObj1 = new Cube2();
		cubeObj2 = new Cube2(10, 20, 30);
		System.out.println("Volume of Cube1 is : " + cubeObj1.getVolume());
		System.out.println("Volume of Cube2 is : " + cubeObj2.getVolume());
	}
}

public class Cube2 {

	int length;
	int breadth;
	int height;
	public int getVolume() {
		return (length * breadth * height);
	}
	Cube2() {
		this(10, 10);
		System.out.println("Finished with Default Constructor");
	}
	Cube2(int l, int b) {
		this(l, b, 10);
		System.out.println("Finished with Parameterized Constructor having 2 params");
	}
	Cube2(int l, int b, int h) {
		length = l;
		breadth = b;
		height = h;
		System.out.println("Finished with Parameterized Constructor having 3 params");
	}
	public static void main(String[] args) {
		Cube2 cubeObj1, cubeObj2;
		cubeObj1 = new Cube2();
		cubeObj2 = new Cube2(10, 20, 30);
		System.out.println("Volume of Cube1 is : " + cubeObj1.getVolume());
		System.out.println("Volume of Cube2 is : " + cubeObj2.getVolume());
	}
}

    Output
    Finished with Parameterized Constructor having 3 params
    Finished with Parameterized Constructor having 2 params
    Finished with Default Constructor
    Finished with Parameterized Constructor having 3 params
    Volume of Cube1 is : 1000
    Volume of Cube2 is : 6000
    Download Cube2.java


    Constructor Chaining

    Every constructor calls its superclass constructor. An implied super() is therefore included in each constructor which does not include either the this() function or an explicit super() call as its first statement. The super() statement invokes a constructor of the super class.
    The implicit super() can be replaced by an explicit super(). The super statement must be the first statement of the constructor.
    The explicit super allows parameter values to be passed to the constructor of its superclass and must have matching parameter types A super() call in the constructor of a subclass will result in the call of the relevant constructor from the superclass, based on the signature of the call. This is called constructor chaining.
    Below is an example of a class demonstrating constructor chaining using super() method.
    class Cube {

	int length;
	int breadth;
	int height;
	public int getVolume() {
		return (length * breadth * height);
	}
	Cube() {
		this(10, 10);
		System.out.println("Finished with Default Constructor of Cube");
	}
	Cube(int l, int b) {
		this(l, b, 10);
		System.out.println("Finished with Parameterized Constructor having
									2 params of Cube");
	}
	Cube(int l, int b, int h) {
		length = l;
		breadth = b;
		height = h;
		System.out.println("Finished with Parameterized Constructor having
									3 params of Cube");
	}
}

public class SpecialCube extends Cube {

	int weight;
	SpecialCube() {
		super();
		weight = 10;
	}
	SpecialCube(int l, int b) {
		this(l, b, 10);
		System.out.println("Finished with Parameterized Constructor having
									2 params of SpecialCube");
	}
	SpecialCube(int l, int b, int h) {
		super(l, b, h);
		weight = 20;
		System.out.println("Finished with Parameterized Constructor having
									3 params of SpecialCube");
	}
	public static void main(String[] args) {
		SpecialCube specialObj1 = new SpecialCube();
		SpecialCube specialObj2 = new SpecialCube(10, 20);
		System.out.println("Volume of SpecialCube1 is : "
				+ specialObj1.getVolume());
		System.out.println("Weight of SpecialCube1 is : "
				+ specialObj1.weight);
		System.out.println("Volume of SpecialCube2 is : "
				+ specialObj2.getVolume());
		System.out.println("Weight of SpecialCube2 is : "
				+ specialObj2.weight);
	}
}
    Download SpecialCube.java
    Output
    Finished with Parameterized Constructor having 3 params of SpecialCube
    Finished with Parameterized Constructor having 2 params of SpecialCube
    Volume of SpecialCube1 is : 1000
    Weight of SpecialCube1 is : 10
    Volume of SpecialCube2 is : 2000
    Weight of SpecialCube2 is : 20
    The super() construct as with this() construct: if used, must occur as the first statement in a constructor, and it can only be used in a constructor declaration. This implies that this() and super() calls cannot both occur in the same constructor. Just as the this() construct leads to chaining of constructors in the same class, the super() construct leads to chaining of subclass constructors to superclass constructors.
    if a constructor has neither a this() nor a super() construct as its first statement, then a super() call to the default constructor in the superclass is inserted.
    Note: If a class only defines non-default constructors, then its subclasses will not include an implicit super() call. This will be flagged as a compile-time error. The subclasses must then explicitly call a superclass constructor, using the super() construct with the right arguments to match the appropriate constructor of the superclass.
    Below is an example of a class demonstrating constructor chaining using explicit super() call.
    class Cube {

	int length;
	int breadth;
	int height;
	public int getVolume() {
		return (length * breadth * height);
	}
	Cube(int l, int b, int h) {
		length = l;
		breadth = b;
		height = h;
		System.out.println("Finished with Parameterized Constructor having
								3 params of Cube");
	}
}

public class SpecialCube1 extends Cube {

	int weight;
	SpecialCube1() {
		super(10, 20, 30); //Will Give a Compilation Error without this line
		weight = 10;
	}
	public static void main(String[] args) {
		SpecialCube1 specialObj1 = new SpecialCube1();
		System.out.println("Volume of SpecialCube1 is : "+ specialObj1.getVolume());
	}
}
    Output
    Finished with Parameterized Constructor having 3 params of Cube
    Volume of SpecialCube1 is : 6000
    Download SpecialCube1.java

    Java Serialization

    Introduction to Object Serialization

    Java object serialization is used to persist Java objects to a file, database, network, process or any other system. Serialization flattens objects into an ordered, or serialized stream of bytes. The ordered stream of bytes can then be read at a later time, or in another environment, to recreate the original objects.
    Java serialization does not cannot occur for transient or static fields. Marking the field transient prevents the state from being written to the stream and from being restored during deserialization. Java provides classes to support writing objects to streams and restoring objects from streams. Only objects that support the java.io.Serializable interface or the java.io.Externalizable interface can be written to streams.
    public interface Serializable
    • The Serializable interface has no methods or fields. (Marker Interface)
    • Only objects of classes that implement java.io.Serializable interface can be serialized or deserialized

    Transient Fields and Java Serialization

    The transient keyword is a modifier applied to instance variables in a class. It specifies that the variable is not part of the persistent state of the object and thus never saved during serialization.
    You can use the transient keyword to describe temporary variables, or variables that contain local information,
    such as a process ID or a time lapse.


    Input and Output Object Streams

    ObjectOutputStream is the primary output stream class that implements the ObjectOutput interface for serializing objects. ObjectInputStream is the primary input stream class that implements the ObjectInput interface for deserializing objects.
    These high-level streams are each chained to a low-level stream, such as FileInputStream or FileOutputStream.
    The low-level streams handle the bytes of data. The writeObject method saves the state of the class by writing the individual fields to the ObjectOutputStream. The readObject method is used to deserialize the object from
    the object input stream.
    Case 1: Below is an example that demonstrates object Serialization into a File
    PersonDetails is the bean class that implements the Serializable interface 
    import java.io.Serializable;
    public class PersonDetails implements Serializable {

	private String name;
	private int age;
	private String sex;
	public PersonDetails(String name, int age, String sex) {
		this.name = name;
		this.age = age;
		this.sex = sex;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
}
    GetPersonDetails is the class that is used to Deserialize object from the File (person.txt). 
    import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.ArrayList;
import java.util.List;
    public class GetPersonDetails {

	public static void main(String[] args) {
		String filename = "person.txt";
		List pDetails = null;
		FileInputStream fis = null;
		ObjectInputStream in = null;
		try {
			fis = new FileInputStream(filename);
			in = new ObjectInputStream(fis);
			pDetails = (ArrayList) in.readObject();
			in.close();
		} catch (IOException ex) {
			ex.printStackTrace();
		} catch (ClassNotFoundException ex) {
			ex.printStackTrace();
		}
		// print out the size
		System.out.println("Person Details Size: " + pDetails.size());
		System.out.println();
	}
}
    PersonPersist is the class that is used to serialize object into the File (person.txt). 
    public class PersonPersist {

	public static void main(String[] args) {
		String filename = "person.txt";
		PersonDetails person1 = new PersonDetails("hemanth", 10, "Male");
		PersonDetails person2 = new PersonDetails("bob", 12, "Male");
		PersonDetails person3 = new PersonDetails("Richa", 10, "Female");
		List list = new ArrayList();
		list.add(person1);
		list.add(person2);
		list.add(person3);
		FileOutputStream fos = null;
		ObjectOutputStream out = null;
		try {
			fos = new FileOutputStream(filename);
			out = new ObjectOutputStream(fos);
			out.writeObject(list);
			out.close();
			System.out.println("Object Persisted");
		} catch (IOException ex) {
			ex.printStackTrace();
		}
	}
}
    ——————————————————————————–


    Case 2: Below is an example that demonstrates object Serialization into the database
    PersonDetails remains the same as shown above
    GetPersonDetails remains the same as shown above
    Create SerialTest Table
    create table SerialTest(
    name BLOB,
    viewname VARCHAR2(30)
    );
    PersonPersist is the class that is used to serialize object into the into the Database Table SerialTest. 
    import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
    public class PersonPersist {

	static String userid = "scott", password = "tiger";
	static String url = "jdbc:odbc:bob";
	static int count = 0;
	static Connection con = null;
	public static void main(String[] args) {
		Connection con = getOracleJDBCConnection();
		PersonDetails person1 = new PersonDetails("hemanth", 10, "Male");
		PersonDetails person2 = new PersonDetails("bob", 12, "Male");
		PersonDetails person3 = new PersonDetails("Richa", 10, "Female");
		PreparedStatement ps;
		try {
			ps = con
					.prepareStatement("INSERT INTO SerialTest VALUES (?, ?)");
			write(person1, ps);
			ps.execute();
			write(person2, ps);
			ps.execute();
			write(person3, ps);
			ps.execute();
			ps.close();
			Statement st = con.createStatement();
			ResultSet rs = st.executeQuery("SELECT * FROM SerialTest");
			while (rs.next()) {
				Object obj = read(rs, "Name");
				PersonDetails p = (PersonDetails) obj;
				System.out.println(p.getName() + "\t" + p.getAge() + "\t"
						+ p.getSex());
			}
			rs.close();
			st.close();
		} catch (Exception e) {
		}
	}
	public static void write(Object obj, PreparedStatement ps)
			throws SQLException, IOException {
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		ObjectOutputStream oout = new ObjectOutputStream(baos);
		oout.writeObject(obj);
		oout.close();
		ps.setBytes(1, baos.toByteArray());
		ps.setInt(2, ++count);
	}
	public static Object read(ResultSet rs, String column)
			throws SQLException, IOException, ClassNotFoundException {
		byte[] buf = rs.getBytes(column);
		if (buf != null) {
			ObjectInputStream objectIn = new ObjectInputStream(
					new ByteArrayInputStream(buf));
			return objectIn.readObject();
		}
		return null;
	}
	public static Connection getOracleJDBCConnection() {
		try {
			Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
		} catch (java.lang.ClassNotFoundException e) {
			System.err.print("ClassNotFoundException: ");
			System.err.println(e.getMessage());
		}
		try {
			con = DriverManager.getConnection(url, userid, password);
		} catch (SQLException ex) {
			System.err.println("SQLException: " + ex.getMessage());
		}
		return con;
	}
}
    ——————————————————————————–
    Case 3: Below is an example that demonstrates object Serialization into the database using Base 64 Encoder
    PersonDetails remains the same as shown above
    GetPersonDetails remains the same as shown above
    Create SerialTest Table
    create table SerialTest(
    name BLOB,
    viewname VARCHAR2(30)
    );
    PersonPersist is the class that is used to serialize object into the Database Table SerialTest 
    import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
    public class PersonPersist {

	static String userid = "scott", password = "tiger";
	static String url = "jdbc:odbc:bob";
	static int count = 0;
	static Connection con = null;
	static String s;
	public static void main(String[] args) {
		Connection con = getOracleJDBCConnection();
		PersonDetails person1 = new PersonDetails("hemanth", 10, "Male");
		PersonDetails person2 = new PersonDetails("bob", 12, "Male");
		PersonDetails person3 = new PersonDetails("Richa", 10, "Female");
		PreparedStatement ps;
		try {
			ps = con
					.prepareStatement("INSERT INTO SerialTest VALUES (?, ?)");
			write(person1, ps);
			ps.execute();
			write(person2, ps);
			ps.execute();
			write(person3, ps);
			ps.execute();
			ps.close();
			Statement st = con.createStatement();
			ResultSet rs = st.executeQuery("SELECT * FROM SerialTest");
			while (rs.next()) {
				Object obj = read(rs, "Name");
				PersonDetails p = (PersonDetails) obj;
				System.out.println(p.getName() + "\t" + p.getAge() + "\t"
						+ p.getSex());
			}
			rs.close();
			st.close();
		} catch (Exception e) {
		}
	}
	public static void write(Object obj, PreparedStatement ps)
			throws SQLException, IOException {
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		ObjectOutputStream oout = new ObjectOutputStream(baos);
		oout.writeObject(obj);
		oout.close();
		byte[] buf = baos.toByteArray();
		s = new sun.misc.BASE64Encoder().encode(buf);
		ps.setString(1, s);
		// ps.setBytes(1, Base64.byteArrayToBase64(baos.toByteArray()));
		ps.setBytes(1, baos.toByteArray());
		ps.setInt(2, ++count);
	}
	public static Object read(ResultSet rs, String column)
			throws SQLException, IOException, ClassNotFoundException {
		byte[] buf = new sun.misc.BASE64Decoder().decodeBuffer(s);
		// byte[] buf = Base64.base64ToByteArray(new
		// String(rs.getBytes(column)));
		if (buf != null) {
			ObjectInputStream objectIn = new ObjectInputStream(
					new ByteArrayInputStream(buf));
			Object obj = objectIn.readObject(); // Contains the object
			PersonDetails p = (PersonDetails) obj;
			System.out.println(p.getName() + "\t" + p.getAge() + "\t"
					+ p.getSex());
		}
		return null;
	}
	public static Connection getOracleJDBCConnection() {
		try {
			Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
		} catch (java.lang.ClassNotFoundException e) {
			System.err.print("ClassNotFoundException: ");
			System.err.println(e.getMessage());
		}
		try {
			con = DriverManager.getConnection(url, userid, password);
		} catch (SQLException ex) {
			System.err.println("SQLException: " + ex.getMessage());
		}
		return con;
	}
}
    Below is a program that shows the serialization of a JButton object to a file and a Byte Array Stream. As before theobject to be serialized must implement the Serializable interface. PersonDetails is the bean class that implements the Serializable interface
    import java.io.ByteArrayOutputStream;
import java.io.FileOutputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;

public class ObjectSerializationExample {

	public static void main(String args[]) {
		try {
			Object object = new javax.swing.JButton("Submit");
			// Serialize to a file namely "filename.dat"
			ObjectOutput out = new ObjectOutputStream(
					new FileOutputStream("filename.dat"));
			out.writeObject(object);
			out.close();
			// Serialize to a byte array
			ByteArrayOutputStream bos = new ByteArrayOutputStream();
			out = new ObjectOutputStream(bos);
			out.writeObject(object);
			out.close();
			// Get the bytes of the serialized object
			byte[] buf = bos.toByteArray();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}
    Download Object Serialization Source code

    Share

    Twitter Delicious Facebook Digg Stumbleupon Favorites More