Begin Learning Java !

Installing EditPlus

2010-03-04T20:34:00.000-08:00

Run -> EP2SETUP.EXE

Configure EDITPLUS2 :
Click - Tools -> Configure User Tools
Select - Tools -> User Tools -> Group 1
Click - Add Tools -> Program

Menu text : javac
Command : c:\jdk1.3\bin\javac.exe
Argument : $(FileName)
Initial Directory : $(FileDir)

Menu text : java
Command : c:\jdk1.3\bin\java.exe
Argument : $(FileNameNoExt)
Initial Directory : $(FileDir)

Menu text : appletviewer
Command : c:\jdk1.3\bin\appletviewer.exe
Argument : $(FileName)
Initial Directory : $(FileDir)

Menu text : Javac1.4
Command : c:\j2sdk1.4.0_01\bin\javac.exe
Argument : $(FileName)
Initial Directory : $(FileDir)

Menu text : Java1.4
Command : c:\j2sdk1.4.0_01\bin\java.exe
Argument : $(FileNameNoExt)
Initial Directory : $(FileDir)

Running Java Program

2010-03-03T09:46:00.000-08:00

Java is developed in 1991. It is Architecture Independent. It is a language basically designed to work in consumer electronics.

Earlier languages like BASIC, COBOL, FORTRON, ADA etc. were not suitable for system programming because it was more structured and procedural in nature.

The first programmer’s language called ‘C’ was developed by Dennis Richie and ended up being too complex.
C++ was developed by Bjarne Stroucstrup and was called as “C with classes” initially.

The four pillars of OOPS(Object Oriented Programming Skills) are :

1. Polymorphism
2. Inheritance
3. Data Abstraction(Hiding the implementation)
4. Encapsulation

In procedural programming focus is on procedures where as in object oriented programming emphasis is given to data.

What we need to create and execute JAVA files :

1) JDK - lib (Libraries)
bin (All EXE Files)
JRE (Java Runtime Environment)
2) Note Pad Plus
3) Integrated Development Environment – Edit Plus

Run – Command – For Windows 95, Windows 98
cmd Windows 2000 and above

Set path at DOS prompt before you compile a file. - set path=c:\jdk1.4\bin
To compile a java file - javac
To execute / interpret a java file - java

class Hello
public static void main(String [] args)
{
System.out.println(“Hello”);
}

javac Hello.java
java Hello

System.out.println(“Hello”);
In System class, we have 3 members (also known as Fields)
1) In - InputStream
2) Out - PrintStream
3) Err - PrintStream Err

println is in System class in Out field which is pointing to PrintStream.

Variables

2010-03-02T10:02:00.000-08:00

A variable is a named part of memory giving 3 information –
int a = 10;
1) A data type it can hold
2) The name of the variable
3) The value of the variable

The three types of variables are :

1] Class Variables : A variable defined outside all methods and whose scope is throughout the class is called Class Variable. Class Variable takes a default value depending on its data type.
For calling methods of a class we should create an instance of that class.

In this example ‘x’ is a class variable. Name the file as ClassVariabl.java since it contains main().

class a                                Output :
{                                        0
   int x;                               0
   void met1()
   {
       System.out.println(x);
   }
}
class ClassVariable
{
   public static void main(String args[])
   {
      a m=new a();
      m.met1();
      System.out.println(m.x);
   }
}

2] Method Variable : A variable defined inside a method and whose scope is only within that method is called Method Variable.

Method Variable needs to be mandetarilly initialized.

class MethodVariable                        Output :
{                                                       10
    void met1()
    {
        int x=10;
        System.out.println(x);
    }
    public static void main(String args[])
    {
        MethodVariable p = new MethodVariable();
        p.met1();
    }
}

3] Instance Variable : Static Variables have only one memory location and all instances share the same where as non-static variables can take separate values for different instances.

All non-static Class Variables are called Instance Variables.
class InstanceVariable                        Output :
{                                                        60
    static int x = 10;                             20
    int y = 20;
    public static void main(String args[])
    {
        InstanceVariable i = new InstanceVariable();
        i.x = 40;
        i.y = 100;
        InstanceVariable j = new InstanceVariable();
        j.x = 60;
        j.y = 200;
        InstanceVariable k = new InstanceVariable();
        System.out.println(k.x);
        System.out.println(k.y);
    }
}

Static/ Non-static Methods

2010-03-01T10:05:00.000-08:00

Non-static methods requires an instance of a class where as static methods can be directly called with class name. Limitation of static methods is that it can access only static class variables.
The source code file name should be the name of the class in which public static void main(String [] args) is there, so that the JVM can directly call it with the .main().
Method Variable can not be static because the scope is within the method.
Every object is not a instance but every instance is an object. Object has no memory location but instance has. Instance has copy of that class. In Java every class has instance other than String.

class a                               Output :
{                                        10
    int x=10;                        20
    void met1()
    {
        System.out.println(x);
    }
}
class b
{
     //int y = 20;
    //this will give compile error non-static variable cannot be referenced from static context
    static int y=20;
    static void met2()
    {
        System.out.println(y);
    }
}
class StaticMethodTest
{
    public static void main(String args[])
    {
        a m=new a();
        m.met1();
        b.met2();
    }
}

Constructor

2010-02-28T12:23:00.000-08:00

The Constructor is like a method having the same name as the class name, without a return type and it is automatically called when an instance is created with appropriate arguments. The main purpose of a Constructor is to initialize the class variables.
The JVM will give a default Constructor only if there is no parameterized constructor in the class.

Without Constructor :

class Student1
{
    String name;
    int id;
    void show()
    {
        System.out.println("Your Name = "+name);
        System.out.println("Your ID   = "+id);
    }
}
class Constructor1
{
    public static void main(String args[])
    {
        Student1 n=new Student1();
        n.name="Maya";
        n.id=100;
        n.show();
    }
}

With Constructor:

class Student2
{
    String name;
    int id;
    void show()
    {
        System.out.println("Your Name = "+name);
        System.out.println("Your ID   = "+id);
    }
    Student2(String a, int b)
    {
        name = a;
        id = b;
    }
}
class Constructor2
{
    public static void main(String args[])
    {
        Student2 n2 = new Student2(“Maya”,100)
        n2.show();
        Student2 y = new Student2();
    }
}

Student2 y gives an error couse there is no
constructor without parameter

Data Types in Java

2010-02-27T12:56:00.000-08:00

Data Types: 1) Predefined Primitive
                   2) User Defined
                      - class
                      - structure
                      - enum

1] Integral    - byte    -     8 bit    -    28 = 256    -128    to 127
                   - short    -    16 bit
                   - int    -    32 bit
                   - long    -    64 bit

2] Floating    - float    -    32 bit
                    - double    64 bit

3] Textual    - char    -    16 bit Unicode

4] Logical    - boolean    1 bit

You can find more about Unicode on www.unicode .org

In ASCII storage system the last 7 bits are used to store data and the first bit is reserved for storing sign. Hence it is difficult to store foreign language symbol, that’s where Unicode comes handy.

1) There are two categories of data types in Java :
    a)    Primitive Data Type
    b)    User Defined Data Types (class, structure, enum)

2)    All data type in Java are is strictly typed (range is fixed) and pre-defined.
3)    Integral and Floating point data types are signed. The default of Integral category is int and byte and short automatically get promoted to int when any calculation is done on them.
4)    Type casting means forcibly putting a large size data type into a smaller size which might result in loss of precession.

class ByteText
{
    public static void main(String args[])
    {
        byte a = 10;
        byte b = 13;
        //byte c = (a+b);        // possible loss of precision
        //System.out.println(c);
        int c1 = (a+b);
        System.out.println(c1);    // output : 23
        byte c2 = (byte) (a+b);
        System.out.println(c2);    // output : 23
        byte c3 = (byte)(a*b);
        System.out.println(c3);    // output : -126
    }
}

byte range is -128 to 127. When there is overflow it starts from beginning
-128    -127    -126
128        129        130

Auto conversion – smaller to bigger

byte --> short --> int -->    double

Type casting – bigger to smaller

byte <-- short <-- int <--    double

Long Type : Since the default of Integral category is int while initializing long if the value goes beyond 32 bits we should have a ‘l’ or ‘L’ suffixed to the value.

