You are here: Home / Java Programming in Hindi / Java Runnable Example for Multi-Threading
by on July 17, 2015

Java Runnable Example for Multi-Threading

Java Runnable Example: जावा में हम दो तरह के Threads Create कर सकते हैं। सबसे सरल तरीका तो यही है कि किसी भी Existing Class को लें और उसे Thread में Convert कर दें। हम ऐसा करने के लिए Class को इस तरह से Modify कर सकते हैं, कि वह Runnable Interface को Implement करे, जिसमें run() नाम का एक Method होता है, जिसकी जरूरत सभी Threads को होती है। run() Method में वे Codes लिखे जाते हैं, जिन्हें एक Thread Execute करता है।

Thread Create करने के दूसरे तरीके में हमें जावा की Thread Class को Derive करके एक Completely Separate Class Create करनी होती है। क्योंकि एक Thread Class स्वयं ही Runnable Interface को Implement करता है, इसलिए इसमें पहले से ही एक run() Method होता है।

हालांकि ये run() Method कुछ भी नहीं करता है। इसलिए हमें अक्सर इस Method को अपनी Derived Class में Override करना होता है, ताकि हम उन सभी Coding को उस Thread में लिख सकें, जिन्हें Thread के Execution के साथ Execute करना है।

Java Runnable Example: Converting a Class to a Thread

किसी Class को एक Thread में Convert करने के लिए जब हम पहला रास्ता चुनते हैं, तब हमें कई काम करने होते हैं। इसमें हमें एक ऐसी Class Create करनी होती है, जो Runnable Interface को Implement करता हो। जब हम किसी Class में Runnable Interface को Implement करते हैं, तब वह Class एक Thread में Convert हो जाती है। किसी Class को Thread में Convert करने के लिए हमें निम्न क्रम में काम करना होता है:

  • एक Class को Declare करते समय उसमें Runnable Interface को Implement करने का Statement लिखा जाता है।
  • फिर उस Class में Runnable Interface के run() Method को Implement किया जाता है, जो कि Runnable Interface का Only Method होता है।
  • फिर Thread Class के एक Object को Data Member की तरह इसी Class में Declare किया जाता है।
  • फिर Thread Class का Object Create करके उसके Reference में start() Method को Call किया जाता है। और
  • अन्त में Thread का काम समाप्त हो जाने के बाद Thread का stop() Method Call किया जाता है।

चलिए, इन सभी Steps को थोडा विस्तार से समझते हैं।

Declaring the Class as Implementing the Runnable Interface

किसी Regular Class को एक Thread में Convert करने के लिए हमें उस Class में Runnable Interface को Implement करना होता है। उदाहरण के लिए मानलो कि हमारे पास निम्नानुसार एक पहले से Existing Applet Class है:

	public class MyApplet extends Applet
	{
		// Body of the class.
	}

इस Class को Thread में Convert करने के लिए हमें इसमें Runnable Interface को निम्नानुसार Implement करना होता है:

	public class MyApplet extends Applet implements Runnable
	{
		// Body of the class.
	}

इसी तरह से यदि हमें किसी अन्‍य साधारण Class को Thread में Convert करना हो, तो हम ये काम निम्नानुसार कर सकते हैं:

	public class MyFirstThread implements Runnable
	{
		// Body of the class.
	}

Implementing the run() Method

पिछले Statement द्वारा हम जावा Compiler को ये बता देते हैं कि हम Class में Runnable Interface को Implement करके इस Class को Thread में Convert कर रहे हैं, इसलिए हमें इस Class में Runnable Interface के सभी Methods को Implement करना जरूरी हो जाता है।

चूंकि Runnable Interface में run() नाम का केवल एक ही Method है, इसलिए Create की जा रही इस Class में हमें केवल इसी Method को Implement करना होता है। इस Method का Syntax निम्नानुसार होता है:

	public void run()
	{
		// Thread’s Executables codes goes here.
	}

इस Method में हमें उन Codes को लिखना होता है, जिन्हें हम Thread के रूप में Execute करना चाहते हैं। run() Method एक बहुत ही महत्वपूर्ण Method है। ये Method किसी भी अन्‍य Method को Call कर सकता है और किसी भी Class को Use कर सकता है। साथ ही ये विभिन्न प्रकार के Variables भी Declare कर सकता है।

