Learn Java Language (Part -3)

Multi-threading

Introduction to java multi-threading

सब phone पर बात करते हुए खाना खा सकते है और साथ ही TV भी देख सकते है। हमारा दिमाग इस तरह प्रोग्राम किया हुआ है की हम एक साथ कई काम कर सकते है। इसे multitasking कहा जाता है। इसी तरह java का कोई भी प्रोग्राम एक साथ कई टास्क complete कर सकता है। Java के इस feature को multi-threading कहते है।

उदाहरण के लिए जब आपका प्रोग्राम user input के लिए wait कर रहा है तो इस समय में वह दूसरा कोई काम complete कर सकता है। जैसे ही database से connectivity की जा सकती है या फिर किसी file को upload किया जा सकता है। 

एक multi-threading प्रोग्राम के 2 या 2 से अधिक parts होते है। ये parts एक साथ execute किये जा सकते है। हर part thread कहलाता है। हर thread एक unique task complete करने के लिए responsible होती है। ये सभी threads main thread में होती है। आपके program की main थ्रेड main() method के साथ शुरू होती है। 

हर thread की एक life cycle होती है। इस life cycle में thread कई stages से गुजरती है। जब आप thread क्लास का object क्रिएट करते है, तो सबसे पहले एक thread new state में आती है। इसके बाद जब thread object पर start() मेथड कॉल किया जाता है तो thread runnable state में पहुँच जाती है। इसके बाद जब run() method कॉल होता है तो thread running state में होती है। इसके बाद ये thread को execution के लिए wait करना पड़े तो thread waiting state में पहुंच जाती है। और जब thread का execution complete हो जाता है तो तो thread destroyed stage में पहुँच जाती है।        

Java में multi-threading 2 तरह से implement की जा सकती है। पहले तरीके में आप thread क्लास को extend करते है। दूसरे तरीके में आप Runnable interface को implement करते है। जब आप चाहते है की आप run() मेथड के अलावा दूसरे methods भी program में यूज़ करे तो आप thread क्लास को extend कर सकते है। और यदि आप सिर्फ run() override करना चाहते है तो आप Runnable interface implement कर सकते है।

                       
1. Thread class implementation

Thread class बहुत सारे methods provide करती है। लेकिन thread class को implement करने के लिए आपको इन सभी methods को override करने की आवश्यकता नहीं है। आप सिर्फ run() मेथड override कर सकते है। Thread class के कुछ important methods निचे दिए जा रहे है। 

सबसे पहले आपको thread class को extend करना होगा। इसके बाद आप अपनी क्लास में run method को override करते है। यदि आप चाहे तो और भी methods को override कर सकते है। लेकिन run() method को override करना necessary है। इसके बाद आप अपनी इस class का object create करते है। Object create करते समय आप चाहे तो thread का एक unique नाम भी पास कर सकते है।

Object create करने के बाद आप उस object पर start() method कॉल करते है। start() मेथड automatically run() method को call करता है, और आपके thread का execution start हो जाता है। आप जितनी threads create करना चाहते है उतने ही object create करते है।

class JavaHindi extends thread
{
    public static void main(String args[])
    {
         JavaHindi jh = new JavaHindi();

         jh.start();
    } 

    Public void run()
    {
          System.out.println(“Thread is running at www.besthinditutorials.com”);
    }
}

2. Runnable interface implementation

Runnable interface में एक ही method होता है। run() method की definition आपको अपनी class में provide करनी होती है। सबसे पहले आप एक class create करते है, जो run() मेथड को implement करती है। इसके बाद आप Thread class का object क्रिएट करते है। इस thread क्लास के object में आप Runnable interface को implement करने वाली class का object और thread का नाम पास करते है। और उसके बाद आप thread class के object पर start() method को call करते है। 

जब आप Runnable interface को implement करने वाली क्लास का object thread क्लास के object में pass करते है तो thread क्लास का object उसी class के object को point करता है। इसका उदाहरण नीचे दिया जा रहा है।

class JavaHindi implements Runnable
{
    JavaHindi()
    {
        Thread t = new Thread(this,HindiThread);
        t.start();
    }   

    Public void run()
    {
          System.out.println(“Thread is running at www.besthinditutorials.com”);
    }

    public static void main(String args[])
    {
         JavaHindi jh = new JavaHindi();
    } 

}

         
3. Synchronization 

जब 2 या 2 से अधिक thread किसी एक resource (method) पर access चाहती है, तो conflict पैदा होता है। इस conflict से बचने के लिए आप एक technique यूज़ करते है। इस technique से एक समय पर एक ही thread वो resource access कर सकती है। इस technique को synchronization कहते है। 

Synchronization की technique में आप किसी method को synchronized बना देते है। इसके लिए आप उस मेथड की definition से पहले synchronized method add कर देते है। जैसे की synchronized void myMethod(){}.   

Synchronization के concept को समझने के लिए आपको monitor का concept समझना होगा। हर object के साथ उसका monitor जुड़ा होता है। जब कोई thread synchronized मेथड को call करती है, तो वो थ्रेड monitor में enter हो जाती है। जैसे ही thread monitor में enter होती है उस resource पर lock लग जाता है। अब जब तक ये thread इस resource को free नहीं करेगी तब तक दूसरी कोई भी thread इस resource को access नहीं कर सकती है। 

किसी भी resource को synchronized बनाने के 2 तरीके है। एक तो जैसे की मैने आपको बताया आप method के आगे synchronized keyword लगा सकते है और उसे synchronized बना सकते है। दूसरे तरीके में आप एक synchronized block create करते है। और इस block में उस class के methods को कॉल करते है, जिनको आप synchronized बनाना चाहते है। इसका उदाहरण निचे दिया जा रहा है।

Synchronized(s1) // s1 is the object of class of which methods you are going to call
{
   // call here methods that you want to make synchronized
}

Exams और interviews के point of view से java multi-threading एक बहुत ही important concept है।                    

File I/O

Introduction to java file I/O 

