Points To Remember

• You can use Reflection to check if the field of a class is static or not.
• You need to get the modifiers of the field to check if the field is static.

How to check if the field of a class is static by Reflection

field.getModifiers()& Modifier.STATIC) == Modifier.STATIC 

package com.ekiras.demo;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

public class Test {
 
 public static void main(String args[]){
  Field[] fields = Person.class.getDeclaredFields();
  for(Field field : fields){
   if((field.getModifiers()& Modifier.STATIC) == Modifier.STATIC ){
    System.out.println("final field :: " + field.getName());
   }
  } 
 } 
}

class Person{
 public static final int someConstant = 2;
 private String name;
 private String email;
 
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public String getEmail() {
  return email;
 }
 public void setEmail(String email) {
  this.email = email;
 }
 
}

Points To Remember

• You can use Reflection to check if the field of a class is final or not.
• You need to get the modifiers of the field to check if the field is final

How to check if the field of a class is final by Reflection

field.getModifiers()& Modifier.FINAL) == Modifier.FINAL 

package com.ekiras.demo;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

public class Test {
 
 public static void main(String args[]){
  Field[] fields = Person.class.getDeclaredFields();
  for(Field field : fields){
   if((field.getModifiers()& Modifier.FINAL) == Modifier.FINAL ){
    System.out.println("final field :: " + field.getName());
   }
  } 
 } 
}

class Person{
 public static final int someConstant = 2;
 private String name;
 private String email;
 
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public String getEmail() {
  return email;
 }
 public void setEmail(String email) {
  this.email = email;
 }
 
 
 
 
}

Points To Remember

• An annotation can be used as a replacement of interfaces.
• You can make both empty/marker annotations and annotations with methods.
• You can define the retention policy for the annotation and where the annotation can be used.

Program : Create A Custom Annotation

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Table {

 public String name() default "table";
}

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface Column {
 public String name() default "";
}

@Table(name="user_table")
public class User {

 @Column(name="ekiras")
 private String username;

 public String password;
}

public class RunTest {

 public static void main(String args[]){
  test();
  
 }

 public static void test(){
  Table table = User.class.getAnnotation(Table.class);
  if(table!=null){
   System.out.println("Class is annotated with @Table and name="+table.name());
   Field[] fields = User.class.getFields();
   for(Field field : fields){
    Column column = field.getAnnotation(Column.class);
    if(column!=null)
     System.out.println("Field "+field.getName() +" annotated with @Column name="+column.name());
    else {
     System.out.println("Field "+field.getName() +" is not annotated with @Column");
    }
   }
  }
 }
 
}

Class is annotated with @Table and name=user_table
Field username annotated with @Column name=ekiras
Field password is not annotated with @Column

Points To Remember

• You to need to add the Reflections jar in the class path. 
• You will not be able to load the packages other than the current package using Package.getPackages() since current class loader will not be able to reach them.

Program : Scan all packages with a Prefix

 public static Set<String> findAllPackagesStartingWith(String prefix) {
     List<ClassLoader> classLoadersList = new LinkedList<ClassLoader>();
     classLoadersList.add(ClasspathHelper.contextClassLoader());
     classLoadersList.add(ClasspathHelper.staticClassLoader());
     Reflections reflections = new Reflections(new ConfigurationBuilder()
             .setScanners(new SubTypesScanner(false), new ResourcesScanner())
             .setUrls(ClasspathHelper.forClassLoader(classLoadersList.toArray(new ClassLoader[0])))
             .filterInputsBy(new FilterBuilder().include(FilterBuilder.prefix(prefix))));
     Set<Class<? extends Object>> classes = reflections.getSubTypesOf(Object.class);

     Set<String> packageNameSet = new TreeSet<String>();
     for (Class<?> classInstance : classes) {
         String packageName = classInstance.getPackage().getName();
         if (packageName.startsWith(prefix)) {
             packageNameSet.add(packageName);
         }
     }
     for(String t : packageNameSet){
      System.out.println(":::"+t);
     }
     return packageNameSet;
 }

