පරාවර්තනය යනු කුමක්ද සහ එය ප්‍රයෝජනවත් වන්නේ ඇයි?

පරාවර්තනය යනු කුමක්ද, එය ප්‍රයෝජනවත් වන්නේ ඇයි?

මම විශේෂයෙන් ජාවා ගැන උනන්දු වෙමි, නමුත් ඕනෑම භාෂාවක මූලධර්ම එක හා සමාන යැයි මම සිතමි.

එකම පද්ධතියේ (හෝ තමාටම) වෙනත් කේත පරීක්ෂා කළ හැකි කේතය විස්තර කිරීමට නම පරාවර්තනය භාවිතා කරයි.

උදාහරණයක් ලෙස, ඔබට ජාවා හි නොදන්නා වර්ගයක වස්තුවක් ඇති බව පවසන්න, ඔබ එය තිබේ නම් එය මත 'doSomething' ක්‍රමයක් අමතන්න කැමතියි. ජාවා හි ස්ථිතික යතුරු ලියන පද්ධතිය සැබවින්ම නිර්මාණය කර ඇත්තේ වස්තුව දන්නා අතුරු මුහුණතකට අනුකූල නොවන්නේ නම් මිස පරාවර්තනය භාවිතා කිරීමෙන් ඔබේ කේතයට වස්තුව දෙස බලා එයට 'doSomething' නමින් ක්‍රමයක් තිබේදැයි සොයා ගත හැකි අතර ඔබ එය අමතන්න අවශ්යයි.

එබැවින්, ඔබට ජාවා හි කේත උදාහරණයක් ලබා දීමට (ප්‍රශ්නයේ ඇති වස්තුව foo යැයි සිතන්න):

Method method = foo.getClass().getMethod("doSomething", null);
method.invoke(foo, null);

ජාවා හි ඉතා සුලභ භාවිතයක් වන්නේ ව්‍යාඛ්‍යාව සමඟ භාවිතා කිරීමයි. JUnit 4, උදාහරණයක් ලෙස, estTest annotation සමඟ ටැග් කර ඇති ක්‍රම සඳහා ඔබේ පන්ති හරහා බැලීමට පරාවර්තනය භාවිතා කරනු ඇති අතර, පසුව ඒකක පරීක්ෂණය ක්‍රියාත්මක කිරීමේදී ඒවා අමතනු ඇත.

ඔබ http://docs.oracle.com/javase/tutorial/reflect/index.html වෙතින් ආරම්භ කිරීමට හොඳ පරාවර්තන උදාහරණ කිහිපයක් තිබේ