class LongText
{
    public static void main(String args[])
    {
        long a = 10;
        long b = 12345678910;
        System.out.println(a);
        System.out.println(b);
    }
}

Output : Compile Error - Integer number too large    Solution : suffix ‘L’ or ‘l’
long b = 12345678910L;

Floating Type : The default of the floating type category is double and hence while initializing float
we should have a ‘f’ or ‘F’ suffixed to the value. Double gives more precision.

class FloatText
{
    public static void main(String args[])
    {
        float a = 10;
        float b = 10.00;
        System.out.println(a);
        System.out.println(b);
    }
}

Default of float is double that’s why in float b = 10.0 , 10.0 is treated as double. In this case you are trying to store 64 bit value in 32 bit value. Solution for this is : float b = 10.0F;

OUTPUT : 10.0
                   10.0

char Type:
class CharText
{
    public static void main(String args[])
    {
        char c = 'a';
        int i = c;
        System.out.println("The ASCI Value of " +c + " is " + i);
    }
}
OUTPUT : The ASCII value of a is 97.

boolean Type :
class BooleanText
{
    static boolean a;
    public static void main(String args[])
    {
        System.out.println(a);
    }
}

OUTPUT :     false
If static method calls non-static variable, the compile error is :
Non static variable ‘b’ cannot be referenced from a static context

Use of toString() :
class PlusText
{
    public static void main(String args[])
    {
        int a = 10;
        int b = 10;
        String s = "Hello";
        Integer i = new Integer(a);
        String s1 = i.toString();
        Integer j = new Integer(b);
        String s2 = j.toString();
        System.out.println(a+s+b);
        System.out.println(s+s1+s2);
    }
}
OUTPUT :     1010Hello

If we do not use toString() then it will be 20Hello.
Java.lang.Object - top most class.
    |                        All classes inherit it. It is a Super class.
    v
toString()            - converts object into a string

Data Variables Wrapper Classes (convert each data variable into object)
byte                     Byte
short                   Short
int                       Integer
long                    Long
float                    Float
double               Double
char                  Character
boolean            Boolea

Operators

2010-02-26T17:54:00.000-08:00

1) Unary :

a) ‘+’ : All primitive data types are corresponding classes, the category of which is called wrapper classes. The main purpose of a wrapper class is to convert the primitive data types into an object.
The topmost class (super class) of all classes in Java is java.lang.Object class which has a method called toString() which converts the object into string.

b) “++” / “—“ : Incase of pre-increment the RHS is first incremented and then assigned to LHS where as in post increment it is first assigned then incremented.
int a = 10;
System.out.println(a++);    OUTPUT : 10
System.out.println(++a);    OUTPUT : 11

int a =100;            int a = 10;        a    b
a = a++;            int b = 20        10    20
a = a++;            a = ++b;        21    21
a = a++;            b = a--;            20    21
OUTPUT : 100        b=++a;    21        21    21

a = a++; In this case since it is same variable the memory location is same. Therefore a = 100
It wont check what is on the right side of the variable, hence ++ is ignored. But b = a++; there are two variables, therefore different memory location. Therefore b = 100 and a = 101

c) ‘~’ Bitwise Inversion Operation : When used ~ all zeroes are changed to ones advice versa
int a = 10;            00000000000000000000000000001010
int b = ~a;            11111111111111111111111111110101
System.out.println(b);
OUTPUT : -11

d) ! Boolean compliment operation :
e) cast ( ) :

2) Aritmetic Operator :
    BODMAS - / * + - and %

3) Comparison Operators: All comparative operators return boolean type value.
                            a) Object Type
                            b) Memory Type

a) Object Type : The instance of keyword is used to check whether a instance on LHS belongs to the class on the RHS or not.
This returns a value only when there is a relationship between the instance and a class check.

class A
{
}
class B extends A
{
}
class C extends A
{
}
class InstanceText
{
    public static void main(String[] args)
    {
        A x = new A();
        B y = new B();
        C z = new C();
        System.out.println(x instanceof B);
        System.out.println(y instanceof A);
        System.out.println(z instanceof B);
    }
}
Subclass knows everything about super class. In java multiple inheritance is not allowed.
OUTPUT : compiler error – inconvertible type - System.out.println(z instanceof B);

b) Memory Type : String is the only class in Java that can be created without the new keyword. The two types of memory comparison operators are :
a) Based on location
b) Based on contents

The two types of memory locations are Stack and Heap.
Primitive data types are stored in Stack where as Objects are stored in Heap.
The “= =” operator checks for the memory location of its operand.
The equals() method in the Object class also acts like the “= =” operator but it is overridden in String and Wrapper classes to check for the contents.

class MemoryText
{
    public static void main(String args[])
    {
        String s = "Hello";
        String s1 = "Hello";
        String s2 = new String("Hello");
        String s3 = new String("Hello");
        MemoryText x = new MemoryText();
        MemoryText y = new MemoryText();
        int i = 10;
        int j = 10;
        Integer a = new Integer(i);                //True
        Integer b = new Integer(j);                //False
        System.out.println(s == s1 );                //False
        System.out.println(s2 == s3);                //True
        System.out.println(x == y);                //False
        System.out.println(s2.equals(s3));            //True
        System.out.println(x.equals(y));            //False
        System.out.println(i == j);                //True
        System.out.println(a.equals(b));            //True
        System.out.println(a == b);                //False
    }
}

4) Bitwise :
                &    |    ^
                1    0    0    1
                1    0    1    0
                -    -    -    -
                1    0    1    1
Others    0    1    0    0

class BitwiseOperator
{
public static void main(String args[])
    {
        int a = 10;
        int b = 20;
        int c = a & b;
        int d = a | b;
        int e = a ^ b;
        System.out.println(c);        // 0
        System.out.println(d);        // 30
        System.out.println(e);        // 30
}
}

5) Short Circuit Operator : && / || If the LHS of “&&” is false the whole answer is false without checking the RHS and if true will act like a normal ‘&’ operator.
class ShortCircuit
{
    public static void main(String args[])
    {
        String s = null;
        if ((s != null) & (s.length() > 5))
        {
            System.out.println("Inside");
        }
        System.out.println("Finished");
    }
}
OUTPUT : Runtime Error – s.length() > 5 – NullPointerException

class ShortCircuit1
{
    public static void main(String args[])
    {
        String s = null;
        if ((s != null) && (s.length() > 5))
        {
            System.out.println("Inside");
        }
        System.out.println("Finished");
    }
}
OUTPUT : Finished

The two ways to convert a String into a primitive int is :
A)    use the static method of Integer class called parseInt()
B)    use the non static method of the Integer class called intValue()

class TernaryText
{
int max(int i, int j)
    {
        int c = (i > j)? i: j;
        return c;
    }
    public static void main(String args[])
    {
        String s = args[0];
        String s1 = args[1];
        int p1 = Integer.parseInt(s);
        Integer i = new Integer(s1);
        int p2 = i.intValue();
        TernaryText E = new TernaryText();
        int r = E.max(p1, p2);
        System.out.println(r );
    }
}

                                    Flow Controls
                                        |
        |------------------------------------------------ |
        |                                |                                        |
    loops                            selection                        jump
        for                                if – else                        break
        do – while                        if                                continue
        while                            switch

switch :     switch is used when
a)    Branching is to balance based on a non boolean value
b)    Multiple conditions have same output

class SwitchTest
{
    public static void main(String args[])
    {
        for(int i=0;i<3;i++)
        {
            switch(i)
            {
                case 2:
                        {
                            System.out.println("Two");
                        }
                default:
                        {
                            System.out.println("Default");
                        }
                case 1:
                        {
                            System.out.println("One");
                        }
            }
        }
    }
}
In a switch case if break is not there between cases it will go in all the cases below a case which is matched. Hence OUTPUT is :
One
One
Two
Default
One

Break: break should always be in a conditional black. You can use break in following :
Break
    loops
switch
labeled breaks

Label Break : In case of a labeled break the break should be followed by the labeled name.
class LabelBreak
{
    public static void main(String args[])
    {
        One:
        {
            Two:
            {
                Three:
                {
                    System.out.println("Before");
                    if(true)
                    {
                        break Two;
                    }
                    System.out.println("After");
                }
                System.out.println("After3");
            }
            System.out.println("After2");
        }
        System.out.println("After1");
    }
}
OUTPUT :    Before
        After2
        After1