यानी run() Method ठीक उसी तरह से वे सारे काम कर सकता है, जो काम एक main() Method करने में सक्षम होता है। अन्तर केवल इतना है कि main() Method Execute होने वाला सबसे पहला Thread होता है, जो अन्‍य Threads को समानान्तर रूप से Run कर सकता है, जबकि run() Method अन्‍य समानान्तर Threads के लिए Entry Point Establish करता है। यानी सभी Threads का Execution run() Method से ही होता है और Thread तभी Terminate होता है जब run() Method Terminate होता है।

जब हम हमारे नए Thread को Start करते हैं, तब जावा Thread के run() Method को ही Call करता है, इसलिए हमें किसी Tread द्वारा Perform होने वाले सभी कामों के Statements को run() Method में ही लिखना होता है। run() Method वास्तव में किसी Program के एक Sub Program की तरह काम करता है, इसलिए run() Method में हम वे Code Statements लिखते हैं, जिन्हें हम सामानान्तर रूप से Execute करना चाहते हैं। इस run() Method को MyFirstThread Class में निम्नानुसार Implement किया जा सकता है:

class MyFirstThread implements Runnable
{
	// This is the entry point of the second thread.
	public void run()
	{
		try
		{
			for(int i=0; i<5; i++)
			{	
				System.out.println("Child Thread : " + i);
				Thread.sleep(1);
			}
		}
		catch(InterruptedException excp)
		{
			System.out.println("Child Thread Interrupted");
		}
		System.out.println("Exiting Child Thread");
	}
}

इस Class में हमने Runnable Interface को Implement करने के लिए run() Method को Define किया है। run() Method में हमने try/catch Block का प्रयोग किया है। हमने ऐसा इसलिए किया है, क्योंकि इस Method में हमने Thread Class के sleep() Method को Use किया है और ये Method उस समय एक Exception Generate करता है, जब कोई दूसरा Thread इस Class के Thread को Interrupt करने की कोशिश करता है।

sleep() Method Thread, Super Class का एक ऐसा Method है, जिसमें हम Argument के रूप में Milliseconds की संख्‍या Specify करते हैं और हम जितनी संख्‍या Specify करते हैं, जावा Compiler उतने समय तक Suspend Mode में चला जाता है और run() Method के अगले Statement को तब Execute करता है, जब Suspend Mode से वापस Normal Mode में आता है।

किसी भी Thread के Suspend Mode की स्थिति वह स्थिति होती है, जिस समय कोई दूसरा नया Thread Start हो सकता है, या कोई Running Thread CPU पर Swap हो सकता है। इस Program में हमने 1 Millisecond के लिए for Loop को Suspend Mode में भेजा है, ताकि इस 1 Millisecond के समय में जावा किसी दूसरे Thread के Statements को Run कर सके। MyFirstClass Thread तब Terminate होता है, जब run() Method में लिखे गए सभी Statements Execute हो जाते हैं या किसी और तरीके से Thread को Terminate कर दिया जाता है।

Declaring a Thread Object

run() Method को Define करने के बाद हमें इस Class में Thread Class का एक Object Create करना होता है। ये काम हम निम्नानुसार Statement द्वारा करते हैं:

      Thread myThread;

ये Thread Object उस Thread का Reference Hold करता है, जिससे किसी Applet या Application Class को Associated करना होता है। हम Create किए गए हमारे Thread Class के Methods को इसी Object के साथ Access कर पाते हैं। Thread Class हमारे द्वारा Create की जाने वाली किसी भी Sub Thread Class का Super Class होता है। इसलिए हम Thread Super Class के Reference में उसकी किसी भी Sub Class के Object का Reference Store कर सकते हैं।

Creating and Starting the Thread Object

अब हमें वे Codes लिखने होते हैं, जो एक Thread को Create करते हैं और उसे Run करते हैं। Thread Class में बहुत सारे Constructors Defined हैं। उनमें से एक निम्नानुसार है, जिसका हम सबसे ज्यादा उपयोग करते हैं:

      Thread(Runnable threadObject, String threadName);

इस Constructor में threadObject उस Class का Object है, जिसमें Runnable Interface को Implement किया गया है। ये Object Define करता है कि किस Thread का Execution शुरू करना है।

जब हम किसी Thread को Run करना चाहते हैं, तब उस Thread का एक Object Create करते हैं और उस Object का Reference इस threadObject में Pass कर देते हैं। ऐसा करने पर वह Thread Run होने लगता है, जिसका Reference threadObject नाम के Parameter में होता है। हम जिस नए Thread को इस Constructor द्वारा Run करना चाहते हैं, उसका एक नाम भी Specify कर सकते हैं। नए Thread का नाम threadName Parameter में Specify किया जाता है।

