ప్రతిబింబాన్ని ఉపయోగించి వస్తువులను పోల్చడం

Class.newInstance()ని ఉపయోగించి వస్తువును సృష్టించడానికి ఉదాహరణ

ప్రతిబింబాన్ని ఉపయోగించి ఒక వస్తువును సృష్టించడానికి మీరు కేటాయించబడ్డారని ఊహించుకోండి. మనం ప్రారంభించాలా?

మేము తక్షణం చేయాలనుకుంటున్న తరగతి కోసం కోడ్‌ని వ్రాయడం ద్వారా ప్రారంభిస్తాము:

public class Employee {
    private String name;
    private String lastName;
    private int age;

    {
        age = -1;
        name = "Rob";
        surname = "Stark";
    }

    public Employee(String name, String surname, int age) {
        this.name = name;
        this.surname = surname;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSurname() {
        return lastName;
    }

    public void setSurname(String surname) {
        this.surname = surname;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", surname='" + surname + '\'' +
                ", age=" + age +
                '}';
    }
}

ఇది మా తరగతిగా ఉంటుంది — అనేక ఫీల్డ్‌లతో, పారామీటర్‌లు, గెట్టర్‌లు మరియు సెట్టర్‌లతో కూడిన కన్‌స్ట్రక్టర్, toString() పద్ధతి మరియు ఇనిషియలైజేషన్ బ్లాక్. ఇప్పుడు రెండవ భాగానికి వెళ్దాం: ప్రతిబింబాన్ని ఉపయోగించి ఒక వస్తువును సృష్టించడం. మేము చూసే మొదటి విధానం Class.newInstance() .

public class Main {
    public static void main(String[] args) throws InstantiationException, IllegalAccessException {
        Employee employee = Employee.class.newInstance();
        System.out.println("age is " + employee.getAge());
    }
}

అద్భుతమైన! మన కోడ్‌ని రన్ చేద్దాం మరియు ప్రదర్శించబడే వయస్సు కోసం చూద్దాం. కానీ మేము తప్పిపోయిన డిఫాల్ట్ కన్స్ట్రక్టర్ గురించి ఎర్రర్‌ను పొందుతాము. ఈ పద్ధతి డిఫాల్ట్ కన్స్ట్రక్టర్‌ని ఉపయోగించి సృష్టించబడిన వస్తువును పొందడానికి మాత్రమే అనుమతిస్తుంది. మన తరగతికి డిఫాల్ట్ కన్‌స్ట్రక్టర్‌ని జోడించి, కోడ్‌ని మళ్లీ పరీక్షిద్దాం.

దోష సందేశం:

కొత్త కన్స్ట్రక్టర్ కోడ్

public Employee() { }

కన్స్ట్రక్టర్‌ని జోడించిన తర్వాత, ఇక్కడ అవుట్‌పుట్ ఉంది:

గొప్ప! ఈ పద్ధతి ఎలా పనిచేస్తుందో మేము కనుగొన్నాము. ఇప్పుడు హుడ్ కింద చూద్దాం. డాక్యుమెంటేషన్‌ను తెరవడం ద్వారా, మా పద్ధతి ఇప్పటికే నిలిపివేయబడిందని మేము చూస్తాము :

ఇది InstantiationException మరియు IllegalAccessExceptionని కూడా విసిరివేయవచ్చు . దీని ప్రకారం, డాక్యుమెంటేషన్ మేము ఒక వస్తువును సృష్టించే ఇతర మార్గాన్ని ఉపయోగిస్తామని సూచిస్తుంది, అవి Constructor.newInstance() . కన్స్ట్రక్టర్ క్లాస్ ఎలా పనిచేస్తుందో వివరంగా విశ్లేషిద్దాం .

getConstructors మరియు getDeclaredConstructors పద్ధతులు

కన్‌స్ట్రక్టర్ క్లాస్‌తో పని చేయడానికి , మేము ముందుగా ఒక ఉదాహరణను పొందాలి. దీని కోసం మాకు రెండు పద్ధతులు ఉన్నాయి: getConstructors మరియు getDeclaredConstructors .

మొదటిది పబ్లిక్ కన్‌స్ట్రక్టర్‌ల శ్రేణిని అందిస్తుంది మరియు రెండవది అన్ని క్లాస్ కన్‌స్ట్రక్టర్‌ల శ్రేణిని అందిస్తుంది.

మన తరగతికి కొంత గోప్యతను ఇద్దాం లేదా ఈ పద్ధతులు ఎలా పని చేస్తాయో ప్రదర్శించడంలో సహాయపడటానికి కొన్ని ప్రైవేట్ కన్స్ట్రక్టర్‌లను క్రియేట్ చేద్దాం.

కొన్ని ప్రైవేట్ కన్స్ట్రక్టర్‌లను జోడిద్దాం:

private Employee(String name, String surname) {
    this.name = name;
    this.lastName = lastName;
}

కోడ్‌ని చూస్తే, కన్స్ట్రక్టర్‌లలో ఒకరు ప్రైవేట్ అని గమనించండి:

మన పద్ధతులను పరీక్షిద్దాం:

public class Main {
	  public static void main(String[] args) {
	      Class employeeClass = Employee.class;

	      System.out.println("getConstructors:");
	      printAllConstructors(employeeClass);

	      System.out.println("\n" +"getDeclaredConstructors:");
	      printDeclaredConstructors(employeeClass);
	  }

