Thursday, 1 September 2011

Unit-II OOPS Concepts in JAVA



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         >     <      >=     <=     ==     !=
 L 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();
      }
}

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();
      }
}

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();
   }
 }

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();
      }
}
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();
      }
}
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);
      }
}

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();
      }
}

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();
      }
}

/*
 * 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
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 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) {
<font size=-1>
 
            int a = 10, b = 20;
            if (a > b)
                  System.out.println("a > b");
            if (a < b)
                  System.out.println("b > a");
      }
}
Output
b > a


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
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
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

Iteration Statements

While Statement:
The while statement is a looping construct control statement that executes a block of code while a condition is true. You can either have a single statement or a block of code within the while loop. The loop will never be executed if the testing expression evaluates to false. The loop condition must be a boolean expression.
The syntax of the while loop is
while (<loop condition>)
<statements>

Below is an example that demonstrates the looping construct namely while loop used to print numbers from 1 to 10.
public class WhileLoopDemo {
 
      public static void main(String[] args) {
            int count = 1;
            System.out.println("Printing Numbers from 1 to 10");
            while (count <= 10) {
                  System.out.println(count++);
            }
      }
}
Output
Printing Numbers from 1 to 10
1
2
3
4
5
6
7
8
9
10
Do-while Loop Statement:
The do-while loop is similar to the while loop, except that the test is performed at the end of the loop instead of at the beginning. This ensures that the loop will be executed at least once. A do-while loop begins with the keyword do, followed by the statements that make up the body of the loop. Finally, the keyword while and the test expression completes the do-while loop. When the loop condition becomes false, the loop is terminated and execution continues with the statement immediately following the loop. You can either have a single statement or a block of code within the do-while loop.
The syntax of the do-while loop is
do
<loop body>
while (<loop condition>);
Below is an example that demonstrates the looping construct namely do-while loop used to print numbers from 1 to 10.
public class DoWhileLoopDemo {
 
      public static void main(String[] args) {
            int count = 1;
            System.out.println("Printing Numbers from 1 to 10");
            do {
                  System.out.println(count++);
            } while (count <= 10);
      }
}
Output
Printing Numbers from 1 to 10
1
2
3
4
5
6
7
8
9
10
Below is an example that creates A Fibonacci sequence controlled by a do-while loop
public class Fibonacci {
 
      public static void main(String args[]) {
            System.out.println("Printing Limited set of Fibonacci Sequence");
            double fib1 = 0;
            double fib2 = 1;
            double temp = 0;
            System.out.println(fib1);
            System.out.println(fib2);
            do {
                  temp = fib1 + fib2;
                  System.out.println(temp);
                  fib1 = fib2; //Replace 2nd with first number
                  fib2 = temp; //Replace temp number with 2nd number
            } while (fib2 < 5000);
      }
}
Output
Printing Limited set of Fibonacci Sequence
0.0
1.0
1.0
2.0
3.0
5.0
8.0
13.0
21.0
34.0
55.0
89.0
144.0
233.0
377.0
610.0
987.0
1597.0
2584.0
4181.0
6765.0
For Loops:
The for loop is a looping construct which can execute a set of instructions a specified number of times. It’s a counter controlled loop.
The syntax of the loop is as follows:
for (<initialization>; <loop condition>; <increment expression>)
<loop body>
The first part of a for statement is a starting initialization, which executes once before the loop begins. The <initialization> section can also be a comma-separated list of expression statements. The second part of a for statement is a test expression. As long as the expression is true, the loop will continue. If this expression is evaluated as false the first time, the loop will never be executed. The third part of the for statement is the body of the loop. These are the instructions that are repeated each time the program executes the loop. The final part of the for statement is an increment expression that automatically executes after each repetition of the loop body. Typically, this statement changes the value of the counter, which is then tested to see if the loop should continue.
All the sections in the for-header are optional. Any one of them can be left empty, but the two semicolons are mandatory. In particular, leaving out the <loop condition> signifies that the loop condition is true. The (;;) form of for loop is commonly used to construct an infinite loop.
Below is an example that demonstrates the looping construct namely for loop used to print numbers from 1 to 10.
public class ForLoopDemo {
 
      public static void main(String[] args) {
            System.out.println("Printing Numbers from 1 to 10");
            for (int count = 1; count <= 10; count++) {
                  System.out.println(count);
            }
      }
}
Output
Printing Numbers from 1 to 10
1
2
3
4
5
6
7
8
9
10
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

 

Transfer Statements:

Continue Statement:
A continue statement stops the iteration of a loop (while, do or for) and causes execution to resume at the top of the nearest enclosing loop. You use a continue statement when you do not want to execute the remaining statements in the loop, but you do not want to exit the loop itself.
The syntax of the continue statement is
continue; // the unlabeled form
continue <label>; // the labeled form
You can also provide a loop with a label and then use the label in your continue statement. The label name is optional, and is usually only used when you wish to return to the outermost loop in a series of nested loops.
Below is a program to demonstrate the use of continue statement to print Odd Numbers between 1 to 10.
public class ContinueExample {
 
      public static void main(String[] args) {
            System.out.println("Odd Numbers");
            for (int i = 1; i <= 10; ++i) {
                  if (i % 2 == 0)
                        continue;
                  // Rest of loop body skipped when i is even
                  System.out.println(i + "\t");
            }
      }
}
Output
Odd Numbers
1
3
5
7
9
Break Statement:
The break statement transfers control out of the enclosing loop ( for, while, do or switch statement). You use a break statement when you want to jump immediately to the statement following the enclosing control structure. You can also provide a loop with a label, and then use the label in your break statement. The label name is optional, and is usually only used when you wish to terminate the outermost loop in a series of nested loops.
The Syntax for break statement is as shown below;
break; // the unlabeled form
break <label>; // the labeled form
Below is a program to demonstrate the use of break statement to print numbers Numbers 1 to 10.
public class BreakExample {
 
      public static void main(String[] args) {
            System.out.println("Numbers 1 - 10");
            for (int i = 1;; ++i) {
                  if (i == 11)
                        break;
                  // Rest of loop body skipped when i is even
                  System.out.println(i + "\t");
            }
      }
}
Output
Numbers 1 - 10
1
2
3
4
5
6
7
8
9
10

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

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());
        }
}
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 Constructor:
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);
<font size=-1>

               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
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,
<br /><font size=-1>

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
Java Inheritance:
Java Inheritance defines an is-a relationship between a superclass and its subclasses. This means that an object of a subclass can be used wherever an object of the superclass can be used. Class Inheritance in java mechanism is used to build new classes from existing classes. The inheritance relationship is transitive: if class x extends class y, then a class z, which extends class x, will also inherit from class y.
For example a car class can inherit some properties from a General vehicle class. Here we find that the base class is the vehicle class and the subclass is the more specific car class. A subclass must use the extends clause to derive from a super class which must be written in the header of the subclass definition. The subclass inherits members of the superclass and hence promotes code reuse. The subclass itself can add its own new behavior and properties. The java.lang.Object class is always at the top of any Class inheritance hierarchy.
class Box {

        double width;
        double height;
        double depth;
        Box() {
        }
        Box(double w, double h, double d) {
               width = w;
               height = h;
               depth = d;
        }
        void getVolume() {
               System.out.println("Volume is : " + width * height * depth);
        }
}

public class MatchBox extends Box {

        double weight;
        MatchBox() {
        }
        MatchBox(double w, double h, double d, double m) {
               super(w, h, d);
<font size=-1>

               weight = m;
        }
        public static void main(String args[]) {
               MatchBox mb1 = new MatchBox(10, 10, 10, 10);
               mb1.getVolume();
               System.out.println("width of MatchBox 1 is " + mb1.width);
               System.out.println("height of MatchBox 1 is " + mb1.height);
               System.out.println("depth of MatchBox 1 is " + mb1.depth);
               System.out.println("weight of MatchBox 1 is " + mb1.weight);
        }
}
Output
Volume is : 1000.0
width of MatchBox 1 is 10.0
height of MatchBox 1 is 10.0
depth of MatchBox 1 is 10.0
weight of MatchBox 1 is 10.0
Download MatchBox.java
What is not possible using java class Inheritance?
1. Private members of the superclass are not inherited by the subclass and can only be indirectly accessed.
2. Members that have default accessibility in the superclass are also not inherited by subclasses in other packages, as these members are only accessible by their simple names in subclasses within the same package as the superclass.
3. Since constructors and initializer blocks are not members of a class, they are not inherited by a subclass.
4. A subclass can extend only one superclass
class Vehicle {

        // Instance fields
        int noOfTyres; // no of tyres
        private boolean accessories; // check if accessorees present or not
        protected String brand; // Brand of the car
        // Static fields
        private static int counter; // No of Vehicle objects created
        // Constructor
        Vehicle() {
               System.out.println("Constructor of the Super class called");
               noOfTyres = 5;
               accessories = true;
               brand = "X";
               counter++;
        }
        // Instance methods
        public void switchOn() {
               accessories = true;
        }
        public void switchOff() {
               accessories = false;
        }
        public boolean isPresent() {
               return accessories;
        }
        private void getBrand() {
               System.out.println("Vehicle Brand: " + brand);
        }
        // Static methods
        public static void getNoOfVehicles() {
               System.out.println("Number of Vehicles: " + counter);
        }
}

class Car extends Vehicle {

        private int carNo = 10;
        public void printCarInfo() {
               System.out.println("Car number: " + carNo);
               System.out.println("No of Tyres: " + noOfTyres); // Inherited.
               //  System.out.println("accessories: "    + accessories); // Not Inherited.
               System.out.println("accessories: " + isPresent()); // Inherited.
               //        System.out.println("Brand: "     + getBrand());  // Not Inherited.
               System.out.println("Brand: " + brand); // Inherited.
               //  System.out.println("Counter: "    + counter);     // Not Inherited.
               getNoOfVehicles(); // Inherited.
        }
}

public class VehicleDetails { // (3)

        public static void main(String[] args) {
               new Car().printCarInfo();
        }
}
Output
Constructor of the Super class called
Car number: 10
No of Tyres: 5
accessories: true
Brand: X
Number of Vehicles: 1
Download VehicleDetails.java
this and super keywords
The two keywords, this and super to help you explicitly name the field or method that you want. Using this and super you have full control on whether to call a method or field present in the same class or to call from the immediate superclass. This keyword is used as a reference to the current object which is an instance of the current class. The keyword super also references the current object, but as an instance of the current class’s super class.
The this reference to the current object is useful in situations where a local variable hides, or shadows, a field with the same name. If a method needs to pass the current object to another method, it can do so using the this reference. Note that the this reference cannot be used in a static context, as static code is not executed in the context of any object.
class Counter {

        int i = 0;
        Counter increment() {
               i++;
               return this;
        }
        void print() {
               System.out.println("i = " + i);
        }
}

public class CounterDemo extends Counter {

        public static void main(String[] args) {
               Counter x = new Counter();
               x.increment().increment().increment().print();
        }
}
Output
Volume is : 1000.0
width of MatchBox 1 is 10.0
height of MatchBox 1 is 10.0
depth of MatchBox 1 is 10.0
weight of MatchBox 1 is 10.0
Download CounterDemo.java

Object Reference Type Casting

In java object typecasting one object reference can be type cast into another object reference. The cast can be to its own class type or to one of its subclass or superclass types or interfaces. There are compile-time rules and runtime rules for casting in java.
How to Typecast Objects with a dynamically loaded Class ? - The casting of object references depends on the relationship of the classes involved in the same hierarchy. Any object reference can be assigned to a reference variable of the type Object, because the Object class is a superclass of every Java class.
There can be 2 casting java scenarios
· Upcasting
· Downcasting

When we cast a reference along the class hierarchy in a direction from the root class towards the children or subclasses, it is a downcast. When we cast a reference along the class hierarchy in a direction from the sub classes towards the root, it is an upcast. We need not use a cast operator in this case.
The compile-time rules are there to catch attempted casts in cases that are simply not possible. This happens when we try to attempt casts on objects that are totally unrelated (that is not subclass super class relationship or a class-interface relationship) At runtime a ClassCastException is thrown if the object being cast is not compatible with the new type it is being cast to.
<br /><font size=-1>
Below is an example showing when a ClassCastException can occur during object casting
//X is a supper class of Y and Z which are sibblings.
public class RunTimeCastDemo {
 
        public static void main(String args[]) {
               X x = new X();
               Y y = new Y();
               Z z = new Z();
               X xy = new Y(); // compiles ok (up the hierarchy)
               X xz = new Z(); // compiles ok (up the hierarchy)
               //             Y yz = new Z();   incompatible type (siblings)
               //             Y y1 = new X();   X is not a Y
               //             Z z1 = new X();   X is not a Z
               X x1 = y; // compiles ok (y is subclass of X)
               X x2 = z; // compiles ok (z is subclass of X)
               Y y1 = (Y) x; // compiles ok but produces runtime error
               Z z1 = (Z) x; // compiles ok but produces runtime error
               Y y2 = (Y) x1; // compiles and runs ok (x1 is type Y)
               Z z2 = (Z) x2; // compiles and runs ok (x2 is type Z)
               //             Y y3 = (Y) z;     inconvertible types (siblings)
                //             Z z3 = (Z) y;     inconvertible types (siblings)
               Object o = z;
               Object o1 = (Y) o; // compiles ok but produces runtime error
        }
}
Download ClassCastException example Source Code

Casting Object References: Implicit Casting using a Compiler

In general an implicit cast is done when an Object reference is assigned (cast) to:
* A reference variable whose type is the same as the class from which the object was instantiated.
An Object as Object is a super class of every Class.
* A reference variable whose type is a super class of the class from which the object was instantiated.
* A reference variable whose type is an interface that is implemented by the class from which the object was instantiated.
* A reference variable whose type is an interface that is implemented by a super class of the class from which the object was instantiated.
Consider an interface Vehicle, a super class Car and its subclass Ford. The following example shows the automatic conversion of object references handled by the compiler
interface Vehicle {
}
class Car implements Vehicle {
}
class Ford extends Car {
}
Let c be a variable of type Car class and f be of class Ford and v be an vehicle interface reference. We can assign the Ford reference to the Car variable:
I.e. we can do the following
Example 1
c = f; //Ok Compiles fine
Where c = new Car();
And, f = new Ford();
The compiler automatically handles the conversion (assignment) since the types are compatible (sub class - super class relationship), i.e., the type Car can hold the type Ford since a Ford is a Car.
Example 2
v = c; //Ok Compiles fine
c = v; // illegal conversion from interface type to class type results in compilation error
Where c = new Car();
And v is a Vehicle interface reference (Vehicle v)
The compiler automatically handles the conversion (assignment) since the types are compatible (class – interface relationship), i.e., the type Car can be cast to Vehicle interface type since Car implements Vehicle Interface. (Car is a Vehicle).
Casting Object References: Explicit Casting
Sometimes we do an explicit cast in java when implicit casts don’t work or are not helpful for a particular scenario. The explicit cast is nothing but the name of the new “type” inside a pair of matched parentheses. As before, we consider the same Car and Ford Class
class Car {
void carMethod(){
}
}
class Ford extends Car {
void fordMethod () {
}
}
We also have a breakingSystem() function which takes Car reference (Superclass reference) as an input parameter.
The method will invoke carMethod() regardless of the type of object (Car or Ford Reference) and if it is a Ford object, it will also invoke fordMethod(). We use the instanceof operator to determine the type of object at run time.
public void breakingSystem (Car obj) {
obj.carMethod();
if (obj instanceof Ford)
((Ford)obj).fordMethod ();
}
To invoke the fordMethod(), the operation (Ford)obj tells the compiler to treat the Car object referenced by obj as if it is a Ford object. Without the cast, the compiler will give an error message indicating that fordMethod() cannot be found in the Car definition.

The following program shown illustrates the use of the cast operator with references.
Note: Classes Honda and Ford are Siblings in the class Hierarchy. Both these classes are subclasses of Class Car. Both Car and HeavyVehicle Class extend Object Class. Any class that does not explicitly extend some other class will automatically extends the Object by default. This code instantiates an object of the class Ford and assigns the object’s reference to a reference variable of type Car. This assignment is allowed as Car is a superclass of Ford. In order to use a reference of a class type to invoke a method, the method must be defined at or above that class in the class hierarchy. Hence an object of Class Car cannot invoke a method present in Class Ford, since the method fordMethod is not present in Class Car or any of its superclasses. Hence this problem can be colved by a simple downcast by casting the Car object reference to the Ford Class Object reference as done in the program. Also an attempt to cast an object reference to its Sibling Object reference produces a ClassCastException at runtime, although compilation happens without any error.
 
class Car extends Object {
 
      void carMethod() {
      }
}
 
class HeavyVehicle extends Object {
}
 
class Ford extends Car {
 
      void fordMethod() {
            System.out.println("I am fordMethod defined in Class Ford");
      }
}
 
class Honda extends Car {
 
      void fordMethod() {
            System.out.println("I am fordMethod defined in Class Ford");
      }
}
 
public class ObjectCastingEx {
 
      public static void main(String[] args) {
            Car obj = new Ford();
            //    Following will result in compilation error
            //    obj.fordMethod(); //As the method fordMethod is undefined for the Car Type
            //  Following will result in compilation error
            // ((HeavyVehicle)obj).fordMethod();
                               //fordMethod is undefined in the HeavyVehicle Type
            //  Following will result in compilation error
            ((Ford) obj).fordMethod();
            //Following will compile and run
            //    Honda hondaObj = (Ford)obj;    Cannot convert as they are sibblings
      }
}
Download Object Reference Casting Source Code
One common casting that is performed when dealing with collections is, you can cast an object reference into a String.
import java.util.Vector;
 
public class StringCastDemo {
 
        public static void main(String args[]) {
               String username = "asdf";
               String password = "qwer";
               Vector v = new Vector();
               v.add(username);
               v.add(password);
               //               String u = v.elementAt(0); Cannot convert from object to String
               Object u = v.elementAt(0); //Cast not done
               System.out.println("Username : " + u);
               String uname = (String) v.elementAt(0); // cast allowed
               String pass = (String) v.elementAt(1); // cast allowed
               System.out.println();
               System.out.println("Username : " + uname);
               System.out.println("Password : " + pass);
        }
}

Download
Object String Casting Source Code
Output
Username : asdf
Username : asdf
Password : qwer

instanceof Operator

The instanceof operator is called the type comparison operator, lets you determine if an object belongs to a specific class, or implements a specific interface. It returns true if an object is an instance of the class or if the object implements the interface, otherwise it returns false.
Below is an example showing the use of instanceof operator
class Vehicle {
 
        String name;
        Vehicle() {
               name = "Vehicle";
        }
}
 
class HeavyVehicle extends Vehicle {
 
        HeavyVehicle() {
               name = "HeavyVehicle";
        }
}
 
class Truck extends HeavyVehicle {
 
        Truck() {
               name = "Truck";
        }
}
 
class LightVehicle extends Vehicle {
 
        LightVehicle() {
               name = "LightVehicle";
        }
}
 
public class InstanceOfExample {
 
        static boolean result;
        static HeavyVehicle hV = new HeavyVehicle();
        static Truck T = new Truck();
        static HeavyVehicle hv2 = null;
        public static void main(String[] args) {
               result = hV instanceof HeavyVehicle;
               System.out.print("hV is an HeavyVehicle: " + result + "\n");
               result = T instanceof HeavyVehicle;
               System.out.print("T is an HeavyVehicle: " + result + "\n");
               result = hV instanceof Truck;
               System.out.print("hV is a Truck: " + result + "\n");
               result = hv2 instanceof HeavyVehicle;
               System.out.print("hv2 is an HeavyVehicle: " + result + "\n");
               hV = T; //Sucessful Cast form child to parent
               T = (Truck) hV; //Sucessful Explicit Cast form parent to child
        }
}
Download instanceof operator Source Code
Output
hV is an HeavyVehicle: true
T is an HeavyVehicle: true
hV is a Truck: false
hv2 is an HeavyVehicle: false
Note: hv2 does not yet reference an HeavyVehicle object, instanceof returns false. Also we can’t use instanceof operator with siblings

Abstract Class in java

Java Abstract classes are used to declare common characteristics of subclasses. An abstract class cannot be instantiated. It can only be used as a superclass for other classes that extend the abstract class. Abstract classes are declared with the abstract keyword. Abstract classes are used to provide a template or design for concrete subclasses down the inheritance tree.
Like any other class, an abstract class can contain fields that describe the characteristics and methods that describe the actions that a class can perform. An abstract class can include methods that contain no implementation. These are called abstract methods. The abstract method declaration must then end with a semicolon rather than a block. If a class has any abstract methods, whether declared or inherited, the entire class must be declared abstract. Abstract methods are used to provide a template for the classes that inherit the abstract methods.
Abstract classes cannot be instantiated; they must be subclassed, and actual implementations must be provided for the abstract methods. Any implementation specified can, of course, be overridden by additional subclasses. An object must have an implementation for all of its methods. You need to create a subclass that provides an implementation for the abstract method.
A class abstract Vehicle might be specified as abstract to represent the general abstraction of a vehicle, as creating instances of the class would not be meaningful.
<br /><font size=-1>
abstract class Vehicle {
 
      int numofGears;
      String color;
      abstract boolean hasDiskBrake();
      abstract int getNoofGears();
}
Example of a shape class as an abstract class
abstract class Shape {
 
      public String color;
      public Shape() {
      }
      public void setColor(String c) {
            color = c;
      }
      public String getColor() {
            return color;
      }
      abstract public double area();
}
We can also implement the generic shapes class as an abstract class so that we can draw lines, circles, triangles etc. All shapes have some common fields and methods, but each can, of course, add more fields and methods. The abstract class guarantees that each shape will have the same set of basic properties. We declare this class abstract because there is no such thing as a generic shape. There can only be concrete shapes such as squares, circles, triangles etc.
public class Point extends Shape {
 
        static int x, y;
        public Point() {
               x = 0;
               y = 0;
        }
        public double area() {
               return 0;
        }
        public double perimeter() {
               return 0;
        }
        public static void print() {
               System.out.println("point: " + x + "," + y);
        }
        public static void main(String args[]) {
               Point p = new Point();
               p.print();
        }
}
Output
point: 0, 0
Notice that, in order to create a Point object, its class cannot be abstract. This means that all of the abstract methods of the Shape class must be implemented by the Point class.
The subclass must define an implementation for every abstract method of the abstract superclass, or the subclass itself will also be abstract. Similarly other shape objects can be created using the generic Shape Abstract class.
A big Disadvantage of using abstract classes is not able to use multiple inheritance. In the sense, when a class extends an abstract class, it can’t extend any other class.











Post a Comment