Sample Login And Validation

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class Login extends JFrame implements ActionListener
{
public JTextField t1;
public TextField t2;
public JLabel l1,l2,l3;
public JButton b1,b2;
public JPanel panel;
public Font g;

public Login()
{
g=new Font("",Font.BOLD,18);
getContentPane().setBackground(Color.magenta);
panel=(JPanel)getContentPane();
panel.setLayout(null);
l1=new JLabel("LOGIN FORM");

l2=new JLabel("LOGIN");
l3=new JLabel("PASSWORD");
t1=new JTextField(20);
t2=new TextField(20);
t2.setEchoChar('*');
b1=new JButton("OK");
b2=new JButton("EXIT");

panel.add(l1);
l1.setFont(g);
panel.add(l2);
panel.add(l3);

panel.add(t1);
panel.add(t2);
panel.add(b1);
panel.add(b2);


l1.setBounds(100,5,150,40);
l2.setBounds(30,60,100,30);
l3.setBounds(30,110,100,30);

t1.setBounds(140,60,150,30);
t2.setBounds(140,110,150,30);

b1.setBounds(140,180,60,30);
b2.setBounds(220,180,65,30);

t1.addActionListener(this);
t2.addActionListener(this);

b1.addActionListener(this);
b2.addActionListener(this);
}
public void actionPerformed(ActionEvent a)
{
String s1="mrp";
String s2="pandey";
String s3="OK";
String s4="EXIT";
String str=a.getActionCommand();

if(s3.equals(str))
{
if(s1.equals(t1.getText()) && s2.equals(t2.getText()))
{
this.dispose();
menu p=new menu();
p.setVisible(true);
p.setSize(800,700);
p.show();
this.dispose();
}
else
{
if(s3.equals(str))
{
t1.setText("");
t2.setText("");
JOptionPane.showMessageDialog(null,"Please varify the correct Login and Password","Warning",JOptionPane.OK_CANCEL_OPTION);
}
}
}

if( str=="EXIT")
{
JOptionPane.showMessageDialog(null,"The project is still in progress,do u want to quit now","Warning",JOptionPane.OK_CANCEL_OPTION);
if(s4.equals(str))
{
System.exit(0);
}
repaint();
}

}
public static void main(String args[])
{
Login f=new Login();
f.setVisible(true);
f.setSize(800,600);
f.show();
}

}

Multiple Interface

interface A {
}

interface B {
}

class X implements A, B {
}

class Y implements A {
B makeB() {
// Anonymous inner class:
return new B() {
};
}
}

public class MultiInterfaces {
static void takesA(A a) {
}

static void takesB(B b) {
}

public static void main(String[] args) {
X x = new X();
Y y = new Y();
takesA(x);
takesA(y);
takesB(x);
takesB(y.makeB());
}
} ///:~

Interface Inherit

/** Find out whether interfaces are inherited.
* Start with Thread which implements Runnable.
*/
public class InterfaceInherit extends Thread {
public static void main(String[] a) {
new InterfaceInherit().start();
}
public void run() {
if (this instanceof InterfaceInherit)
System.out.println("This is InterfaceInherit");
if (this instanceof Thread)
System.out.println("This is Thread");
if (this instanceof Runnable)
System.out.println("This is Thread -- Interfaces ARE inherited!");
}
}

Interface

interface I1 {

void methodI1(); // public static by default
}

interface I2 extends I1 {

void methodI2(); // public static by default
}

class A1 {

public String methodA1() {
String strA1 = "I am in methodC1 of class A1";
return strA1;
}
public String toString() {
return "toString() method of class A1";
}
}

class B1 extends A1 implements I2 {

public void methodI1() {
System.out.println("I am in methodI1 of class B1");
}
public void methodI2() {
System.out.println("I am in methodI2 of class B1");
}
}

class C1 implements I2 {

public void methodI1() {
System.out.println("I am in methodI1 of class C1");
}
public void methodI2() {
System.out.println("I am in methodI2 of class C1");
}
}


abstract class D1 implements I2 {

public void methodI1() {
}

}

public class InterFaceEx {

public static void main(String[] args) {
I1 i1 = new B1();
i1.methodI1();
((I2) i1).methodI2();
I2 i2 = new B1();
i2.methodI1();
i2.methodI2();


String var2 = ((A1) i1).methodA1();
System.out.println("var2 : " + var2);
String var3 = ((B1) i1).methodA1();
System.out.println("var3 : " + var3);
String var4 = i1.toString();
System.out.println("var4 : " + var4);
String var5 = i2.toString();
System.out.println("var5 : " + var5);
I1 i3 = new C1();
String var6 = i3.toString();
System.out.println("var6 : " + var6);
Object o1 = new B1();

((I1) o1).methodI1();
((I2) o1).methodI1();
((B1) o1).methodI1();

}
}