Loop Break : To throw the control out of loop.
class BreakFor
{
    public static void main(String[] args)
    {
        for (int i = 1; i < 10 ; i++ )
        {
            System.out.println(i);
            if(i = = 4)
            {
                break;
            }
        }

    }
}
OUTPUT :     1        2        3

Continue : Continue is used to manually go down to next alteration without reaching the end of the current black.
class ContinueBreak
{
    public static void main(String args[])
    {
        for(int i=0; i <10 ; i++)
        {
            if(i % 2 == 0)
            {
                continue;
            }
            System.out.println(i);
        }
    }
}
OUTPUT :     1    3    5    7    9

This Keyword

2010-02-25T18:22:00.000-08:00

Use One : The first use of this is it refer to the class variable when the parameter variable or method variable hides the class variable.

class This1
{
    int a;
    This1(int a)
    {
        this.a = a;
    }
    public static void main(String args[])
    {
        This1 m = new This1(10);
        System.out.println(m.a);
    }
}

OUTPUT : 10

class This2
{
    int x=10;
    void met()
    {
        int x = 40;
        System.out.println(x);
        System.out.println(this.x);
    }
    public static void main(String args[])
    {
        This2 m = new This2();
        m.met();
        System.out.println(m.x);
    }
}

OUTPUT :     40
        10
        10

Use Two: The second use of this is to call another constructor of the same class from within a constructor by passing appropriate arguments.

Web Site Form                Database

Name    :             Name            Salary
Salary    :            Yes            Yes
OK                No (Unknown)    Yes
                Yes            No (0)
                No (Unknown)    No (0)

class This3
{
    String name;
    int sal;
    This3(String s, int i)
    {
        name=s;
        sal=i;
        System.out.println("Name   : "+name);
        System.out.println("Salary : " + sal);
    }
    This3(String s)
    {
        this(s,0);
    }
    This3(int i)
    {
        this("Unknown",i);
    }
    This3()
    {
        this(0);
    }

    public static void main(String args[])
    {
        This3 w = new This3("Maya", 1000);
        This3 x = new This3("Sangeeta");
        This3 y = new This3(5000);
        This3 z = new This3();
    }
}

OUTPUT :
        Name    : Maya
        Salary    : 1000
        Name    : Sangeeta
        Salary    : 0
        Name    : Unknown
        Salary    : 5000
        Name    : Unknown
        Salary    : 0

Super Keyword

2010-02-24T18:27:00.000-08:00

Use One: The first use of super is to refer to a super class variable or method which is hidden (variable) or overridden (method) in the super class.
Super can be written only in now static.

class A
{
    int x = 10;
    void met1()
    {
        System.out.println(x);
    }
}

class Super1 extends A
{
    int x=100;
    void met1()
    {
        System.out.println("Super1");
        System.out.println(super.x);
        super.met1();
    }

    public static void main(String args[])
    {
        Super1 p = new Super1();
        p.met1();
        System.out.println(p.x);
    }
}

OUTPUT :    Super1
        10
        10
        100

Use Two: The second use of super is to call a specific super class constructor from the subclass’s constructor by passing appropriate arguments.
The call to super should be in the first line of the sub class’s constructor.

class Area
{
    int l, b;
    Area(int a, int b)
    {
        l=a;
        this.b = b;
    }
    void calArea()
    {
        int c = l * b;
        System.out.println("Area : "+c);
    }
}

class Volume extends Area
{
    int h;
    Volume(int a, int b, int c)
    {
        super(a,b);
        h=c;
    }
    void calVolume()
    {
        int v = l * b * h;
        System.out.println("Volume : " + v);
    }
    public static void main(String args[])
    {
        Volume x = new Volume(10,20,30);
        x.calArea();
        x.calVolume();
    }
}

OUTPUT : Area    : 200
                   Volume    : 6000

Order of Constructor calling

2010-02-23T10:07:00.000-08:00

All subclasses constructor have a implicit super in its first line which calls the default constructor of super class. This is necessary because the super class methods and variables should be loaded in memory before the subclass is created.

class A
{
A()    {    System.out.println("One");    }
}
class B extends A
{
    B()    {    System.out.println("Two");    }
}
class C extends B
{
    C()    {    System.out.println("Three");    }
}
class ConstuctorOrder1
{
    public static void main(String args[])
    {    C x = new C();    }
}

OUTPUT :
One
Two
Three

class A
{
    A()
    {    System.out.println("One");    }
    void met1()    {    System.out.println("Met1");    }
}
class B extends A
{
    B()
    {    System.out.println("Two");    }
}
class C extends B
{
    C()
{    System.out.println("Three");    }
}
class ConstuctorOrder2
{
    public static void main(String args[])
    {
        C x = new C();
        x.met1();
       }
}

OUTPUT :
One
Two
Three
Met1

class A
{
    A()
    {    System.out.println("One");    }
}
class B extends A
{
    B(int i)
    {    System.out.println("Four");    }
}
class C extends B
{
    C()
    {
System.out.println("Three");
    }
}
class ConstuctorOrder3
{
    public static void main(String args[])
    {
        C x = new C();
}
}
OUTPUT :    Compile Error – can not resolve symbol – Symbol : constructor B

class A
{
    A()
    {
        System.out.println("One");
    }
}
class B extends A
{
    B(int i)
    {
        System.out.println("Four");
    }
}
class C extends B
{
    C()
    {
        super(10);
        System.out.println("Three");
    }
}
class ConstuctorOrder4
{
    public static void main(String args[])
    {
        C x = new C();
        x.met1();
       }
}

OUTPUT :
One
Four
Three

Call by reference / Call by value

2010-02-22T10:09:00.000-08:00

Primitive data types in Java is passed by value where as objects are always passed by reference.

class CallByReference
{
    int a, b;
    CallByReference(int x, int y)
    {
        a = x;
        b = y;
    }
    void met1(CallByReference m)
    {
        m.a =m.a * 2;
        m.b =m.b / 2;
    }
    public static void main(String[] args)
    {
        CallByReference p1 = new CallByReference(10, 20);
        System.out.println(p1.a+" "+p1.b);
        p1.met1(p1);
        System.out.println(p1.a+" "+p1.b);
        p1.met1(p1);
        System.out.println(p1.a+" "+p1.b);
    }
}

OUTPUT :
10    20
20    10
40    5

Call by value :

class CallByValue
{
    int met1(int a)
    {
        return ++a;
    }
    public static void main(String[] args)
    {
        int i = 10;
        CallByValue p = new CallByValue();
        int j = p.met1(i);
        System.out.println(i);
        System.out.println(j);
    }
}

Inner Class

2010-02-21T10:16:00.000-08:00

1) Normal Inner Class : For a normal inner class a instance of the outer class is mandatory and through that instance a inner class instance class instance can be created. The inner class can access even the private variable of the outer class but not vise versa.
Two class files created would be A.class and A$B.class after you compile.

class A
{
    private int x = 10;
    class B
    {
        int y=20;
        void met1()
        {
            System.out.println(x+" "+y);
        }
    }
}

class Inner1
{
    public static void main(String args[])
    {
        A m = new A();
        A.B n = m.new B();
        n.met1();
    }
}

OUTPUT :    10    20

2) Static Inner Class : Inner classes can not have static keywords but in case it has one the whole class should be declared as static inner class.

class A
{
    static int x = 10;
    class B
    {
        static int y=20;
        static void met1()
        {
            System.out.println(x+" "+y);
        }
    }
}
class Inner2
{
    public static void main(String args[])
    {
        A.B.met1();
        System.out.println(A.x);
        System.out.println(A.B.y);
    }
}

OUTPUT : Compile Error – inner classes can not have static declaration

class A
{
    static int x = 10;
    static class B
    {
        static int y=20;
        static void met1()
        {
            System.out.println(x+" "+y);
        }
    }
}
class Inner2
{
    public static void main(String args[])
    {
        A.B.met1();
        System.out.println(A.x);
        System.out.println(A.B.y);
    }
}

OUTPUT :
10    20
10
20

