ప్రతిబింబాన్ని ఉపయోగించి వస్తువు యొక్క అంతర్గత స్థితిని మార్చడం

ప్రైవేట్ ఫీల్డ్‌తో క్లాస్

ఫీల్డ్ యాక్సెస్ మాడిఫైయర్‌ల గురించి మీ అందరికీ బాగా తెలుసు. మరియు ఫీల్డ్ ప్రైవేట్ మాడిఫైయర్‌ని కలిగి ఉంటే, మేము దానిని బయటి నుండి యాక్సెస్ చేయలేము.

public class Person {
  private int age;
  public String nickname;
  public Person(int age, String nickname) {
   this.age = age;
   this.nickname = nickname;
  }
}

మా ప్రధాన తరగతిలో ప్రాప్యతను తనిఖీ చేద్దాం :

public class Main {
   public static void main(String[] args) {
     Person person = new Person();  
     System.out.println(person.nickname);
    // System.out.println(person.age); No access to the field
  }
}

మాకు యాక్సెస్ లేదువయస్సుఫీల్డ్, కానీ మనకు ప్రతిబింబం ఉంది. :) మరియు దాని సహాయంతో, మేము ప్రైవేట్ ఫీల్డ్‌లను యాక్సెస్ చేయవచ్చు మరియు పని చేయవచ్చు.

ప్రతిబింబాన్ని ఉపయోగించి వస్తువు నుండి ప్రైవేట్ ఫీల్డ్‌ను పొందడం

getDeclaredFields() పద్ధతిని ఉపయోగించి మన తరగతిలోని అన్ని ఫీల్డ్‌ల శ్రేణిని పొందండి . ఇది మనం పని చేయగల మరియు సవరించగల ఫీల్డ్ ఆబ్జెక్ట్‌ను అందిస్తుంది :

public static void main(String[] args) {
        Field[] fields = Person.class.getDeclaredFields();
        List<String> actualFieldNames = getFieldNames(fields);
        actualFieldNames.forEach(System.out::println);
    }

    static List<String> getFieldNames(Field[] fields) {
        List<String> fieldNames = new ArrayList<>();
        for (Field field : fields)
            fieldNames.add(Modifier.toString(field.getModifiers()) + " " + field.getName());
        return fieldNames;
    }

getFieldNames పద్ధతిలో , మేము మా తరగతి నుండి రెండు ఫీల్డ్‌లను పొందుతాము. getModifiers పద్ధతి మా ఫీల్డ్ యొక్క మాడిఫైయర్‌ని అందిస్తుంది మరియు getName దాని పేరును అందిస్తుంది. ఇప్పుడు ఈ ఫీల్డ్‌ని సవరించడానికి మరియు యాక్సెస్ చేయడానికి ప్రయత్నిద్దాం. ముందుగా, పబ్లిక్ ఫీల్డ్ నుండి డేటాను పొందడానికి ప్రయత్నిద్దాం:

public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {
    Person person = new Person(10, "CodeGym");

    Field field = Person.class.getDeclaredField("nickname");
    String nickname = (String) field.get(person);
    System.out.println(nickname);

    System.out.println(person.nickname);
}

ప్రతిబింబం సహాయంతో మరియు ఆబ్జెక్ట్‌కు మా సూచనను ఉపయోగించడం ద్వారా మేము ఫీల్డ్‌ని యాక్సెస్ చేయవచ్చు. అంతా గొప్పదే! ప్రైవేట్ ఫీల్డ్‌కి వెళ్దాం.

మేము అభ్యర్థించిన ఫీల్డ్ పేరును మా ప్రైవేట్‌గా మారుస్తామువయస్సుఫీల్డ్:

public static void main(String[]args)throws NoSuchFieldException, IllegalAccessException {
		Person person = new Person(10, "CodeGym");

    Field field = Person.class.getDeclaredField("age");
    int age =(int)field.get(person);
    System.out.println(age);

    // System.out.println(person.age);
}

సృష్టించిన వస్తువు ద్వారా మాకు ప్రాప్యత లేదు, కాబట్టి ప్రతిబింబాన్ని ఉపయోగించి ప్రయత్నించండి. మాకు లోపం వస్తుంది:

చట్టవిరుద్ధమైన యాక్సెస్ మినహాయింపు

మేము చట్టవిరుద్ధమైన యాక్సెస్ మినహాయింపును పొందుతాము . లోపల ఏముందో ఒకసారి చూద్దాం:

దాన్ని గుర్తించడానికి ప్రయత్నిద్దాం.

ప్రస్తుతం అమలులో ఉన్న పద్ధతికి పేర్కొన్న క్లాస్, ఫీల్డ్, నిర్వచనానికి ప్రాప్యత లేనప్పుడు, ఒక అప్లికేషన్ ప్రతిబింబంగా ఒక ఉదాహరణను సృష్టించడానికి ప్రయత్నించినప్పుడు (అరే కాకుండా), ఫీల్డ్‌ను సెట్ చేయడానికి లేదా పొందడానికి లేదా పద్ధతిని అమలు చేయడానికి ప్రయత్నించినప్పుడు చట్టవిరుద్ధమైన యాక్సెస్ మినహాయింపు విసిరివేయబడుతుంది . పద్ధతి, లేదా కన్స్ట్రక్టర్.

ఇక్కడ పద్ధతులు కూడా ఈ మినహాయింపును విసిరివేస్తాయి. ఈ మినహాయింపును నివారించడానికి, మేము ప్రైవేట్ ఫీల్డ్‌ను యాక్సెస్ చేయడానికి ప్రత్యేక పద్ధతిని ఉపయోగిస్తాము.

సెట్ యాక్సెస్ (బూలియన్ ఫ్లాగ్)

ఈ పద్ధతి ఫీల్డ్ లేదా క్లాస్ కోసం సెక్యూరిటీ యాక్సెస్ చెక్‌లను నివారించడం సాధ్యం చేస్తుంది. ఫీల్డ్ కోసం భద్రతా యాక్సెస్ తనిఖీలు నిర్వహించబడతాయో లేదో నిర్ధారించడానికి మేము పద్ధతిని ఒప్పు లేదా తప్పుని పాస్ చేయవచ్చు . మన కోడ్‌ని సరిచేయడానికి ప్రయత్నిద్దాం:

public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {
    Person person = new Person(10, "CodeGym");

    Field field = Person.class.getDeclaredField("age");
    field.setAccessible(true);

    int age = (int) field.get(person);
    System.out.println("The current value is " + age);
}

ఫలితాన్ని చూద్దాం:

గొప్ప! మా తరగతి గురించి మాకు సమాచారం వచ్చింది. మన ఫీల్డ్‌కి కొత్త విలువను కేటాయించడం ద్వారా దాన్ని మార్చడానికి కూడా ప్రయత్నిద్దాం:

public static void main(String[]args)throws NoSuchFieldException, IllegalAccessException {
Person person = new Person(10, "CodeGym");

    Field field = Person.class.getDeclaredField("age");
    field.setAccessible(true);

    field.set(person, 19);

    int age =(int)field.get(person);
    System.out.println("The current value is " + age);
}

మా ఫీల్డ్‌ని మార్చిన తర్వాత, మనకు లభిస్తుంది:

setAccessible(false) కి కాల్ చేయడానికి ప్రయత్నిద్దాం .

public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {
    Person person = new Person(10, "CodeGym");

    Field field = Person.class.getDeclaredField("age");
    
    field.setAccessible(true);
    field.set(person, 19);
    field.setAccessible(false);

    System.out.println("The current value is " + field.get(person));
}

యాక్సెసిబిలిటీని ఫాల్స్‌కి రీస్టోర్ చేసిన తర్వాత, మేము గెట్ మెథడ్‌కి కాల్ చేయడానికి ప్రయత్నించినప్పుడు మళ్లీ మా మినహాయింపును పొందుతాము :

కాబట్టి ప్రైవేట్ ఫీల్డ్‌లతో పనిచేసేటప్పుడు జాగ్రత్తగా ఉండండి మరియు ప్రతిబింబం చాలా శక్తివంతమైన సాధనం అని మర్చిపోవద్దు!