Thread Pool

public class ThreadPoolTest {

public static void main(String[] args) {
if (args.length != 2) {
System.out.println("Tests the ThreadPool task.");
System.out.println(
"Usage: java ThreadPoolTest numTasks numThreads");
System.out.println( " numTasks - integer: number of task to run.");
System.out.println( " numThreads - integer: number of threads " +
"in the thread pool.");
return;
}
int numTasks = Integer.parseInt(args[0]);
int numThreads = Integer.parseInt(args[1]);

// create the thread pool
ThreadPool threadPool = new ThreadPool(numThreads);

// run example tasks
for (int i=0; i<numTasks; i++) {
threadPool.runTask(createTask(i));
}

// close the pool and wait for all tasks to finish.
threadPool.join();
}


/**
Creates a simple Runnable that prints an ID, waits 500
milliseconds, then prints the ID again.
*/
private static Runnable createTask(final int taskID) {
return new Runnable() {
public void run() {
System.out.println("Task " + taskID + ": start");

// simulate a long-running task
try {
Thread.sleep(500);
}
catch (InterruptedException ex) { }

System.out.println("Task " + taskID + ": end");
}
};
}
}







import java.util.LinkedList;

/**
A thread pool is a group of a limited number of threads that
are used to execute tasks.
*/
public class ThreadPool extends ThreadGroup {

private boolean isAlive;
private LinkedList taskQueue;
private int threadID;
private static int threadPoolID;

/**
Creates a new ThreadPool.
@param numThreads The number of threads in the pool.
*/
public ThreadPool(int numThreads) {
super("ThreadPool-" + (threadPoolID++));
setDaemon(true);

isAlive = true;

taskQueue = new LinkedList();
for (int i=0; i<numThreads; i++) {
new PooledThread().start();
}
}


/**
Requests a new task to run. This method returns
immediately, and the task executes on the next available
idle thread in this ThreadPool.

Tasks start execution in the order they are received.
@param task The task to run. If null, no action is taken.
@throws IllegalStateException if this ThreadPool is
already closed.
*/
public synchronized void runTask(Runnable task) {
if (!isAlive) {
throw new IllegalStateException();
}
if (task != null) {
taskQueue.add(task);
notify();
}

}


protected synchronized Runnable getTask()
throws InterruptedException
{
while (taskQueue.size() == 0) {
if (!isAlive) {
return null;
}
wait();
}
return (Runnable)taskQueue.removeFirst();
}


/**
Closes this ThreadPool and returns immediately. All
threads are stopped, and any waiting tasks are not
executed. Once a ThreadPool is closed, no more tasks can
be run on this ThreadPool.
*/
public synchronized void close() {
if (isAlive) {
isAlive = false;
taskQueue.clear();
interrupt();
}
}


/**
Closes this ThreadPool and waits for all running threads
to finish. Any waiting tasks are executed.
*/
public void join() {
// notify all waiting threads that this ThreadPool is no
// longer alive
synchronized (this) {
isAlive = false;
notifyAll();
}

// wait for all threads to finish
Thread[] threads = new Thread[activeCount()];
int count = enumerate(threads);
for (int i=0; i<count; i++) {
try {
threads[i].join();
}
catch (InterruptedException ex) { }
}
}


/**
A PooledThread is a Thread in a ThreadPool group,
designed to run tasks (Runnables).
*/
private class PooledThread extends Thread {


public PooledThread() {
super(ThreadPool.this,
"PooledThread-" + (threadID++));
}


public void run() {
while (!isInterrupted()) {

// get a task to run
Runnable task = null;
try {
task = getTask();
}
catch (InterruptedException ex) { }

// if getTask() returned null or was interrupted,
// close this thread by returning.
if (task == null) {
return;
}

// run the task, and eat any exceptions it throws
try {
task.run();
}
catch (Throwable t) {
uncaughtException(this, t);
}
}
}
}
}


Run As : java ThreadPoolTest 5 2

Thread State

class ThreadStateDemo extends Thread{

Thread obj;
public static void main(String a[]){


new ThreadStateDemo();
}
ThreadStateDemo(){
obj=new Thread(this);

System.out.println("Thread obj is born");
System.out.println("Thread obj is ready");

obj.start();
}

public void run(){

System.out.println("THread obj is running");
}
}

Thread All Methods

class ChopStick{

boolean available;

ChopStick(){

available=true;
}

public synchronized void takeup(){

while(!available){
try
{
System.out.println("Hello is waiting for the other chopStick");
wait();
}
catch(InterruptedException e){}
}
available=false;
}

public synchronized void putdown(){

available=true;
notify();
}
}