3) Inner class inside a method : Any outer class method variable which will be accessed in the inner class should be declared as final.
The inner class instance should be created and the inner class methods should be called before exiting the outer class method.

class M
{
    int x = 10;
    void met1()
    {
        final int y=20;
        class N
        {    int z = 30;
            void met2()
            {
                System.out.println(x+" "+y+" "+z);
            }
        }
        N p = new N();
        p.met2();
        System.out.println("Back");
    }
}
class Inner3
{
    public static void main(String args[])
    {
        M a = new M();
        a.met1();
     }
}

OUTPUT :
10    20    30
Back

Over Loading

2010-02-20T10:21:00.000-08:00

Over loading means having the same method name but different type and order of parameters.
Overloading can not be done based only on return types.
class OverLoad1
{
    void met1()
    {
        System.out.println("A");
    }
    int met1()
    {
        System.out.println("B");
        return 10;
    }
    public static void main(String args[])
       {
        OverLoad1 o = new OverLoad1();
        o.met1();
    }
}

OUTPUT : Compile Error – met1() is already defined in OverLoad1

class OverLoad2
{
    void met1(int a)
    {
        System.out.println("A");
    }
    int met1(String s)
    {
        System.out.println("B");
        return 0;
    }
    public static void main(String args[])
    {
        OverLoad2 o = new OverLoad2();
        o.met1(10);
    }
}

OUTPUT : A

Packages

2010-02-19T11:41:00.000-08:00

The scope of a private variable in only in the class in which it is declared.
The scope of default or friendly is in all classes in the same package either by
a) Inheritance OR     b) by creating an instance

The visibility of the protected is like default as well as in another class in another package only if there is an inheritance and a instance of sub class is mandatory for non static variables (static variables can be called without creating an instance)
The visibility of public is in all classes in any Package.

package One;
public class Pack1
{
    private int x1 = 10;
    static int x2 = 20;
    protected int x3 = 30;
    protected static int x4 = 40;
    public int x5 = 50;
}

Save this file as Pack1.java under the same folder     : c:\students\Maya>
Set the path                        : c:\students\Maya>set path=c:\jdk1.3\lib
Compile the file                    : c:\students\Maya>javac –d . Pack1.java
The above command creates One folder under Maya and saves compiled file Pack1.class in One.

package One;
class Pack2 extends Pack1
{
    public static void main(String [] args)
    {
        //System.out.println(x1);
                System.out.println(x2);
        //System.out.println(x3);
        System.out.println(x4);
        //System.out.println(x5);
    }
}

Save this file as Pack2.java under the same folder     : c:\students\Maya>
Compile the file                    : c:\students\Maya>javac –d . Pack2.java
Run the file                         : c:\students\Maya>java One.Pack2

OUTPUT : Compile Error –     x1    private access in One.Pack1
                x3    non static variable can not be referenced from a static
                x5    non static variable can not be referenced from a static
Hence comment these 3 lines using “//” and save and compile Pack2.java file.

OUTPUT :
        20
        40

package One;
class Pack3
{
    public static void main(String [] args)
    {
        Pack1 m = new Pack1();
        //System.out.println(m.x1);
         System.out.println(m.x2);
        System.out.println(m.x3);
        System.out.println(m.x4);
        System.out.println(m.x5);
    }
}

OUTPUT : Compile Error -     x1    private access in One.Pack1

Non static variables x3 and x5 are getting printed because instance of Pack1 class is created to refer to them. Non static variables can be called in static methods by referring them by the instance. Comment x1 and then save the file.
Save this file as Pack2.java under the same folder     : c:\students\Maya>

Compile the file                    : c:\students\Maya>javac –d . Pack3.java
Run the file                         : c:\students\Maya>java One.Pack3

OUTPUT :     20    30    40    50

package Two;
import One.*;
class Pack4
{
    public static void main(String [] args)
    {
        Pack1 n = new Pack1();
        //System.out.println(n.x1);
               //System.out.println(n.x2);
        //System.out.println(n.x3);
        //System.out.println(n.x4);
        System.out.println(n.x5);
    }
}

Save this file as Pack4.java under the same folder     : c:\students\Maya>
Compile the file                    : c:\students\Maya>javac –d . Pack4.java
Run the file                        : c:\students\Maya>java Two.Pack4
The above command creates Two folder under Maya and saves compiled file Pack1.class in Two.

OUTPUT : Compile Error – n.x1    private access in One.Pack1
            n.x2    not public in Pack1. default has a scope within same package
n.x3    has a protected access in Pack1. Protected has a scope within the same package & in another package only inherited class
n.x4    on has a protected access in Pack1. Protected has a scope within the same package & in another package only inherited class

package Two;
import One.*;
class Pack5 extends Pack1
{
    public static void main(String [] args)
    {
        Pack1 p = new Pack1();
        //System.out.println(p.x1);
                //System.out.println(p.x2);
        //System.out.println(p.x3);
        System.out.println(p.x4);
        System.out.println(p.x5);

        Pack5 p1 = new Pack5();
        //System.out.println(p1.x1);
                //System.out.println(p1.x2);
        System.out.println(p1.x3);
        System.out.println(p1.x4);
        System.out.println(p1.x5);

    }
}

Save this file as Pack5.java under the same folder     : c:\students\Maya>
Compile the file                    : c:\students\Maya>javac –d . Pack5.java
Run the file                        : c:\students\Maya>java Two.Pack5

OUTPUT : Compile Error – p.x1    private access in One.Pack1
            p.x2    not public in Pack1. default has a scope within same package
p.x3    has a protected access in Pack1. Protected has a scope within the same package & in another package only inherited class. But the non static variables can be referenced only by the instance of subclass
p1.x1    private access in One.Pack1
p1.x2    not public in Pack1. default has a scope within same package

OUTPUT : After commenting the above lines : 40    50    30    40    50

Save all java files under same folder c:\students\Maya. Compile files Pack1.class, Pack2.class and Pack3.class get created in folder One whereas Pack4.class and Pack5.class get created in folder Two.

Over Riding

2010-02-18T11:58:00.000-08:00

When in a method in the sub class has the same signature as that of the super class, the sub class method is set to over ride the super class method.
The six parts in the signature of a method are :

1)    Visibility Modifier
2)    Keyword
3)    Return Type
4)    Name
5)    Parameters
6)    Throws Conditions

The main rule of over riding that the signature of the method should be the same.
The two exceptions to this rule are :
1)    the overriding method can not be less accessible than the overridden method
2)    the over riding method can not throw super classes of the exception that is thrown by the overridden method.

class A
{
    public void met1()
    {
        System.out.println("A");
    }
}
class OverRidden extends A
{
    void met1()
    {
        System.out.println("OVERRIDDEN");
    }
    public static void main(String args[])
       {
        OverRidden o = new OverRidden();
        o.met1();
       }
}

OUTPUT :   Attempting to assign weaker access privilege.
Because overriding method OverRidden.met1(), has less accessibility (default) than the overridden method A.met1() (public).

class A
{
    public void met1()
    {
        System.out.println("A");
    }
}
class OverRidden extends A
{
    void met1()
    {
        System.out.println("OVERRIDDEN");
    }
    public static void main(String args[])
   {
        OverRidden o = new OverRidden();
        o.met1();
   }
}

OUTPUT : OVERRIDDEN

The hierarchy of Throwable Exception

2010-02-17T12:19:00.000-08:00

class A
{
    void met1() throws Exception
    {
        System.out.println("A");
    }
}
class Throw1 extends A
{
    void met1() throws Exception
    {
        System.out.println("OVERRIDDEN");
    }
    public static void main(String args[])throws Exception
   {
        Throw1 o = new Throw1();
        o.met1();
   }
}

OUTPUT : OVERRIDDEN
If we don’t write throws Exception with main(), there will be a compile error – Unprotected Exception
Same level throws Exception creates no error.

class A
{
    void met1() throws Exception
    {
        System.out.println("A");
    }
}
class Throw2 extends A
{
    void met1()
    {
        System.out.println("OVERRIDDEN");
    }
    public static void main(String args[])
       {
        Throw2 o = new Throw2();
        o.met1();
       }
}

OUTPUT : OVERRIDDEN
No error since over ridden method throwing higher level Exception than the over riding method.

