Sie sind auf Seite 1von 168

cc 

‡ Object Oriented Programming Structure


‡ Features of OOPS
 Objects / Instance
 Classes
 Inheritance
 Polymorphism
‡ Overloading / Static Polymorphism / Compile-
time polymorphism
‡ Overriding / Dynamic polymorphism / Run-time
polymorphism
 Encapsulation
 Abstraction
cc 

‡ Objects ± Real time entity


‡ Classes ± Blueprint of an object. It gives
structure to the objects
‡ Inheritance ± Deriving base class properties
and behaviour to the child class
‡ Polymorphism - One object in different forms
‡ Encapsulation - Hiding the irrelevant details to
the irrelevant entity
‡ Abstraction ± Revealing the relevant details to
the relevant entity.
¦ 

‡ The original name of Java was Oak, and it was


developed as a part of the Green project at Sun
Microsystems.
‡ Java was conceived by James Gosling, Patrick
Naughton, Chris Warth, Ed Frank, and Mike
Sheridon at Sun Microsystems in 1991.
‡ Sun formally announced the Java SunWorld in
1995.
O   

‡ Object Oriented Programming language


‡ Platform Independent
‡ Robust
‡ Portable
‡ Scalable
‡ Multithreaded
‡ Architecturally neutral
‡ Secured
d 

‡ JDK ± Java Development Kit


‡ JRE ± Java Run-time Environment
‡ JVM - Java Virtual Machine

    

The Java Virtual Machine provides a platform-


independent way of executing code, by abstracting the
differences between operating systems and CPU
architectures.

JVM is Write Once-Run Anywhere (WORA) software.

JVM forms part of large system JRE.

JVM's main job is interpreting java byte code and


translating this into actions or OS calls.

 JVM is OS dependent which makes java source code as


machine independent.
  
 O   cc 

‡ Classes - Classification
‡ Encapsulation - maintainability, flexibility and
extensibility.
‡ Polymorphism ± one method will behave
differently.
‡ Inheritance ± Reusability, Easier updates, Do
not break what is already working.
      

‡ Package declaration;
‡ Import statements
‡ Class declaration
{
Variable declaration/ definition;
method declaration / definition;
}
  

‡ class <classname>
{
public static void main(String[] args)
{
// Object instantiation
<classname> m = new <classname>();
}
}
d  d  d
 

‡ Variables - myVariable
‡ Method - myMethod()
‡ Class - MyClass
‡ Package - mypackage
‡ Constants - MYCONSTANT
Ô   

‡ Local variable (variable inside method or block)


‡ Class Variable (Static Variable)
‡ Instance Variable ( variable inside the class)

Note:
‡ Local variables require explicit initialization.
‡ Instance variables are initialized automatically.
       
Ñ   Ñ 
‡ byte 0
‡ short 0
‡ int 0
‡ long 0L
‡ float 0.0F
‡ double 0.0D
‡ char '\u0000'
‡ boolean false
‡ All reference types null
d 

‡ It is a Spl. Method
‡ Purpose: To initialize the class members
‡ Features:
 Same name as that of the class name
 No return type including VOID
 Can have access specifier
 Can be overloaded
 Constructors are NOT inherited
 Invoked automatically whenever the object is
created.
 The no. of time of invocation depends on no. of
object created
 

‡ Group data objects of the same type, in a


contiguous block of memory.
‡ An array is an object; it is created with new.
‡ Can be declared as a primitive type or Class
type.
‡ Array index starts with 0.
‡ You cannot resize an array.
‡ You can use the same reference variable to
refer to an entirely new array.
      
   
‡ Array declaration
<element type>[] <array name>;

int[] myArray;
‡ Constructing an array
·array name> =
new ·element type> [·array size>];

myArray = new int[5];


       

‡ Explicit initialization in one line.


<element type>[] <array name> =
{ <array initialize list> };

Primitive array:
*****************
int[] myArray = { 1 , 2 , 3 , 4 , 5 } ;

Reference Array:
********************
Object[] objArr = { new Pizza(), new Pizza(), null };
       

‡ Explicit initialization can also be done using


array subscripts.
int[] myArray = new int[3];
myArray [0] = 10;
myArray [1] = 20;
myArray [2] = 30;
   
‡ Deriving the parent class properties and
methods to the child class.
‡ Types of inheritance:
 Single level inheritance
- one super and one sub class
 Multilevel inheritance
- The sub class of one level forms the super
class of another level
 Multiple inheritance [ not supported by java]
- many super and one sub class
 Hierarchical inheritance
- one super and many sub classes
 Hybrid inheritance
- multiple and multi level combined.
   

‡ Two important concepts


 Generalization - Up the hierarchy
 Specialization - Down the hierarchy
‡ Purpose : Reusability (without changing its
identity)
‡ Syntax:
<modifier> class <name>  
<superclass>
{
<declaration>*
}
 ¦      

‡ When you want to know if one thing should


extend another, use the IS-A test.
Eg : Triangle IS-A Shape
‡ Do not apply inheritance if the subclass and
super class do not pass the IS-A test.
‡ Is-a relationship can be described in Java
keyword extends.
‡ The IS-A relationship ± Unidirectional
 ¦      

‡ When two classes are related, but not through


inheritance, (for example, one class has a
reference to another class) then you say that
the two classes are joined by HAS-A
relationship.
‡ Has-a relationship can be described in Java
code as member fields.
Note:
‡ Code reuse is also best achieved by
aggregation when there is no is-a relationship
 ¦      

