java what मैं जावा में किसी अन्य से एक कन्स्ट्रक्टर को कैसे कॉल करूं?




what is garbage collection in java (13)

हां, this() उपयोग के साथ एक कन्स्ट्रक्टर को दूसरे से कॉल करना संभव है this()

class Example{
   private int a = 1;
   Example(){
        this(5); //here another constructor called based on constructor argument
        System.out.println("number a is "+a);   
   }
   Example(int b){
        System.out.println("number b is "+b);
   }

क्या किसी अन्य से एक कन्स्ट्रक्टर को कॉल करना संभव है (उसी वर्ग के भीतर, उप-वर्ग से नहीं)? यदि हां कैसे? और एक और कन्स्ट्रक्टर को कॉल करने का सबसे अच्छा तरीका क्या हो सकता है (यदि ऐसा करने के कई तरीके हैं)?


[ नोट: मैं सिर्फ एक पहलू जोड़ना चाहता हूं, जिसे मैंने अन्य उत्तरों में नहीं देखा: इस आवश्यकता को सीमाओं को दूर करने के लिए कैसे करें () को पहली पंक्ति में होना चाहिए)। ]

जावा में एक ही कक्षा के एक और निर्माता को this() माध्यम से एक निर्माता से बुलाया जा सकता है। ध्यान दें कि this पहली पंक्ति पर होना चाहिए।

public class MyClass {

  public MyClass(double argument1, double argument2) {
    this(argument1, argument2, 0.0);
  }

  public MyClass(double argument1, double argument2, double argument3) {
    this.argument1 = argument1;
    this.argument2 = argument2;
    this.argument3 = argument3;
  }
}

यह पहली पंक्ति पर दिखाई देना है जो एक बड़ी सीमा की तरह दिखता है, लेकिन आप स्थिर तरीकों के माध्यम से अन्य रचनाकारों के तर्कों का निर्माण कर सकते हैं। उदाहरण के लिए:

public class MyClass {

  public MyClass(double argument1, double argument2) {
    this(argument1, argument2, getDefaultArg3(argument1, argument2));
  }

  public MyClass(double argument1, double argument2, double argument3) {
    this.argument1 = argument1;
    this.argument2 = argument2;
    this.argument3 = argument3;
  }

  private static double getDefaultArg3(double argument1, double argument2) {
    double argument3 = 0;

    // Calculate argument3 here if you like.

    return argument3;

  }

}

इस श्रेणी का उपयोग किसी कन्स्ट्रक्टर से कन्स्ट्रक्टर को कॉल करने के लिए किया जा सकता है, जब कक्षा के लिए कई कन्स्ट्रक्टर लिखते हैं, तो ऐसे समय होते हैं जब आप डुप्लिकेट कोड से बचने के लिए दूसरे से एक कन्स्ट्रक्टर को कॉल करना चाहते हैं।

बेलो एक लिंक है जिसे मैं कन्स्ट्रक्टर और गेटर्स () और सेटर्स () के बारे में अन्य विषय समझाता हूं और मैंने दो रचनाकारों के साथ एक कक्षा का उपयोग किया। मुझे उम्मीद है कि स्पष्टीकरण और उदाहरण आपकी मदद करेंगे।

सेटर विधियों या रचनाकारों


हां, किसी भी श्रेणी में रचनाकार कक्षा में उपस्थित हो सकते हैं और इनका उपयोग करके किसी अन्य निर्माता द्वारा उन्हें बुलाया जा सकता है this() [कृपया this कीवर्ड के साथ this this() कन्स्ट्रक्टर कॉल को भ्रमित न करें]। this() या this(args) कन्स्ट्रक्टर में पहली पंक्ति होना चाहिए।

उदाहरण:

Class Test {
    Test() {
        this(10); // calls the constructor with integer args, Test(int a)
    }
    Test(int a) {
        this(10.5); // call the constructor with double arg, Test(double a)
    }
    Test(double a) {
        System.out.println("I am a double arg constructor");
    }
}

इसे कन्स्ट्रक्टर ओवरलोडिंग के रूप में जाना जाता है।
कृपया ध्यान दें कि कन्स्ट्रक्टर के लिए केवल ओवरलोडिंग अवधारणा लागू है और विरासत या ओवरराइडिंग नहीं है।


जैसा कि पहले से ही कहा है, आप इसका उपयोग this(…) , जिसे एक स्पष्ट कन्स्ट्रक्टर आमंत्रण कहा जाता है।