අවසාන වශයෙන්, ඔව්, පරාවර්තනයට සහාය වන (C # වැනි) වෙනත් සංඛ්‍යාත්මකව ටයිප් කළ භාෂාවල සංකල්ප බොහෝ දුරට සමාන ය. ගතිකව ටයිප් කළ භාෂාවල, ඉහත විස්තර කර ඇති භාවිත නඩුව අඩු අවශ්‍යතාවයක් ඇත (සම්පාදකයා විසින් ඕනෑම වස්තුවකට ඕනෑම ක්‍රමයක් කැඳවීමට ඉඩ සලසයි, එය නොපවතින විට ධාවන වේලාවේදී අසමත් වේ), නමුත් සලකුණු කරන ලද හෝ සොයන ක්‍රම සොයන දෙවන අවස්ථාව එක්තරා ආකාරයකින් වැඩ කිරීම තවමත් පොදු ය.

අදහස් දැක්වීමකින් යාවත්කාලීන කරන්න:

පද්ධතියේ කේතය පරීක්ෂා කිරීමට සහ වස්තු වර්ග බැලීමට ඇති හැකියාව පරාවර්තනය නොවේ, ඒ වෙනුවට ස්වයං පරීක්‍ෂණය කරන්න. පරාවර්තනය යනු ස්වයං විචාරය භාවිතා කිරීමෙන් ධාවන වේලාවේදී වෙනස් කිරීම් කිරීමේ හැකියාවයි. සමහර භාෂාවන් ස්වයං විග්‍රහයට සහාය වන නමුත් පරාවර්තනයට සහාය නොදක්වන බැවින් මෙහි වෙනස අවශ්‍ය වේ. එවැනි එක් උදාහරණයක් වන්නේ C ++ ය

පරාවර්තනය යනු ධාවන වේලාවේදී පන්ති, ක්‍රම, ගුණාංග ආදිය පරීක්ෂා කිරීමට හා ගතිකව ඇමතීමට භාෂාවකට ඇති හැකියාවයි.

නිදසුනක් ලෙස, ජාවා හි ඇති සියලුම වස්තූන් සඳහා ක්‍රමවේදයක් ඇත getClass(), එමඟින් ඔබ එය සම්පාදනය කරන වේලාවේ නොදැන සිටියද (උදා. ඔබ එය ප්‍රකාශයට පත් කළේ නම් Object) - මෙය සුළු දෙයක් ලෙස පෙනුනද එවැනි පරාවර්තනයක් කළ නොහැක වැනි අඩු ගතික භාෂාවලින් C++. වඩාත් දියුණු භාවිතයන් ඔබට ලැයිස්තුගත කිරීමට සහ ඇමතුම් ක්‍රම, ඉදිකිරීම්කරුවන් යනාදිය ඉඩ දෙයි.

පරාවර්තනය වැදගත් වන්නේ එය සෑම දෙයක්ම සම්පාදනය කරන වේලාවට "දැන ගැනීමට" අවශ්‍ය නොවන වැඩසටහන් ලිවීමට ඉඩ සලසන හෙයින් ඒවා වඩාත් ක්‍රියාශීලී වන අතර ඒවා ක්‍රියාත්මක වන වේලාවට එකට බැඳ තැබිය හැකි බැවිනි. දන්නා අතුරුමුහුණත් වලට එරෙහිව කේතය ලිවිය හැකි නමුත් වින්‍යාස ලිපිගොනු වලින් පරාවර්තනය කරමින් භාවිතා කළ යුතු සත්‍ය පන්ති ක්ෂණිකව කළ හැකිය.

නවීන රාමු රාශියක් මෙම හේතුව නිසාම පරාවර්තනය පුළුල් ලෙස භාවිතා කරයි. වෙනත් බොහෝ නූතන භාෂාවන් පරාවර්තනය ද භාවිතා කරන අතර, ස්ක්‍රිප්ටින් භාෂාවන්හි (පයිතන් වැනි) ඒවා වඩාත් තදින් ඒකාබද්ධ වී ඇත, මන්ද එම භාෂාවල සාමාන්‍ය ක්‍රමලේඛන ආකෘතිය තුළ එය වඩාත් ස්වාභාවික යැයි හැඟෙන බැවිනි.

පරාවර්තනය සඳහා මා කැමතිම භාවිතයක් වන්නේ පහත ජාවා ඩම්ප් ක්‍රමයයි. එය ඕනෑම වස්තුවක් පරාමිතියක් ලෙස ගෙන සෑම ක්ෂේත්‍ර නාමයක්ම සහ අගයක්ම මුද්‍රණය කිරීමට ජාවා පරාවර්තන API භාවිතා කරයි.

import java.lang.reflect.Array;
import java.lang.reflect.Field;

public static String dump(Object o, int callCount) {
    callCount++;
    StringBuffer tabs = new StringBuffer();
    for (int k = 0; k < callCount; k++) {
        tabs.append("\t");
    }
    StringBuffer buffer = new StringBuffer();
    Class oClass = o.getClass();
    if (oClass.isArray()) {
        buffer.append("\n");
        buffer.append(tabs.toString());
        buffer.append("[");
        for (int i = 0; i < Array.getLength(o); i++) {
            if (i < 0)
                buffer.append(",");
            Object value = Array.get(o, i);
            if (value.getClass().isPrimitive() ||
                    value.getClass() == java.lang.Long.class ||
                    value.getClass() == java.lang.String.class ||
                    value.getClass() == java.lang.Integer.class ||
                    value.getClass() == java.lang.Boolean.class
                    ) {
                buffer.append(value);
            } else {
                buffer.append(dump(value, callCount));
            }
        }
        buffer.append(tabs.toString());
        buffer.append("]\n");
    } else {
        buffer.append("\n");
        buffer.append(tabs.toString());
        buffer.append("{\n");
        while (oClass != null) {
            Field[] fields = oClass.getDeclaredFields();
            for (int i = 0; i < fields.length; i++) {
                buffer.append(tabs.toString());
                fields[i].setAccessible(true);
                buffer.append(fields[i].getName());
                buffer.append("=");
                try {
                    Object value = fields[i].get(o);
                    if (value != null) {
                        if (value.getClass().isPrimitive() ||
                                value.getClass() == java.lang.Long.class ||
                                value.getClass() == java.lang.String.class ||
                                value.getClass() == java.lang.Integer.class ||
                                value.getClass() == java.lang.Boolean.class
                                ) {
                            buffer.append(value);
                        } else {
                            buffer.append(dump(value, callCount));
                        }
                    }
                } catch (IllegalAccessException e) {
                    buffer.append(e.getMessage());
                }
                buffer.append("\n");
            }
            oClass = oClass.getSuperclass();
        }
        buffer.append(tabs.toString());
        buffer.append("}\n");
    }
    return buffer.toString();
}

පරාවර්තනයේ ප්‍රයෝජන

පරාවර්තනය බහුලව භාවිතා වන්නේ ජාවා අතථ්‍ය යන්ත්‍රය තුළ ක්‍රියාත්මක වන යෙදුම්වල ධාවන කාල හැසිරීම පරීක්ෂා කිරීමට හෝ වෙනස් කිරීමට හැකියාව අවශ්‍ය වැඩසටහන් මගිනි. මෙය සාපේක්ෂව දියුණු අංගයක් වන අතර එය භාවිතා කළ යුත්තේ භාෂාවේ මූලධර්ම පිළිබඳ දැඩි අවබෝධයක් ඇති සංවර්ධකයින් විසින් පමණි. එම අවවාදය මනසේ තබාගෙන, පරාවර්තනය ප්‍රබල තාක්‍ෂණයකි.

විස්තාරණ ලක්ෂණ

යෙදුමක් මඟින් බාහිර, පරිශීලක-නිර්වචනය කරන ලද පන්ති භාවිතා කළ හැකිය. පංති බ්‍රව්සර් සහ දෘශ්‍ය සංවර්ධන පරිසරයන් පංතිවල සාමාජිකයින් ගණනය කිරීමට පන්ති බ්‍රව්සරයකට හැකි විය යුතුය. නිවැරදි කේත ලිවීමට සංවර්ධකයාට උපකාර කිරීම සඳහා පරාවර්තනයෙන් ලබා ගත හැකි ආකාරයේ තොරතුරු භාවිතා කිරීමෙන් දෘශ්‍ය සංවර්ධන පරිසරයන්ට ප්‍රයෝජන ගත හැකිය. නිදොස්කරණය කරන්නන් සහ පරීක්ෂණ මෙවලම් පංතිවල සිටින පුද්ගලික සාමාජිකයන් පරීක්ෂා කිරීමට නිදොස් කරන්නන්ට හැකි විය යුතුය. පරීක්ෂණ කට්ටලයක ඉහළ මට්ටමේ කේත ආවරණයක් සහතික කිරීම සඳහා, පන්තියක් මත අර්ථ දක්වා ඇති සොයාගත හැකි කට්ටල ඒපීඅයි ක්‍රමානුකූලව ඇමතීමට පරීක්ෂණ පටි මගින් පරාවර්තනය භාවිතා කළ හැකිය.

පරාවර්තනයේ අඩුපාඩු

පරාවර්තනය බලවත් ය, නමුත් එය විචක්ෂණ ලෙස භාවිතා නොකළ යුතුය. පරාවර්තනය භාවිතා නොකර මෙහෙයුමක් කළ හැකි නම්, එය භාවිතා කිරීමෙන් වැළකී සිටීම වඩාත් සුදුසුය. පරාවර්තනය හරහා කේතයට ප්‍රවේශ වන විට පහත සඳහන් කරුණු මතක තබා ගත යුතුය.

• කාර්ය සාධනය ඉහළින්

පරාවර්තනයට ගතිකව විසඳන වර්ග ඇතුළත් වන හෙයින්, සමහර ජාවා අතථ්‍ය යන්ත්‍ර ප්‍රශස්තිකරණය සිදු කළ නොහැක. එහි ප්‍රති, ලයක් ලෙස පරාවර්තක මෙහෙයුම් වලට ඒවායේ පරාවර්තක නොවන සගයන්ට වඩා මන්දගාමී කාර්ය සාධනයක් ඇති අතර ඒවා කාර්ය සාධන සංවේදී යෙදුම්වල නිතර හඳුන්වන කේත කොටස් වලින් වැළකී සිටිය යුතුය.

• ආරක්ෂක සීමාවන්

පරාවර්තනය සඳහා ආරක්ෂක කළමනාකරුවෙකු යටතේ ධාවනය වන විට නොපවතින ධාවන කාල අවසරයක් අවශ්‍ය වේ. ඇප්ලෙට් වැනි සීමිත ආරක්ෂක සන්දර්භයක් තුළ ක්‍රියාත්මක විය යුතු කේතය සඳහා මෙය වැදගත් සලකා බැලීමකි.

• අභ්‍යන්තර නිරාවරණය

පරාවර්තනය මඟින් පුද්ගලික ක්ෂේත්‍ර හා ක්‍රම වෙත ප්‍රවේශ වීම වැනි පරාවර්තක නොවන කේතයන්හි නීතිවිරෝධී මෙහෙයුම් සිදු කිරීමට කේතයට ඉඩ දී ඇති හෙයින්, පරාවර්තනය භාවිතා කිරීම අනපේක්ෂිත අතුරු ආබාධ ඇති කළ හැකි අතර එමඟින් කේත ක්‍රියා විරහිත විය හැකි අතර අතේ ගෙන යා හැකි හැකියාව විනාශ විය හැකිය. පරාවර්තක කේතය වියුක්තයන් බිඳ දමයි, එබැවින් වේදිකාවේ වැඩි දියුණු කිරීම් සමඟ හැසිරීම වෙනස් කළ හැකිය.

මූලාශ්‍රය: පරාවර්තන API

පරාවර්තනය යනු යෙදුමක් හෝ රාමුවක් තවම ලියා නොමැති කේත සමඟ වැඩ කිරීමට ඉඩ දෙන ප්‍රධාන යාන්ත්‍රණයකි!

උදාහරණයක් ලෙස ඔබේ සාමාන්‍ය web.xml ගොනුව ගන්න. මෙහි සර්වට්ලට් මූලද්‍රව්‍ය ලැයිස්තුවක් අඩංගු වන අතර එහි කූඩු කළ සර්වට් පන්තියේ අංග අඩංගු වේ. සර්වට් බහාලුම මඟින් වෙබ්.එක්එම්එල් ගොනුව සකසනු ඇති අතර පරාවර්තනය තුළින් එක් එක් සර්වට් පන්තියේ නව අවස්ථාවක් නිර්මාණය කරයි.

තවත් උදාහරණයක් වනුයේ XML විග්‍රහ කිරීම සඳහා ජාවා API (JAXP) ය . එක්ස්එම්එල් විග්‍රහ කරන්නෙකු ප්‍රකට පද්ධති ගුණාංග හරහා 'ප්ලග් ඉන්' කර ඇති අතර ඒවා පරාවර්තනය තුළින් නව අවස්ථා තැනීමට භාවිතා කරයි.

අවසාන වශයෙන්, වඩාත් සවිස්තරාත්මක උදාහරණය වසන්තය එහි බෝංචි නිර්මාණය කිරීමට පරාවර්තනය භාවිතා කරන අතර එහි අධික ලෙස ප්‍රොක්සි භාවිතා කිරීමයි

සෑම භාෂාවක්ම පරාවර්තනයට සහය නොදක්වන නමුත් මූලධර්ම සාමාන්‍යයෙන් එයට අනුබල දෙන භාෂාවල සමාන වේ.

පරාවර්තනය යනු ඔබේ වැඩසටහනේ ව්‍යුහය "පරාවර්තනය" කිරීමේ හැකියාවයි. නැත්නම් වඩා කොන්ක්‍රීට්. ඔබ සතුව ඇති වස්තූන් සහ පංති දෙස බැලීම සහ ඒවා ක්‍රියාත්මක කරන ක්‍රම, ක්ෂේත්‍ර සහ අතුරුමුහුණත් පිළිබඳ තොරතුරු ක්‍රමලේඛයෙන් ලබා ගැනීම. ඔබට විවරණ වැනි දේවල් දෙස බැලිය හැකිය.

එය බොහෝ අවස්ථාවන්හිදී ප්‍රයෝජනවත් වේ. සෑම තැනකම ඔබට ඔබේ කේතයට පන්ති ගතිකව සම්බන්ධ කිරීමට හැකි විය යුතුය. ලොට්ගේ වස්තු සම්බන්ධතා සිතියම් කරුවන් පරාවර්තනය භාවිතා කරන්නේ දත්ත සමුදායන්ගෙන් වස්තූන් ක්ෂණිකව හඳුනා ගැනීමට හැකි වන පරිදි ඔවුන් භාවිතා කිරීමට යන්නේ කුමන වස්තූන් දැයි නොදැන ය. ප්ලග් ඉන් ගෘහ නිර්මාණ ශිල්පය යනු පරාවර්තනය ප්‍රයෝජනවත් වන තවත් ස්ථානයකි. කේත ගතිකව පැටවීමට සහ ප්ලගිනයක් ලෙස භාවිතා කිරීමට නිවැරදි අතුරු මුහුණත ක්‍රියාත්මක කරන වර්ග තිබේද යන්න තීරණය කිරීම එම අවස්ථාවන්හිදී වැදගත් වේ.

පරාවර්තනය මඟින් නව වස්තූන් ක්ෂණිකව ස්ථාපනය කිරීමට, ක්‍රමවේදයන් කැඳවීමට සහ පන්ති විචල්‍යයන් ක්‍රියාත්මක කිරීමේදී පූර්ව දැනුමක් නොමැතිව ධාවන වේලාවේදී ගතිකව ක්‍රියාත්මක කිරීමට / සැකසීමට ඉඩ ලබා දේ.

Class myObjectClass = MyObject.class;
Method[] method = myObjectClass.getMethods();

//Here the method takes a string parameter if there is no param, put null.
Method method = aClass.getMethod("method_name", String.class); 

Object returnValue = method.invoke(null, "parameter-value1");

ඉහත උදාහරණයේ දී ශුන්‍ය පරාමිතිය යනු ඔබට ක්‍රමවේදය ක්‍රියාත්මක කිරීමට අවශ්‍ය වස්තුවයි. ක්‍රමය ස්ථිතික නම් ඔබ ශුන්‍යය සපයයි. ක්‍රමය ස්ථිතික නොවේ නම්, ඉන්වොයිස් කරන අතරතුර ඔබට ශුන්‍ය වෙනුවට වලංගු MyObject උදාහරණයක් සැපයිය යුතුය.

පරාවර්තනය ඔබට පන්තියේ පුද්ගලික සාමාජික / ක්‍රම වෙත ප්‍රවේශ වීමට ඉඩ දෙයි:

public class A{

  private String str= null;

  public A(String str) {
  this.str= str;
  }
}

.

A obj= new A("Some value");

Field privateStringField = A.class.getDeclaredField("privateString");

//Turn off access check for this field
privateStringField.setAccessible(true);

String fieldValue = (String) privateStringField.get(obj);
System.out.println("fieldValue = " + fieldValue);

• පංති පරීක්ෂා කිරීම සඳහා (ස්වයං විග්‍රහයක් ලෙස ද දැන ගන්න) ඔබට පරාවර්තන පැකේජය ආනයනය කිරීමට අවශ්‍ය නොවේ ( java.lang.reflect). පන්ති පාර-දත්ත හරහා ප්‍රවේශ විය හැකිය java.lang.Class.

පරාවර්තනය ඉතා ප්‍රබල API එකක් වන නමුත් එය වැඩිපුර භාවිතා කරන්නේ නම් එය යෙදුම මන්දගාමී විය හැක, මන්ද එය ධාවන වේලාවේදී සියලු වර්ගයන් නිරාකරණය කරයි.

ජාවා පරාවර්තනය තරමක් බලවත් වන අතර එය ඉතා ප්‍රයෝජනවත් වේ. ජාවා පරාවර්තනය මඟින් පන්ති, අතුරුමුහුණත්, ක්ෂේත්‍ර සහ ක්‍රමවේදයන් ධාවන වේලාවේදී පරීක්‍ෂා කිරීමට හැකි වේ . නව වස්තූන් ක්ෂණිකව ක්‍රියාත්මක කිරීම, ක්‍රමවේදයන් ක්‍රියාත්මක කිරීම සහ පරාවර්තනය භාවිතා කරමින් ක්ෂේත්‍ර අගයන් ලබා ගැනීම / සැකසීම ද කළ හැකිය .

පරාවර්තනය භාවිතා කරන්නේ කෙසේද යන්න ඔබට පෙන්වීමට ඉක්මන් ජාවා පරාවර්තන උදාහරණයක්:

Method[] methods = MyObject.class.getMethods();

    for(Method method : methods){
        System.out.println("method = " + method.getName());
    }

මෙම උදාහරණය පන්ති වස්තුව MyObject නමින් පන්තියෙන් ලබා ගනී. පංති වස්තුව භාවිතා කිරීමෙන් උදාහරණයට එම පන්තියේ ක්‍රම ලැයිස්තුවක් ලැබේ, ක්‍රම නැවත කියවා ඒවායේ නම් මුද්‍රණය කරයි.

හරියටම මේ සියල්ල ක්‍රියා කරන ආකාරය මෙහි විස්තර කර ඇත

සංස්කරණය කරන්න : වසර 1 කට පමණ පසු මම මෙම පිළිතුර සංස්කරණය කරන්නේ පරාවර්තනය පිළිබඳ කියවීමේදී පරාවර්තනය පිළිබඳ තවත් භාවිතයන් කිහිපයක් මට ලැබී ඇති බැවිනි.

• වසන්තය බෝංචි වින්‍යාසය භාවිතා කරයි:

<bean id="someID" class="com.example.Foo">
    <property name="someField" value="someValue" />
</bean>

වසන්ත සන්දර්භය මෙම <බෝංචි> මූලද්‍රව්‍යය ක්‍රියාවට නංවන විට, එම පන්තිය ක්ෂණිකව ක්‍රියාත්මක කිරීම සඳහා "com.example.Foo" තර්කය සමඟ Class.forName (String) භාවිතා කරයි.

<දේපල> මූලද්‍රව්‍යය සඳහා සුදුසු සැකසුම ලබා ගැනීමට එය නැවත පරාවර්තනය භාවිතා කර එහි අගය නිශ්චිත අගයට සකසනු ඇත.

• පුද්ගලික / ආරක්ෂිත ක්‍රම පරීක්ෂා කිරීම සඳහා ජුනිට් පරාවර්තනය භාවිතා කරයි.

පුද්ගලික ක්‍රම සඳහා,

Method method = targetClass.getDeclaredMethod(methodName, argClasses);
method.setAccessible(true);
return method.invoke(targetObject, argObjects);

පුද්ගලික ක්ෂේත්‍ර සඳහා,

Field field = targetClass.getDeclaredField(fieldName);
field.setAccessible(true);
field.set(object, value);

උදාහරණයක්:

උදාහරණයක් ලෙස දුරස්ථ යෙදුමක් ගන්න, එමඟින් ඔබේ යෙදුමට ඔවුන්ගේ API ක්‍රම භාවිතා කර ඔබ ලබා ගන්නා වස්තුවක් ලබා දේ. දැන් වස්තුව මත පදනම්ව ඔබට යම් ආකාරයක ගණනය කිරීමක් කිරීමට අවශ්‍ය විය හැකිය.

වස්තුව වර්ග 3 ක් විය හැකි බවට සැපයුම්කරු සහතික වන අතර අප කුමන වර්ගයේ වස්තුවක් මත පදනම්ව ගණනය කිරීමක් කළ යුතුය.

එබැවින් අපි එකිනෙකට වෙනස් තර්කනයක් අඩංගු පන්ති 3 කින් ක්‍රියාත්මක කළ හැකිය .එමෙන්ම වස්තු තොරතුරු ධාවන වේලාවේදී ලබා ගත හැකි බැවින් ගණනය කිරීම සඳහා ඔබට සංඛ්‍යාත්මකව කේත කළ නොහැක. එබැවින් පරාවර්තනය භාවිතා කරනුයේ පන්තියේ වස්තුව ක්ෂණිකව ගණනය කිරීම සඳහා ය. වස්තුව සැපයුම්කරුගෙන් ලැබුණි.

පරාවර්තනය සඳහා සරල උදාහරණය. චෙස් ක්‍රීඩාවකදී, පරිශීලකයා ධාවන වේලාවේදී ගෙන යන්නේ කුමක් දැයි ඔබ නොදනී. ධාවන වේලාවේදී දැනටමත් ක්‍රියාත්මක කර ඇති ක්‍රම ඇමතීමට පරාවර්තනය භාවිතා කළ හැකිය:

public class Test {

    public void firstMoveChoice(){
        System.out.println("First Move");
    } 
    public void secondMOveChoice(){
        System.out.println("Second Move");
    }
    public void thirdMoveChoice(){
        System.out.println("Third Move");
    }

    public static void main(String[] args) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException { 
        Test test = new Test();
        Method[] method = test.getClass().getMethods();
        //firstMoveChoice
        method[0].invoke(test, null);
        //secondMoveChoice
        method[1].invoke(test, null);
        //thirdMoveChoice
        method[2].invoke(test, null);
    }

}

පරාවර්තනය යනු ක්‍රියාත්මක වන ක්‍රම, පන්ති, අතුරුමුහුණත් වල හැසිරීම පරීක්ෂා කිරීමට හෝ වෙනස් කිරීමට භාවිතා කරන API ය .

1. පරාවර්තනය සඳහා අවශ්‍ය පන්ති යටතේ සපයනු ලැබේ java.lang.reflect package.
2. පරාවර්තනය අපට වස්තුවක් අයත් පන්තිය පිළිබඳ තොරතුරු සහ එම වස්තුව භාවිතා කිරීමෙන් ක්‍රියාත්මක කළ හැකි පන්තියේ ක්‍රම පිළිබඳ තොරතුරු ලබා දෙයි.
3. පරාවර්තනය තුළින් අපට ඒවා සමඟ භාවිතා කරන ප්‍රවේශ පිරිවිතර නොසලකා ධාවන වේලාවේදී ක්‍රමවේදයන් ක්‍රියාත්මක කළ හැකිය.

මෙම java.langසහ java.lang.reflectපැකේජ ජාවා පිළිබිඹු සඳහා පන්ති ලබා දෙයි.

පිළිබඳ තොරතුරු ලබා ගැනීම සඳහා පරාවර්තනය භාවිතා කළ හැකිය -

1. පන්තියේ මෙම getClass()ක්රමය වස්තුවක් අයත් වන පන්තියේ නම ලබා ගැනීමට භාවිතා කරයි.

2. ඉදිකිරීම්කරුවන් මෙම getConstructors()ක්‍රමය භාවිතා කරනුයේ වස්තුවක් අයත් පන්තියේ පොදු ඉදිකිරීම්කරුවන් ලබා ගැනීම සඳහා ය.

3. ක්‍රමgetMethods() වස්තුවක් අයත් පන්තියේ පොදු ක්‍රම ලබා ගැනීම සඳහා මෙම ක්‍රමය භාවිතා කරයි.

මෙම මෙනෙහි API ප්රධාන වශයෙන් භාවිතා වේ:

IDE (ඒකාබද්ධ සංවර්ධන පරිසරය) උදා: සූර්යග්‍රහණය, MyEclipse, NetBeans ආදිය.
නිදොස්කරණය සහ පරීක්ෂණ මෙවලම් ආදිය.

පරාවර්තනය භාවිතා කිරීමේ වාසි:

විස්තාරණතා විශේෂාංග: යෙදුමක් මඟින් සම්පූර්ණ සුදුසුකම් ලත් නම් භාවිතා කරමින් විස්තාරණ වස්තු පිළිබඳ අවස්ථා නිර්මාණය කිරීමෙන් බාහිර, පරිශීලක-නිර්වචනය කරන ලද පන්ති භාවිතා කළ හැකිය.

නිදොස්කරණය සහ පරීක්ෂණ මෙවලම්: පංතිවල පෞද්ගලික සාමාජිකයන් පරීක්ෂා කිරීම සඳහා නිදොස් කිරීමේ දේපල පරාවර්තක දේපල භාවිතා කරයි.

අඩුපාඩු:

කාර්ය සාධනය ඉහළින් : පරාවර්තක මෙහෙයුම් වලට ඒවායේ පරාවර්තක නොවන සගයන්ට වඩා මන්දගාමී කාර්ය සාධනයක් ඇති අතර, කාර්ය සාධන සංවේදී යෙදුම්වල නිතර හඳුන්වන කේතයේ කොටස් වලින් වැළකී සිටිය යුතුය.

අභ්‍යන්තර නිරාවරණය: පරාවර්තක කේතය වියුක්තයන් බිඳ දමයි, එබැවින් වේදිකාවේ වැඩි දියුණු කිරීම් සමඟ හැසිරීම වෙනස් කළ හැකිය.

Ref: Java Reflection javarevisited.blogspot.in

මගේ අවබෝධය අනුව:

පරාවර්තනය ක්‍රමලේඛකයාට ක්‍රමලේඛයට ගතිකව ප්‍රවේශ වීමට ඉඩ දෙයි. එනම්, ක්‍රමලේඛකයෙකු පන්තියක් හෝ එහි ක්‍රමවේදයන් ගැන නොදන්නේ නම් යෙදුමක් කේතනය කිරීමේදී, පරාවර්තනය භාවිතා කිරීමෙන් ඔහුට එම පන්තිය ගතිකව (ධාවන වේලාවේදී) භාවිතා කළ හැකිය.

පන්ති නාමයක් නිතර වෙනස් වන අවස්ථා වලදී එය නිතර භාවිතා වේ. එවැනි තත්වයක් ඇති වුවහොත්, ක්‍රමලේඛකයාට යෙදුම නැවත ලිවීම සහ පන්තියේ නම නැවත නැවතත් වෙනස් කිරීම සංකීර්ණ වේ.

ඒ වෙනුවට, පරාවර්තනය භාවිතා කිරීමෙන්, විය හැකි පන්ති නාමයක් ගැන කරදර විය යුතුය.

පරාවර්තනය යනු ඔබේ වැඩසටහනේ ධාවන කාල තොරතුරු වෙත ප්‍රවේශ වීමට සහ හැසිරීම වෙනස් කිරීමට (සමහර සීමාවන් සහිතව) ඉඩ සලසන ශ්‍රිත සමූහයකි.

එය ප්‍රයෝජනවත් වන්නේ එය ඔබගේ වැඩසටහනේ මෙටා තොරතුරු මත පදනම්ව ධාවන කාල හැසිරීම වෙනස් කිරීමට ඉඩ සලසන බැවිනි, එනම්, ඔබට ශ්‍රිතයක නැවත පැමිණීමේ වර්ගය පරීක්ෂා කර තත්වය හැසිරවිය හැකි ආකාරය වෙනස් කළ හැකිය.

නිදසුනක් ලෙස C # හි ඔබට එකලස් කිරීමක් (a .dll) ධාවන වේලාවේදී එය පරීක්ෂා කර බලා, පන්ති හරහා සැරිසැරීමට සහ ඔබ සොයාගත් දේ අනුව ක්‍රියා කිරීමට හැකිය. ධාවන වේලාව පිළිබඳ පන්තියක නිදසුනක් නිර්මාණය කිරීමට, එහි ක්‍රමයට ආයාචනා කිරීමට ද එය ඔබට ඉඩ දෙයි.

එය ප්‍රයෝජනවත් විය හැක්කේ කොතැනින්ද? සෑම අවස්ථාවකම ප්‍රයෝජනවත් නොවන නමුත් සංයුක්ත තත්වයන් සඳහා. නිදසුනක් ලෙස ඔබට ලොග් වීමේ අරමුණු සඳහා පන්තියේ නම ලබා ගැනීමට, වින්‍යාස ගොනුවක නිශ්චිතව දක්වා ඇති දේ අනුව සිදුවීම් සඳහා ගතිකව නිර්මාණය කිරීමට සහ එසේ කළ හැකිය ...

මට අවශ්‍ය වන්නේ ලැයිස්තුගත කර ඇති සියල්ලට යම් කරුණක් එක් කිරීමට ය.

පරාවර්තන API සමඟ ඔබට toString()ඕනෑම වස්තුවක් සඳහා විශ්වීය ක්‍රමයක් ලිවිය හැකිය .

නිදොස්කරණය කිරීමේදී එය ප්‍රයෝජනවත් වේ.

මෙන්න උදාහරණයක්:

class ObjectAnalyzer {

   private ArrayList<Object> visited = new ArrayList<Object>();

   /**
    * Converts an object to a string representation that lists all fields.
    * @param obj an object
    * @return a string with the object's class name and all field names and
    * values
    */
   public String toString(Object obj) {
      if (obj == null) return "null";
      if (visited.contains(obj)) return "...";
      visited.add(obj);
      Class cl = obj.getClass();
      if (cl == String.class) return (String) obj;
      if (cl.isArray()) {
         String r = cl.getComponentType() + "[]{";
         for (int i = 0; i < Array.getLength(obj); i++) {
            if (i > 0) r += ",";
            Object val = Array.get(obj, i);
            if (cl.getComponentType().isPrimitive()) r += val;
            else r += toString(val);
         }
         return r + "}";
      }

      String r = cl.getName();
      // inspect the fields of this class and all superclasses
      do {
         r += "[";
         Field[] fields = cl.getDeclaredFields();
         AccessibleObject.setAccessible(fields, true);
         // get the names and values of all fields
         for (Field f : fields) {
            if (!Modifier.isStatic(f.getModifiers())) {
               if (!r.endsWith("[")) r += ",";
               r += f.getName() + "=";
               try {
                  Class t = f.getType();
                  Object val = f.get(obj);
                  if (t.isPrimitive()) r += val;
                  else r += toString(val);
               } catch (Exception e) {
                  e.printStackTrace();
               }
            }
         }
         r += "]";
         cl = cl.getSuperclass();
      } while (cl != null);

      return r;
   }    
}

පරාවර්තනය යනු වස්තුවට ඔවුන්ගේ පෙනුම දැකීමට ඉඩ දීමයි. මෙම තර්කය පරාවර්තනය සමඟ කිසිදු සම්බන්ධයක් නැති බව පෙනේ. ඇත්ත වශයෙන්ම, මෙය "ස්වයං හඳුනාගැනීමේ" හැකියාවයි.

පරාවර්තනය යනු ජාවා සහ සී # වැනි ස්වයං දැනුම හා ස්වයං සංවේදීතාවයේ හැකියාවක් නොමැති එවැනි භාෂාවන් සඳහා වූ වචනයකි. ඔවුන්ට ස්වයං දැනුමේ හැකියාවක් නොමැති නිසා, එය පෙනෙන්නේ කෙසේදැයි නිරීක්ෂණය කිරීමට අපට අවශ්‍ය වූ විට, එය පෙනෙන්නේ කෙසේද යන්න ගැන මෙනෙහි කිරීමට අපට තවත් දෙයක් තිබිය යුතුය. රූබි සහ පයිතන් වැනි විශිෂ්ට ගතික භාෂාවන්ට වෙනත් පුද්ගලයින්ගේ උදව් නොමැතිව තමන්ගේම පරාවර්තනය වටහා ගත හැකිය. පරාවර්තන පන්තියේ වස්තුවක් වන කැඩපතක් නොමැතිව ජාවා වස්තුවට එය පෙනෙන්නේ කෙසේදැයි අපට කිව නොහැකි නමුත් පයිතන්හි ඇති වස්තුවකට කැඩපතක් නොමැතිව එය වටහා ගත හැකිය. ඉතින් අපිට ජාවා වල පරාවර්තනය අවශ්‍යයි.

ජාවා ප්‍රලේඛන පිටුවෙන්

java.lang.reflectපන්ති සහ වස්තු පිළිබඳ පරාවර්තක තොරතුරු ලබා ගැනීම සඳහා පැකේජය පන්ති සහ අතුරු මුහුණත් සපයයි. පරාවර්තනය මඟින් පටවන ලද පංතිවල ක්රම, ක්රම සහ ඉදිකිරීම්කරුවන් පිළිබඳ තොරතුරු ක්රමලේඛගතව ප්රවේශ වීමට ඉඩ සලසයි, සහ පරාවර්තනය කළ ක්ෂේත්ර, ක්රම සහ ඉදිකිරීම්කරුවන් ආරක්ෂක සීමාවන් තුළ ඔවුන්ගේ යටින් පවතින සගයන් මත ක්රියා කිරීමට භාවිතා කරයි.

AccessibleObjectඅවශ්‍ය නම් ප්‍රවේශ චෙක්පත් යටපත් කිරීමට ඉඩ ReflectPermissionලබා දේ.

මෙම පැකේජයේ පන්ති, java.lang.Classනිදොස්කරණය කරන්නන්, පරිවර්තකයින්, වස්තු පරීක්ෂකවරුන්, පන්ති බ්‍රව්සර් වැනි සේවාවන් සමඟ Object Serializationසහ JavaBeansඉලක්කගත වස්තුවක පොදු සාමාජිකයින්ට (එහි ධාවන පන්තිය මත පදනම්ව) හෝ ප්‍රකාශයට පත් කරන ලද සාමාජිකයින්ට ප්‍රවේශය අවශ්‍ය වේ. දී ඇති පන්තියක්

එයට පහත ක්‍රියාකාරීත්වය ඇතුළත් වේ.

1. පන්ති වස්තු ලබා ගැනීම,
2. පන්තියක ගුණාංග පරීක්ෂා කිරීම (ක්ෂේත්‍ර, ක්‍රම, ඉදිකිරීම්කරුවන්),
3. ක්ෂේත්‍ර අගයන් සැකසීම සහ ලබා ගැනීම,
4. ආයාචනා කිරීමේ ක්රම,
5. වස්තූන්ගේ නව අවස්ථා නිර්මාණය කිරීම.

පංතිය විසින් නිරාවරණය කරන ක්‍රම සඳහා මෙම ප්‍රලේඛන සබැඳිය දෙස බලන්න Class.

මෙම ලිපියෙන් (ජනාධිපති ඩෙනිස් සොස්නොස්කි, සභාපති, සොස්නොස්කි මෘදුකාංග විසඳුම්, ඉන්කෝපරේෂන්) සහ මෙම ලිපියෙන් (ආරක්ෂක ගවේෂණ පීඩීඑෆ්):

පරාවර්තනය භාවිතා කිරීමට වඩා සැලකිය යුතු අඩුපාඩු මට පෙනේ

පරාවර්තනයේ පරිශීලකයා:

1. එය වැඩසටහන් සංරචක ගතිකව සම්බන්ධ කිරීමේ ඉතා විවිධාකාර ක්‍රමයක් සපයයි
2. ඉතා පොදු ආකාරවලින් වස්තූන් සමඟ වැඩ කරන පුස්තකාල නිර්මාණය කිරීම සඳහා එය ප්‍රයෝජනවත් වේ

පරාවර්තනයේ අඩුපාඩු:

1. ක්ෂේත්‍රය සහ ක්‍රම ප්‍රවේශය සඳහා භාවිතා කරන විට පරාවර්තනය සෘජු කේතයට වඩා මන්දගාමී වේ.
2. එය ඔබගේ කේතය තුළ සත්‍ය වශයෙන්ම සිදුවන්නේ කුමක්ද යන්න අපැහැදිලි කළ හැකිය
3. එය ප්‍රභව කේතය මඟ හැරීම මඟින් නඩත්තු ගැටළු ඇති කළ හැකිය
4. පරාවර්තන කේතය අනුරූප සෘජු කේතයට වඩා සංකීර්ණ ය
5. දත්ත ප්‍රවේශ ආරක්ෂණ සහ ටයිප් ආරක්ෂාව වැනි ප්‍රධාන ජාවා ආරක්ෂක සීමාවන් උල්ලං violation නය කිරීමට එය ඉඩ දෙයි

සාමාන්‍ය අපයෝජනයන්:

1. සීමිත පන්ති පැටවීම,
2. සීමිත පන්තියක ඉදිකිරීම්කරුවන්, ක්‍රම හෝ ක්ෂේත්‍ර වෙත යොමු කිරීම් ලබා ගැනීම,
3. නව පන්ති අවස්ථා නිර්මාණය කිරීම, ක්‍රම කැඳවීම, සීමිත පන්තියක ක්ෂේත්‍ර අගයන් ලබා ගැනීම හෝ සැකසීම.

පරාවර්තන අංගය අනිසි ලෙස භාවිතා කිරීම පිළිබඳ මෙම SE ප්‍රශ්නය දෙස බලන්න:

ජාවා හි පුද්ගලික ක්ෂේත්‍රයක් කියවන්නේ කෙසේද?

සාරාංශය:

පද්ධති කේතයක් තුළ සිට සිදුකරන එහි කාර්යයන් අනාරක්ෂිත ලෙස භාවිතා කිරීම ජාවා ආරක්ෂක මාදිලියේ සම්මුතියකට පහසුවෙන්ම හේතු විය හැක . එබැවින් මෙම අංගය අරපිරිමැස්මෙන් භාවිතා කරන්න

නමේ සඳහන් වන පරිදි, එය පන්ති ක්‍රමය සඳහා එය දරණ දේ පිළිබිඹු කරයි.

කේතය නොදැන සැබවින්ම සේවාවන් කැඳවීම සඳහා බොහෝ රාමු සහ දැව යට ඇති යෙදුම් භාවිතා කරයි.

පරාවර්තනය මඟින් ඔබට වඩාත් සාමාන්‍ය කේත ලිවීමේ හැකියාව ලබා දේ. ධාවන වේලාවේදී වස්තුවක් නිර්මාණය කිරීමට සහ ධාවන වේලාවේදී එහි ක්‍රමය ඇමතීමට එය ඔබට ඉඩ සලසයි. එබැවින් වැඩසටහන ඉතා පරාමිතිගත කළ හැකිය. බාහිර ලෝකයට නිරාවරණය වන එහි විචල්‍යයන් සහ ක්‍රමවේදය හඳුනා ගැනීමට එය වස්තුව හා පන්තිය ස්වයං විග්‍රහ කිරීමට ඉඩ දෙයි.

Reflectionබොහෝ භාවිතයන් ඇත. මා වඩාත් හුරුපුරුදු වන්නේ මැස්ස මත කේත නිර්මාණය කිරීමට හැකිවීමයි.

IE: ගතික පන්ති, කාර්යයන්, ඉදිකිරීම්කරුවන් - ඕනෑම දත්තයක් මත පදනම්ව (xml / array / sql results / hardcoded / etc ..)

මට මෙම ප්‍රශ්නයට ආදර්ශයෙන් පිළිතුරු දීමට අවශ්‍යයි. පළමුවෙන්ම ක්‍රියාත්මක වන යෙදුම සහ නොනැසී පවත්නා ගබඩාව අතර ඇති පරතරය අවම කිරීම සඳහා ප්‍රකාශ උත්පාදනය කිරීම සඳහා Hibernateව්‍යාපෘති භාවිතා කරයි . වසමේ දේවල් වෙනස් වන විට, ඒවා දත්ත ගබඩාවට දිගටම පවත්වා ගෙන යාමට ඒවා ගැන දැන සිටිය යුතුය.Reflection APICRUDHibernate

විකල්පයක් ලෙස ක්රියා කරයි Lombok Project. එය සම්පාදනය කරන වේලාවේදී කේතය එන්නත් කරයි, එහි ප්‍රති code ලය වන්නේ ඔබේ වසම් පන්තිවලට කේත ඇතුල් කිරීමයි. (මම හිතන්නේ එය ලබා ගන්නන්ට සහ සැකසීමට සුදුසු ය)

Hibernateතෝරාගනු reflectionලැබුවේ එය යෙදුමක් තැනීමේ ක්‍රියාවලියට අවම බලපෑමක් ඇති බැවිනි.

ජාවා 7 සිට අප සතුව MethodHandlesඇත Reflection API. ව්‍යාපෘති වලදී, ල gers ු-සටහන් සමඟ වැඩ කිරීම සඳහා අපි ඊළඟ කේතය පිටපත් කරන්නෙමු:

Logger LOGGER = Logger.getLogger(MethodHandles.lookup().lookupClass().getName());

මෙම නඩුවේ යතුරු ලියනය කිරීම දුෂ්කර බැවින්.

උදාහරණයෙන් පැහැදිලි කිරීම වඩාත් සුදුසු යැයි මට පෙනී යන අතර කිසිදු පිළිතුරක් එසේ නොකරන බව පෙනේ ...

පරාවර්තනයන් භාවිතා කිරීම සඳහා ප්‍රායෝගික උදාහරණයක් වනුයේ ජාවා භාෂාවෙන් ලියන ලද ජාවා භාෂා සේවාදායකයක් හෝ PHP භාෂාවෙන් ලියා ඇති PHP භාෂා සේවාදායකයක් ය. ඔබ භාෂා සේවාදායකය ටයිප් කරන විට හැකි සෑම ගැලපීමක්ම පෙන්වීමට සියලුම ටැග් නම් (ස්වයංක්‍රීයව සම්පූර්ණ කළ හැකි වචන) තිබීම සඳහා, ඩොක් බ්ලොක් සහ පුද්ගලික සාමාජිකයන් ඇතුළුව පන්තිය පිළිබඳ සියල්ල පරීක්ෂා කළ යුතුය. ඒ සඳහා එම පන්තියේ පිළිබිඹුවක් අවශ්‍ය වේ.

වෙනස් උදාහරණයක් වනුයේ පුද්ගලික ක්‍රමයක ඒකක පරීක්ෂාවකි. එසේ කළ හැකි එක් ක්‍රමයක් නම්, පරාවර්තනයක් නිර්මාණය කිරීම සහ පරීක්ෂණයේ සැකසුම් අවධියේදී ක්‍රමයේ විෂය පථය මහජනයාට වෙනස් කිරීමයි. ඇත්ත වශයෙන්ම කෙනෙකුට තර්ක කළ හැකිය පුද්ගලික ක්‍රම කෙලින්ම පරීක්ෂා නොකළ යුතු නමුත් එය කාරණය නොවේ.