高级特性 反射

原创 2015年07月07日 13:20:33

如果我们把类看成制造一样事物的图纸把对象看成某种具体的事物那么

如果要使用对象的属性方法等东西就有了两种方法:

1是将这个对象制造出来 然后再调用

2是将这个对象的图纸拿到手 然后对照图纸 指定某对象来使用其图纸上面的东西

第二种方法就是反射

 

如果用图形来表示:

---à对象

--à图纸--à对象(这就是反射)

看起来像相当于多了拿到图纸这一个步骤就像光反射了一下才到达目的地一样所以叫反射

 

作为反射的基础主要有以下内容:

9种基本类型+数组+集合

构造+属性+方法

最后就是小框架的演习

 

/*

需求:

演习反射和框架基础的全部内容

9种基本类型+数组+集合

构造+属性+方法

最后就是小框架的演习

 

*/

 

import java.util.*;

import java.io.*;

import java.lang.reflect.*;

 

class ReflectionPoint

{

         publicstatic void main(String[] args) throws Exception

         {

                   Stringstr1 = "moriarty";

                  

                   //三种拿到字节码文件的方式

                   Classcls1 = str1.getClass();

                   Classcls2 = String.class;

                   Classcls3 = Class.forName("java.lang.String"); //注意这个要写类的全名 导包不管用

                  

                   //同一份字节码文件

                   sop(cls1== cls2);

                   sop(cls2== cls3);

 

                   //String不是基本类型

                   sop(cls1.isPrimitive());

                   //int是基本类型

                   sop(int.class.isPrimitive());

                   //int跟Integer不一样

                   sop(int.class== Integer.class);

                   //int跟Integer的TYPE一样

                   sop(int.class== Integer.TYPE);

                   //数组不属于基本类型

                   sop(int[].class.isPrimitive());

                   //数组属于数组

                   sop(int[].class.isArray());

 

                   /*

                    Constructor<T>getConstructor(Class<?>... parameterTypes)

         返回一个 Constructor 对象,它反映此 Class 对象所表示的类的指定公共构造方法。

                   */

                  

                   //通过反射拿到String类的构造函数

                   Constructorconstructor1 = String.class.getConstructor(StringBuffer.class);

                   //通过反射建立String对象

                   Stringstr2 = (String)constructor1.newInstance(new StringBuffer("fantizi"));

                   //从对象中调用方法

                   sop(str2.charAt(2));

                  

                   //通过反射的方式拿到成员变量(但其实还是先新建了对象)

                   MyRectanglemr = new MyRectangle(4,5);

                   //拿到私有成员变量 首先要使用getDeclaredField

                   Fieldfield1 = mr.getClass().getDeclaredField("y");

                   //然后还要讲field变量setAccessible(true)

                   field1.setAccessible(true);

                   sop(field1.get(mr));

                  

                   //将所有String类型的成员变量里的b换成a 使用反射

                  

                   MyRectanglemr2 = new MyRectangle(5,5);

                   changeStringValue(mr2);

                   sop(mr2.str1+mr2.str2+mr2.str3);

 

                   //使用成员方法的反射 完成charAt的调用

                   MethodcharAtMethod = String.class.getMethod("charAt",int.class);

                   sop(charAtMethod.invoke(str1,2));//这里的str1是最开始定义的"moriarty"

                   sop(charAtMethod.invoke(str1,newObject[]{2}));

                  

                   //对接受数组参数的成员方法进行反射

                   //说白了 也就是main方法里面的参数(数组参数) 也就是对main方法进行反射

                  

                  String startingClassName = args[0];

                   MethodmainMethod =

                            Class.forName(startingClassName).getMethod("main",String[].class);

                   mainMethod.invoke(null,newObject[]{new String[]{"1ab","adfasd"}});

                  

                   TestArgumentsta = new TestArguments();

                   Classxxx = ta.getClass();

                   sop(xxx.getName());

                   //注意编译的时候 javaReflectionPoint TestArguments

 

                   //数组与Object的关系与反射类型

                   int[]a1 = new int[]{1,2,3};

                   int[]a2 = new int[4];

                   int[][]a3 = new int[][]{{1,2,3},{3,4,6}};

                   String[]a4 = new String[]{"a","b","c","d"};

 

                   sop(a1.getClass()== a2.getClass());

                   //编译错误:不可比较的类型

//               sop(a1.getClass()== a3.getClass());

//               sop(a1.getClass()== a4.getClass());

                   sop(a1.getClass().getName());

                   sop(a2.getClass().getSuperclass().getName());

                   sop(a4.getClass().getSuperclass().getName());

                   //学习asList()方法 转换成集合

 

                   Objectobj1 = a1;

                   Objectobj2 = a2;

                   Object[]obj3 = a3;//重要obj3是二维数组不是一维数组!!!极为重要!

//               Object[]obj33 = a1;//基本类型不是Object

                   Object[]obj4 = a4;

                   //一维数组和二维数组确实不一样 打印为false

                   sop(obj1.getClass()== obj3.getClass());

                   sop(obj1.getClass().getName());

                   sop(obj3.getClass().getName());

                   sop(Arrays.asList(a1));

                   sop(Arrays.asList(a3));

                   sop(Arrays.asList(a4));

//进化 打印任意维度的数组!

                   printObject(a3);

 

                   Collection<MyRectangle>coll = new HashSet<MyRectangle>();

                   coll.add(newMyRectangle(3,4));

                   coll.add(newMyRectangle(7,4));

                   coll.add(newMyRectangle(1,4));

                   coll.add(newMyRectangle(1,4));

                  

                   sop("coll.size()="+coll.size());

 

                   //小框架

                   //配置文件里面需要是HashSet否则无法使用比较

                   InputStreamin = new FileInputStream("config.properties");

                   Propertiesprop = new Properties();

                   prop.load(in);

                   in.close();

 

                   StringclassName = prop.getProperty("className");

                   Collection<MyRectangle>coll2 =

                            (HashSet<MyRectangle>)Class.forName(className).newInstance();

                  

                   coll2.add(newMyRectangle(3,4));

                   coll2.add(newMyRectangle(7,4));

                   coll2.add(newMyRectangle(1,4));

                   coll2.add(newMyRectangle(1,4));

                  

                   sop("coll2.size()="+coll2.size());

         }

 

//使用迭代 打印任意维度的数组!!

//做出来的关键是:模拟整个过程的运行 不要害怕思考 不要偷懒