हालांकि, ध्यान रखें कि ऐसे स्पष्ट कन्स्ट्रक्टर आमंत्रण कथन के भीतर आप इसका उल्लेख नहीं कर सकते हैं

  • किसी भी आवृत्ति चर या
  • कोई उदाहरण विधि या
  • इस वर्ग या किसी भी सुपरक्लास में घोषित किसी भी आंतरिक वर्ग , या
  • this या
  • super

जैसा कि जेएलएस (§8.8.7.1) में बताया गया है।


दूसरे कन्स्ट्रक्टर से कॉलर कन्स्ट्रक्टर

class MyConstructorDemo extends ConstructorDemo
{
    MyConstructorDemo()
    {
        this("calling another constructor");
    }
    MyConstructorDemo(String arg)
    {
        System.out.print("This is passed String by another constructor :"+arg);
    }
}

इसके अलावा आप super() कॉल का उपयोग करके पैरेंट कन्स्ट्रक्टर को कॉल कर सकते हैं


मैं आपको एक आसान तरीका बताऊंगा

दो प्रकार के निर्माता हैं:

  1. डिफ़ॉल्ट कन्स्ट्रक्टर
  2. पैरामीटरयुक्त कन्स्ट्रक्टर

मैं एक उदाहरण में समझाऊंगा

class ConstructorDemo 
{
      ConstructorDemo()//Default Constructor
      {
         System.out.println("D.constructor ");
      }

      ConstructorDemo(int k)//Parameterized constructor
      {
         this();//-------------(1)
         System.out.println("P.Constructor ="+k);       
      }

      public static void main(String[] args) 
      {
         //this(); error because "must be first statement in constructor
         new ConstructorDemo();//-------(2)
         ConstructorDemo g=new ConstructorDemo(3);---(3)    
       }
   }                  

उपर्युक्त उदाहरण में मैंने 3 प्रकार के कॉलिंग दिखाए

  1. यह () इस पर कॉल कन्स्ट्रक्टर में पहला कथन होना चाहिए
  2. यह नाम कम वस्तु है। यह स्वचालित रूप से डिफ़ॉल्ट कन्स्ट्रक्टर को कॉल करता है। 3. यह पैरामीटरयुक्त कन्स्ट्रक्टर को कॉल करता है।

नोट: यह कन्स्ट्रक्टर में पहला बयान होना चाहिए।


इसका उपयोग this(args) । पसंदीदा पैटर्न सबसे छोटे कन्स्ट्रक्टर से सबसे बड़े काम करना है।

public class Cons {

 public Cons() {
  // A no arguments constructor that sends default values to the largest
  this(madeUpArg1Value,madeUpArg2Value,madeUpArg3Value);
 }

 public Cons(int arg1, int arg2) {
  // An example of a partial constructor that uses the passed in arguments
  // and sends a hidden default value to the largest
  this(arg1,arg2, madeUpArg3Value);
 }

 // Largest constructor that does the work
 public Cons(int arg1, int arg2, int arg3) {
  this.arg1 = arg1;
  this.arg2 = arg2;
  this.arg3 = arg3;
 }
}

आप मूल्य के अधिक हाल ही में वकालत किए गए दृष्टिकोण का उपयोग भी कर सकते हैं या बस "के":

public class Cons {
 public static Cons newCons(int arg1,...) {
  // This function is commonly called valueOf, like Integer.valueOf(..)
  // More recently called "of", like EnumSet.of(..)
  Cons c = new Cons(...);
  c.setArg1(....);
  return c;
 }
} 

एक सुपर क्लास को कॉल करने के लिए, super(asdf) उपयोग करें। सुपर को कॉल कन्स्ट्रक्टर में पहला कॉल होना चाहिए या आपको एक कंपाइलर त्रुटि मिल जाएगी।


