Java的常用包之七

Class类
在Java中，每个class都有一个相应的Class对象。也就是说，当我们编写一个类，编译完成后，在生成的.class文件中，就会产生一个Class对象，用于表示这个类的类型信息。
获取Class实例的三种方式：
 （1）利用对象调用getClass()方法获取该对象的Class实例；
 （2）使用Class类的静态方法forName()，用类的名字获取一个Class实例；
 （3）运用.class的方式来获取Class实例，对于基本数据类型的封装类，还可以采用.TYPE来获取相对应的基本数据类型的Class实例。

public class  ClassTest
...{
     public static void main(String args[])
     ...{
              Point pt=new Point();
              Class c1=pt.getClass(); 
              System.out.println(c1.getName());
              
              try
              ...{
              Class c2=Class.forName("Point");
              System.out.println(c2.getName());
              }
              catch(Exception e)
              ...{
                      e.printStackTrace();
              }
              
              Class c3=Point.class;
              System.out.println(c3.getName());
              
              Class c4=int.class;
              System.out.println(c4.getName());
              
              Class c5=Integer.TYPE;
              System.out.println(c5.getName());
              
              Class c6=Integer.class;
              System.out.println(c6.getName());
         
              
     }    
     
}
class Point
...{
       int x,y;
}

  在运行期间，如果我们要产生某个类的对象，Java虚拟机(JVM)会检查该类型的Class对象是否已被加载。如果没有被加载，JVM会根据类的名称找到.class文件并加载它。一旦某个类型的Class对象已被加载到内存，就可以用它来产生该类型的所有对象

public class ClassTest1
...{
       public static void main(String[] args)
       ...{
             System.out.println("before new Point()");
               new Point();
               System.out.println("after new Point()");
        
               try
               ...{
                      Class.forName("Line");
               }
               catch(Exception e)
               ...{
                     e.printStackTrace();
               } 
       }    
}
class Point
...{
       static
       ...{
              System.out.println("Loading Point");
       }
       int x,y;
}
class Line
...{
       static
       ...{
              System.out.println("Loading Line");
       }
}

从命令行获得参数， newInstance() 调用类中缺省的构造方法。

public class ClassTest2
...{
       public static void main(String[] args)
       ...{
               if(args.length!=1)
              ...{
                     return;
              }
              try
              ...{
                     Class c=Class.forName(args[0]);//从命令行获得参数，
                     Point pt=(Point)c.newInstance();//获取一个OBJCET类型对象，newInstance()调用类中缺省的构造方法，
                     //如果构造方法被重写将会抛出异常，但是如果我们只能实例化一个默认构造函数的类的话，这个应用也就没什么意义
                     //反射机制的出现使我们可以实例化构造函数带参数的对象。
                     pt.output();
              }
              catch(Exception e)
              ...{
                     e.printStackTrace();
              }
      }
}
class Point
...{
       static
        ...{
               System.out.println("Loading Point");
       }
       int x,y;
       void output()
       ...{
              System.out.println("x="+x+","+"y="+y);
       }
}

反射机制

 

import java.lang.reflect.*;
class ClassTest3
...{
    public static void main(String[] args)
    ...{    
        if(args.length!=1)
        ...{
            return;
        }
        try
        ...{
            Class c=Class.forName(args[0]);
            Constructor[] cons=c.getDeclaredConstructors();
            /**//*for(int i=0;i<cons.length;i++)
            {
                System.out.println(cons[i]);
            }
            Method[] ms=c.getDeclaredMethods();
            for(int i=0;i<ms.length;i++)
            {
                System.out.println(ms[i]);
            }*/
            Class[] params=cons[0].getParameterTypes();//因为这里只有一个构造方法，所以不在进行判断。
            Object[] paramValues=new Object[params.length];
            for(int i=0;i<params.length;i++)
            ...{
                if(params[i].isPrimitive())
                ...{
                    paramValues[i]=new Integer(i+3);
                }
            }
            Object o=cons[0].newInstance(paramValues);
            Method[] ms=c.getDeclaredMethods();
            ms[0].invoke(o,null);
        }
        catch(Exception e)
        ...{
            e.printStackTrace();
        }
    }
}
class Point
...{
    static
    ...{
        System.out.println("Loading Point");
    }
    int x,y;
    void output()
    ...{
        System.out.println("x="+x+","+"y="+y);
    }
    Point(int x,int y)
    ...{
        this.x=x;
        this.y=y;
    }
}
class Line
...{
    static
    ...{
        System.out.println("Loading Line");
    }
}