‡ class Car
{
}
class BMW extends Car => IS-A R/S
{
boolean auto_gear = ³true´ => Has-A R/S
}
 

‡ Polymorphism (from Greek, meaning ³many


forms´) is a feature that allows one interface to
be used for a general class of actions that is
one interface with multiple methods.
‡ Types:
 Overloading => Ad-Hoc Polymorphism
- Same method name with different set of
parameters.
- Early Binding
 Overriding => True polymorphism
- Same method name with same set of parameters.
- Late Binding
Ô c
  

‡ Function Overloading
‡ Constructor Overloading
‡ NO operator Overloading in Java

‡ Rules :
 No. of parameter should change
 Datatype of the parameter should change
 Sequence of passing the paramter should
change.
c
  
‡ The overridden method in the superclass is NOT inherited by
the subclass, and the new method in the subclass must
uphold the following rules of method overriding:
 The new method definition must have the same method
signature (i.e., method name and parameters) and the
same return type.
 Overridden Methods Cannot Be Less Accessible.
‡ A subclass cannot override fields of the superclass, but it can
hide them.
‡ Works only with inheritance.
‡ Constructors cant be Overridden.
‡ Super keyword is used to invoke an overridden method in the
superclass.
     
 
‡ this() construct is used to implement local chaining of
constructors in the class when an instance of the class is
created.
‡ The this() call invokes the constructor with the
corresponding parameter list.
‡ super() method is used to invoke the IMMEDIATE base
class constructor. This allows the subclass to influence
the initialization of its inherited state when an object of
the subclass is created.
‡ this() and super() call must occur as the `   


 
 
  !    
class GParent
{
int a,b,c;
GParent() {
System.out.println("From gparent");
}

GParent(int a,int b) {
//this(a,b,100);
this();
System.out.println("a= "+a+" b = "+ b);
}

GParent(int a,int b,int c) {


this.a=a;
this.b=b;
this.c=c;
System.out.println("a= "+a+" b = "+ b + " c= " +c);
}
}
  !    

class Parent extends GParent


{
int x,y;
Parent()
{
System.out.println("From parent");
}

Parent(int x,int y)
{
super(x,y);
this.x=x;
this.y = y;
System.out.println("x= "+x+" y = "+ y);
}

}
  !    
class Child extends Parent
{
Child()
{
super(23,343);
System.out.println("From child");
}

}
class SuperEx
{
public static void main(String[] a)
{
//Parent p = new Parent(12,23);
Child d = new Child();

}
    

‡ Use instanceof to test the type of an object.


‡ Restore full functionality of an object by casting.
‡ Example:
public void doSomething(Employee e) {
if ( e instanceof Manager )
{
G
 G

}
// rest of operation
}
  " #

‡ It¶s a Access Modifier


‡ The static keyword is used as a modifier on
variables, methods, and nested classes.
‡ The static keyword declares the attribute or
method is associated with the class as a whole
rather than any particular instance of that class.
‡ Thus static members are often called class
members, such as class attributes or class
methods.
  " #

‡ A static method can access only the static


variable. But the normal variable can access
both static and normal variable.
‡ Static members will get loaded into the memory
only once.
‡ Static members are subjected to change
common for all the instance.
‡ NO NEED FOR OBJECT to access the static
member.
      
class StatEx
{
int i=10;
static int j = 20;

public void normalMethod()


{
System.out.println("Instance var = " + i++);
System.out.println("Static var = " + j++);
}

public static void main(String arg[])


{
StatEx s1 = new StatEx();
StatEx s2 = new StatEx();
s1.normalMethod();
s2.normalMethod();
}
}
    
class StatEx
{
int i=10;
static int j = 20;

public static void staticMethod()


{
//System.out.println("Instance var = " + i++); //illegal
System.out.println("Static var = " + j++);
}

public static void main(String arg[])


{
staticMethod();
staticMethod();
}
}
       
class StatEx1
{
static int counter;

//static initializer
static
{
counter=10;
System.out.println("Static block invoked "+counter);
}
public static void sMethod()
{
System.out.println("Static method" + counter++);
}

}
       

class StatEx
{
public static void main(String arg[])
{
System.out.println("from main");
StatEx1.sMethod();
StatEx1.sMethod();
}
}
O  " #

‡ Variable become Constant


‡ Method cant be Overridden
‡ Class cant be inherited

‡ Note:
 All final variable need Explicit initialization
u  d 

‡ Conversion of primitive types to the object


equivalent done through wrapper classes.
‡ Allow objects to be created from primitive types.
‡ Wrapped values are immutable (Cant modify) .
To wrap another value, you need to create
another object.
‡ Wrapper class are present in java.lang package
‡ All the wrapper classes are declared final.
  
  Ô  
d  u  d  
‘ 
        
    


 
 
  

   

       

    

    

     

    

All the wrapper classes except x  


 are
subclasses of an abstract class called  , whereas
x  
 are derived directly from the 

class.
x  $ 

‡ Converting a value type to a reference type is


known as Boxing.
‡ Converting a reference type to a value type is
known as UnBoxing.

int x=10;
Integer n = new Integer(x); //Boxing
int y = n.intValue(); //UnBoxing
x   $ 

Example:

int x=10;
Integer n = x; //AutoBoxing
int y = n; //AutoUnBoxing
    u  
 
G  


Ñ  

  Ñ     

  Ñ    



 

    Ñ    

 



Ñ    

 



Ñ    

 

` ` Ñ    

 

  Ñ    

 

 d
 
  
Ô 
u  G  
 G  ! 



Boolean static boolean parseBoolean(«) String


Character Not available
Byte static byte parseByte(«) String, or String and radix
Short static short parseShort(..) String, or String and radix
Integer static int parseInt(«) String, or String and radix
Long static long parseLong(«) String, or String and radix
Float static float parseFloat(«) String
Double static double parseDouble(«) double or String
u  d
  
‡ Primitive xxxValue()
 To convert Wrapper to primitive

‡ Primitive parseXxx(String)
 To convert a String to a primitive

‡ Wrapper valueOf(String)
 To convert a String to a Wrapper
c% d 

‡ Root class of Java => Object


‡ equals() method = > Check only values
‡ toString() method =>Check value & reference
‡ hashCode() => return the address of the object

‡ Object Class is in java.lang package.


 d 
‡ Class which have a abstract method (method
without definition) is abstract class.
‡ Can have normal method and variable
‡ Cant be instantiated
‡ Methods may or may not be implemented by
the child class.
‡ Use abstract keyword to declare a class as
abstract.
‡ Abstract method cannot be private or final
‡ A class can inherit only one abstract class.
‡ NEED RELATIONSHIP between classes
  
‡ Interface is to support multiple inheritance in
Java.
‡ Interfaces should be implemented by the child
class
‡ Can have only abstract method.
‡ Interface contain only constants.NO Variables.
‡ All the fields are public static final in nature.
‡ Interfaces cant be instantiated
‡ A class can implement many interfaces.
‡ All the methods should be implemented by the
child class.
‡ NO NEED FOR RELATIONSHIP
 

‡ Assigning a integral constant to a symbolic


name => enum
‡ Use enum when you want a variable to hold
only a predetermined set of values.
‡ You use the keyword enum and not class to
declare an enum.
‡ Just like a class, an enum can have
constructors, methods, and fields.
‡ An enum cannot be declared within a method.
‡ You cannot instantiate an enum with the new
operator.
 

‡ The enums do not participate in class hierarchy:


they cannot extend and they cannot be
extended.
‡ You cannot directly call an enum constructor.
‡ An enum may have a main() method and
therefore can be executed by name from the
command line like an application.
   

enum Edge
{
TOP,BOTTOM,LEFT,RIGHT
};

class MyClass
{
public static void main(String[] a)
{
Edge e = Edge.TOP;
int i = e.ordinal();
System.out.println(e);
System.out.println(i);
}
}
   

enum Edge
{
TOP,BOTTOM,LEFT,RIGHT;

public static void main(String[] a)


{
Edge e = Edge.TOP;
int i = e.ordinal();
System.out.println(e);
System.out.println(i);
}
}
   
public enum Day
{

MONDAY(8,true),
TUESDAY(8,true),
WEDNESDAY(8,true),
THURSDAY(8,true),
FRIDAY(8,true),
SATURDAY(4,false),
SUNDAY(0,false);

private int hours;


private boolean weekday;
   
Day(int whours,boolean wday)
{
hours=whours;
wday=weekday;
}

public int getHours()


{
return hours;
}

public boolean isWeekDay()


{
return weekday;
}
   

public static void showDay(Day d)


{
if(d.isWeekDay())
{
System.out.println(d +" is a weekday and has "+
d.getHours() +" hours working hours");
}
else
{
System.out.println(d +" is a not weekday and has
"+ d.getHours() +" hours working hours");
}
}
   

public static void main(String[] ar)


{
Day day;
day = Day.SUNDAY;
showDay(day);
}

}
 d 
‡ A class that is declared within another class or
interface, is called a nested class.
‡ There are four categories of nested classes
 egular class - class within the class
 Method-local class ± class within the method of
the outer class
 Static nested class - inner classes marked with
the static modifier (top-level nested class)
 Anonymous class - part of a method argument.
‡ All inner classes are nested classes, but not all
nested classes are inner classes.
      d 
class MyOuter
{
int x =7;
class MyInner
{
public void InnerMethod()
{
System.out.println("x == " + x);
}
}
public void OuterMethod()
{
MyInner inn = new MyInner();
inn.InnerMethod();
}
      d 

public static void main(String[] a)


{
MyOuter mo = new MyOuter();
MyOuter.MyInner mi = mo.new MyInner();
mi.InnerMethod();
mo.OuterMethod();
//mi.OuterMethod(); illegal
//mo.InnerMethod(); illegal

}
     

‡ A method-local inner class can be instantiated


only within the method where the inner class is
defined.
‡ Can access the outer class level variable.
‡ CANT access the variable inside the method in
which the inner class is created except a final
variable.
‡ Method-local inner class can be declared
abstract and final.
‡ method-local inner class can't use any access
specifiers.
     
class MouterClass
{
int x =10;
public void OuterMethod()
{
final int j=90;
class MinnerClass
{
public void minnerMethod()
{
System.out.println("Hello ..." + x + j);
}
}
MinnerClass mic = new MinnerClass();
mic.minnerMethod();
}
public static void main(String[] a)
{
MouterClass moc = new MouterClass();
moc.OuterMethod();
}
}
     

‡ Static nested classes are inner classes marked


with the static modifier.
‡ A static nested class is not an inner class, it's a
top-level nested class.
‡ A static nested class cannot access non-static
members of the outer class.
     
class OuterClass
{
static int i =10;
public void method()
{
System.out.println("i == " + ++i);
}
static class InnerClass
{
public void display()
{
System.out.println("i == " + i);
}
}
     

public static void main(String[] a)


{
OuterClass.InnerClass ic = new
OuterClass.InnerClass();
ic.display();

OuterClass oc = new OuterClass();


oc.method();
}
}
  d  

‡ Anonymous inner classes have no name.


‡ Anonymous inner classes cannot have
constructor.
  d  
import java.awt.*;
import java.awt.event.*;
class FrameExample
{
private Frame f;
public FrameExample()
{
f = new Frame("Hello .....!");
}
public void launchFrame()
{
f.setSize(170,170);
f.setBackground(Color.blue);
f.setVisible(true);
  d  
// Add a window listener
f.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent evt)
{
System.exit(0);
}
}); //Anonymous Inner Classes

public static void main(String args[])


{
FrameExample f = new FrameExample();
f.launchFrame();
}
}
   ¦  
‡ An exception in Java is a signal that indicates
the occurrence of some important or
unexpected condition during execution.
‡ Error Types:
 happens due to problems originating from the
execution environment. (Error Class)
 happens due to problems originating inside the
application itself. (Exception Class)

‡ Exception Should be Handled or Thrown to the


exception handler.
   

‡ Errors (represented by subclasses of Error)


occur in the Java virtual machine (JVM) and not
in the application itself.
‡ The exceptions (represented by subclasses of
Exception), on the other hand, generally
originate from within the application.
‡ Types:
 Checked Exception
 Unchecked Exception
d &    

‡ Checked exceptions are generally related to


how the program interacts with its environment.
‡ This is the category of exceptions for which the
compiler checks (hence the name checked
exceptions) to ensure that your code is
prepared for them.
‡ The programmer is required to write code to
deal with checked exceptions. The compiler
checks that such code exists.
‡ It MUST be thrown programmatically or
Handled.
$ &    

‡ Occur due to program bugs.


‡ Runtime exceptions are not checked by the
compiler.
‡ Write the correct code to avoid the runtime
exceptions than write the code to catch them
but it is not illegal to catch them.
‡ Runtime exceptions and errors combined are
also called unchecked exceptions and they are
mostly thrown by the JVM.
Ô    d ¦  
Object

Throwable

Exception Error

Others« RuntimeException Others«

Others«
        
‡ Contains five keywords:
 try - catch ± throw - throws ± finally
Method throws ExceptionName{
try{
--risky code goes here
}catch(ExceptionClassName ObjectName){
-- Exception handler block code
throw Exception_Instance //Ducking it
}
finally{
-- cleanup your code goes here
}
}
    
‡ A try block should be followed by at least one catch
block.
‡ The code inside try block is called as protected code.
‡ Can have one or more catch block.
‡ If you have multiple catch block, make sure that the last
catch block contain the super most class in the hierarchy.
‡ You may also write an optional ³finally´ block. This block
contains code that is ALWAYS executed, either after the
³try´ block code, or after the ³catch´ block code.
‡ The catch block may or may not contain throw keyword.
‡ The try block can also be nested.
  
class PrintStack
{
public static void main(String args[])
{
int Num1= 30 , Num2 = 0;
try
{
int Num3=Num1/Num2;
}
catch(ArithmeticException obj)
{
System.out.println("Exception"+obj);
obj.printStackTrace();
}
}
}
      

‡ The Declare or Handle Rule


 ¦andle the exception by using the
try-catch-finally block.
‡ Declare that the code causes an exception by
using the throws clause.
‡ You do not need to declare runtime exceptions
or errors.
‡ You can choose to handle runtime exceptions.
     
 In any method that might throw an exception,
you may declare the method as ³throws´ that
exception, and thus avoid handling the exception
yourself
 Example
‡ public void myMethod throws IOException {
« normal code with some I/O
}
Ô# 
class UncheckedThrows
{
public void show() throws ArithmeticException
{
System.out.println("Hai I am not handled");
}

public static void main(String[] arg)


{
new UncheckedThrows().show();
}
}
 c
   
   
lThe overriding method can throw:
l No exceptions
l One or more of the exceptions thrown by the
overridden method.
l One or more subclasses of the exceptions
thrown by the overridden method.

l The overriding method cannot throw:


l Additional exceptions not thrown by the
overridden method.
l Super classes of the exceptions thrown by
the overridden method
$       

‡ Create User-Defined Exception as a Class that


EXTENDS Exception Class.
‡ Instantiate the created Exception and use it in
the catch block as a handler.
  
import java.io.*;

class MyException extends Exception


{
MyException()
{
System.out.println("UserDefined Error occured");
}

public String toString()


{
return "MyException thrown";
}
}
  '
class UserExceptions
{
public void valid()
{
try
{
String str1,str2;
BufferedReader br=new BufferedReader(new
InputStreamReader(System.in));
System.out.println("Enter Login id");
str1=br.readLine();
System.out.println("Enter password");
str2=br.readLine();
if(str1.equals(str2))
System.out.println("Hai welcome");
else
throw new MyException();
}
  '
catch(MyException e)
{
System.out.println("Sorry U r not a valid user" + e);
valid();
}
catch(IOException ioe){}
}

public static void main(String[] arg) throws IOException


{
UserExceptions e1=new UserExceptions();

e1.valid();
}

}
 d O 
‡ An object of the String class represents a string
of characters.
‡ The String class belongs to the java.lang
package, which does not require an import
statement.
‡ Like other classes, String has constructors and
methods.
‡ Unlike other classes, String has two operators,
+ and += (used for concatenation).
‡ String class is declare final , therefore
immutable.
A    

‡ are anonymous objects of the String class


‡ are defined by enclosing text in double quotes.
³This is a literal String´
‡ don¶t have to be constructed.
‡ can be assigned to String variables.
‡ can be passed to methods and constructors as
parameters.
‡ have methods you can call.
A     
66   
     
    

66  



    
     

66  



     
    
    

‡ Once created, a string cannot be changed:


none of its methods changes the string.
‡ Such objects are called immutable.
‡ Immutable objects are convenient because
several references can point to the same object
safely: there is no danger of changing an object
through one reference without the others being
aware of the change.

  c    

‡ Uses less memory


String word1 = "Java"; String word1 = ³Java";
String word2 = word1; String word2 = new String(word1);

word1 word1 ³Java"

³Java" word2 ³Java"


word2
Less efficient:
OK wastes memory
  
      

‡ Less efficient ² you need to create a new


string and throw away the old one even for
small changes.
String word = ³Java´;
char ch = Character.toUpperCase(word.charAt (0));
word = ch + word.substring (1);

word ³java"

³Java"
 

‡ An empty String has no characters. It¶s


length is 0.
String word1 = ""; Empty strings
String word2 = new String();

‡ Not the same as an uninitialized String.

private String errorMsg; G 


is

dd 

‡ Copy constructor creates a copy of an existing


String. Also rarely used.
‡ Not the same as an assignment.
Copy Constructor: Each variable points to a different copy of the String.

String word1 = new String(³Java´); word1 ³Java"


String word2 = new String(word);
word2 ³Java"
Assignment: Both variables point to the same String.

String word1 = ³Java´; word1


String word2 = word; ³Java"
word2
c d 

‡ Most other constructors take an array as a


parameter to create a String.

?  
    

  

‡ String index starts with 0 like arrays.


   d 

‡ char charAt(i) => Returns the char at position i.


‡ int length(); => Returns the number of
characters in the string.
‡ String substring() => Returns a substring object
‡ substring(i,k) substring(i)
³television".substring (2,5); ³television".substring (2);
   
›  ›
   d 
‡ indexOf() => returns the index position of the
character.
‡ equals()
‡ equalsIgnoreCase()
‡ compareTo()
‡ compareToIgnoreCase()
‡ trim()
‡ replace()
‡ toUpperCase()
‡ toLowerCase()
 x  d 

‡ String Buffers are mutable strings.


‡ StringBuffer is a final class.
‡ They can be created empty, from a string or
with a capacity. An empty StringBuffer is
created with 16-character capacity.
‡ Can grow dynamically in size without bounds.
   x  
‡ length()
‡ capacity()
‡ ensureCapacity()
‡ setLength()
‡ charAt()
‡ Append()
‡ setCharAt()
‡ Insert()
‡ deleteCharAt()
‡ replace()
‡ reverse()
 x  d 

‡ Same like StringBuffer Class


‡ StringBuilder¶s methods are not synchronized.
‡ StringBuilder methods should run faster than
StringBuffer methods.
d  
‡ A collection allows a group of objects to be
treated as a single unit.
‡ Arbitrary objects can be stored, retrieved, and
manipulated as elements of collections.
‡ Provided in the java.util package.
‡ The collections framework comprises three
main parts.
 Interfaces => Collection
 Classes => Collections
 Algorithms
Ô d     
lThe root of the hierarchy of the collections interfaces
is the Collection interface.
l There is another kind of collections called maps,
which are represented by the super interface Map.

Both a Map object and a Set collection cannot contain


duplicates data items.
while a List collection can contain duplicates.
Ô d     
 A collection has no special order and does
not reject duplicates. (java.util.Collection)
 A list is ordered and accept duplicates.
(java.util.List).
 A set has no special order but rejects
duplicates. (java.util.Set)
 A map supports searching on a key field,
values of which must be unique.
(java.util.Map)
d  d  

‡ ArrayList, LinkedList, and Vector are the


classes that implement the List interface.
‡ HashMap and HashTable are examples of
classes that implement the Map interface.
‡ HashSet and LinkedHashSet are examples of
classes that implement the Set interface.
A 
import java.util.*;
class ListExample {
public static void main(String[] args) {
List list = new ArrayList();
list.add("one");
list.add("second");
list.add("3rd");
list.add(new Integer(4));
list.add(new Float(5.0F));
list.add("second"); 66   
list.add(new Integer(4)); 66  

System.out.println(list);
}
}
 

import java.util.*;
class SetExample {
public static void main(String[] args) {
Set set = new HashSet();
set.add("one");
set.add("second");
set.add("3rd");
set.add(new Integer(4));
set.add(new Float(5.0F));
set.add("second"); 66  


set.add(new Integer(4)); 66  


System.out.println(set);
}
}
 
!"#   
‡ The storage associated with any one collection can be
implemented in many ways, but the Collections API
implements the four methods that are most widely used:
 Array: supports insertion, deletion, but growing the
store is more difficult.
 ArrayList: grow in number of elements. Search is
faster. But not insertion and deletion. Vector(provides
synchronization)
 Linked list: supports insertion, deletion, and growing
the store, but makes indexed access slower. Use
when insertions and deletions happen frequently.
 Tree: supports insertion, deletion, and growing the
list. Indexed access is slow, but searching is faster.
 ¦ash table: supports insertion, deletion, and growing
the store. Indexed access is slow, but searching is
particularly fast. ¦owever, hashing requires the use
of unique keys for storing data elements.
 d  
‡ HashSet :
 provides the faster access to a data item.
 no guarantee that the items will be ordered.
 does not offer synchronization.
‡ Tree Set:
 presents sorted data items.
 performance is not as good as ¦ashSet.
 does not offer synchronization.
‡ LinkedHashSet:
 Similar to ¦ashSet that maintains a doubly linked
list.
 It is an ordered collection, ordered by insertion,
but not sorted.
 does not offer synchronization
 d  
‡ HashTable:
 implementation is based on the hashtable data
structure.
 No ordering.
 implementation is synchronized
‡ HashMap:
 based on the hashtable data structure.
 No ordering
 allows null and is unsynchronized
‡ LinkedHashMap:
 maintains a doubly linked list.
‡ TreeMap:
 implements the SortedMap interface
 Sorted and unsynchronized.
 
`    &  ' 