मुझे पता है कि इस सवाल के इतने सारे उदाहरण हैं लेकिन मुझे जो मिला वह मैं अपना विचार साझा करने के लिए यहां डाल रहा हूं। चेन कंस्ट्रक्टर के दो तरीके हैं। उसी कक्षा में आप इस कीवर्ड का उपयोग कर सकते हैं। विरासत में, आपको सुपर कीवर्ड का उपयोग करने की आवश्यकता है।

    import java.util.*;
    import java.lang.*;

    class Test
    {  
        public static void main(String args[])
        {
            Dog d = new Dog(); // Both Calling Same Constructor of Parent Class i.e. 0 args Constructor.
            Dog cs = new Dog("Bite"); // Both Calling Same Constructor of Parent Class i.e. 0 args Constructor.

            // You need to Explicitly tell the java compiler to use Argument constructor so you need to use "super" key word
            System.out.println("------------------------------");
            Cat c = new Cat();
            Cat caty = new Cat("10");

            System.out.println("------------------------------");
            // Self s = new Self();
            Self ss = new Self("self");
        }
    }

    class Animal
    {
        String i;

        public Animal()
        {
            i = "10";
            System.out.println("Animal Constructor :" +i);
        }
        public Animal(String h)
        {
            i = "20";
            System.out.println("Animal Constructor Habit :"+ i);
        }
    }

    class Dog extends Animal
    {
        public Dog()
        {
            System.out.println("Dog Constructor");
        }
        public Dog(String h)
        {
            System.out.println("Dog Constructor with habit");
        }
    }

    class Cat extends Animal
    {
        public Cat()
        {
            System.out.println("Cat Constructor");
        }
        public Cat(String i)
        {
            super(i); // Calling Super Class Paremetrize Constructor.
            System.out.println("Cat Constructor with habit");
        }
    }

    class Self
    {
        public Self()
        {
            System.out.println("Self Constructor");
        }
        public Self(String h)
        {
            this(); // Explicitly calling 0 args constructor. 
            System.out.println("Slef Constructor with value");
        }
    }

ऐसे डिज़ाइन पैटर्न हैं जो जटिल निर्माण की आवश्यकता को कवर करते हैं - यदि इसे संक्षेप में नहीं किया जा सकता है, तो फैक्ट्री विधि या फैक्ट्री क्लास बनाएं।

नवीनतम जावा और लैम्ब्डा के अतिरिक्त, एक कन्स्ट्रक्टर बनाना आसान है जो आपके इच्छित प्रारंभिक कोड को स्वीकार कर सकता है।

class LambdaInitedClass {

   public LamdaInitedClass(Consumer<LambdaInitedClass> init) {
       init.accept(this);
   }
}

इसे कॉल करें ...

 new LambdaInitedClass(l -> { // init l any way you want });

हां, दूसरे से कन्स्ट्रक्टर को कॉल करना संभव है। लेकिन इसके लिए एक नियम है। यदि एक कन्स्ट्रक्टर से दूसरे में कॉल किया जाता है, तो

वर्तमान कन्स्ट्रक्टर में नया कन्स्ट्रक्टर कॉल पहला कथन होना चाहिए

public class Product {
     private int productId;
     private String productName;
     private double productPrice;
     private String category;

    public Product(int id, String name) {
        this(id,name,1.0);
    }

    public Product(int id, String name, double price) {
        this(id,name,price,"DEFAULT");
    }

    public Product(int id,String name,double price, String category){
        this.productId=id;
        this.productName=name;
        this.productPrice=price;
        this.category=category;
    }
}

तो नीचे की तरह कुछ काम नहीं करेगा।

public Product(int id, String name, double price) {
    System.out.println("Calling constructor with price");
    this(id,name,price,"DEFAULT");
}

आप "इस" कीवर्ड का उपयोग करके उसी वर्ग के किसी अन्य निर्माता से एक निर्माता बना सकते हैं। उदाहरण -

class This1
{
    This1()
    {
        this("Hello");
        System.out.println("Default constructor..");
    }
    This1(int a)
    {
        this();
        System.out.println("int as arg constructor.."); 
    }
    This1(String s)
    {
        System.out.println("string as arg constructor..");  
    }

    public static void main(String args[])
    {
        new This1(100);
    }
}

आउटपुट - तर्क कन्स्ट्रक्टर के रूप में स्ट्रिंग .. डिफ़ॉल्ट कन्स्ट्रक्टर .. int कन्स्ट्रक्टर के रूप में int ..


जब मुझे कोड के अंदर से दूसरे कन्स्ट्रक्टर को कॉल करने की आवश्यकता होती है (पहली पंक्ति पर नहीं), तो मैं आमतौर पर इस तरह एक सहायक विधि का उपयोग करता हूं:

class MyClass {
   int field;


   MyClass() {
      init(0);
   } 
   MyClass(int value) {
      if (value<0) {
          init(0);
      } 
      else { 
          init(value);
      }
   }
   void init(int x) {
      field = x;
   }
}

लेकिन अक्सर मैं जितना संभव हो सके, पहली पंक्ति पर सरल लोगों से अधिक जटिल रचनाकारों को बुलाकर इसे दूसरी तरफ करने की कोशिश करता हूं। उपर्युक्त उदाहरण के लिए

class MyClass {
   int field;

   MyClass(int value) {
      if (value<0)
         field = 0;
      else
         field = value;
   }
   MyClass() {
      this(0);
   }
}




constructor