class A
{
    void met1() throws Exception
    {
        System.out.println("A");
    }
}
class Throw3 extends A
{
    void met1() throws RuntimeException
    {
        System.out.println("OVERRIDDEN");
    }
    public static void main(String args[])
       {
        Throw3 o = new Throw3();
        o.met1();
       }
}

OUTPUT : OVERRIDDEN
No error since the method in super class is throwing Exception of the higher level than the over riding method in the sub class from the Throwable hierarchy.

class A
{
    void met1() throws Exception
    {
        System.out.println("A");
    }
}
class Throw4 extends A
{
    void met1() throws Throwable
    {
        System.out.println("OVERRIDDEN");
    }
    public static void main(String args[])
       {
        Throw4 o = new Throw4();
        o.met1();
       }
}

OUTPUT : Compile Error – met1() in Throw4 does not throw Throwable.
Because overriding method is throwing higher level Exception than over method.

Late Binding / Virtual Method Invocation / Runtime Polymorphism / Dynamic Binding

2010-02-16T13:06:00.000-08:00

Late Binding / Virtual Method Invocation / Runtime Polymorphism / Dynamic Binding

In late binding we create the instance of the super class but call the constructor of the sub class, only to check if a upper class method is overridden in the in the sub class or not.

class A
{
    int x = 10;
    A()
    {
        System.out.println("Constructor in A");
    }
    void met1()
    {
        System.out.println("met1 in A");
    }
    void met2()
    {
        System.out.println("met2 in A");
    }
}
class B extends A
{
    int x = 20;
    B()
    {
        System.out.println("Constructor in B");
    }
    void met1()
    {
        System.out.println("met1 in B");
    }
    void met3()
    {
        System.out.println("met3 in B");
    }
}
class LateBinding
{
    public static void main(String args[])
       {
        A m = new B();
        System.out.println(m.x);
        m.met1();
        m.met2();
        //m.met3();
       }
}

OUTPUT : Compile Error – can not resolve symbol met3(). Comment it.
OUTPUT :
Constructor in A
Constructor in B
10
met1 in B
met2 in A

A m = new B();    is same as     A m = new A();
                            B n = new B();
                            m = n;

Creating an object of class A and invoking the constructor of B which invokes constructor of A (super class).

Abstract Classes

2010-02-15T13:21:00.000-08:00

1.    A method without a body is called abstract method.
2.    If a class has an abstract method the whole class should be declared as abstract class.
3.    Any sub class extending the abstract class should override all the abstract methods of the super class.
4.    Abstract classes can have non abstract methods.
5.    Abstract classes can not be instantiated.
6.    Abstract classes need not have an abstract method.

In order to prevent Instance creation
-    Declare class as Abstract.
-    Declare constructor of the class private.

abstract class Shape1
{
    abstract void area();
    void met1()
    {
        System.out.println("met1 in shape1");
    }
}
class Square extends Shape1
{
    void area()
    {
        System.out.println("area in Square");
    }
}
class Rectangle extends Shape1
{
    void area()
    {
        System.out.println("area in Rectangle");
    }
}
class Abstract1
{
    public static void main(String args[])
    {
        //Shape1 x = new Shape1();
        Square a = new Square();
        a.area();
        a.met1();
        Rectangle b = new Rectangle();
        b.area();
        b.met1();

    }
}

OUTPUT : Compile Error – Shape1() is abstract; can not be instantiated. Comment it.

OUTPUT :
met1 in Shape1
area in Square
area in Rectangle
met1 in Shape1

Interface

2010-02-14T13:31:00.000-08:00

To over ride met1() and met2() methods from different classes in one class, you need to inherit class A and class B. But multiple inheritance is not allowed in Java. That’s where you need to use interface.

An interface is like a class but having all methods as public and abstract and all variables as static, public and final.
A class can extend only one class but can implement multiple interfaces.
Any class implementing an interface should override all the methods of that interface.

interface A
{
    public void met1();
}
interface B
{
    final int x = 10;
    public void met2();
}
class Interface1 implements A, B
{
    public void met1()
    {
        System.out.println("met1 in Interface1");
    }
    public void met2()
    {
        System.out.println("met2 in Interface1");
    }
    public static void main(String args[])
    {    System.out.println(B.x);    }
}

OUTPUT : 10

Applet

2010-02-13T18:43:00.000-08:00

Application                        Applet
1) console                          Browser
2) main()                            init()            once in life cycle
                                         start     maximize    multiple time
                                         stop    minimize    multiple time
                                         destroy            once in life cycle
3) System.out.println()        paint()

1) An applet in a Java class file embedded in a htm; page which is loaded and executed by the browser
2) Applets require browser where as Applications are console (DOS prompt) based.
3) The entry point in an Application in the main() method where as the life cycle methods of an Applet are init(), start(), stop() and destroy().
4) init() and destroy() are called only once in the life cycle where as start() and stop() is called whenever the Applet is maximized and minimized respectively.
5) In an Application for printing we use System.out.println() method where as in Applet we use the paint() method.

import java.applet.*;
import java.awt.*;
public class MyApplet extends Applet
{
    public void paint(Graphics g)
    {
        g.drawString("Hello",100,100);
    }
}
Save this file as MyApplet.java and compile. Don’t execute the file.
In NotePlus - Tools - Configure User Tools - java - [ ] Capture Output (Remove)

Click new - File - html     and save this file as MyApplet1.html

<BODY>

<APPLET code=MyApplet.class width=400 height=400 >

</APPLET>

</BODY>

Save this file MyApplet.html and press CTRL+3 to see appletview. When you click CTRL+3, MyApplet.html file get executed which run Applet MyApplet.class which prints “Hello” at 100th row and 100th column.
Next Applet takes values (parameters) from HTML page and print it on the screen.

import java.applet.*;
import java.awt.*;
public class ParamApplet extends Applet
{
    String s;
    int x,y;
    public void init()
    {
        s = getParameter("N");
        String s1 = getParameter("X");
        String s2 = getParameter("Y");
        x = Integer.parseInt(s1);
        Integer j = new Integer(s2);
        y=j.intValue();
    }
    public void paint(Graphics g)
    {
        g.drawString(s,x,y);
    }
}

Click new -> File -> html    and save this file as ParamApplet1.html

<BODY BGCOLOR="#FFFFFF">

<Applet code=ParamApplet.class width=400 height=400>

<Param name="N" value="ABC">

<Param name="X" value="100">

<Param name="Y" value="200">

</Applet>

</BODY>

OUTPUT : ABC get printed at 100th row and 100th column
Life Cycle of an Applet : String is an immutable class whereas StringBuffer is a mutable object which means any changes.
We use the toString() method to convert an Object to a string.

import java.applet.*;
import java.awt.*;
public class LifeCycleApplet extends Applet
{
    StringBuffer sb;
    public void init()
    {
        sb = new StringBuffer();
        sb.append("init ");
    }
    public void start()
    {
        sb.append("start ");
    }
    public void stop()
    {
        sb.append("stop ");
    }
    public void paint(Graphics g)
    {
        g.drawString(sb.toString(),100,100);
    }
}

Click new -> File -> html    and save this file as ParamApplet1.html

<BODY BGCOLOR="#FFFFFF">

<Applet code=ParamApplet.class width=400 height=400>

<Param name="N" value="ABC">

<Param name="X" value="100">

<Param name="Y" value="200">

</Applet>

</BODY>

OUTPUT : ABC get printed at 100th row and 100th column
Life Cycle of an Applet : String is an immutable class whereas StringBuffer is a mutable object which means any changes.
We use the toString() method to convert an Object to a string.

import java.applet.*;
import java.awt.*;
public class LifeCycleApplet extends Applet
{
    StringBuffer sb;
    public void init()
    {
        sb = new StringBuffer();
        sb.append("init ");
    }
    public void start()
    {
        sb.append("start ");
    }
    public void stop()
    {
        sb.append("stop ");
    }
    public void paint(Graphics g)
    {
        g.drawString(sb.toString(),100,100);
    }
}

Click new -> File -> html    and save this file as LifeCycleApplet.html

<BODY BGCOLOR="#FFFFFF">

<APPLET code=LifeCycleApplet.class height=400 width=400>

</APPLET>

</BODY>

Method In Applet :