public Set<Package> findAllPackagesStartingWith(String prefix) {
     List<ClassLoader> classLoadersList = new LinkedList<ClassLoader>();
     classLoadersList.add(ClasspathHelper.contextClassLoader());
     classLoadersList.add(ClasspathHelper.staticClassLoader());
     Reflections reflections = new Reflections(new ConfigurationBuilder()
             .setScanners(new SubTypesScanner(false), new ResourcesScanner())
             .setUrls(ClasspathHelper.forClassLoader(classLoadersList.toArray(new ClassLoader[0])))
             .filterInputsBy(new FilterBuilder().include(FilterBuilder.prefix(prefix))));
     Set<Class<? extends Object>> classes = reflections.getSubTypesOf(Object.class);

     Set<Package> packageNameSet = new TreeSet<Package>();
     for (Class<?> classInstance : classes) {
         if (classInstance.getPackage().getName().startsWith(prefix)) {
             packageNameSet.add(classInstance.getPackage());
         }
     }
     
     return packageNameSet;
 }

package = javassist
package = javassist.bytecode
package = javassist.bytecode.analysis
package = javassist.bytecode.annotation
package = javassist.bytecode.stackmap
package = javassist.compiler
package = javassist.compiler.ast
package = javassist.convert
package = javassist.expr
package = javassist.runtime
package = javassist.scopedpool
package = javassist.tools
package = javassist.tools.reflect
package = javassist.tools.rmi
package = javassist.tools.web
package = javassist.util
package = javassist.util.proxy
package = javax.annotation
package = javax.annotation.concurrent
package = javax.annotation.meta
package = javax.xml.parsers
package = javax.xml.transform
package = javax.xml.transform.dom
package = javax.xml.transform.sax
package = javax.xml.transform.stream

• We can use reflection to find all the fields available within a class.
• We can get all the declared fields in a class by getDeclaredFields().
• We can search for any field in a class by using getField(). It throws NoSuchFieldException if the field does not exist in the class.

import java.lang.reflect.Field;


class SampleClass{

 String s1 = "Class variable";
 int a = 123;

}

class Test{

 public static void main(String args[]){
   Test obj = new Test();
   try{
 Class clazz = Class.forName("SampleClass");
        Field feilds[] = obj.getDeclaredFields(clazz);
        for(Field feild : feilds){
          System.out.println(feild);
        }
   }catch(Exception e){
 e.printStackTrace();
   }
   
 }

  public Field[] getDeclaredFields(Class clazz){
    return clazz.getDeclaredFields(); 
 }

}

java.lang.String SampleClass.s1
int SampleClass.a

import java.lang.reflect.Field;

class SuperClass{
 public String abc = "super class";

}

class SampleClass extends SuperClass{

 public String s1 = "Class variable";
 public int a = 123;

}

class Test{

 public static void main(String args[]){
   Test obj = new Test();
   try{
 Class clazz = Class.forName("SampleClass");
        Field feild = obj.getField(clazz, "abc");
        System.out.println(feild);
   }catch(Exception e){
 e.printStackTrace();
   }
   
 }

  public Field getField(Class clazz, String field) throws NoSuchFieldException{
    return clazz.getField(field); 
 }

}

public java.lang.String SuperClass.abc

• We can use Reflection API to get all methods available in a class.
• Method class is present in java.land.reflect.Method class.
• We can use getDeclaredMethods() to get all the declared Methods in a class.
• We can use getMethods() to get all the methods available in a class. It also includes methods from its super classes.

import java.lang.reflect.Method;


class SampleClass{

 String s1 = "Class variable";
 int a = 123;

 public SampleClass(){
  System.out.println("SampleClass Default Constructor");
 }

 public SampleClass(String str){
  System.out.println("SampleClass Overloaded Constructor");
 }

 public void show(){
  System.out.println("SampleClass Show Method");
 }

 public void print(){
  System.out.println("SampleClass Print Method");
 }

}

class Test{

