আমার যদি দুটি ভেরিয়েবল থাকে:
Object obj;
String methodName = "getName";এর ক্লাসটি না জেনে objআমি কীভাবে চিহ্নিত পদ্ধতিটি কল করতে পারিmethodName ?
যে পদ্ধতিটি বলা হচ্ছে তার কোনও পরামিতি নেই এবং একটি Stringফেরতের মান রয়েছে। এটি জাভা শিমের জন্য প্রাপ্তি ।
উত্তর:
হিপ থেকে কোডিং করা, এটি এমন কিছু হবে:
java.lang.reflect.Method method;
try {
method = obj.getClass().getMethod(methodName, param1.class, param2.class, ..);
} catch (SecurityException e) { ... }
catch (NoSuchMethodException e) { ... }প্যারামিটারগুলি আপনাকে প্রয়োজনীয় খুব নির্দিষ্ট পদ্ধতিটি সনাক্ত করে (যদি বেশ কয়েকটি ওভারলোড পাওয়া যায়, যদি পদ্ধতিটির কোনও আর্গুমেন্ট না থাকে তবে কেবল দিন methodName )।
তারপরে আপনি কল করে সেই পদ্ধতিটি শুরু করলেন
try {
method.invoke(obj, arg1, arg2,...);
} catch (IllegalArgumentException e) { ... }
catch (IllegalAccessException e) { ... }
catch (InvocationTargetException e) { ... }আবার .invokeআপনার কাছে কিছু না থাকলে যুক্তিগুলি ছেড়ে দিন । কিন্তু হ্যাঁ. জাভা প্রতিবিম্ব সম্পর্কে পড়ুন
methodমধ্যে method.invoke(obj, arg1, arg2,...);। একটি সমস্যার method = null;সমাধান করে তবে উত্তরে এর উল্লেখ করা কোনও খারাপ ধারণা নয়।
invokeযা ফিরে আসে তা ফিরে আসবে। যদি কোনও ব্যতিক্রম পদ্ধতিটি চলতে দেখা দেয় তবে ব্যতিক্রমটি একটিতে আবৃত হবে InvocationTargetException।
ব্যবহার করুন পদ্ধতি আবাহন প্রতিফলন থেকে:
Class<?> c = Class.forName("class name");
Method method = c.getDeclaredMethod("method name", parameterTypes);
method.invoke(objectToInvokeOn, params);কোথায়:
"class name" ক্লাসের নামobjectToInvokeOn প্রকারের অবজেক্ট এবং এটি সেই পদার্থ যা আপনি পদ্ধতিটি চালু করতে চান"method name" আপনি যে পদ্ধতিতে কল করতে চান তার নামparameterTypesধরণের Class[]এবং পদ্ধতিটি গ্রহণ করে এমন প্যারামিটারগুলি ঘোষণা করেparamsটাইপ Object[]এবং পদ্ধতিতে পাস করার জন্য পরামিতি ঘোষণাযারা জাভা 7-তে সরাসরি-ফরওয়ার্ড কোড উদাহরণ চান তাদের জন্য:
Dog শ্রেণী:
package com.mypackage.bean;
public class Dog {
private String name;
private int age;
public Dog() {
// empty constructor
}
public Dog(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public void printDog(String name, int age) {
System.out.println(name + " is " + age + " year(s) old.");
}
}ReflectionDemo শ্রেণী:
package com.mypackage.demo;
import java.lang.reflect.*;
public class ReflectionDemo {
public static void main(String[] args) throws Exception {
String dogClassName = "com.mypackage.bean.Dog";
Class<?> dogClass = Class.forName(dogClassName); // convert string classname to class
Object dog = dogClass.newInstance(); // invoke empty constructor
String methodName = "";
// with single parameter, return void
methodName = "setName";
Method setNameMethod = dog.getClass().getMethod(methodName, String.class);
setNameMethod.invoke(dog, "Mishka"); // pass arg
// without parameters, return string
methodName = "getName";
Method getNameMethod = dog.getClass().getMethod(methodName);
String name = (String) getNameMethod.invoke(dog); // explicit cast
// with multiple parameters
methodName = "printDog";
Class<?>[] paramTypes = {String.class, int.class};
Method printDogMethod = dog.getClass().getMethod(methodName, paramTypes);
printDogMethod.invoke(dog, name, 3); // pass args
}
}আউটপুট:
Mishka is 3 year(s) old.
আপনি এইভাবে প্যারামিটারগুলির সাথে কনস্ট্রাক্টরকে আবেদন করতে পারেন:
Constructor<?> dogConstructor = dogClass.getConstructor(String.class, int.class);
Object dog = dogConstructor.newInstance("Hachiko", 10);বিকল্পভাবে, আপনি মুছে ফেলতে পারেন
String dogClassName = "com.mypackage.bean.Dog";
Class<?> dogClass = Class.forName(dogClassName);
Object dog = dogClass.newInstance();এবং কর
Dog dog = new Dog();
Method method = Dog.class.getMethod(methodName, ...);
method.invoke(dog, ...);প্রস্তাবিত পাঠ: নতুন শ্রেণীর উদাহরণ তৈরি করা
Methodআপত্তি পাবেন?
পদ্ধতিটি এভাবে আহ্বান করা যেতে পারে। আরও সম্ভাবনা রয়েছে (প্রতিবিম্ব এপিআই পরীক্ষা করুন), তবে এটি সবচেয়ে সহজ:
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import org.junit.Assert;
import org.junit.Test;
public class ReflectionTest {
private String methodName = "length";
private String valueObject = "Some object";
@Test
public void testGetMethod() throws SecurityException, NoSuchMethodException, IllegalArgumentException,
IllegalAccessException, InvocationTargetException {
Method m = valueObject.getClass().getMethod(methodName, new Class[] {});
Object ret = m.invoke(valueObject, new Object[] {});
Assert.assertEquals(11, ret);
}
}প্রথম, না। এই ধরণের কোড এড়িয়ে চলুন। এটি আসলেই খুব খারাপ কোড এবং অনিরাপদ হতে থাকে ( জাভা প্রোগ্রামিং ভাষার জন্য সুরক্ষিত কোডিং গাইডলাইনস এর বিভাগ 6 দেখুন , সংস্করণ 2.0 )।
যদি এটি অবশ্যই করতে হয়, java.beans প্রতিবিম্ব করতে পছন্দ করুন। বিনগুলি তুলনামূলকভাবে নিরাপদ এবং প্রচলিত অ্যাক্সেসের অনুমতি দেয় প্রতিচ্ছবি মোড়ক করে।
আমার সহকর্মীর উত্তরগুলি সম্পূর্ণ করতে, আপনি নিবিড় মনোযোগ দিতে চান:
এখানে একটি পুরানো জাভা ১.৪ কোড রয়েছে যা এই পয়েন্টগুলিকে বিবেচনা করে:
/**
* Allow for instance call, avoiding certain class circular dependencies. <br />
* Calls even private method if java Security allows it.
* @param aninstance instance on which method is invoked (if null, static call)
* @param classname name of the class containing the method
* (can be null - ignored, actually - if instance if provided, must be provided if static call)
* @param amethodname name of the method to invoke
* @param parameterTypes array of Classes
* @param parameters array of Object
* @return resulting Object
* @throws CCException if any problem
*/
public static Object reflectionCall(final Object aninstance, final String classname, final String amethodname, final Class[] parameterTypes, final Object[] parameters) throws CCException
{
Object res;// = null;
try {
Class aclass;// = null;
if(aninstance == null)
{
aclass = Class.forName(classname);
}
else
{
aclass = aninstance.getClass();
}
//Class[] parameterTypes = new Class[]{String[].class};
final Method amethod = aclass.getDeclaredMethod(amethodname, parameterTypes);
AccessController.doPrivileged(new PrivilegedAction() {
public Object run() {
amethod.setAccessible(true);
return null; // nothing to return
}
});
res = amethod.invoke(aninstance, parameters);
} catch (final ClassNotFoundException e) {
throw new CCException.Error(PROBLEM_TO_ACCESS+classname+CLASS, e);
} catch (final SecurityException e) {
throw new CCException.Error(PROBLEM_TO_ACCESS+classname+GenericConstants.HASH_DIESE+ amethodname + METHOD_SECURITY_ISSUE, e);
} catch (final NoSuchMethodException e) {
throw new CCException.Error(PROBLEM_TO_ACCESS+classname+GenericConstants.HASH_DIESE+ amethodname + METHOD_NOT_FOUND, e);
} catch (final IllegalArgumentException e) {
throw new CCException.Error(PROBLEM_TO_ACCESS+classname+GenericConstants.HASH_DIESE+ amethodname + METHOD_ILLEGAL_ARGUMENTS+String.valueOf(parameters)+GenericConstants.CLOSING_ROUND_BRACKET, e);
} catch (final IllegalAccessException e) {
throw new CCException.Error(PROBLEM_TO_ACCESS+classname+GenericConstants.HASH_DIESE+ amethodname + METHOD_ACCESS_RESTRICTION, e);
} catch (final InvocationTargetException e) {
throw new CCException.Error(PROBLEM_TO_ACCESS+classname+GenericConstants.HASH_DIESE+ amethodname + METHOD_INVOCATION_ISSUE, e);
}
return res;
}Object obj;
Method method = obj.getClass().getMethod("methodName", null);
method.invoke(obj, null);//Step1 - Using string funClass to convert to class
String funClass = "package.myclass";
Class c = Class.forName(funClass);
//Step2 - instantiate an object of the class abov
Object o = c.newInstance();
//Prepare array of the arguments that your function accepts, lets say only one string here
Class[] paramTypes = new Class[1];
paramTypes[0]=String.class;
String methodName = "mymethod";
//Instantiate an object of type method that returns you method name
Method m = c.getDeclaredMethod(methodName, paramTypes);
//invoke method with actual params
m.invoke(o, "testparam");আপনি যদি বেশ কয়েকবার কল করেন তবে আপনি জাভা introduced তে প্রবর্তিত নতুন পদ্ধতি হ্যান্ডলগুলি ব্যবহার করতে পারেন Here এখানে আমরা আপনার স্ট্রিংটি ফেরানোর পদ্ধতিটির জন্য যাচ্ছি:
Object obj = new Point( 100, 200 );
String methodName = "toString";
Class<String> resultType = String.class;
MethodType mt = MethodType.methodType( resultType );
MethodHandle methodHandle = MethodHandles.lookup().findVirtual( obj.getClass(), methodName, mt );
String result = resultType.cast( methodHandle.invoke( obj ) );
System.out.println( result ); // java.awt.Point[x=100,y=200]invokeExactযখনই পারেন ব্যবহার করতে চান। তার জন্য, কল সাইটের স্বাক্ষরটি সঠিকভাবে যদিও হ্যান্ডলালের ধরণের সাথে মেলে। কাজ পেতে সাধারণত খানিকটা ঝোঁক লাগে। এক্ষেত্রে আপনার সাথে প্রথম প্যারামিটারটি নিক্ষেপ করতে হবে: methodHandle = methodHandle.asType(methodHandle.type().changeParameterType(0, Object.class));এবং তারপরে String result = (String) methodHandle.invokeExact(obj);
এটি জাভা রিফ্লেকশন প্যাকেজটির সাথে করণীয়ীয় এমন কিছু বলে মনে হচ্ছে।
http://java.sun.com/developer/technicalArticles/ALT/Reflection/index.html
বিশেষত নাম অনুসারে আমন্ত্রণ পদ্ধতিতে:
আমদানি করুন java.lang.reflect। *;
public class method2 {
public int add(int a, int b)
{
return a + b;
}
public static void main(String args[])
{
try {
Class cls = Class.forName("method2");
Class partypes[] = new Class[2];
partypes[0] = Integer.TYPE;
partypes[1] = Integer.TYPE;
Method meth = cls.getMethod(
"add", partypes);
method2 methobj = new method2();
Object arglist[] = new Object[2];
arglist[0] = new Integer(37);
arglist[1] = new Integer(47);
Object retobj
= meth.invoke(methobj, arglist);
Integer retval = (Integer)retobj;
System.out.println(retval.intValue());
}
catch (Throwable e) {
System.err.println(e);
}
}
}FunctionalInterfaceএগুলি সূচী করার জন্য আপনি পাত্রে পদ্ধতি সংরক্ষণ করতে ব্যবহার করতে পারেন । আপনি তাদের সংখ্যার দ্বারা প্রার্থনা করতে অ্যারে ধারক ব্যবহার করতে পারেন বা স্ট্রিং দিয়ে তাদের প্রার্থনা করতে হ্যাশম্যাপ করতে পারেন। এই কৌশল দ্বারা, আপনি আপনার পদ্ধতিগুলিকে গতিময়তরভাবে দ্রুত চালনার জন্য সূচক করতে পারেন ।
@FunctionalInterface
public interface Method {
double execute(int number);
}
public class ShapeArea {
private final static double PI = 3.14;
private Method[] methods = {
this::square,
this::circle
};
private double square(int number) {
return number * number;
}
private double circle(int number) {
return PI * number * number;
}
public double run(int methodIndex, int number) {
return methods[methodIndex].execute(aNumber);
}
}আপনি ল্যাম্বদা সিনট্যাক্সও ব্যবহার করতে পারেন:
public class ShapeArea {
private final static double PI = 3.14;
private Method[] methods = {
number -> {
return number * number;
},
number -> {
return PI * number * number;
},
};
public double run(int methodIndex, int number) {
return methods[methodIndex].execute(aNumber);
}
}O(1)।
Method method = someVariable.class.getMethod(SomeClass);
String status = (String) method.invoke(method);SomeClassবর্গ এবং someVariableএকটি পরিবর্তনশীল।
নিম্নলিখিত কোড উল্লেখ করুন আপনাকে সাহায্য করতে পারে।
public static Method method[];
public static MethodClass obj;
public static String testMethod="A";
public static void main(String args[])
{
obj=new MethodClass();
method=obj.getClass().getMethods();
try
{
for(int i=0;i<method.length;i++)
{
String name=method[i].getName();
if(name==testMethod)
{
method[i].invoke(name,"Test Parameters of A");
}
}
}
catch(Exception ex)
{
System.out.println(ex.getMessage());
}
}ধন্যবাদ ....
পদ্ধতি ব্যবহারের জন্য প্রস্তুত:
যুক্তি ছাড়াই কোনও পদ্ধতির আবেদন করতে:
public static void callMethodByName(Object object, String methodName) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
object.getClass().getDeclaredMethod(methodName).invoke(object);
}যুক্তি সহ একটি পদ্ধতি চাওয়া:
public static void callMethodByName(Object object, String methodName, int i, String s) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
object.getClass().getDeclaredMethod(methodName, int.class, String.class).invoke(object, i, s);
}উপরোক্ত পদ্ধতিগুলি নীচের মতো ব্যবহার করুন:
package practice;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
public class MethodInvoke {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, IOException {
String methodName1 = "methodA";
String methodName2 = "methodB";
MethodInvoke object = new MethodInvoke();
callMethodByName(object, methodName1);
callMethodByName(object, methodName2, 1, "Test");
}
public static void callMethodByName(Object object, String methodName) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
object.getClass().getDeclaredMethod(methodName).invoke(object);
}
public static void callMethodByName(Object object, String methodName, int i, String s) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
object.getClass().getDeclaredMethod(methodName, int.class, String.class).invoke(object, i, s);
}
void methodA() {
System.out.println("Method A");
}
void methodB(int i, String s) {
System.out.println("Method B: "+"\n\tParam1 - "+i+"\n\tParam 2 - "+s);
}
}আউটপুট:
পদ্ধতি এ পদ্ধতি বি: পরম 1 - 1 পরম 2 - পরীক্ষা
class Student{
int rollno;
String name;
void m1(int x,int y){
System.out.println("add is" +(x+y));
}
private void m3(String name){
this.name=name;
System.out.println("danger yappa:"+name);
}
void m4(){
System.out.println("This is m4");
}
}import java.lang.reflect.Method;
public class StudentTest{
public static void main(String[] args){
try{
Class cls=Student.class;
Student s=(Student)cls.newInstance();
String x="kichha";
Method mm3=cls.getDeclaredMethod("m3",String.class);
mm3.setAccessible(true);
mm3.invoke(s,x);
Method mm1=cls.getDeclaredMethod("m1",int.class,int.class);
mm1.invoke(s,10,20);
}
catch(Exception e){
e.printStackTrace();
}
}
}আপনার প্রতিবিম্ব ব্যবহার করা উচিত - আর ডি ক্লাস অবজেক্ট, তারপরে এই ক্লাসের একটি পদ্ধতি এবং তারপরে al চ্ছিক পরামিতিগুলির সাথে কোনও অবজেক্টে এই পদ্ধতিটি চাওয়া। চেষ্টা করুন- ব্লক নিম্নলিখিত স্নিপেট মোড়ানো মনে রাখবেন
আশা করি এটা সাহায্য করবে!
Class<?> aClass = Class.forName(FULLY_QUALIFIED_CLASS_NAME);
Method method = aClass.getMethod(methodName, YOUR_PARAM_1.class, YOUR_PARAM_2.class);
method.invoke(OBJECT_TO_RUN_METHOD_ON, YOUR_PARAM_1, YOUR_PARAM_2);এটি আমার পক্ষে ভাল কাজ করছে:
public class MethodInvokerClass {
public static void main(String[] args) throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, ClassNotFoundException, InvocationTargetException, InstantiationException {
Class c = Class.forName(MethodInvokerClass.class.getName());
Object o = c.newInstance();
Class[] paramTypes = new Class[1];
paramTypes[0]=String.class;
String methodName = "countWord";
Method m = c.getDeclaredMethod(methodName, paramTypes);
m.invoke(o, "testparam");
}
public void countWord(String input){
System.out.println("My input "+input);
}}
আউটপুট:
My input testparam
আমি পদ্ধতির নামটি অন্য পদ্ধতিতে (প্রধান হিসাবে) পাস করে প্রার্থনা করতে সক্ষম হয়েছি।
ব্যবহার import java.lang.reflect.*;
public static Object launchProcess(String className, String methodName, Class<?>[] argsTypes, Object[] methodArgs)
throws Exception {
Class<?> processClass = Class.forName(className); // convert string classname to class
Object process = processClass.newInstance(); // invoke empty constructor
Method aMethod = process.getClass().getMethod(methodName,argsTypes);
Object res = aMethod.invoke(process, methodArgs); // pass arg
return(res);
}এবং আপনি এটি কীভাবে ব্যবহার করবেন তা এখানে:
String className = "com.example.helloworld";
String methodName = "print";
Class<?>[] argsTypes = {String.class, String.class};
Object[] methArgs = { "hello", "world" };
launchProcess(className, methodName, argsTypes, methArgs);সঙ্গে jooR নিছক আছে:
on(obj).call(methodName /*params*/).get()এখানে আরও বিস্তৃত উদাহরণ:
public class TestClass {
public int add(int a, int b) { return a + b; }
private int mul(int a, int b) { return a * b; }
static int sub(int a, int b) { return a - b; }
}
import static org.joor.Reflect.*;
public class JoorTest {
public static void main(String[] args) {
int add = on(new TestClass()).call("add", 1, 2).get(); // public
int mul = on(new TestClass()).call("mul", 3, 4).get(); // private
int sub = on(TestClass.class).call("sub", 6, 5).get(); // static
System.out.println(add + ", " + mul + ", " + sub);
}
}এই মুদ্রণ:
3, 12, 1
আমার জন্য একটি খুব সহজ এবং বোকা প্রমাণ উপায় হ'ল এইভাবে একটি পদ্ধতি কলার পদ্ধতি করা:
public static object methodCaller(String methodName)
{
if(methodName.equals("getName"))
return className.getName();
}তারপরে আপনার যখন পদ্ধতিটি কল করতে হবে তখন এই জাতীয় কিছু রাখুন
//calling a toString method is unnessary here, but i use it to have my programs to both rigid and self-explanitory
System.out.println(methodCaller(methodName).toString()); className.getName().toString()? আপনি প্রতিবিম্বের পুরো পয়েন্টটি মিস করছেন।