Skip to main content

Q) Write a program that user defined class implements java.long.Runnable interface instead of extending thread class.



A)
Note:
->whenever user defined thread class implements Runnable interface, instantiate java.long.Thread class to create the Thread object. Make use of Runnable interface as argument taking constructor of Thread class. Supply user defined Thread class reference as argument to the Thread class constructor.

// RunnableExample.java

class Mythreadone implements Runnable
{
       public void run()
       {
              for (int i=1;i<=30;i++)
              {
                     System.out.println(i);
                     try
                     {
                           Thread.sleep(400); // suspended y=the Thread, not technically required.
                     }
                     catch(Exception e)
                     {
                          
                     }
              }
       }
}
class MyThreadTwo implements Runnable
{
       public void run()
       {
              for(int i=70;i<=100;i++)
              {
                     System.out.println(i);
                     try
                     {
                           Thread.sleep(400); // initially suspended.
                     }
                     catch(Exception e)
                     {
                          
                     }
              }
                    
       }
}

class RunnableExample {

       public static void main(String[] args) {
              Thread t1=new Thread(new Mythreadone());
              Thread t2=new Thread(new MyThreadTwo());
              t1.setPriority(7); //not technically required.
              t1.start();
              t2.start();
       }
}

-> start () method belongs to Thread class. So, if our class is implements Runnable then it will not working, error will raised.
->to avoid this problem we create Runnable interface of its child class object then that object reference is passed as argument to the Thread class, so, then only start method is called.
->Runnable is an interface that’s why its child class object is created.

Note:
->whenever user defined class is required to inherit from another class and at the same time multithreading also should be implemented in that class, we go for Rubnnable interface.

Ex:
Class A extends B implements Runnable
{

}

->Because at a time we can’t extend 2 classes in java. So, A can’t inherit B and Thread class, so, A is extends B and Runnable is implemented.

Comments

Post a Comment

Popular posts from this blog

Q) What is JDBC driver? What is its role in java database connection?

A) ->A translation software written in java according o JDBC specification is nothing but “JDBC driver”. -> JDBC driver implements JDBC API. Use single API. JDBC driver role: They are 4 roles   1)       Establishing connection between JDBC client and database server. 2)       Receiving JDBC method calls made by JDBC client while performing database (CRUD) operations. 3)       Translating java method calls into DBMS understandable calls and forwarding them to database server. 4)       Receiving the results from database server. Translating them into java format and handling over the same to the JDBC client.
Post a Comment
Read more

Q) What is ODBC?

A) ->open database connectivity is a technology from MS that enables any language program (other than java) to communication with database Management System. ->in java program ODBC is directly not allowed for the fallowing reasons 1) OS dependency 2) Procedural oriented approach 3) Security thread
Post a Comment
Read more

Q) Explain about nested classes?

A) ->defining a class with in another class is known as nesting of the class. Ex: class A {        class B        {                      } //nested class, and inner class.because it is not static class. } //enclosing class or outer class. ->static class is declared in inside an another class then it does not become an inner class. Note: non-static nested class is known as “inner class”. In the above example class B is nested but not an inner class. Ex: class D {        static c        {                      } //nested class, but not an inner class , because of static class. } //outer class. ->we have three different kinds of inner classes. 1) Member inner class 2) Meth...
Post a Comment
Read more