(
!$ %   

ArrayList List Yes Ordered by index No


Not sorted

LinkedList List Yes Ordered by index No


Not sorted
Vector List Yes Ordered by index Yes
Not sorted
HashSet Set No Not ordered No
Not sorted
LinkedHashSet Set No Ordered by No
insertion
Not sorted
TreeSet Set No Sorted either by No
natural order or by
your comparison
rules
 
`    &  ' 

(
!$ %   

HashMap Map No Not ordered No


Not sorted

LinkedHashMap Map No Ordered No

Hashtable Map No Not ordered Yes


Not sorted

TreeMap Map No Sorted either by No


natural order or by
your comparison
rules
d   
   
  
  
‡ Advantages
 Can hold different types of objects.
 esizable
‡ Disadvantages
 Must cast to correct type
 Cannot do compile-time type checking.
0   

‡ For checking the type of object during the


compilation time.
‡ Enclose the type within angular brackets <>.
  d 

‡ The java.text.DateFormat class provides


several methods for formatting the date/time for
a default or a specific location, and yet you can
keep your code completely independent of the
locale conventions for months, days of the
week, days of the months, and so on.
‡ You create a locale object by using the Locale
class
  Ô 
‡ A process is a program that is currently
executing. Every process has at least one
thread running within it.
‡ Threads are referred to as lightweight
processes.
‡ A thread is a path of code execution through a
program, and each thread has its own local
variables, program counter (pointer to the
current instruction being executed), and
lifetime.
Ô 

‡ A thread is
 an object
‡ A thread is a flow of control
‡ A thread is a series of executed statements
‡ A thread is a nested sequence of method calls
  Ô     Ô & 

‡ G  )
 is a mechanism to run many
Heavyweight processes simultaneously in a
different address space so context switch or
intercommunication between processes is
much expensive.
‡ G   
 is a mechanism of running
various lightweight processes under single
process within its own space
‡ G  
 there will be more than one
processor and each thread will be handled by a
different processor.
d   Ô 

‡ By extending Thread class


‡ By implementing Runnable interface.
‡ Even a non-multithreaded program has one
thread of execution, called the main thread.
‡ Call the start() method to start the thread.
‡ When a thread is started, it calls the run()
method to make our thread to perform useful
work.
 !    
Ô  
class MyThread extends Thread
{
public void run()
{
// thread body of execution
}
}
‡ Creating thread:
MyThread thr1 = new MyThread();
‡ Start Execution:
thr1.start();
 !Ô 
        
class ClassName implements Runnable{
public void run()
{
// thread body of execution
}
}
‡ Creating Object:
ClassName myObject = new ClassName();
‡ Creating Thread Object:
Thread thr1 = new Thread( myObject );
‡ Start Execution:
thr1.start();
Ô   


‡ Thread scheduling is implementation


dependent and cannot be relied on to
act in the same way on every JVM
‡ The two approaches to scheduling are
 Preemptive - will be applied for thread with
highest and lowest priority
 Time-Sliced (ound-obin) Scheduling ± will be
applied when more than one thread has the
same priority.
Ô #    

Ô 
Ô

 




Ô 
Ô
Ô 
Ô Ô

V All threads are parts of a process hence communication


easier and simpler.
V Independent executables
Ô   
A thread can in one of several possible states:
1.Running
Currently running
In control of CPU
2.Ready to run
Can run but not yet given the chance
3.Resumed
Ready to run after being suspended or block
4.Suspended
Voluntarily allowed other threads to run
5.Blocked
Waiting for some resource or event to occur
Ô     
Why priorities?
Determine which thread receives CPU
control and gets to be executed first
Definition:
± Integer value ranging from 1 to 10
± Higher the thread priority ĺ larger chance
of being executed first

± Example:
Ɣ Two threads are ready to run
Ɣ First thread: priority of 5, already running
Ɣ Second thread = priority of 10, comes in while first
thread is running
Ô    

‡ Done in two ways


 To method
public synchronized void method()
{ }
 To block
synchronized(this)
{

}
u   

‡ Wait() and notify should be used to restrict the


thread before doing an operation without a
notification from the other thread.
‡ Should be used along with the synchronized
block
# 

‡ When a thread enters a wait state, it does


nothing until it is notified by another thread.
‡ It also gives up it¶s lock on the object when wait
is called.
 
!  "
# 
$66


%
 
‡ To awaken a thread, a different thread which
has a lock on the same object must call notify.
‡ When notify is called, the block that had the
lock on the object continues to have it¶s lock it
releases it.
 Ôa thread is awakened from its wait() and
can grab the lock and continue processing.
‡ There are two versions - notify() and notifyAll().
‡ Notify is safe only under 2 conditions:
 uhen only 1 thread is waiting, and thus
guaranteed to be awakened.
 uhen multiple threads are waiting on the same
condition, and it doesn¶t matter which one
awakens.
‡ In general, use notifyAll()
Ô 0 
‡ You can include thread in a set of threads by
adding it to an instance of ThreadGroup
‡ ThreadGroups can contain not only threads but
also other ThreadGroups.
  
‡ Semaphore is a synchronization mechanism,
which implements mutual exclusion among
processes to avoid race condition to access any
shared resource.
‡ Semaphore maintains a counter to implement
locking and unlocking. It avoids busy waiting. If
a critical section is in use, the calling process
will be removed from a run queue and put into a
sleep state.
‡ Java 5 comes with semaphore implementations
in the java.util.concurrent package so you don't
have to implement your own semaphores.
‡ !        $ * +
   
‡ Semaphores have two purposes
 Mutex: Ensure threads don¶t access critical
section at same time
 Scheduling constraints: Ensure threads
execute in specific order
‡ A semaphore is an IPC mechanism that is
implemented conceptually with at least these
two components
± a counter (int) variable
± a wait queue of processes
‡ And has at least these two operation
± ë  for the semaphore to be free (p)
± 2  that the semaphore is now free (v)
  

‡ The semaphore has at least these possible


states:
 Oree, or available, or not in use
 Not free, or unavailable, or in use
‡ Interpretation of the counter variable:
 If the counter is positive, then the semaphore is
free.
 If the counter is zero (or negative), then the
semaphore is in use (not free).
  
‡ Cases using a semaphore S
1. If a process does a wait (p) on S, and if the
semaphore is free, then S is decremented
(S.counter = S.counter ± 1;)
2. If a process does a wait (p) on S and if S is not
free, then the process is blocked and put in S¶s
wait queue.
3. If a process does a signal (v) on S and if there
is no process in the wait queue for S, then the
semaphore is set to free by incrementing its
counter (to positive).
4. If a signal (v) on S and there is a process in the
S queue, then the process at the head of the
queue is removed and unblocked (and can
continue to execute)
c 
‡ Usual Purpose: storing data to µnonvolatileµ
devices, e.g. harddisk
‡ Classes provided by package java.io
‡ Data is transferred to devices by µstreamsµ

output - stream
Program Device

input - stream
Program Device
&  
  
  
d $

  
   
 
 
   


¦
¦#    
¦#

 (
 
&  
  
  
d $

  
   
 
 
   
 
 
 
Ac  ¦
¦#      
¦#

 (  
    
   
 
uÔ
c 
‡ JAVA distinguishes between 2 types of
streams:
‡ Text ± streams, containing µcharactersµ

Program M µ M A S T R I N G \n Device

‡ Binary Streams, containing 8 ± bit information

Program       Device


c 
‡ Streams in JAVA are Objects, having
 2 types of streams (text / binary) and
 2 directions (input / output)

‡ Results in 4 base-classes dealing with I/O:


1. eader: text-input
2. uriter: text-output
3. InputStream: byte-input
4. OutputStream: byte-output
x  
)Ô O  

pro con

Binary Efficient in terms Preinformation


of time and space about data needed
(input to understand
content
&output
stream)
Text(reader Human readable, Not efficient
contains
and writer) redundant
information
x  
)Ô O  

‡ When use Text- / BinaryFiles ?


‡ ALWAYS use TextFiles for final results
‡ Binary Files might be used for non-final
interchange between programs
‡ Binary Files are always used for large amount
of data (images, videos etc.)
     

‡ Serialization: process of saving objects to a


stream i.e. in-memory object to a byte stream.
 Each object is assigned a serial number on the
stream
 If the same object is saved twice, only serial
number is written out the second time
 uhen reading, duplicate serial numbers are
restored as references to the same object
‡ The objects must be read from the stream in
the same order in which they were written.
     

‡ Why isn¶t everything serializable?

 Security reasons ± may not want contents of


objects printed out to disk, then anyone can print
out internal structure and analyze it
 Could also have temporary variables that are
useless once the program is done running.
       
‡ The requirements for serialization are
straightforward:
 Only class instances rather than primitive types
can be serialized.
 Oor an object to be serializable, its class or some
ancestor must implement the empty
 ›› interface.
 An empty interface is called a marker interface.
‡ The syntax for serialization is straightforward:
 An object is serialized by writing it to an
c c   .
 An object is deserialized by reading it from an
c   .
     

Writing objects to a file


O ! "  

O ! "# $%
&'? ! " 

&'? ! " 
 $&'?(
 $? 
       

=> Reading objects from a file


FileInputStream in =
new FileInputStream( ³save.txt´ );
ObjectInputStream ois =
new ObjectInputStream( in );
myObject d = (myObject_type) ois.readObject();
ois.close();
d        

‡ If an object is to be serialized:
 The class must be declared as public
 The class must implement  
 The class must have a no-argument constructor
 All fields of the class must be serializable: either
primitive types or serializable objects
‡ The   interface does not define any methods!
 Åuestion: uhat possible use is there for an interface
that does not declare any methods?
 Answer:   is used as flag to tell Java it
needs to do extra work with this class
c%      *

‡ writeObject() will throw an Error if the object


passed to it is not Serializable.
‡ You can control serialization by implementing
the Externalizable interface.
‡ readObject() returns something of type Object,
so it needs to be cast.
        
 

‡ Technically, primitive types cannot be serialized


or deserialized. However, the
&'? ! " implements the
( !  interface, which declares
methods such as M to write primitive
types to streams.
&'?M! " implements (M! 
for reading primitive types
transient
static `

‡ A field marked as   is not impacted


by serialization.
 During deserialization, ›  fields are
restored to their default values (e.g., transient
numeric fields are restored to zero).
? fields are not impacted by serialization.
xd

‡ Java DataBase Connectivity


‡ The JDBC ( Java Database Connectivity) API
defines interfaces and classes for writing
database applications in Java by making
database connections.
‡ JDBC provides RDBMS access by allowing you
to embed SQL inside Java code
JDBC Architecture
Java application calls the JDBC library. JDBC
loads a driver which talks to the database. We
can change database engines without changing
database code.

import the java.sql package.


  xd
‡ To register the Driver:
 Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
‡ To Get the connecttion:
 Connection con = DriverManager.
getConnection("jdbc:odbc:Deepi","sa","pass@123");
‡ To create a SQL statement:
 Statement st=con.createStatement();
‡ To execute it:
 st.execute(³DDL Åuery´);
 st.executeUpdate(³DML Åuery´);
 st.executeÅuery(³select query´);
0   d 0d

‡ Provides automated memory management.


‡ Deletes the unused objects in the memory.
‡ Only the JVM decides when to run the GC, you
can only suggest it.
‡ An object becomes eligible for Garbage
Collection when its last live reference
disappears.
0   


"`

How Memory is allocated:
 Object creation
Object is constructed either on a memory heap or on
a stack.

 Memory heap
uhen new keyword is called memory is allocated in
the heap and returned when the reference is made
null
 Stack
During method calls, objects are created for method
arguments and method variables. These objects are
created on stack.
Such objects are eligible for garbage-collection when
they go out of scope.
0   

‡ Advantages of Garbage Collection :


 More productivity
 Program Integrity

‡ Disadvantages of Garbage Collection :


 program performance

(  

‡ Finalize()
 Class Object has a finalize() method.
 Before gc happens the finalize() method is called
 It is called only once
 Oinalize method can be overridden by the user.
 Oinalize can be used to make an object not to be
garbage collected
d     

‡ Three classical algorithms


 G 
  

 
 

‡ Tweaks
 0    

 
!"#$Ô
‡ Out of scope
 ‘ %  0 
  
 % 0  
  %    
 &# 
‡ Start with 
 0lobal variables, variables on stack& in
registers
‡ Recursively visit every object through pointers
 G & ' 
  
‡ 3* 

  )   
 Can then    

   
  

‡ Annotations in Java is all about adding meta-


data facility to the Java Elements like
 package declarations,
 class,
 constructors,
 methods,
 fields,
 variables and etc
‡ An annotation indicates that the declared
element should be processed in some special
way by a compiler, development tool,
deployment tool, or during runtime.
‡ Annotations are defined using an @ syntax
   
d  

Type Class File


Source File Parser Checker Writer
 &"
 
Class
c '( File
&)  
c '"
(
%

)  
c '"
 (
%
Comments
%

Error
   
+d  
Type Annotation Class File
Source File Parser Checker Checker Writer

 &" Class
)  
c '( File
&)  
c '"
(
%

)  
c '"
 (
%
%

Program
with
annotations Error Error

Annotation
Checker
Plugins
  Ô 

‡ G )
‡ 
#3 