जब भी यूज़र से program में input लेने की बात होती है तो ऐसा program run करवाने के बाद console की मदद से किया जाता है और output भी console पर ही देखा जाता है। कुछ software ऐसे होते है जो बहुत सारे data को एक साथ execute करते है। इसलिए उनमें input भी इतना ही अधिक दिया जाता है।  लेकिन इतना सारा input किसी human के द्वारा हाथों से नहीं किया जा सकता है। Input के साथ ही कई बार output भी इतना अधिक हो सकता है की किसी human द्वारा इसको computer की screen पर देखना possible नहीं होता है। ऐसा भी हो सकता है की इस output की आपको किसी और execution में जरुरत पड़े या आप इसको print करना चाहते है। ऐसी situation में आप java के File I/O  mechanism को यूज़ कर सकते है। 

Java कुछ ऐसी classes provide करती है जिनकी मदद से आप input भी किसी file से read कर सकते है और output भी किसी file में store करवा सकते है। मेरा मतलब है यदि आप चाहे तो input console से लेने की बजाय किसी file से read कर सकते है और output भी console पर दिखाने की बजाए किसी file में store करके दिखा सकते है। 

Files के द्वारा input और output operations perform करने के लिए आप stream को यूज़ करते है। Data की sequence को stream कहते है। Input stream से input लिया जाता है। और output stream से output लिया जाता है। Java में streams 2 तरह की होती है। Byte stream में data bytes की form में होता है और character stream में data character की form में होता है। इन दोनों तरह की streams के बारे में निचे दिया जा रहा है।

1. Byte stream

Byte stream में data bytes की form में होता है। इसमें input और output के लिए 2 classes provide की गयी है। ये दोनों abstract classes होती है। ये classes ऐसे methods provide करती है जिनकी मदद से आप files के साथ operations perform करते है। इन classes के बारे में निचे दिया जा रहा है। 

2. InputStream

ये एक abstract class है। ये byte input stream class होती है। FileInputStream class इसे extend करती है। और इसके methods को file operations के लिए यूज़ करती है। 

FileInputStream एक byte stream input class है। इस class का object create करके आप byte input stream create करते है। फिर इस object पर different methods call करके files के साथ operations perform करते है। 

import java.io.*;

public class FileIOExample
{
     public static void main(String args[]) throws IOException
     {
         FileInputStream in = new FileInputStream("directory-address-of-file");

         int a;

         while((a = in.read()) != -1)
         {
              System.out.println((char)a);
              in.close();
         }
     }
}

4. OutputStream 

ये एक abstract class होती है। ये एक byte output stream class है। FileOutputStream class इसे extend करती है। इस class के कुछ methods निचे दिए हुए है जो FileOutputStream class यूज़ करती है। 

FileOutputStream class एक byte stream output class है। सबसे पहले आप इस class का object क्रिएट करते है और फिर उस object पर write method call करके bytes() को file में write() करते है। 

import java.io.*;

public class FileIOExample
{
    public static void main(String args[]) throws IOException
    {
        FileOutputStream out = new FileOutputStream("directory-address-to-store-file");

        a = 5;
     
        out.write(a);
        out.close();
    }
}
     
 
5. Character Stream

Character stream में data bytes में ना होकर सीधा characters की form में होता है। Character stream में input और ouput के लिए 2 abstract classes यूज़ की जाती है। इन classes के बारे में निचे दिया जा रहा है। 

6. Reader 

Reader एक abstract class है। ये एक character input stream class है। FileReader class इसे extend करती है। इस class के methods निचे दिए जा रहे है। 

FileReader एक character input stream class है। ये Reader class को extend करती है। इस class का object create करके आप character input stream create करते है। फिर उस object पर read method call करके data read करते है। 

import java.io.*;

public class FileIOExample
{
   FileReader in = new FileReader("director-address-of-file");
 
   int a;
 
   while((a=in.read())!=-1)
   {
        System.out.print((char)a);
        in.close();
   }
}

7. Writer 

ये एक abstract class है। ये एक character output stream class है। FileWriter class इसे extend करती है। इस class के कुछ methods होते है जिन्हें FileWriter class यूज़ करती है। 

FileWriter class का object create करके आप character output stream क्रिएट करते है। फिर उस object पर write() method call करके data write() करते है। 

import java.io.*;

public class FileIOExample
{
   public static void main(String args[]) throws IOException
   {
       FileWriter out = new FileWriter("directory-addres-of-File");
     
      int a = 5;

      out.write();

     out.close();
   }
}

Serialization

Introduction to java serialization 

आप कोई video game खेल रहे है और उसमे आप बहुत आगे जा चुके है। अब आपको आपकी माँ खाना खाने के लिए बुलाती है। और आप video game बंद करके खाना खाने चल जाते है। थोड़ी देर बाद आप वापस आते है। और video game start करते है। आपने game को जँहा छोड़ा था game वापस वँही से start हो जाता है। कल्पना कीजिये कैसा हो यदि आपको ये game शुरू से खेलना पड़े। लेकिन ऐसा नहीं होता है। इसी प्रकार आपके program में कुछ ऐसी processing हो सकती है जिसे आप थोड़े समय बाद वापस उसी जगह से शुरू कर सकते है। Java के इस feature को Serialization कहते है। 

Serialization में आप object की state को save करते है। जैसे की आप कोई music player बना रहे है। तो आपको उसमे pause और play का feature जरूर add करना पड़ेगा। यदि यूज़र song को pause करके जब वापस play करता है और song शुरू से शुरू हो जाता है तो यूज़र को आपका music player बिलकुल पसंद नहीं आएगा। ऐसे situation में आप serialization को यूज़ कर सकते है।  

जब आप किसी object की state को save करते है तो वो process serialization कहलाती है। और जब आप उस object को restore करते है तो वो process de-serialization कहलाती है। Object की state आप byte stream के द्वारा किसी file में store करवाते है। 

तो आखिर क्या होता है जब आप किसी object को serialize करते है। जब आप किसी object को serialize करते है तो उसके data members की value file में store हो जाती है। जैसे की यदि कोई variable है EmployeeName और ये किसी employee का नाम store करता है। तो ये variable उस नाम के साथ file में store हो जाता है। जब आप object को De-serialize करते है तो वापस ये value memory में load हो जाती है।

1. Serializable interface 

किसी object को serialize करना बहुत आसान है। इसके लिए आपको serializable interface implement करना होता है। जो class serializable interface करती है उसके objects ही serialize किये जा सकते है। 