         publicstatic void printObject(Object obj)

         {

                   Classcls = obj.getClass();

                   if(cls.isArray())

                   {

                            for(int i =0; i<Array.getLength(obj) ; i++)

                            {

                                     if(Array.get(obj,i).getClass().isArray())

                                     {

                                               printObject(Array.get(obj,i));

                                     }

                                     else

                                               sop(Array.get(obj,i));

                            }

                   }

                   else

                            sop(obj);

         }

        

         publicstatic void changeStringValue(Object obj) throws Exception

         {

                   /*

                   field对象里面的方法

                   voidset(Object obj, Object value)

         将指定对象变量上此 Field 对象表示的字段设置为指定的新值。   

                     */

                  

                   Field[]f = obj.getClass().getFields();

                   for( Field field : f )

                   {

                            if(field.getType() == String.class)

                            {

                                     Stringoldvalue = (String)field.get(obj);

                                     Stringnewvalue = oldvalue.replace('b','a');

                                     field.set(obj,newvalue);

                            }

                   }

         }

 

         publicstatic void sop(Object obj)

         {

                   System.out.println(obj);

         }

}

 

class MyRectangle

{

         privateint x,y;

         publicString str1 = "ball";

         publicString str2 = "basketball";

         publicString str3 = "itcast";

 

         publicMyRectangle(int x , int y)

         {

                   this.x= x;

                   this.y= y;

         }

 

         publicint hashCode()

         {

                   intresult = 3;

 

                   result= x+result*y;

                   System.out.println("result="+result);

 

                   returnresult;

         }

 

         publicboolean equals(Object obj)

         {

                   System.out.println(obj.getClass().getName()+"调用");

                   if(this == obj)

                            returntrue;

                   if(getClass() != obj.getClass())

                   {

                            returnfalse;

                   }

                   MyRectangleother = (MyRectangle)obj;

                   if(x != other.x)

                   {

                            returnfalse;

                   }

                   elseif ( y != other.y)

                   {

                            returnfalse;

                   }

                   returntrue;

         }

}

 

class TestArguments

{

         publicstatic void main(String[] args) throws Exception

         {

                   for(String str : args )

                   {

                            System.out.println(str);

                   }

         }

}

版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

Java的高级特性反射

首先简单说说什么反射,其实就是动态的加载类,我们在写JDBC的时候加载驱动Class.forName("xxxx"),这句话就涉及到了反射。 反射是自JAVA诞生就具备的高级特性,其强大的扩...
  • clr_lr
  • clr_lr
  • 2015年07月10日 12:55
  • 274

Java的一些高级特性(三)——关于反射

首先我们来看一个使用Class类的例子。 我们可以通过对象的getClass()方法得到一个Class对象,如下: package com.freesoft.javaadvanced; im...

Java高级特性之反射学习总结

java反射

php高级特性-反射

一、什么是反射?它是指在PHP运行状态中,扩展分析PHP程序,导出或提取出关于类、方法、属性、参数等的详细信息,包括注释。这种动态获取的信息以及动态调用对象的方法的功能称为反射API。 反射是操纵面...

C#高级学习第四章反射和特性

Type: Type类是抽象类,它能获取它对应类的所有成员(public) MyClass my=new MyClass(); Type type=my.GetType();   通过对象获取这个对象...

【IOS 开发】Objective - C 面向对象高级特性 - 包装类 | 类处理 | 类别 | 扩展 | 协议 | 委托 | 异常处理 | 反射

包装类 | 类处理 | 类别 | 扩展 | 协议 | 委托 | 异常处理 | 反射

基础加强____【Java高级特性__反射】

反射是java出现就具备的高级特性,其强大的扩展能力使Java严谨死板的语法变得灵活 使用反射能够超越一些Java对普通类的限定,有关反射的主要相关类存在于java.lang.reflect包中 但是...
  • ie800
  • ie800
  • 2014年02月12日 13:57
  • 1330

【java高级特性之反射】Field类和Constructor类的使用

反射就是将Java类中的各个成分映射成为响应的java类。 一.Constructor(构造方法)反射: 利用Constructor来构造对象: 1.获取Constructor的示例对象:...

C# 高级特性(二)Attribute和反射

使用Attribute的时候大多需要用到反射,所以放在一起。 Attribute: 我的理解是,它可以给你的类、方法、字段等添加一些描述性语言,在运行期间又可以通过反射的方法获取它的内容。 在编...

JAVA高级特性:反射

反射机制
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:高级特性 反射
举报原因:
原因补充:

(最多只允许输入30个字)