import java.applet.*;
import java.awt.*;
import java.net.*;
public class CodeDocTextApplet extends Applet
{
    URL u1, u2;
    public void init()
    {
        u1 = getCodeBase();
        u2 = getDocumentBase();
    }
    public void paint(Graphics g)
    {
        g.drawString(u1.toString(),50,50);
        g.drawString(u2.toString(),50,100);
    }
}

Click new -> File -> html    and save this file as CodeDocTextApplet.html

<BODY>

<APPLET code=CodeDocTextApplet.class HEIGHT=200 WIDTH=400 >

</APPLET>

</BODY>

AWT-(Abstract Window Toolkit)

2010-02-12T20:15:00.000-08:00

Three categories of AWT controls are :
1.    Non-Menu Components
2.    Container Components
3.    Menu Components
Two categories of Container Components are :
1.    Panel and Applet
2.    Window and Frame
Two reasons for the bifurcation :
1.    Based on the type of Application
2.    Based on the type of Layout Manager

Panel and Applet has Flow Layout as its default Layout Manager and Frame and Window has Border as its Layout Manager

In a Border Layout one control in one position in a frame at a time.

1) Application and Applet

1) Application
import java.awt.*;
class Login
{
    Frame f;
    Label l1, l2;
    TextField tf1, tf2;
    Button b1;
    Login()
    {
        f=new Frame("Login");
        l1=new Label("Login");
        l2=new Label("Password");
        tf1=new TextField(10);
        tf2=new TextField(10);
        b1=new Button("OK");

        //Change in Layout Manager if necessary
        f.setLayout(new FlowLayout());

        f.add(l1);
        f.add(tf1);
        f.add(l2);
        f.add(tf2);
        f.add(b1);

        f.setSize(100,400);
        f.setVisible(true);
    }
    public static void main(String args[])
{
        Login x = new Login();
    }
}

1) Applet
import java.awt.*;
import java.applet.*;
public class LoginApplet extends Applet
{
    Frame f;
    Label l1, l2;
    TextField tf1, tf2;
    Button b1;

    public void init()
    {
        f=new Frame("Login");
        l1=new Label("Login");
        l2=new Label("Password");
        tf1=new TextField(10);
        tf2=new TextField(10);
        b1=new Button("OK");

        add(l1);
        add(tf1);
        add(l2);
        add(tf2);
        add(b1);

    }
}

Click new -> File -> html    and save this file as CodeDocTextApplet.html

<BODY>

<APPLET code= LoginApplet.class HEIGHT=200 WIDTH=400 >

</APPLET>

</BODY>

Listener

2010-02-11T20:54:00.000-08:00

1.    An Event is an object generated by the component on user inter action
2.    An Event Source is a component which generated the Event.
3.    An Event Listener is an object to which the component has delegated the task of handling the Event.
4.    The Event Handlers are the methods inside the Event Listener which actually handle the Event.
5.    The Event Listener should be registered with the Event Source to receive Events.

Application 1 :     Take a Login and Password from the user and display it on the screen on clicking OK button and clear both the TextFields on clicking RESET button.

import java.awt.event.*;
import java.awt.*;
import java.applet.*;
class Login1 implements ActionListener
{
    Frame f;
    Label l1, l2;
    TextField tf1, tf2,tf3;
    Button b1, b2;

    Login1()
    {
        f=new Frame("Login");
        l1=new Label("Login");
        l2=new Label("Password");
        tf1=new TextField(10);
        tf2=new TextField(10);
        tf3 =new TextField(35);
        b1=new Button("OK");
        b2=new Button("RESET");

        //Change in Layout Manager if necessary
        f.setLayout(new FlowLayout());

        f.add(l1);
        f.add(tf1);
        f.add(l2);
        f.add(tf2);
        f.add(b1);
        f.add(b2);
        b1.addActionListener(this);
        b2.addActionListener(this);
        tf2.setEchoChar('*');

        f.setSize(100,400);
        f.setVisible(true);
    }
    public void actionPerformed(ActionEvent e)
       {
        if (e.getSource() == b1)
        {
            String s = tf1.getText();
            String s1 = tf2.getText();
            System.out.println("Login = "+s+" "+"Password = "+s1);
        }
        else
        {
            tf1.setText(" ");
            tf2.setText("");
        }
    }
    public static void main(String [] args)
    {
        Login1 x = new Login1();
    }
}

Applet 1 : Take a Login and Password from the user and display it on the third TextField which appears only on clicking OK button and clear both the TextFields on clicking RESET button.

import java.awt.*;
import java.applet.*;
import java.awt.event.*;
public class LoginApplet1 extends Applet implements ActionListener
{
    Frame f;
    Label l1, l2;
    TextField tf1, tf2, tf3;
    Button b1,b2;

    public void init()
    {
        f=new Frame("Login");
        l1=new Label("Login");
        l2=new Label("Password");
        tf1=new TextField(10);
        tf2=new TextField(10);
        tf3=new TextField(35);
        b1=new Button("OK");
        b2=new Button("RESET");
        tf3.setVisible(false);

        add(l1);
        add(tf1);
        add(l2);
        add(tf2);
        add(b1);
        add(b2);
        add(tf3);

        b1.addActionListener(this);
        b2.addActionListener(this);
        tf2.setEchoChar('*');

    }

    public void actionPerformed(ActionEvent e)
    {
        if(e.getSource() == b1)
        {
            String s = tf1.getText();
            String s1 = tf2.getText();
            tf3.setText("Login : "+s+" "+"Password : "+s1);
            tf3.setVisible(true);
        }
        else
        {
            tf3.setVisible(false);
            tf1.setText(" ");
            tf2.setText("");
        }
        validate(); // to rearrange controls
        repaint();   // to get back to original screen
    }
}

Click new -> File -> html    and save this file as LoginApplet1.html

<BODY>

<Applet code=LoginApplet1.class height=100 width=400 >

</Applet>

</BODY>

Application 2 : Display 4 Buttons (“NORTH”, “SOUTH”, “EAST”,”WEST”) in four parts of Frame and TextArea in the center. On clicking any button, display the button name in the TextArea.

import java.applet.*;

import java.awt.*;
import java.awt.event.*;
class Frame1 implements ActionListener
{
    Frame f;
    TextArea ta;
    Button b1, b2, b3, b4;

    Frame1()
    {
        f = new Frame("Border Frame");
        ta = new TextArea(20,20);
        b1 = new Button("NORTH");
        b2 = new Button("SOUTH");
        b3 = new Button("EAST");
        b4 = new Button("WEST");

        f.add(b1,BorderLayout.NORTH);
        f.add(b2,BorderLayout.SOUTH);
        f.add(b3,BorderLayout.EAST);
        f.add(b4,BorderLayout.WEST);
        f.add(ta,BorderLayout.CENTER);

        b1.addActionListener(this);
        b2.addActionListener(this);
        b3.addActionListener(this);
        b4.addActionListener(this);

        f.setSize(400,400);
        f.setVisible(true);
    }
    public void actionPerformed(ActionEvent e)
    {
        if(e.getSource() == b1)
            ta.append("NORTH\n");
        else
            if(e.getSource() == b2)
                ta.append("SOUTH\n");
            else
                if(e.getSource() == b3)
                    ta.append("EAST\n");
                else
                    ta.append("NORTH\n");
    }
    public static void main(String [] args)
    {
        Frame1 f = new Frame1();
    }
}

Applet 2 : Same as above
import java.applet.*;
import java.awt.*;
import java.awt.event.*;
public class FrameApplet1 extends Applet implements ActionListener
{
    Frame f;
    TextArea ta;
    Button b1, b2, b3, b4;

    public void init()
    {
        f = new Frame("Border Frame");
        ta = new TextArea(20,20);
        b1 = new Button("NORTH");
        b2 = new Button("SOUTH");
        b3 = new Button("EAST");
        b4 = new Button("WEST");

        add(b1,BorderLayout.NORTH);
        add(b2,BorderLayout.SOUTH);
        add(b3,BorderLayout.EAST);
        add(b4,BorderLayout.WEST);
        add(ta,BorderLayout.CENTER);

        b1.addActionListener(this);
        b2.addActionListener(this);
        b3.addActionListener(this);
        b4.addActionListener(this);
    }
    public void actionPerformed(ActionEvent e)
    {
        if(e.getSource() == b1)
            ta.append("NORTH\n");
        else
            if(e.getSource() == b2)
                ta.append("SOUTH\n");
            else
                if(e.getSource() == b3)
                    ta.append("EAST\n");
                else
                    ta.append("NORTH\n");
        validate();
        repaint();
    }
}