मानलो कि हमें MyFirstThread Class के Thread को Run करना है। इस स्थिति में हम जिस Class में Runnable Interface को Implement कर रहे हैं, उसी Class में एक Data Member की तरह निम्नानुसार Thread Super Class का एक Object Create करना होता है:

      Thread childThread;

अब इस Thread Super Class के Reference Holder Object में जब हम निम्नानुसार MyFirstThread Class के Thread Object का Reference देते हैं, तो जावा Compiler उस MyFirstThread Thread के run() Method को Execute कर देता है। यानी

      childThread = new Thread(this, “ChildThread”);

इस Statement में this Object MyFirstThread Class के ही एक Thread Object का Reference है और ये Method MyFirstThread Class के run() Method को ही Execute करता है। इस नए Run होने वाले Thread का नाम हमने “ChildThread” रखा है।

class MyFirstThread implements Runnable
{
	Thread childThread;
	MyFirstThread()		// No-Argument Constructor 
	{
		childThread = new Thread(this, "ChildThread");
		System.out.println("Child " + childThread);
		childThread.start();			// Start the Child Thread
	}
	
	// This is the entry point of the second thread.
	public void run()
	{
		try
		{
			for(int i=0; i<5; i++)
			{	
				System.out.println("Child Thread : " + i);
				Thread.sleep(1);
			}
		}
		catch(InterruptedException excp)
		{
			System.out.println("Child Thread Interrupted");
		}
		System.out.println("Exiting Child Thread");
	}
}

इस Thread में हमने एक Constructor Create किया है, ताकि हम जैसे ही इस MyFirstThread Class का कोई भी Object Create करें, उसका नाम “ChildThread” हो जाए और वह Thread स्वयं ही Run भी हो जाए। हमने जो Constructor लिखा है, वह निम्नानुसार है:

Thread childThread;

MyFirstThread()		// No-Argument Constructor 
{
	childThread = new Thread(this, "ChildThread");
	System.out.println("Child " + childThread);
	childThread.start();			// Start the Child Thread
}

सबसे पहले हमने Thread Super Class का एक Object childThread Create किया है। चूंकि इस Object को हमने कोई Memory Allocate नहीं की है, इसलिए हम इसमें केवल किसी अन्‍य Thread Object का Reference ही Store कर सकते हैं।

फिर हमने MyFirstThread का एक No-Argument Constructor Create किया है। इस Constructor में जावा Compiler को Thread Class के एक 2-Argument Constructor के पहले Parameter द्वारा ये बताया है कि हमने किस Class में Runnable Interface को Implement किया है।

चूंकि हम इस Constructor को MyFirstThread Class के अन्दर ही Define कर रहे हैं, इसलिए Thread Class के 2-Argument Constructor में पहले Argument के रूप में “this” Object का प्रयोग करके हमने जावा को बताया है कि हमने इसी Class में Runnable Interface को Implement किया है, जिसमें हम इस Constructor को Define कर रहे हैं।

साथ ही दूसरे Argument के रूप में हमने Create होने वाले नए Thread Object का नाम “ChildThread” दिया है। अब इस Create होने वाले Child Thread को Run करने के लिए Thread Class के start() Method को Thread Super Class के Reference Object childThread Object के लिए Call किया है।

Stopping the Thread

जब Thread का run() Method अपने अन्त पर पहुंचता है, तभी Thread भी अपने अन्त पर पहुंच जाता है। कई बार जावा स्वयं ही किसी Thread को जरूरत के अनुसार Stop कर देता है।

उदाहरण के लिए मानलो कि हम जिस Applet को Execute कर रहे हैं, उसमें एक Applet है और हम किसी दूसरे Web Page पर चले जाते हैं, ऐसे में Browser स्वयं ही Applet के Thread को Stop कर देता है।

निम्न उदाहरण Program में हमने एक Class में एक Thread को Implement किया है, साथ ही उसके Main Program द्वारा ये भी दर्शाया है कि हम किस प्रकार से एक साधारण से Statement द्वारा नया Thread Object Create कर सकते हैं:

// Program
// File Name : ThreadApplication.java

	// Creating another Thread
	class MyFirstThread implements Runnable
	{
		Thread childThread;
	
		MyFirstThread()		// No-Argument Constructor
		{
			childThread = new Thread(this, "ChildThread");
	
			System.out.println("Child " + childThread);
	
			childThread.start();		// Start the Child Thread
		}
	
		// This is the entry point of the second thread.
		public void run()
		{
			try
			{
				for(int i=0; i<5; i++)
				{	
					System.out.println("Child Thread : " + i);
					Thread.sleep(1);
				}
			}
			catch(InterruptedException excp)
			{
				System.out.println("Child Thread Interrupted");
			}
			System.out.println("Exiting Child Thread");
		}
	}

	//-------------------------------------------------------------------
	
	class ThreadApplication
	{
		public static void main(String args[])
		{
			new MyFirstThread();
		
			try
			{
				for(int i=0; i<5; i++)
				{
					System.out.println("Main Thread : " + i);
					Thread.sleep(2);
				}
			}	
			catch(InterruptedException excp)
			{
				System.out.println("Main Thread Interrupted");
			}
			System.out.println("Main Thread Exiting");
		}
	}
	
// Output 
   Child Thread[ChildThread,5,main]
   Main Thread : 0
   Child Thread : 0
   Child Thread : 1
   Main Thread : 1
   Child Thread : 2
   Main Thread : 2
   Child Thread : 3
   Main Thread : 3
   Child Thread : 4
   Exiting Child Thread
   Main Thread : 4
   Main Thread Exiting

इस Program के main() Method में हमने MyFirstThread Class का एक Object Create किया है। चूंकि main() Method जावा के Run Time Virtual Machine में Run होता है, लेकिन किसी भी अन्‍य Thread को Active करने की क्षमता main() Method में ही होती है। इसलिए इस main() Method में ही हमने हमारी MyFirstThread Class के Thread को एक Object के रूप में Create किया है। जब Program Run होता है, तब सबसे पहले निम्न Statement द्वारा एक Object Create होता है, जो कि MyFirstThread Class का Object होता है।

    new MyFirstThread();

चूंकि MyFirstThread Class में हमने Runnable Interface को Implement किया है, इसलिए ये Class एक Thread की तरह काम करता है और main() Method के समानान्तर Execute हो सकता है।

जब ये Statement Execute होता है, तब ये Statement MyFirstThread Class के No-Argument Constructor को Execute करता है। इस Constructor में एक नया Thread Create होता है और उस नए Thread का Reference childThread नाम के Thread Class के Reference Object में Store हो जाता है।

फिर इस Thread को Run करने के लिए इसी Constructor में Thread के start() Method को Use किया गया है। ये Method Create होने वाले नए ChildThread के run() Method को Execute करके उस समय वापस main() Thread में आ जाता है, जब एक Millisecond के लिए Child Thread Sleeping Mode में जाता है।

फिर Main Thread Execute होता है जहां try/catch Block में एक Loop के अन्दर एक Message Print किया जाता है। जब Message Print हो जाता है, तब Main Method भी 2 Millisecond के लिए Sleeping Mode में जाता है। जिस समय Main Thread Sleeping Mode में जाता है, उस समय जावा फिर से Childe Thread के Statements का Execution शुरू कर देता है।

ये Swapping की Process तब तक चलती रहती है, जब तक कि Child Thread का End नहीं हो जाता है। इस Program में हमने केवल एक ही Child Thread Create किया है। यदि हम चाहें तो एक से ज्यादा Child Thread Create कर सकते हैं। ऐसा करने के लिए हमें Application के main() Method में निम्नानुसार Modification करना होता है:

// Program
class ThreadApplication
{
	public static void main(String args[])
	{
		new MyFirstThread();
		new MyFirstThread();
	
		try{
			for(int i=0; i<5; i++){
				System.out.println("Main Thread : " + i);
				Thread.sleep(2);
			}
		}	
		catch(InterruptedException excp)
		{
			System.out.println("Main Thread Interrupted");
		}
		System.out.println("Main Thread Exiting");
	}
}

// Output 
   Child Thread[ChildThread,5,main]
   Child Thread[ChildThread,5,main]
   Main Thread : 0
   Child Thread : 0
   Child Thread : 0
   Child Thread : 1
   Main Thread : 1
   Child Thread : 2
   Child Thread : 1
   Main Thread : 2
   Child Thread : 3
   Child Thread : 2
   Child Thread : 4
   Main Thread : 3
   Exiting Child Thread
   Main Thread : 4
   Child Thread : 3
   Child Thread : 4
   Main Thread Exiting
   Exiting Child Thread

