java多态反射机制例子

 package  duotai;

 class  Customer{
     @SuppressWarnings ( "unused" )
     private  String account;
     @SuppressWarnings ( "unused" )
     private  String password;
     //有两个函数名称一样，但是系统可以接受，这叫做函数重载（静态多态性）
     //一个函数呈现为多种状态，系统能够根据参数来决定调用谁
     //三种情况：参数个数不同，参数个数相同类型不同，个数类型相同出现的顺序不同
     //静态是指：虽然函数名只有一个，但是要写代码要写多个
     public  Customer()
     {
         System.out.println("构造函数1" );
     }

     public  Customer(String account, String password) {
         System.out.println("构造函数2" );
         this .account=account;
         this .password=password;
     }
 }


 public   class  CustomerTest {
     public   static   void  main(String[] args) {
         @SuppressWarnings ( "unused" )
         Customer cus1 = new  Customer(); //调用构造函数
         @SuppressWarnings ( "unused" )
         Customer cus2 = new  Customer( "3213" , "1213" ); //调用构造函数
     }

 }

 

 package  duotai;

 //模块1调用一个对话框，让对话框显示出来

 class  Module1 {
     private  Dialog dialog;

     public  Module1(Dialog dialog) {
         this .dialog = dialog;
     }

     public   void  callDialog(){
         dialog.show();
     }

 }

 abstract   class  Dialog{
     public   abstract   void  show();
 }
 class  Dialog1  extends  Dialog {
     public   void  show() {
         System.out.println("对话框1显示" );
     }
 }
 //客户对Dialog1不满意想自己开发一个Dialog2，被Module1调用，不能改变Module1原代码

 class  Dialog2  extends  Dialog{
     public   void  show() {
         System.out.println("对话框2显示" );
     }
 }


 public   class  DaliogTest {

     public   static   void  main(String[] args) {

         Dialog1 dia = new  Dialog1();
         Module1 mod1 = new  Module1(dia);

         mod1.callDialog();
     }

 }

 

 package  duotai;

 //动态多态性一般在继承时使用
 abstract   class  Person{
     public   abstract   void  printInfo();
 }

 class  Student  extends  Person{
     public   void  printInfo() {
         System.out.println("学生打印" );
     }
 }

 class  Teacher  extends  Person{
     public   void  printInfo() {
         System.out.println("老师打印" );
     }
 }

 public   class  StudentTest {
 /*  public static void print(Student stu) {
         stu.printInfo();
     }

     public static void print(Teacher tea) {
         tea.printInfo();
     }*/
   public   static   void   print(Person p) { //父类的引用可以指向子类对象
     p.printInfo();
 }
     public   static   void  main(String[] args) {
         print(new  Student());
     }

 }

 

 package  fanshe;


 public   class  Customer {
     private  String account;
     private  String password;

     public  Customer() {
         System.out.println("构造函数1" );
     }

     public  Customer(String account, String password) {
         System.out.println("构造函数2" );
         this .account = account;
         this .password = password;
     }

     public   void  printInfo() {
         System.out.println("账号："  + account +  "密码"  + password);
     }
 }

 

 package  fanshe;

 import  java.lang.reflect.Constructor;
 import  java.lang.reflect.Method;

 public   class  Test1 {
     @SuppressWarnings ( "unchecked" )
     public   static   void  main(String[] args)  throws  Exception {

         String className = "fanshe.Customer" ;
         // className cus = new className();
         // 得到类的信息
         Class c = Class.forName(className);

         // 得到构造函数，就可以生成一个对象
         Constructor[] cons = c.getConstructors();
         for  ( int  i =  0 ; i < cons.length; i++) {
             String str = cons[i].getName();
             System.out.println("名字："  + str);

             Class[] params = cons[i].getParameterTypes();// 得到参数类型
             for  ( int  j =  0 ; j < params.length; j++) {
                 String name = params[j].getName();
                 System.out.println(name);
             }
         }
         //得到里面的成员函数(包括继承过来的)，就可以调用成员函数
         Method[] met = c.getMethods();
         for  ( int  i =  0 ; i < met.length; i++) {
             String str = met[i].getName();
             System.out.println("名字："  + str);

             Class[] params = met[i].getParameterTypes();// 得到参数类型
             for  ( int  j =  0 ; j < params.length; j++) {
                 String name = params[j].getName();
                 System.out.println(name);
             }
         }
     }

 }

 

 package  fanshe;

 import  java.lang.reflect.Constructor;
 import  java.lang.reflect.Method;

 public   class  Test2 {
     @SuppressWarnings ( "unchecked" )
     public   static   void  main(String[] args)  throws  Exception {
         /*
          * 反射为配置文件改变模块行为提供了可能
          */
         String className = "fanshe.Customer" ;
         Class c = Class.forName(className);
         //c.newInstance();表示调用不带参数的构造函数
         // 生成一个对象：用构造函数
         Constructor con1 = c.getConstructor(new  Class[] {Class.forName( "java.lang.String" ),Class.forName( "java.lang.String" ) });
         //Constructor con1 = c.getConstructor(new Class[] {});// 得到不带参数的构造函数

         // 生成对象
         Object obj = con1.newInstance(new  Object[] { "222" , "111" });
         //Object obj = con1.newInstance(new Object[] {});// 表示不传入参数
         //怎样调用obj里面的方法
         Method met = c.getMethod("printInfo" ,  new  Class[]{}); //得到方法
         met.invoke(obj, new  Object[]{}); //调用

         /*Customer cus = new Customer("222","111");
         cus.printInfo();*/

     }

 }


 /*public class Test2 {
     public static void main(String[] args) throws Exception {
         String className = "fanshe.Customer";
         Class c = Class.forName(className);
         Constructor con1 = c.getConstructor(new Class[] {Class.forName("java.lang.String"),Class.forName("java.lang.String") });
         Object obj = con1.newInstance(new Object[] {"222","111"});
         Method met = c.getMethod("printInfo", new Class[]{});
         met.invoke(obj, new Object[]{});
     }
 }*/