Click new -> File -> html and save this file as FrameApplet1.html

Rules of AWT :

1) Declare the Controls.

2) Initialize the Controls in Constructor or init() method.
3) Change Layout Manager.
4) Add Controls to Container.
5) Register the Listener.
6) Set Size and Visibility of the Frame.

Frame is for grouping Controls.
Panel is for grouping Components.

import java.awt.*;

import java.applet.*;
import java.awt.event.*;
public class FramePanel extends Applet implements ActionListener
{
    Frame f;
    TextField tf1;
    Button b1;
    Panel p;
    TextArea ta1;

    public void init()
{
        f = new Frame("Frame With Panel");
        tf1 = new TextField(20);
        b1 = new Button("OK");
        p = new Panel();
        ta1 = new TextArea(10,20);
        add(ta1);
        add(p);
        p.add(tf1);
        p.add(b1);
        add(p,BorderLayout.SOUTH);
        tf1.requestFocus();
        tf1.addActionListener(this);
        b1.addActionListener(this);
    }
    public void actionPerformed(ActionEvent e)
    {
        String s = tf1.getText();
        tf1.setText(" ");
        tf1.requestFocus();
        ta1.append(s+"\n");
    }
}

Click new -> File -> html    and save this file as FrameApplet1.html

<BODY>

<Applet code=FramePanel1.class height=100 width=400 >

</Applet>

</BODY>

Applet : Whatever is typed inside TextField is added to dropdown Choice Popup when ADD Button is selected and is deleted from dropdown Choice Popup when DELETE Button is clicked.

import java.awt.*;

import java.applet.*;
import java.awt.event.*;
public class FramePopup extends Applet implements ActionListener
{
    Frame f;
    TextField tf1;
    Button b1,b2;
    Choice c;
    public void init()
{
        f = new Frame("Frame With Popup");
        tf1 = new TextField(20);
        b1 = new Button("ADD");
        b2 = new Button("DELETE");
        c = new Choice();
        add(tf1);
        add(b1);
        add(b2);
        add(c);
        b1.addActionListener(this);
        b2.addActionListener(this);
    }
    public void actionPerformed(ActionEvent e)
    {
        if(e.getSource() == b1)
        {
            String s = tf1.getText();
            c.add(s);
            tf1.setText(" ");
        }
        else if(e.getSource() == b2)
        {
            String s1 = c.getSelectedItem();
            c.remove(s1);
            tf1.setText(" ");
        }
        f.validate();
        f.repaint();
       }
}

Click new  File  html and save this file as FramePopup.html

Application : There are two Panels with different background. In one panel, there are two Buttons. On clicking ADD Button, a TextField appears. Whatever user type in this TextField is added as a Button in second Panel and at the same time the TextField disappears. On clicking DELETE Button, again a TextField appears. After user type in this TextField, the same name Button gets deleted from second Panel.

import java.awt.*;

import java.applet.*;
import java.awt.event.*;
class FramePanel2 implements ActionListener
{
   Frame f;
   Panel p1, p2;
   TextField tf1, tf2;
   Button b1,b2;

   FramePanel2()
   {
       f=new Frame("Frame with Panels");
       p1 = new Panel();
       p1.setBackground(Color.red);
       p2 = new Panel();
       p2.setBackground(Color.green);
       b1 = new Button("ADD");
       b2 = new Button("DELETE");

       //Change in Layout Manager if necessary
       f.setLayout(new FlowLayout());

       f.add(p1);
       p1.add(b1);
       p1.add(b2);
       f.add(p2);

       b1.addActionListener(this);
       b2.addActionListener(this);

       f.setSize(400,400);
       f.setVisible(true);
   }
   public void actionPerformed(ActionEvent e)
{
       if (e.getSource() == b1)
       {
           tf1 = new TextField(20);
           tf1.addActionListener(this);
           p1.add(tf1);
           tf1.requestFocus();
           b1.setEnabled(false);
           b2.setEnabled(false);
       }
       else
       if(e.getSource() == tf1)
       {
           String s1 = tf1.getText();
           tf1.setText(" ");
           p1.remove(tf1);
           Button b3 = new Button(s1);
           p2.add(b3);
           b1.setEnabled(true);
           b2.setEnabled(true);
       }
       else
       if(e.getSource() == b2)
       {
           tf2 = new TextField(20);
           tf2.addActionListener(this);
           p1.add(tf2);
           tf2.requestFocus();
           b1.setEnabled(false);
           b2.setEnabled(false);
       }
       else
       if(e.getSource() == tf2)
       {
           String s2 = tf2.getText();
           Component c[] = p2.getComponents();
           for(int i = 0; i < c.length; i++)
           {
               if(c[i] instanceof java.awt.Button)
               {
                   Button b4 = (Button) c[i];
                   if(s2.equals(b4.getLabel()))
                   {
                       p2.remove(b4);
                   }
               }
           }
           p1.remove(tf2);
           b1.setEnabled(true);
           b2.setEnabled(true);

           Component c1[] = p2.getComponents();
           if(c1.length == 0)
           {
               b2.setEnabled(false);
           }
       }
       f.validate();
       f.repaint();
   }
   public static void main(String [] args)
   {
       FramePanel2 x = new FramePanel2();
   }
}

Application : Menu “File” is displayed on the Frame. On clicking File the Popup containing “Open”, “Save” and “Exit”; options are displayed. On clicking “Open” option FileDialog appears which let user to open file from hard disk. On clicking “Save” option FileDialog appears which let user to save file to hard disk. On clicking “Exit” option Panel containing “YES” and “NO” Buttons appear. On clicking “YES” Button application is closed whereas on clicking “NO” Button, Panel disappear.

import java.awt.*;
import java.awt.event.*;
class FrameMenu implements ActionListener
{
    Frame f;
    Menu m;
    MenuBar mb;
    MenuItem m1, m2, m3;
    Panel p;
    Button b1, b2;
    Dialog d;
    FileDialog fd1, fd2;

    FrameMenu()
    {
        f=new Frame("Frame with Menu");
        m = new Menu("File");
        mb = new MenuBar();
        m1 = new MenuItem("Open");
        m2 = new MenuItem("Save");
        m3 = new MenuItem("Exit");
        fd1 = new FileDialog(f, "Open File",FileDialog.LOAD);
        fd2= new FileDialog(f, "Save File",FileDialog.SAVE);
        d = new Dialog(f, "Are You Sure");
        p = new Panel();
        b1 = new Button("YES");
        b2 = new Button("NO");

        //Change in Layout Manager if necessary
        //f.setLayout(new FlowLayout());

        m.add(m1);
        m.add(m2);
        m.add(m3);
        mb.add(m);
        f.setMenuBar(mb);

        m1.addActionListener(this);
        m2.addActionListener(this);
        m3.addActionListener(this);

        f.setSize(200,200);
        f.setVisible(true);
    }
    public void actionPerformed(ActionEvent e)
       {
        if (e.getSource() == m1)
        {
            fd1.show();
        }
        else
        if(e.getSource() == m2)
        {
            fd2.show();
        }
        else
        if(e.getSource() == m3)
        {
            d.setSize(100,100);
            d.setVisible(true);
            d.add(p);
            p.add(b1);
            p.add(b2);
            b1.addActionListener(this);
            b2.addActionListener(this);
        }
        else
        if(e.getSource() == b1)
        {
            System.exit(0);
        }
        else
        if(e.getSource() == b2)
        {
            d.setVisible(false);
        }
        f.validate();
        f.repaint();
    }
    public static void main(String [] args)
    {
        FrameMenu x = new FrameMenu();
    }
}

Adjustment Listener

2010-02-10T21:19:00.000-08:00

ScrollBar
    Public void adjustmentValueChanged(ActionEvent e)
    {
        ----
        ----
    }