class Hello extends Thread{

ChopStick left,right;

int hello_num;

Hello(int num,ChopStick chop1,ChopStick chop2){

hello_num=num;
left=chop1;
right=chop2;
}

public void eat(){

left.takeup();
right.takeup();
System.out.println("Hello "+(hello_num+1)+" is eating");
}

public void think(){

left.putdown();
right.putdown();

System.out.println("Hello "+(hello_num+1)+" is THinking");
}

public void run(){

while(true){

eat();
try
{
sleep(1000);
}
catch(InterruptedException ex){}

think();

try
{
sleep(1000);
}
catch(InterruptedException ex){}

}
}
}




class ThreadAllDemo{

static ChopStick[] chopsticks=new ChopStick[5];
static Hello[] hellos=new Hello[5];

public static void main(String a[]){

for(int count=0;count<=4;count++){

chopsticks[count]=new ChopStick();
}

for(int count=0;count<=4;count++){

hellos[count]=new Hello(count,chopsticks[count],chopsticks[(count+1)%5]);
}


for(int count=0;count<=4;count++){

hellos[count].start();
}
}
}

Thread Synchronization Methods

class One{

synchronized void display(int num){

System.out.println(""+num);

try
{

Thread.sleep(1000);
}
catch(InterruptedException e){
System.out.println("Error : "+e);
}
System.out.println("Done");
}
}

class Two implements Runnable{

int number;
One objo;
Thread objo1;

public Two(One one_num,int num){

objo=one_num;

number=num;

objo1=new Thread(this);
objo1.start();
}

public void run(){

objo.display(number);
}
}


class SynchMethod{
public static void main(String a[]){


One objo=new One();

int digit=10;

Two objSynch1=new Two(objo,digit++);
Two objSynch2=new Two(objo,digit++);
Two objSynch3=new Two(objo,digit++);

//wait for THreads to end

try
{

objSynch1.objo1.join();
objSynch2.objo1.join();
objSynch3.objo1.join();
}
catch(InterruptedException ex){
System.out.println("Error : "+ex);
}

}
}

Thread Synchronization

class DemoOne{

void display(int num){

System.out.println(""+num);
try
{
Thread.sleep(1000);
}
catch(InterruptedException e){
System.out.println("Interrupted");
}
System.out.println("Done");
}
}



class DemoTwo implements Runnable{

int number;
DemoOne objone;
Thread objTh;

public DemoTwo(DemoOne one_num,int num){

objone=one_num;
number=num;

objTh=new Thread(this);

objTh.start();
}

public void run(){

synchronized(objone){
objone.display(number);
}
}
}



class SynchBlock{

public static void main(String a[]){

DemoOne objone=new DemoOne();

int digit=10;

DemoTwo objSynch1=new DemoTwo(objone,digit++);
DemoTwo objSynch2=new DemoTwo(objone,digit++);
DemoTwo objSynch3=new DemoTwo(objone,digit++);

try
{//wait for Threads to end

objSynch1.objTh.join();
objSynch2.objTh.join();
objSynch3.objTh.join();
}
catch(InterruptedException ex){
System.out.println("Error : "+ex);
}
}
}

Thread Priority

class Priority extends Thread{

int num;

public Priority(int num){

this.num=num;
}


public void run(){
for(int count=0;count<=num;count++){
System.out.println("Count is "+count);
}

System.out.println(Thread.currentThread().getName());
System.out.println("Its Priority was : "+Thread.currentThread().getPriority());

Thread.currentThread().setPriority(MAX_PRIORITY);

System.out.println("Its Priority now is : "+Thread.currentThread().getPriority());
}



public static void main(String a[]){

for(int ctr=0;ctr<2;ctr++){

Priority obj=new Priority(5);

obj.start();
obj.setName("Thread "+(ctr+1));
}
}
}

Thread

class MyThread extends Thread{

public static void main(String ar[]){

MyThread obj=new MyThread();
obj.create();

System.out.println("This is the main Thread");
}

public void create(){

Thread obj1=new Thread(this);

obj1.start();
}

public void run(){

while(true){
try{
System.out.println("This is the child Thread ");
Thread.sleep(500);
}
catch(InterruptedException ex)
{
System.out.println("Error : "+ex);
}
}
}
}

Thread

class CurrentThDetails{

public static void main(String ar[]){

Thread current=Thread.currentThread();

//displays information
System.out.println("Current Thread Details : "+current);
current.setName("Demo Thread");

System.out.println("After changing the names : "+current);

}
}