class ClassToSerialize implements Serializable
{
    String Name = "YourName";
    int Age = 24;
 }
  

2. Serializing objects 

जब भी आप किसी object को serialize करते है तो एक file क्रिएट होती है और object की current state उस file में store हो जाती है। किसी भी object को serialize करने के लिए आप ObjectOutputStream class का object create करते है। जब आप इस class का object create तो उसमे FileOutputStream class का object argument की तरह pass करते है। इसके बाद ObjectOutputStream class के object पर writeObject() method call करते है। जो object आप serialize करना चाहते है उसे आप इस method में argument की तरह pass करते है। 

ऊपर दिए उदाहरण में ये बताया गया की कैसे एक class serializable interface को implement करती है। अब आपको ये देखना है की इस class के objects को कैसे serialize किया जाता है। इसका उदाहरण निचे दिया जा रहा है। 

import java.io.*;

public class HowToSerialize
{
    public static void main(String args[]) throws IOException
    {
         FileOutputStream fstream = new FileOutputStream("directory-address-of-file);
         ObjectOuputStream obstream = new ObjectOutputStream(fstream);

         ClassToSerialize CTS = new ClassToSerialize();
       
         obstream.writeObject(CTS);
    }
}
          

3. De-serializing objects

जब आप किसी object की processing फिर से शुरू करना चाहते है तो उसकी पुरानी state file में से memory में load की जाती है। किसी object को वापस file से memory में load करने के लिए आप ObjectInputStream class का object create करते है। Object create करते समय आप इसमें FileInputStream class का object argument की तरह pass करते है। इसके बाद आप ObjectInputStream class के object पर readObject() method call करते है। ये method आपको उस class का object return करता है। इसलिए आप इसको उसी class के reference variable में cast करके store करवाते है। 

import java.io.*;

public class HowToSerialize
{
    public static void main(String args[]) throws IOException, ClassNotFoundException
    {
          FileInputStream fstream = new FileInputStream("directory-address-of-file");
          ObjectInputStream obstream = new ObjectInputStream(fstream);

          ClassToSerialize CTS2 = (ClassToSerialize) obstream.readObject();

          System.out.println(CTS2.Name);
          System.out.println(CTS2.Age);

     }

}

Collections Framework

1. Introduction to collections framework 

यदि आपने data structures पहले से पढ़ रखा है तो java collections आप आसानी से समझ सकते है। Java में बहुत सारे objects को एक साथ organize करने के लिए कुछ data structures (set, list, queue and array) यूज़ किये जाते है। इन data structures को java में collections कहते है। इन data structure के collection को collection framework कहा जाता है। इन collections की मदद से आप objects के साथ वो सभी operations ( searching, sorting, insertion, deletion आदि) perform कर सकते है। जो आप normal data के साथ करते है। 

Collections framework में आपके काम को आसान बनाने के लिए पहले से ही classes और interfaces provide किये गए है। ये classes इन interfaces को implement करती है। इन classes को extend करके आप आसानी से objects को organize कर सकते है। आपको अलग से data structure क्रिएट करने की जरुरत नहीं है। Collections framework के सभी interfaces और classes generic है, इसलिए object का type आप collection क्रिएट करते समय देते है। इन interfaces और classes के बारे में निचे दिया जा रहा है।

2. Collection interface

Collections framework के सभी interfaces collection interface को by default implement करते है। Collection interface ऐसे बहुत सारे methods provide करता है जो आप objects को manage करने के लिए यूज़ करेंगे। इन सभी methods की list निचे दी जा रही है।

3. List interface 

ArrayList और LinkedList classes list interface को implement करती है। ये classes objects को list की तरह store करती है। एक list collection में आप duplicate objects भी store कर सकते है। इन classes का object create करके आप objects को list की तरह store कर सकते है। 

4. ArrayList

ArrayList<objType> ArrList = new ArrayList<objType>();

arrList.add(obj1);
arrList.add(obj2);
arrList.add(obj3);

LinkedList

LinkedList<objType> linklist = new LinkedList<objType>();

linklist.add(obj1);
linklist.add(obj2);
linklist.add(obj3);

5. Set interface

HashSet or TreeSet classes set interface को implement करती है। Set collection में objects किसी set की तरह ही store किये जाते है। इसमें आप duplicate objects नहीं store कर सकते है। इन दोनों में से किसी भी class का object create करके आप set collection क्रिएट कर सकते है। 

7. HashSet 

HashSet<objType> hSet = new HashSet<objType>();

hSet.add(obj1);
hSet.add(obj2);
 
 
8. TreeSet

TreeSet<objType> tSet = new TreeSet<objType>();

tSet.add();
tSet.add();

9. Queue interface

Queue interface को PriorityQueue class implement करती है। जब भी आप इस collection में objects store करते है तो वे First In First Out की form में store होता है। 

10. PriorityQueue

PriorityQueue<objType> pQueue = new PriorityQueue<objType>();

pQueue.add(obj1);
pQueue.add(obj2);

11. Map interface

HashMap और TreeMap class Map interface को implement करती है। Map collection में data key और value के pair में store किया जाता है। हर element को store और access करने के लिए key यूज़ की जाती है। Map collection में elements unique होते है। 

12. HashMap

HashMap<objType> hMap = new HashMap<objType>();

hMap.add(key,obj1);
hMap.add(key.obj2);
 
  
13. TreeMap 

TreeMap<objType> tMap = new TreeMap<objType>();

tMap.add(key,obj1);
tMap.add(key,obj2);

14. Iterator interface

Collection interface की तरह ही सभी interface Iterator interface को भी by default implement करते है। ये interface iterator(), hasNext() और next() methods provide करता है। इन methods की मदद से आप अपने collection को traverse कर सकते है। सबसे पहले आप collection पर iterator() method call करते है। ये method collection के first element की index return करता है। इसको आप iterator interface के reference variable में store करवाते है।  इसके बाद आप hasNext() method को यूज़ करते हुए loop चलाते है। और next() method के द्वारा collection की सभी values को traverse करते है। 

ArrayList<objType> aList = new ArrayList<objType>();

aList.add(key,obj1);
aList.add(key,obj2);

Iterator<objType> itr = aList.iterator();
while(itr.hasNext())
{
    System.out.println(itr.next());
}

Lambda Expressions

1. Functional interface

Lambda expressions को समझने से पहले आपको functional interface के बारे में समझना होगा। एक functional interface वो interface होता है, जिसमे केवल एक ही abstract method होता है। जैसे की multi-threading के लिए यूज़ किया जाने वाला runnable interface एक functional interface कहलाता है। ऐसे interface का काम उसमे define किया गया वह एक method ही define करता है। 

उदाहरण के लिए निचे मैने एक interface क्रिएट किया है। ये एक function interface है। इस interface का नाम welcome है। इस interface में एक hello() मेथड है जो की by default abstract है। ये method एक स्ट्रिंग argument लेता है और message print करता है।
             