Applet : Three ScrollBars each displaying colour value for r, g, and b respectively. On changing these three values, the TextField as well as the Background color is changed to that color and at the same time color code is displayed in TextField.
ScrollBar sb1, sb2, sb3;
Sb1 = new ScrollBar(ScrollBar.VERTICAL,
    0,    starting point
    1,     increment
    0,     minimum value
    255,)    maximum value

import java.awt.*;
import java.applet.*;
import java.awt.event.*;
public class FrameScroll extends Applet implements AdjustmentListener
{
   Frame f;
   TextField tf1;
   Scrollbar sb1, sb2, sb3;

   public void init()
    {
       f = new Frame("Frame With Scroll");
       tf1 = new TextField(20);
       sb1 = new Scrollbar(Scrollbar.VERTICAL,0,1,0,255);
       sb2 = new Scrollbar(Scrollbar.VERTICAL,0,1,0,255);
       sb3 = new Scrollbar(Scrollbar.VERTICAL,0,1,0,255);

       add(sb1);
       add(sb2);
       add(sb3);
       add(tf1);

//       add.setLayout(new FlowLayout());
       sb1.addAdjustmentListener(this);
       sb2.addAdjustmentListener(this);
       sb3.addAdjustmentListener(this);
   }
   public void adjustmentValueChanged(AdjustmentEvent e)
   {
       repaint();
   }
   public void paint(Graphics g)
   {
       int a = sb1.getValue();
       int b = sb2.getValue();
       int c = sb3.getValue();
       Color d = new Color(a,b,c);
       setBackground(d);
       tf1.setText(a+" "+b+" "+c);
       tf1.setBackground(d);
   }
}

Click new -> File -> html and save this file as FrameScroll.html

<BODY>

<Applet code=FrameScroll.class height=100 width=400 >

</Applet>

</BODY>

Applet : Take color value in three TextField for r, g, and b respectively. On clicking “SHOW COLOR” Button, change the Background color to that color.

import java.awt.*;
import java.applet.*;
import java.awt.event.*;
public class FrameColors extends Applet implements ActionListener
{
    Frame f;
    TextField tf1, tf2, tf3;
    Button b1;

    public void init()
       {
        f = new Frame("Frame With Scroll");
        tf1 = new TextField(5);
        tf2 = new TextField(5);
        tf3 = new TextField(5);
        b1 = new Button("Show Color");

        add(tf1);
        add(tf2);
        add(tf3);
        add(b1);

//        add.setLayout(new FlowLayout());
        tf1.addActionListener(this);
        tf2.addActionListener(this);
        tf3.addActionListener(this);
        b1.addActionListener(this);
    }
    public void actionPerformed(ActionEvent e)
    {
        repaint();
    }
    public void paint(Graphics g)
    {
        String x = tf1.getText();
        String y = tf2.getText();
        String z = tf3.getText();

        int a = Integer.parseInt(x);
        int b = Integer.parseInt(y);
        int c = Integer.parseInt(z);

        Color d = new Color(a,b,c);
        setBackground(d);
    }
}

Click new -> File -> html and save this file as FrameColors.html

<BODY>

<Applet code=FrameColors.class height=100 width=400 >

</Applet>

</BODY>

Component Listeners

2010-02-09T19:25:00.000-08:00

Component Shown
Component Hidden
Component Moved
Component Resized

Applet : On clicking “SHOW” Button, a Component Frame appears on the screen and simultaneously word “Shown” is displayed in the TextArea. On moving or resizing Frame Component, the word “Moved” or “Resized” appear in the TextArea. On clicking “HIDDEN” Button, Frame Component disappear and word “Hidden” is displayed in TextArea.

import java.awt.*;

import java.applet.*;
import java.awt.event.*;
public class FrameComponent extends Applet implements ActionListener,ComponentListener
{
    Frame f1;
    TextArea ta1;
    Button b1, b2;
    public void init()
{
       f1 = new Frame("Frame With Component");
       ta1 = new TextArea(20,20);
       b1 = new Button("Show");
       b2 = new Button("Hide");

       add(b1);
       add(b2);
       add(ta1);

       b1.addActionListener(this);
       b2.addActionListener(this);
       f1.addComponentListener(this);
    }
    public void actionPerformed(ActionEvent e)
    {
       if(e.getSource() == b1)
       {
           f1.setVisible(true);
       }
       else
       if(e.getSource() == b2)
       {
           f1.setVisible(false);
       }
    }
    public void componentShown(ComponentEvent e1)
    {
       ta1.append("Shown\n");
    }
    public void componentHidden(ComponentEvent e1)
    {
       ta1.append("Hidden\n");
    }
    public void componentMoved(ComponentEvent e1)
    {
       ta1.append("Moved\n");
    }
    public void componentResized(ComponentEvent e1)
    {
       ta1.append("Resized\n");
    }
}

Click new -> File -> html and save this file as FrameComponent.html

Item Listener

2010-02-08T19:27:00.000-08:00

List
Checkbox
Choice
CheckboxGroup (Radio Buttons)

Public void itemStateChanged(ItemEvent)
{
------
------
}

import java.awt.*;
import java.applet.*;
import java.awt.event.*;
public class FrameCheckbox extends Applet implements ItemListener
{
    Checkbox cb1, cb2, cb3;

    public void init()
{
        cb1 = new Checkbox("Java");
        cb2 = new Checkbox("VB");
        cb3 = new Checkbox("C++");

        add(cb1);
        add(cb2);
        add(cb3);

        cb1.addItemListener(this);
        cb2.addItemListener(this);
        cb3.addItemListener(this);
    }
    public void itemStateChanged(ItemEvent e)
    {
        repaint();
    }
    public void paint(Graphics g)
    {
        g.drawString("Books Selected",100,100);
        if(cb1.getState())
        {
            g.drawString("Java",100,120);
        }
        if(cb2.getState())
        {
            g.drawString("VB",100,130);
        }
        if(cb3.getState())
        {
            g.drawString("C++",100,140);
        }
    }
}

Click new -> File -> html and save this file as FrameCheckbox.html

<BODY>

<Applet code=FrameCheckbox.class height=200 width=400 >

</Applet>

</BODY>

Applet : This is to display Radio Buttons.

import java.awt.*;
import java.applet.*;
import java.awt.event.*;
public class FrameCheckboxGroup extends Applet implements ItemListener
{
    Checkbox cb1, cb2;
    CheckboxGroup cbg1;

    public void init()
{
        cbg1 = new CheckboxGroup();
        cb1 = new Checkbox("Male",cbg1,false);
        cb2 = new Checkbox("Female",cbg1,false);

        add(cb1);
        add(cb2);

        cb1.addItemListener(this);
        cb2.addItemListener(this);
    }
    public void itemStateChanged(ItemEvent e)
    {
        repaint();
    }
    public void paint(Graphics g)
    {
        g.drawString("Sex is : ",100,100);
        if(cb1.getState())
        {
            g.drawString("Male",150,100);
        }
        if(cb2.getState())
        {
            g.drawString("Female",150,100);
        }
    }
}

Click new -> File -> html    and save this file as FrameCheckboxGroup.html

<BODY>

<Applet code=FrameCheckboxGroup.class height=200 width=400 >

</Applet>

</BODY>

Applet : Choice (Dropdown List)

import java.awt.*;
import java.applet.*;
import java.awt.event.*;
public class FrameChoice extends Applet implements ItemListener
{
    Choice c;

    public void init()
{
        c = new Choice();
        c.add("Select Option");
        c.add("Under Graduate");
        c.add("Graduate");
        c.add("Post Graduate");
        add(c);
        c.addItemListener(this);
    }
    public void itemStateChanged(ItemEvent e)
    {
        repaint();
    }
    public void paint(Graphics g)
    {
        g.drawString("Qualification : ",100,100);
        String s1 = c.getSelectedItem();
        if(s1 == "Under Graduate")
        {
            g.drawString("Under Graduate",200,100);
        }
        if(s1 == "Graduate")
        {
            g.drawString("Graduate",200,100);
        }
        if(s1 == "Post Graduate")
        {
            g.drawString("Post Graduate",200,100);
        }
    }
}

Click new -> File -> html and save this file as FrameChoice.html

<BODY>

<Applet code=FrameChoice.class height=200 width=400 >

</Applet>

</BODY>