‡ #*   #* 
 & 
‡ Marker annotations take no parameters. They
are used to mark a Java element to be
processed in a particular way.
‡ 3 ,
public @interface MyAnnotation {
}

‡ - ,
@MyAnnotation
public void mymethod() {
....
}
    
‡ Single-element, or single-value type, annotations
provide a single piece of data only. This can be
represented with a data=value pair or, simply with the
value (a shortcut syntax) only, within parenthesis.

‡ 3 ,
public @interface MyAnnotation {
String doSomething();
}
‡ - ,
@MyAnnotation ("What to do")
public void mymethod() {
....
}
O 
   

‡ Full-value type annotations have multiple data members.
‡ 3 ,
public @interface MyAnnotation {
String doSomething();
int count;
String date();
}
‡ - ,
@MyAnnotation (doSomething=
"What to do",
count=1,
date="09-09-2005")
public void mymethod() {
....
}
Ô x    

‡ Java defines seven built-in annotations.


‡ Four are imported from java.lang.annotation
‡ @Retention,
‡ @Documented,
‡ @Target,
‡ and @Inherited.

‡ Three are included in java.lang.


 @Override,
 @Deprecated,
 and @Suppressuarnings.
Ô Ô     
‡ @Target(ElementType.TYPE)
 can be applied to any element of a class
‡ @Target(ElementType.FIELD)
 can be applied to a field or property
‡ @Target(ElementType.METHOD)
 can be applied to a method level annotation
‡ @Target(ElementType.PARAMETER)
 can be applied to the parameters of a method
‡ @Target(ElementType.CONSTRUCTOR)
 can be applied to constructors
‡ @Target(ElementType.LOCAL_VARIABLE)
 can be applied to local variables
‡ @Target(ElementType.ANNOTATION_TYPE)
 indicates that the declared type itself is a
   
‡ When we have some Annotations defined in the
source code and have a mechanism through
which we can say that to what extent the
Annotations should be retained. The three
possible ways of telling this are,
 etain the Annotation in the Source Code only
 etain the Annotation in the Class file also.
 etain the Annotation Definition during the un-
time so that JVM can make use of it.
‡ The Annotation that is used to achieve this is
@Retention and it takes a possible values of
SOURCE, CLASS and RUNTIME defined in
RetentionPolicy Enumeration.
^    

‡ Less coding
‡ Easier to change
‡ Smarter development.
‡ Providing information to the Compiler.
‡ Providing information to the tools.
‡ Providing information to the Runtime System