इस Program में हमने दो Child Thread Create किए हैं और प्राप्त होने वाले Output में दो Child Threads व एक Main Thread यानी कुल तीन Threads Execute हो रहे हैं और तीनों Threads आपस में समय&समय पर Swapping भी कर रहे हैं, जिससे तीनों Threads लगभग एक साथ अपने अन्त पर पहुंचते हैं। चलिए, एक और उदाहरण द्वारा Runnable Interface को Implement करके Thread Create करना व उस Thread को Use करना सीखते हैं।

// Program
	class NewThread implements Runnable 					// Step 1
	{		
		public void run()																					// Step 2
		{	
			for(int i=0; i<6; i++)
			{
				System.out.println(“\t NewThread : “ + i );
			}
			System.out.println(“End of NewThread”);
		}
	}
	
	class ImplementedThreadTesting
	{
		public static void main(String args[])
		{
			NewThread newThreadObject = new NewThread();				 
			Thread runnableNewThread = new Thread(newThreadObject);	//Step 3		
			runnableNewThread.start();				//Step 4
			System.out.println(“End of Main Thread”);
		}
	}

// Output 
	End of Main Thread
         NewThread : 0
         NewThread : 1
         NewThread : 2
         NewThread : 3
         NewThread : 4
         NewThread : 5
	End of NewThread

इस उदाहरण के Output में हम देख सकते हैं कि main() Method वाला Main Thread Program के शुरू होते ही End पर पहुंच रहा है, फिर भी जो Child Thread है, जिसे Main() Thread Execute कर रहा है, Main Thread के End होने के बाद भी Execute होता है और अपने अन्त पर पहुंचता है। Output का पहला Statement “End of Main Thread” सबसे पहले Execute हो रहा है, जबकि ये Statement main() Method का अन्तिम Statement है।

इस Statement के Execute होने का मतलब ये है कि इससे पहले के सभी Statements Execute हो चुके हैं, जबकि हम Output में देख सकते हैं कि इस Statements से पहले के Statements बाद में Execute हो रहे हैं। चलिए, इस Program के Run होने की Process को समझने की कोशिश करते हैं।

Program जैसे ही Run होता है, जावा का Virtual Machine main() Method के लिए एक Main Thread उपलब्ध कर देता है, जिससे main() Method जावा द्वारा प्रदान किए जाने वाले Main() Thread में Run होने लगता है। फिर हमने main() Method में NewThread Class का एक Object newThreadObject Create किया है। इस Thread Object का प्रयोग जावा Compiler को ये बताने के लिए किया जाता है, कि हम किस Thread को समानान्तर रूप से Run करना चाहते हैं।

चूंकि हम NewThread Class में Define किए गए run() Method के Statements को समानान्तर रूप से Run करना चाहते हैं, इसलिए हमने निम्न Statement द्वारा NewThread Class का Object newThreadObject Create किया है।

   NewThread newThreadObject = new NewThread();

जावा को ये बताने के लिए कि हमने जो newThreadObject Create किया है, वह एक Thread है और हम इसे Current Thread यानी Main Thread में Main Thread के समानान्तर Run करना चाहते हैं, Thread Class का एक Object Create किया है और इस Thread Class Object के Constructor में Run किए जाने वाले नए Thread के Object newThreadObject को Argument के रूप में Pass किया है।

ऐसा करने पर जावा का Compiler समझ जाता है कि हम Current Thread यानी Main Thread में एक और Sub Thread Run करना चाहते हैं और हम जिस Thread को Run करना चाहते हैं, वह Thread NewThread Class के रूप में Described है, क्योंकि हम अगले Statement में इसी NewThread Class के एक Object newThreadObject को Argument के रूप में Thread Super Class के Constructor में Pass कर रहे हैं।

        Thread runnableNewThread = new Thread(newThreadObject);

जब हम Thread Class का एक Object Create करके उसमें Run किए जाने वाले Thread की Class का एक Object Reference के रूप में Pass कर देते हैं, तब जावा के Thread Super Class के Object में Run किए जाने वाले Thread का Reference Store हो जाता है। अब इस Thread Object में जिस Thread का Reference होता है, उस Thread के run() Method को Execute करने के लिए हमें Thread Class के start() Method को Execute करना होता है। ये काम निम्न Statement द्वारा करते हैं:

    runnableNewThread.start();