	  static void printDeclaredConstructors(Class<?> c){
	      for (Constructor<?> constructor : c.getDeclaredConstructors()) {
	          System.out.println(constructor);
	      }
	  }

	  static void printAllConstructors(Class<?> c){
	      for (Constructor<?> constructor : c.getConstructors()) {
	          System.out.println(constructor);
	      }
	  }
}

మరియు మేము ఈ ఫలితాన్ని పొందుతాము:

సరే, ఈ విధంగా మనం కన్‌స్ట్రక్టర్ ఆబ్జెక్ట్‌కి యాక్సెస్ పొందుతాము. ఇప్పుడు అది ఏమి చేయగలదో మనం మాట్లాడవచ్చు.

java.lang.reflect.Constructor తరగతి మరియు దాని అత్యంత ముఖ్యమైన పద్ధతులు

అత్యంత ముఖ్యమైన పద్ధతులను మరియు అవి ఎలా పని చేస్తాయో చూద్దాం:

getName() & getModifiers()

పని చేయడానికి సౌకర్యంగా ఉండేలా మా శ్రేణిని జాబితాలో చుట్టుము . మేము getName మరియు getModifiers పద్ధతులను కూడా వ్రాస్తాము :

static List<Constructor<?>> getAllConstructors(Class<?> c) {
    return new ArrayList<>(Arrays.asList(c.getDeclaredConstructors()));
}

static List<String> getConstructorNames(List<Constructor<?>> constructors) {
    List<String> result = new ArrayList<>();
    for (Constructor<?> constructor : constructors) {
        result.add(constructor.toString());
    }
    return result;
}

static List<String> getConstructorModifiers(List<Constructor<?>> constructors) {
    List<String> result = new ArrayList<>();
    for (Constructor<?> constructor : constructors) {
        result.add(Modifier.toString(constructor.getModifiers()));
    }
    return result;
}

మరియు మా ప్రధాన పద్ధతి, ఇక్కడ మేము ప్రతిదీ పిలుస్తాము:

public static void main(String[] args) {
    Class employeeClass = Employee.class;
    var constructors = getAllConstructors(employeeClass);
    var constructorNames = getConstructorNames(constructors);
    var constructorModifiers = getConstructorModifiers(constructors);

    System.out.println("Employee class:");
    System.out.println("Constructors :");
    System.out.println(constructorNames);
    System.out.println("Modifiers :");
    System.out.println(constructorModifiers);
}

మరియు ఇప్పుడు మనకు కావలసిన మొత్తం సమాచారాన్ని చూస్తాము:

మినహాయింపు రకాలు ()

ఈ పద్ధతి మా కన్స్ట్రక్టర్ విసిరే మినహాయింపుల శ్రేణిని పొందడానికి అనుమతిస్తుంది. మన కన్స్ట్రక్టర్‌లలో ఒకరిని సవరించి, కొత్త పద్ధతిని వ్రాస్దాం.

ఇక్కడ మేము మా ప్రస్తుత కన్స్ట్రక్టర్‌ను కొద్దిగా మారుస్తాము:

private Employee(String name, String surname) throws Exception {
    this.name = name;
    this.lastName = lastName;
}

మరియు ఇక్కడ మేము మినహాయింపు రకాలను పొందడానికి ఒక పద్ధతిని కలిగి ఉన్నాము మరియు దానిని మెయిన్‌కి జోడించండి :

static List<Class<?>> getConstructorExceptionTypes(Constructor<?> c) {
      return new ArrayList<>(Arrays.asList(c.getExceptionTypes()));
}


var constructorExceptionTypes = getConstructorExceptionTypes(constructors.get(0));
System.out.println("Exception types :");
System.out.println(constructorExceptionTypes);

పైన, మేము మా జాబితాలో మొదటి కన్స్ట్రక్టర్‌ని యాక్సెస్ చేసాము. మేము ఒక నిర్దిష్ట కన్స్ట్రక్టర్‌ను ఎలా పొందాలో కొంచెం తరువాత చర్చిస్తాము.

మరియు మేము త్రోలు మినహాయింపును జోడించిన తర్వాత అవుట్‌పుట్‌ను చూడండి :

మరియు మినహాయింపును జోడించే ముందు:

ప్రతిదీ అద్భుతంగా ఉంది, కానీ మా కన్స్ట్రక్టర్లకు ఏ పారామితులు అవసరమో మనం ఎలా చూస్తాము? దీన్ని కూడా గుర్తించండి.

getParameters() & getParameterTypes() & getGenericParameterTypes()

మా ప్రైవేట్ కన్స్ట్రక్టర్‌ను మెరుగుపరచడం ద్వారా మళ్లీ ప్రారంభిద్దాం. ఇప్పుడు ఇది ఇలా కనిపిస్తుంది:

private Employee(String name, String surname, List<String> list) {
    this.name = name;
    this.lastName = lastName;
}

మరియు మాకు మూడు అదనపు పద్ధతులు ఉన్నాయి: పారామీటర్ల క్రమాన్ని మరియు వాటి రకాలను పొందడానికి getParameters , పారామీటర్ రకాలను పొందడానికి getParameterTypes మరియు జెనరిక్స్‌తో చుట్టబడిన రకాలను పొందడానికి getGenericParameterTypes .

static List<Parameter> getConstructorParameters(Constructor<?> c) {
    return new ArrayList<>(Arrays.asList(c.getParameters()));
}

static List<Class<?>> getConstructorParameterTypes(Constructor<?> c) {
    return new ArrayList<>(Arrays.asList(c.getParameterTypes()));
}

static List<Type> getConstructorParametersGenerics(Constructor<?> c) {
    return new ArrayList<>(Arrays.asList(c.getGenericParameterTypes()));
}

మరియు మేము మా ఇప్పటికే అంత చిన్నది కాని ప్రధాన పద్ధతికి మరికొంత సమాచారాన్ని జోడిస్తాము :

var constructorParameterTypes = getConstructorParameterTypes(constructors.get(0));
var constructorParameters = getConstructorParameters(constructors.get(0));
var constructorParametersGenerics = getConstructorParametersGenerics(constructors.get(0));

System.out.println("Constructor parameters :");
System.out.println(constructorParameters);

System.out.println("Parameter types :");
System.out.println(constructorParameterTypes);

System.out.println("Constructor parameter types :");
System.out.println(constructorParametersGenerics);

అవుట్‌పుట్‌ను చూస్తే, మా కన్స్ట్రక్టర్‌ల పారామితుల గురించి చాలా వివరణాత్మక సమాచారాన్ని మేము చూస్తాము:

ఇది ప్రతి పద్ధతి మధ్య వ్యత్యాసాన్ని స్పష్టంగా చూపుతుంది. పారామీటర్ రకాలు, చుట్టబడిన రకాలు మరియు సాధారణంగా ప్రతిదానిపై సమాచారాన్ని పొందడానికి మాకు ప్రత్యేక ఎంపికలు ఉన్నాయని మేము చూస్తాము. సూపర్! ఇప్పుడు మేము కన్‌స్ట్రక్టర్ క్లాస్‌తో పరిచయం కలిగి ఉన్నాము, మేము మా కథనం యొక్క ప్రధాన అంశానికి తిరిగి రావచ్చు — వస్తువులను సృష్టించడం.

Constructor.newInstance()ని ఉపయోగించి వస్తువును సృష్టించడం

ఆబ్జెక్ట్‌లను సృష్టించడానికి రెండవ మార్గం కన్స్ట్రక్టర్‌లో కొత్త ఇన్‌స్టాన్స్ పద్ధతిని కాల్ చేయడం. పని చేసే ఉదాహరణను పరిశీలిద్దాం మరియు నిర్దిష్ట కన్స్ట్రక్టర్‌ను ఎలా పొందవచ్చో చూద్దాం.

మీరు ఒకే కన్స్ట్రక్టర్‌ని పొందాలనుకుంటే, మీరు getConstructor పద్ధతిని ఉపయోగించాలి ( గెట్‌కన్‌స్ట్రక్టర్‌లతో గందరగోళం చెందకూడదు , ఇది అన్ని కన్‌స్ట్రక్టర్‌ల శ్రేణిని అందిస్తుంది). getConstructor పద్ధతి డిఫాల్ట్ కన్‌స్ట్రక్టర్‌ని అందిస్తుంది .

public static void main(String[] args) throws NoSuchMethodException {
    Class employeeClass = Employee.class;
    Constructor<?> employeeConstructor = employeeClass.getConstructor();
    System.out.println(employeeConstructor);
}

మరియు మనం నిర్దిష్ట కన్స్ట్రక్టర్‌ను పొందాలనుకుంటే, ఈ పద్ధతికి కన్స్ట్రక్టర్ యొక్క పారామీటర్ రకాలను పాస్ చేయాలి.

getDeclaredConstructor పద్ధతిని ఉపయోగించి మాత్రమే మేము మా ప్రైవేట్ కన్స్ట్రక్టర్‌ని పొందగలమని మర్చిపోవద్దు .

Constructor<?> employeeConstructor2 = employeeClass.getDeclaredConstructor(String.class, String.class, List.class);
System.out.println(employeeConstructor2);

ఈ విధంగా మనం నిర్దిష్ట కన్స్ట్రక్టర్‌ని పొందవచ్చు. ఇప్పుడు ప్రైవేట్ మరియు పబ్లిక్ కన్స్ట్రక్టర్లను ఉపయోగించి వస్తువులను సృష్టించడానికి ప్రయత్నిద్దాం.

పబ్లిక్ కన్స్ట్రక్టర్:

Class employeeClass = Employee.class;
Constructor<?> employeeConstructor = employeeClass.getConstructor(String.class, String.class, int.class);
System.out.println(employeeConstructor);

Employee newInstance = (Employee) employeeConstructor.newInstance("Rob", "Stark", 10);
System.out.println(newInstance);

ఫలితం మనం పని చేయగల వస్తువు:

ప్రతిదీ గొప్పగా పనిచేస్తుంది! ఇప్పుడు మేము ప్రైవేట్ కన్స్ట్రక్టర్‌తో ప్రయత్నిస్తాము:

Constructor<?> declaredConstructor = employeeClass.getDeclaredConstructor(String.class, String.class, List.class);
System.out.println(declaredConstructor);

Employee newInstance2 = (Employee) declaredConstructor.newInstance("Rob", "Stark", new ArrayList<>());
System.out.printf(newInstance2.toString());

ఫలితంగా మా కన్స్ట్రక్టర్ గోప్యత లోపం:

Java ఈ కన్స్ట్రక్టర్‌ని ఉపయోగించి ఒక వస్తువును సృష్టించలేకపోయింది, కానీ వాస్తవానికి మనం ప్రధాన పద్ధతిలో ఏదో ఒక అద్భుతం చేయవచ్చు . మేము మా కన్స్ట్రక్టర్ యొక్క యాక్సెస్ స్థాయిని చేయగలము, మా తరగతిలోని వస్తువులను సృష్టించడం సాధ్యమవుతుంది:

declaredConstructor.setAccessible(true);

వస్తువును సృష్టించిన ఫలితం

మేము మా కన్స్ట్రక్టర్‌లో వయస్సుని సెట్ చేయము, కనుక ఇది ప్రారంభించబడినప్పుడు అలాగే ఉంటుంది.

అద్భుతం, సంగ్రహిద్దాం!

Constructor.newInstance()ని ఉపయోగించి వస్తువులను సృష్టించడం వల్ల కలిగే ప్రయోజనాలు

రెండు పద్ధతులు ఒకే పేరును పంచుకుంటాయి, కానీ వాటి మధ్య తేడాలు ఉన్నాయి:

ఈ కారణాల వల్ల, Class.newInstance () కంటే Constructor.newInstance () కు ప్రాధాన్యత ఇవ్వబడుతుంది మరియు ఇది స్ప్రింగ్, గువా, జూకీపర్, జాక్సన్, సర్వ్‌లెట్ మొదలైన వివిధ ఫ్రేమ్‌వర్క్‌లు మరియు APIల ద్వారా ఉపయోగించే పద్ధతి.