       interface Welcome
         {
            String hello(String name);
         }

2. Lambda expressions 

Lambda expression एक बिना नाम का method होता है। इस method का कोई type भी नहीं होता है। यदि इसकी body में आप एक single statement यूज़ कर रहे है तो आपको curly braces और return statement लगाने की भी जरुरत नहीं है। ये method खुद execute नहीं होता है। Lambda expression functional interface के abstract method का signature यूज़ करता है।    

Lambda expressions को केवल तब ही यूज़ किया जा सकता है, जब type आपके पास पहले से available हो जैसे की variable initialization, return statement और method argument आदि। और दूसरी जितनी भी conditions है जिनमे type आपके पास पहले से available हो आप lambda expression यूज़ कर सकते है। 

Lambda expression create करने के लिए आप lambda operator (->) यूज़ करते है। ये एक simple operator होता है, जिसके left side में parameters होते है और right side में method body होती है जिसे lambda body भी कहा जाता है।

Lambda expression का result आप उसी interface के reference variable में store करते है जिसका signature आपने यूज़ किया था। आप चाहे तो उस class का भी reference variable क्रिएट कर सकते है जो functional interface को implement करती है। Lambda expression का उदाहरण निचे दिया जा रहा है।
           
       Welcome wel;
       String name = "Vipin";
       wel = (name)-> {
       System.out.println("Hello"+name);
       };

Generics

Introduction to java generics 

यदि में आप से कहु की में ऐसा addition का method बना सकता हुँ जो हर तरीके के data type के variables को add कर सकता है। हर data type से मेरा मतलब है यदि में चाहूँ तो integers add कर लू और उसी method से double भी add कर लू । आप पुछेंगे क्या ऐसा करना possible है??. जी हाँ बिलकुल possible है। ऐसा method आसानी से बनाया जा सकता है। और में ही नहीं हर कोई बना सकता है।

Generics की मदद से आप ऐसा method बना सकते है जो हर तरह के data type के साथ execute कर सकते है। इन methods में आप data type को parameters की तरह pass करते है। इससे compiler को पता चलता है की किस तरह के data type के साथ method को execute करना है।

Java का ये feature readability बढ़ाता है, programmers का time बचाता है और computer की memory भी बचाता है। क्योंकि आपको हर तरह के data type के लिए अलग से code लिखने की जरुरत नहीं होती है।

Generics को केवल reference types (class) के साथ ही यूज़ किया जा सकता है। आप कोई primitive types जैसे की int और char आदि के साथ generics को यूज़ नहीं कर सकते है। इसलिए java में सभी primitive types को class के रूप में implement किया गया है। जैसे की int के लिए Integer और double के Double आदि।

केवल methods ही नहीं आप classes, interfaces और constructors को भी generic बना सकते है।

Generic class का structure निचे दिया जा रहा है।

class GenWorld<T>
{

}

जब आप इस क्लास का object क्रिएट करेंगे तो उसका structure कुछ ऐसा होगा -

GenWorld<Integer> obj1 = new GenWorld<Integer>(20);

Example

class GenWorld<T>
{
    T getValue;
     public GenWorld(T n)
     {
               this.getValue=n;
     }