चूंकि runnableNewThread Thread Object में इससे पिछले Statement के Execution के कारण NewThread Class के Object का Reference Store हो जाता है, इसलिए इस Statement के Execution से इसी NewThread Class के run() Method का Execution शुरू होता है। जब ये Statement Execute होता है, तब जावा Compiler NewThread Class के run() Method के Execution को Start करके वापस Main Thread में आ जाता है और Main Thread के main() Method के निम्न Statement का Execution कर देता है:

        System.out.println(“End of Main Thread”);

चूंकि ये Statement main() Method का अन्तिम Statement होता है, इसलिए इस Statement के Execution के बाद main() Method का End हो जाता है। लेकिन जिस दूसरे Sub Thread को Main Thread में main() Method द्वारा Start किया गया है, वह Thread अभी End पर नहीं पहुंचा है, इसलिए Main() Thread में main() Method के End हो जाने के बावजूद NewThread के run() Method का Execution होता रहता है और जब उस Child Thread के run() Method का End होता है, तब Program पूरी तरह से Terminate होता है।

उपरोक्त उदाहरणों का सारांश ये है कि हम जिस Sub Program या Code Segment को एक Thread की तरह समानान्तर रूप से Execute करना चाहते हैं, उस Sub Program के Code Statements को एक ऐसी Class में Define करना होता है, जिसमें Runnable Interface को Implement किया गया होता है। Runnable Interface को Implement करने पर हमें इसके run() Method को उस Create की जा रही Class में Implement करना जरूरी होता है।

Runnable Interface का run() एक ऐसा Method है, जिसमें लिखे Statements समानान्तर रूप से Thread की तरह Run होते हैं, इसलिए हमें हमारे Sub Program के सभी Code Statements को run() Method में ही Define करना होता है। इतना कर देने पर हमारे Thread का Description तैयार हो जाता है।

अब हमें इस Thread को Run करना होता है। किसी भी Thread को Run करने के लिए हमें Thread Super Class के start() Method को Use करना होता है। इसलिए हमें जावा को ये बताना पडता है कि हम किस Thread को Execute करना चाहते हैं। जावा को ये बताने के लिए हमें Thread Super Class का एक Object Create करना होता है और उसके Constructor में हमारे नए Thread के एक Object का Reference Argument के रूप में देना होता है।

जब हम Thread Super Class के Constructor में किसी दूसरे User Defined Thread Class के Object का Reference देते हैं, तब Compiler Thread Super Class के Object में उस नए Thread के Object का Reference Store कर देता है।

अब जब हम इस Thread Super Class के Object के लिए start() Method को Call करते हैं, तब ये Method हमारे Create किए गए Thread के run() Method को Execute कर देता है, क्योंकि Thread Super Class के Object में हमारे Thread Object का Reference होता है। इस तरह से हमारा नया Thread समानान्तर रूप से उस Thread में Run होने लगता है, जिसमें हमने Thread को Start किया होता है।

किसी साधारण Class की तरह ही हम किसी Applet Class में भी Runnable Interface को Implement कर सकते हैं और एक Applet में एक ही समय में एक से ज्यादा कामों को समानान्तर रूप से पूरा कर सकते हैं। चूंकि एक Applet Create करने के लिए हमें हमेंशा Applet Class की Sub Class Create करनी होती है। इसलिए किसी Applet Class में यदि हमें Runnable Interface को Implement करना हो, तो हमें निम्नानुसार Syntax Use करना होता है:

	public class MyApplet extends Applet implements Runnable
	{
		public void run()
		{
			// Executable codes goes here.
		}
	}

इस Applet में जो काम हमें Applet में करना होता है, उन कामों को तो Applet के Methods में Implement करते हैं, जबकि जो काम हमें Applet के समानान्तर करने होते हैं, उन कामों को Applet में Implement किए गए run() Method में Implement करते हैं।

Java Programming Language in Hindiये Article इस वेबसाईट पर Selling हेतु उपलब्‍ध EBook Java in Hindi से लिया गया है। इसलिए यदि ये Article आपके लिए उपयोगी रहा, तो निश्चित रूप से ये पुस्तक भी आपके लिए काफी उपयोगी साबित होगी। 

Java Programming Language in Hindi | Page: 682 | Format: PDF

BUY NOW GET DEMO REVIEWS

Filed Under: Java Programming in Hindi