 public static void main(String args[]){
   Test obj = new Test();
   try{
 Class clazz = Class.forName("SampleClass");
        Method declaredMethods[] = obj.getDeclaredMethods(clazz);
        for(Method method : declaredMethods){
          System.out.println(method);
        }
   }catch(Exception e){
 e.printStackTrace();
   }
   
 }

  public Method[] getDeclaredMethods(Class clazz){
    return clazz.getDeclaredMethods(); 
 }

  

}

public void SampleClass.show()
public void SampleClass.print()

import java.lang.reflect.Method;


class SampleClass{

 String s1 = "Class variable";
 int a = 123;

 public SampleClass(){
  System.out.println("SampleClass Default Constructor");
 }

 public SampleClass(String str){
  System.out.println("SampleClass Overloaded Constructor");
 }

 public void show(){
  System.out.println("SampleClass Show Method");
 }

 public void print(){
  System.out.println("SampleClass Print Method");
 }

}

class Test{

 public static void main(String args[]){
   Test obj = new Test();
   try{
 Class clazz = Class.forName("SampleClass");
 Method allMethods[] = obj.getAllMethods(clazz);
        for(Method method : allMethods){
          System.out.println(method);
        }
   }catch(Exception e){
 e.printStackTrace();
   }
   
 }

  public Method[] getAllMethods(Class clazz){
    return clazz.getMethods(); 
 }

  

}

public void SampleClass.show()
public void SampleClass.print()
public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
public final void java.lang.Object.wait() throws java.lang.InterruptedException
public boolean java.lang.Object.equals(java.lang.Object)
public java.lang.String java.lang.Object.toString()
public native int java.lang.Object.hashCode()
public final native java.lang.Class java.lang.Object.getClass()
public final native void java.lang.Object.notify()
public final native void java.lang.Object.notifyAll()

• We can get the constructors declared in a class using Reflection API.
• Constructor class is present in java.lang.reflect.Constructor class.
• The getDeclaredConstructors() method will return an array of Constructors in a class.

import java.lang.reflect.Constructor;


class SampleClass{

 String s1 = "Class variable";
 int a = 123;

 public SampleClass(){
  System.out.println("SampleClass Default Constructor");
 }

 public SampleClass(String str){
  System.out.println("SampleClass Overloaded Constructor");
 }

 public void show(){
  System.out.println("SampleClass Show Method");
 }

 public void print(){
  System.out.println("SampleClass Print Method");
 }

}

class Test{

 public static void main(String args[]){
   Test obj = new Test();
   try{
 Class clazz = Class.forName("SampleClass");
        Constructor cc[] = obj.getConstructors(clazz);
        for(Constructor constructor : cc){
          System.out.println(constructor);
        }
   }catch(Exception e){
 e.printStackTrace();
   }
   
 }

  public Constructor[] getConstructors(Class clazz){
    return clazz.getDeclaredConstructors(); 
 }

}

public SampleClass()
public SampleClass(java.lang.String)

• Reflection API is a powerful technique to find out environment of a class as well as to inspect the class itself.
• Reflection API was introduced in Java v1.1
• It allows user to get full information about the classes, interfaces, constructors, methods, variables etc.
• It is available in java.lang.reflect package.

class A{

  public A(){
    System.out.println("class A constructor");
  }

  public void show(){
    System.out.println("class A show() ");
  }
  public void show(String s){
    System.out.println(s);
  }
}

public class Test{
    
   public static void main(String args[]){
     try{

       Class clazz = A.class;
       A object = (A)clazz.newInstance();
       object.show();
       object.show("class A show(String)");

     }catch(Exception e){
       System.out.println("Error");

     }
}

}

class A constructor
class A show() 
class A show(String)

class A{

  public A(){
    System.out.println("class A constructor");
  }

  public void show(){
    System.out.println("class A show() ");
  }
  public void show(String s){
    System.out.println(s);
  }
}

public class Test{
    
   public static void main(String args[]){
     try{
       A object = (A)Class.forName("A").newInstance();
       object.show();
       object.show("class A show(String)");

     }catch(Exception e){
       System.out.println("Error");

     }
}

}

class A constructor
class A show() 
class A show(String)