      public void display()
      {
            System.out.println(this.getValue);
       }
}

public class GenDemo
{
    public static void main(String args[])
    {
            GenWorld<Integer> = intgen = new GenWorld<Integer>(10);
            GenWorld<String> Stringgen = new GenWorld<String>(“vipin”);
            intgen.display();
            Stringgen.display();
      }
}

ऊपर दिए उदाहरण में जैसा की आप देख सकते है class को अलग तरह से declare किया गया है। यंहा पर हमने class के नाम के आगे (&lt; &gt;) brackets में generic टाइप declare किया है। ये दिखता है की हमारी क्लास generic है।

अब आप variable declaration को देखिये यंहा पर हमारे variable का type generic है जो की हमने ऊपर क्लास क्रिएट करते समय बनाया था।

इसके बाद एक constructor डिक्लेअर किया गया है जिसमे generic argument पास हो रहा। असल में जब आप object create करेंगे तो जिस भी टाइप का डेटा आप डालेंगे ये उसी में convert हो जायेगा। यही यदि आप इन्टिजर डालेंगे तो ये इन्टिजर हो जायेगा और स्ट्रिंग डालेंगे तो स्ट्रिंग।

अब आते है सबसे महत्वपूर्ण बात पर जैसे आप देख सकते है की generic class के ऑब्जेक्ट थोड़ी different तरीके से क्रिएट किये जाते है। आप जिस तरह का डेटा argument में पास करने वाले है वो आपको object क्रिएट करते समय बताना होता है. जैसे की मैने ऊपर दिए गए उदाहरण में किया है।

1. Generic methods 

जैसा की आपने ऊपर दिए हुए example में देखा के एक generic class का method generic type को यूज़ कर सकता है इसलिए वह method भी generic ही होता है। लेकिन यदि आप चाहे तो किसी ऐसी class में भी generic method declare कर सकते है जो खुद generic नहीं है। Generic methods क्रिएट करने के लिए structure निचे दिया जा रहा है। 

<T> void myMethod(T x)
{
     T a = x;

     System.out.println("hello",a);
}

2. Generic constructor

Classes और methods के साथ साथ आप constructors को भी generic declare कर सकते है। ये ठीक ऐसे ही होता है जैसे आपने methods को generic declare किया था। Constructor के generic होने के लिए class का generic होना आवश्यक नहीं है। इसका उदाहरण निचे दिया जा रहा है -

class GenWorld
{
   public <T>GenWorld(T arg)
   {
       // this is is a generic constructor
   }
}

3. Generic interfaces

Classes, methods और constructors की तरह ही आप interfaces को भी generic declare कर सकते है। इसका तरीका बिलकुल simple है।

public interface myInterface<T>
{
    public T myFunction();
}

public class myClass implements myInterface<T>
{
    public T myFunction()
    {
      //
    }

}

4. Bounded types

ऊपर दिए गए उदाहरण में आप T को किसी भी data type से replace कर सकते है ऐसा करना ठीक है लेकिन कभी ऐसा भी हो सकता है जब चाहे की यूज़र सिर्फ numbers ही पास करे। मतलब आप यूज़र को numbers के अलावा कोई भी data type pass करने से रोकना चाहते है।

ऐसी situation को handle करने के लिए java bounded types provide करती है। Type parameter(T) declare करते समय आप जो type आप यूज़ करना चाहते है उसकी super class को extend करते है। ऐसा करने से T को सिर्फ उसी super class के types के द्वारा replace किया जा सकता है। इसका structure निचे दिया जा रहा है -

class GenWorld<T extends Number>
{
    // इस class में आप T की जगह सिर्फ numbers ही यूज़ कर सकते है।
} 

5. Wildcard arguments 

एक बार आप जब किसी generic क्लास का एक particular type argument के द्वारा object क्रिएट करते है तो आपका वह object generic न होकर एक particular type का हो जाता है। ऊपर दिए गए उदाहरण को यदि आप देखे तो intgen एक generic type नहीं है क्योंकि इसे integer argument के साथ क्रिएट किया गया है। इसलिए intgen और stringgen दोनों अलग अलग तरह के object है इनको आप उसी क्लास के किसी दूसरे object को refer नहीं कर सकते है। लेकिन यदि वो object भी integer type argument के साथ create किया गया है तो आप ऐसा कर सकते है। 

अब आप सोचिये की आप generic क्लास के हर object को print करवाना चाहते है उसके लिए आप एक function बनाते है जो object को argument की तरह लेता है और print करवाता है। इसके लिए आप ऐसा करेंगे।

void dispObj(GenWorld<T> obj) // can not do this, because all object are not allowed with this statement and function checks for strings only.
{
  //
}   

जैसा की ऊपर दिया गया है आप ऐसा ही कुछ करने का प्रयास करेंगे लेकिन ये गलत होगा क्योंकि सभी object pass नहीं किये जा सकते है। इस जगह पर आप wildcard arguments यूज़ कर सकते है और function के अंदर किसी भी तरह के object को print करवा सकते है। Wildcard का structure और उदाहरण निचे दिए जा रहे है।

void dispObj(GenWorld<?> obj)
{

Applets

Introduction to java applets 

Applet एक java program होता है जो browser में run होता है। ये एक ऐसा प्रोग्राम होता है जो HTML के साथ काम कर सकता है। इसे HTML code में ही include कर लिया जाता है। Java program की file और HTML program की files अलग अलग होती है। HTML में java program को load करने के लिए आप <applet> tag यूज़ करते है। जब कोई भी यूज़र इस HTML पेज को browser पर देखता है तो HTML के साथ java program भी load हो जाता है। लेकिन इसके लिए आपको applet (java program) को और HTML file को एक ही server पर save करना पड़ता है। 

Applet ऐसा java program होता है जो Applet class को extend करता है। Applet program को .class extension से save किया जाता है। जब कोई यूज़र browser में applet को देखता है तो applet का code उस user की machine में download हो जाता है। पहले applet का code user की machine में download होता है फिर applet browser में रन होता है। इसलिए आप कह सकते है की applets client side applications होती है।Applets को run होने के लिए JVM की जरुरत होती है। JVM browser plugin के रूप में भी हो सकती है या आपके system में भी हो सकती है। 

Applet प्रोग्राम को आप browser में ना देख कर एक applet viewer में भी देख सकते है। जब आप किसी applet program को HTML में include ना करके directly रन करवा देते है, तो java automatically applet को applet viewer में शो कर देती है।    

एक applet java program में main() मेथड नहीं होता है। Applet class कई life cycle methods provide करती है जिनसे applet को handle किया जाता है। हर method को एक specific task perform करने के लिए बनाया गया है।  Applet की life cycle में ये सभी methods एक ना एक बार जरूर execute किये जाते है। आइये इन सभी methods के बारे में जानने का प्रयास करते है।

1. Life cycle of java applets 

Applet क्लास 5 important methods provide करती है, जिन्हे आप override करते है। इन methods को life cycle methods भी कहते है। एक applet program अपनी life cycle में इन सभी methods से होकर गुजरता है। ये सभी methods आपको applet program पर पूरा पूरा control provide करते है। ये सभी methods निचे दिए जा रहे है। 

* init() - इस method में आप variables को initialize कर सकते है या फिर कोई object क्रिएट कर सकते है। किसी भी तरह का initialization आप इस method में कर सकते है। जैसे की applet का background color set कर सकते है। 

* start() - ये मेथड init() method के बाद automatically call होता है। ये method browser में applet को call करता है। 

* stop() - ये मेथड applet को stop करने के लिए यूज़ किया जाता है। आप जब applet वाले HTML page को छोड़ कर किसी दूसरी window पर जाते है तो ये method call होता है और applet pause हो जाता है। जब आप वापस उसी window पर आते है, तो applet फिर से शुरू हो जाता है। 

* destroy() - जब आप browser को close करते है तो ये मेथड call होता है और applet destroy हो जाता है। 

* paint() - इस method को आप applet में कुछ draw करने के लिए यूज़ किया जाता है। ये method start() मेथड के बाद call होता है।                          

आइये अब applet का एक complete उदाहरण देखते है। 

Example 

// Java code

class picture extends Applet
{
   public void init()
   {
     void setBackground(color.red);
   }

   public void paint(Graphics g)
   {
     g.drawString("Applet are for GUI",30,30);
   }
}

//HTML code

<html>

<head>
<title>applet example</applet>
</head>

<applet code="picture.class" width="300" height="300">

</applet>

</html>

2. Parameter passing in java applets 

आप java file को HTML file के through parameters भी पास कर सकते है। कई बार ऐसा होता है की आप input user से किसी form के द्वारा लेते है। और further processing के लिए आपको इस input को java file को pass करने के आवश्यकता होती है। इसलिए applet API parameter passing का feature provide करती है। Java file को parameters pass करने के लिए HTML एक <param> नाम का tag provide करती है। इस tag को आप <applet> starting और </applet> closing tags के बीच में लिखते है। इस टैग के 2 attributes होते है। पहला attribute name होता है। इस attribute में आप उस value का नाम लिखते है जो आप parameters के द्वारा pass करना चाहते है। दूसरा attribute value होता है। इस आप name attribute में pass किये गए naam की value देते है। ये key value pair की तरह work करते है।

Java file में इन parameters को include करने के लिए सबसे पहले आप एक variable क्रिएट करते है। इसके बाद आप इस variable की value provide करने के लिए एक getParameters() method कॉल करते है। इस method में आप उस parameter का नाम pass करते है, जिसकी value आप variable में store करवाना चाहते है। ये method उस parameter की value variable में store कर देता है। इसका उदाहरण निचे दिया जा रहा है।

Applets java को बहुत ही advanced feature है, इसकी मदद से आप कई प्रकार के graphics design कर सकते है।

//html file
<html>

<head>
<title>applet example</applet>
</head>

<applet code="picture.class" width="300" height="300">
<param name=userName value=Vipin Sharma>

</applet>

</html>

//java file

class userName extends Applet
{
   String username;

   public void start()
   {
     username = getParameter("userName");
   }

   public void paint(Graphics g)
   {
     g.drawString(username,30,30);
   }
}
       

    
        

  Event Handling

Introduction to java event handling

जब आप किसी GUI application को चलाते समय कोई mouse click करते है या किसी menu में से कोई item select करते है या फिर कोई button press करते है तो events generate होते है। आप ऐसे भी कह सकते है की जब भी user कोई action लेता है तो events generate होते है। User के action लेने पर components की state में change आता है, जिससे compiler को पता चलता है की event generate हुआ है। आप इन events को अपने यूज़ के लिए handle कर सकते है। आप compiler को बताते है की यूज़र mouse click करे तब क्या करना है और button press करे तब क्या करना है। इसे event handling कहते है। 

जिस class में event generate होता है उसे आप source class कहते है। और जो class इस event को handle करती है वह listener होती है। Event generate हुआ है, ये जानने के लिए listener class को listener interface implement करना पड़ता है।     

Event handling उसी प्रकार है जैसे की आपके घर पर कोई आकर bell बजाये। जब वह व्यक्ति bell बजा रहा है तो वह एक event generate कर रहा है। इस event को आप handle करते है और जाकर दरवाजा खोलते है। इस situation में आपके घर आने वाला व्यक्ति source class है, और आप listener class है। और आपने (listener class ने ) अपने घर में bell लगा रखीं है। Bell यँहा पर listener interface है, जो आपने implement किया है। यँहा पर एक धयान देने योग्य बात ये है की यदि आप bell नहीं लगते तो आपको पता नहीं चलता की कोई व्यक्ति आया है। यानि की जब तक आप listener interface implement नहीं करते है तो तब तक आपको पता नहीं चलता है की कोई event generate हुआ है।

अलग अलग events के लिए अलग अलग तरह के listener interfaces मौजूद है, जैसे की mouse से related events के लिए MouseListener और keyboard से related events के लिए KeyListener आदि। Listener class जिस तरह के events के बारे में notification चाहती है उस interface को implement करती है। उदाहरण के लिए आप Mouse events के बारे में जानना चाहते है। Listener interface implement करने के बाद आप source class में जाकर ये define करते है की जब भी mouse से related कोई event generate हो तो किस class को सूचित किया जाये। ऐसा आप एक method द्वारा करते है, जिसका उदाहरण निचे दिया जा रहा है।

addMouseListener(MouseListener obj) // obj is object of listener class

ये statement जब आप source class में लिखते है, तो source में generate होने वाले सभी mouse related events का notification listener class को मिलता है और listener class उन events को handle करती है। हर listener interface में उस तरह की जितने भी events possible हो सकते है उन सबके लिए एक method होते है। आप इन methods को override करके हर event को handle कर सकते है। जैसे की MouseListener interface 5 तरह के mouse events को handle कर सकता है। ये 5 method निचे दिए जा रहे है। इन सभी methods का यूज़ इनके नाम से ही पता चल जाता है।

* public void mouseClicked()

* public void mouseEntered()

* public void mouseExited()

* public void mousePressed()

* public void mouseReleased()                        

आइये अब इसे एक उदाहरण से समझने का प्रयास करते है। जैसे की आपको पता है, applets event based program होते है। इस उदाहरण में मैने applets प्रयोग किया है। हालांकि आप AWT या Swing library के साथ भी events को यूज़ कर सकते है।

Example 

// Source class

public class ListenToMe extends Applet
{

  public void init()
  {
         String msg;
    YesSpeak ys = new YesSpeak();
    addMouseListener(MouseListener ys);//passing listener object
  }

  public void paint(Graphics g)
  {
    g.drawString( msg,30,30);
  }

}

//Listener class

class YesSpeak implements MouseListener
{
   ListenToMe lm = new ListenToMe();

   public void mouseClicked(MouseEvent me)
   {
     lm.msg = "Mouse was Clicked!!";
     repaint();
   }

   public void mouseEntered(MouseEvent me)
   {
     lm.msg = "Mouse was entered!!";
     repaint();
   }

   public void mouseExited(MouseEvent me)
   {
    lm.msg = "Mouse was exited!!";
    repaint();
  }

  public void mousePressed(MouseEvent me)
  {
    lm.msg = "Mouse was pressed!!";
    repaint();
  }

  public void mouseReleased(MouseEvent me)
  {
    lm.msg = "Mouse was released!!";
    repaint();
  }
}

//HTML file

<html>
<head>
<title>Event Handling</title>
</head>
<applet code="ListenToMe.java" width=300 height=300>
</applet>
</html>

Adapter classes

जब आप किसी listener class में कोई listener interface implement करते है, तो आपको उस interface के सभी methods को implement करना पड़ता है। जैसे की आपने पिछले उदाहरण में देखा की mouse listener class के सभी interfaces को implement किया गया। लेकिन ऐसा भी हो सकता है की आप सभी method को implement ना करके किसी एक method को implement करना चाहते हो। ऐसी situation में आप adapter classes को यूज़ कर सकते है। 

हर listener interface के लिए एक adapter class provide की गयी है, जैसे की MouseListener interface के लिए MouseAdapter और KeyListener interface के लिए KeyAdapter आदि। ये adapter class उस interface के सभी methods का default implementation provide करती है। आपको सभी methods को implement करने की जरुरत नहीं होती है। जो method आप यूज़ करना चाहते है उसे ही आप override करते है। Adapter classes की मदद से programmers का time बचता है। इसका उदाहरण निचे दिया जा रहा है। 

//source class

public class AdapterCall extends Applet
{
   String msg;

   public void init()
   {
     AdapterReply ar = new AdapterReply();
     addMouseListener (ar);
   }

   public void paint(Graphics G)
   {
     g.drawString(msg,30,30);
   }
}

//listener class

class AdapterReply extends MouseAdapter
{
   AdapterCall ac = new AdapterCall();

   public void mouseClicked(MouseEvent me)
   {
     ac.msg = "mouse was clicked";
     repaint();
   }

}

//HTML file

<html>
<head>
<title>adapter handling</title>
</head>
<applet code = "ÄdapterCall.java" width=300 height=300>
</applet>
</html>

Java event handling एक बहुत ही बड़ा topic है, यँहा पर मैने सिर्फ event handling का concept समझाने का प्रयास किया है।        

AWT(Abstract Windows Toolkit)

1. Java AWT (Abstract Windows Toolkit)

Java में GUI (Graphical User Interface) create करने के 2 तरीके है, पहला AWT और दूसरा SWING. Swing AWT का extended version है, इसमें कुछ advanced features होते है। AWT के द्वारा भी अच्छी graphical application develop की जा सकती है। AWT एक GUI library होती है, जो graphical application में graphical components(Buttons, Text box, Check box) add करने के लिए packages और classes provide करती है। AWT library को किसी भी java program के साथ यूज़ किया जा सकता है। उसके लिए आपको java.awt.* package को import करना पड़ता है।   

कोई भी application जैसे की calculator या text editor आदि आप AWT library के components (Buttons, Text-box, Check-box etc.) को यूज़ करते हुए बना सकते है। AWT के साथ अच्छी बात ये है की आप आसानी से इसे यूज़ कर सकते है। सभी components classes के द्वारा represent किये जाते है। आप सिर्फ इन classes के object create करते है और वो components आपकी application में add हो जाते है। यदि आप AWT के साथ काम कर सकते है तो Swing के साथ काम करने में आपको कोई problem नहीं होगी।

AWT library में 2 तरह की classes होती है। पहली container और दूसरी component classes होती है। AWT library इन ही 2 तरह की classes से मिलकर बनी हुई है। यदि आप इन 2 तरह की classes का concept समझ ले तो आपको AWT यूज़ करने में कोई problem नहीं होगी। इन दोनों तरह की classes के बारे में निचे दिया जा रहा है।

2. Container classes

Container एक window होती है। जिसमे आप components को add करते है। ये आपकी application की main window होती है, जैसे की आपके browser की window है। ये window component के लिए base का काम करती है। इस window में आप components(buttons, text boxes, check boxes आदि) को add करते है। एक container में आप किसी दूसरे container को भी add कर सकते है। AWT library में 4 तरह की container classes है आप कोई सी भी यूज़ कर सकते है और उसमे components को add करवा सकते है। सबसे ज्यादा frame class को यूज़ किया जाता है। इन चारों container classes के बारे में निचे दिया जा रहा है। 

इन सभी windows को आप अपने according customize कर सकते है। जैसे की window की size अपने according रख सकते है और आप window में कौनसा layout यूज़ करना चाहते है, ये भी आप define कर सकते है। इस काम के लिए AWT library कुछ methods provide करती है। इन methods का नाम और upyog निचे दिया जा रहा है। 

3. Component classes 

Components वो controls होते है, जिनसे users interact करते है। जैसे की button, text-field, scroll-bar और text-area आदि। Components standalone नहीं होते है। बिना container के आप component को यूज़ नहीं कर सकते है। पहले आप component क्रिएट करते है और फिर उसे container में add करवाते है। इसके बाद ही user components को यूज़ कर सकता है। हर component एक class को represent करता है। Component create करने के लिए आप simple उस component class का object क्रिएट करते है। कुछ common components और उनका उपयोग निचे दिया जा रहा है।             

Containers की तरह ही आप components को भी configure कर सकते है। जैसे की components का background color change कर सकते है ओर उनकी size को छोटा या बड़ा कर सकते है। इन सभी कामों के लिए AWT library methods provide करती है। इन methods की मदद से आप सभी components को अपनी application के according configure कर सकते है। 

4. Frame class 

Frame एक container class है। अपनी application और need के according आप कोई सा भी container यूज़ कर सकते है। लेकिन ज्यादातर frame का यूज़ किया जाता है। Frame container में आपको title bar, menu bar और borders मिलती है इसलिए सभी basic graphical applications के लिए इस यूज़ किया जाता है। इसी वजह से मैने AWT के example में भी frame class को ही यूज़ किया है। Frame class को आप 2 तरह से यूज़ कर सकते है। पहले तरीके में आप frame class को extend करते है। दूसरे तरीके में आप frame class को extend ना करके frame class का object create करते है। ये दोनों ही तरीके उदाहरण के सहित निचे दिए जा रहे है।

class guiLabel extends Frame
{

  guiLabel()
  {
    Label lb = new Label("This is AwT BeSt ExAmPlE");

    add(lb);

    setSize(200,200);

    setVisible(true);
  }

  public static void main(String args[])

  {
    guiLabel gl = new guiLabel();
  }

}

ऊपर दिए हुए उदाहरण में frame class को extend किया गया है। इस उदाहरण को आप आसानी से समझ सकते है। निचे दिए उदाहरण में frame class का object create किया गया है।

class guiButton
{

  public static void main()
  {

    Frame f = new Frame();

    Button b1 = new Button("Click it!!");

    f.add(b1);
    f.setTitle("Button Example");
    f.setSize(200,200);
    f.setVisible(true);

  }

}

Servlets

Introduction to java servlets 

Java servlets applets के opposite होते है। Applets में आप HTML program के अंदर java program यूज़ करते है। और servlets में आप java program के अंदर HTML program लिखते है। Servlets ऐसे java program होते है जो HTML file generate करते है। 

Java आपको ऐसे features provide करती है जिससे आप किसी java program के द्वारा एक HTML file generate कर सकते है और उसे web पर execute करवा सकते है। इसके लिए आपको java program के अंदर HTML program लिखना होता है। और जब आप इस java code को execute करवाते है तो वो HTML code भी execute होता है और उसके code के according आपको webpage show हो जाता है। लेकिन इसके लिए जरुरी है की आप अपने servlet program को किसी web server पर store करे और उसे वही से execute करवाये।

1. Packages used by java servlets 

Servlets को यूज़ करने के लिए आपको program में 2 packages को import करना पड़ता है। इनके बारे में निचे दिया जा रहा है। 

Tasks of java servlets 

* Processing HTML  

* Opening web browser 

* Displaying web page

Steps to create java servlets program 

* सबसे पहले अपने program में servlet packages को import कीजिये। 

* यदि आप HTTP protocol यूज़ करना चाहते है तो HttpServlet class को extend कीजिये नहीं तो GenericServlet class को extend कीजिये। 

* यदि आप HTTP servlet create कर रहे है तो doGet() और doPost() method से request handle करते है। और यदि आप generic servlets create कर रहे है तो life cycle methods में request handle करते है। 

* किस तरह की file produce होगी ये आपको पहले ही define करना होता है। जैसे की आप HTML define करेंगे। इसके लिए आप setContentType() method यूज़ करते है। इस method को response object पर call किया जाता है।   

* इसके बाद आप response object पर getWriter() method call करेंगे। ये method PrintWriter stream return करता है। इसलिए आप इसे PrintWriter object में store करेंगे। 

* इसके बाद आप PrintWriter object पर println method call करेंगे और उसमे अपना HTML code लिखेंगे। 

* इसके बाद आप इस object पर close() method call करके stream को close करेंगे। आप चाहे तो destroy() method का default implementation भी इस काम के लिए यूज़ कर सकते है।   

Example 

public class HelloJava extends HttpServlet
{
    private String message;
    public void init() throws ServletException
    {
          message = "Hello Java";
    }
    public void doGet(HttpServletRequest request, HttpServletsResponse response)
    {
         response.setContentType("text/html");
         PrintWriter out = response.getWriter();
         out.println("<h1>"+message+"</h1>");
   }
   public void destroy()
   {
    }
} 

Swing

Introduction to java swing 

Abstract windows toolkit की कामियों को पूरा करने के लिए swing को बनाया गया है। AWT library basic GUI controls provide करती है। Swing AWT का advanced version है। AWT के साथ 2 problems होती है।

* AWT programs size में बहुत बड़े होते है। 

* AWT components fixed रहते है, आप उन्हें ज्यादा change नहीं कर सकते है।       

इन दोनों problems को swing remove कर देता है। Swing AWT पर based बना हुआ है। इसलिए swing AWT को replace नहीं करता है। यदि आप AWT के साथ familiar है तो swing को समझने में आपको कोई परेशानी नहीं होगी।     

1. Features of java swing

* सभी swing कंपोनेंट्स Platform independent होते है।   

* सभी swing components lightweight होते है।  

* Swing plug-gable look and feel को support करता है।

* Swing MVC(Model-View-Controller) architecture को फॉलो करता है।   

2. Swing classes

* JWindow - JWindow container क्लास hierarchy को represent करती है। JFrame और JDialog क्लासेज इस class को higher करती है।

* JFrame -  JFrame class AWT की frame क्लास के बेस पर बनायीं गयी है। ये एक container क्लास होती है। ये आपकी बेस window होती है जिसमे आप दूसरे components add करके अपनी एप्लीकेशन को design करते है।  इसमें आप different components जैसे की buttons, labels आदि add कर सकते है। Components add करने के लिए आप add() मेथड यूज़ करते है।

* JDialog  - इस क्लास का ऑब्जेक्ट क्रिएट करके आप अपनी एप्लीकेशन में Dialog box डाल सकते है।

* JComponent  - ये क्लास swing hierarchy में सभी components को represent करती है। सभी swing components इस क्लास को directly inherit करती है।

* JLabel - इस क्लास का object क्रिएट करके आप text labels अपनी एप्लीकेशन में add कर सकते है।

* JButton  - इस क्लास का object क्रिएट करके आप अपनी window में button ऐड कर सकते है। इसका ऑब्जेक्ट क्रिएट करते समय आप एक string पास  करते है जो की बटन का नाम होती है।

* JTextField - इस क्लास का ऑब्जेक्ट create करके आप अपनी अपनी एप्लीकेशन में text box add कर सकते है।

* JScrollBar - ये class एप्लीकेशन में scroll bar ऐड करने के लिए यूज़ की जाती है।

* JMenuBar - इस क्लास के माध्यम से आप अपनी window में menu bar add कर सकते है।

* JCheckBox  - इस क्लास का ऑब्जेक्ट क्रिएट करके आप अपनी window में check box add कर सकते है।

* JList  - ये क्लास आपकी window में एक list ऐड करती है।

* JTextArea - इस क्लास के माध्यम से आप अपनी एप्लीकेशन में text area ऐड कर सकते है।

* JRadioButton  - ये क्लास application में radio button add करने के लिए यूज़ की जाती है।

Example 

public class swingDemo
{
    public static void main(String args[])
    {
        JFrame frame = new JFrame();
        JButton button = new JButton("Click here!");
     
       button.setBounds(100,100,100,60);
       frame.add(button);
       frame.setSize(300,300);
       f.setVisible(true);
    }
}