「java++i原理」java 原理

admin 2023-03-17 09:21:10 365

本篇文章给大家谈谈java++i原理，以及java 原理对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

1、java中++和+=的执行原理有什么不同
2、jvm底层原理是什么呢？有大神可以说说吗？
3、分析 Java I/O 的工作机制
4、Java中的I/O流的基本知识
5、Java中IO缓冲区的原理是什么
6、java反射机制的实现原理

java中++和+=的执行原理有什么不同

例如：i+=1 运行的底层Heap申请一个区域存放i，在数据区域开劈一个区域存放1，2个内存段被数据被送入到寄存器中进行运算，运算结果被放到heap中，数据区域运算后被自动释放后有GC回收；

而i++ 是将heap中数据直接送到寄存器中进行运算，运算结果会直接存放在heap中。

jvm底层原理是什么呢？有大神可以说说吗？

JVM是Java虚拟机的简称，它是Java语言的核心，负责解释和执行Java代码。JVM的底层原理包括以下几个方面：

1.类加载器：JVM使用类加载器将编译好的Java文件加载，在运行时将编译后的字节码转换为机器码。

2.内存管理：JVM对内存进行分配和管理，包括堆、栈等多种内存结构。

3.执行引擎：JVM的执行引擎可以将Java代码转换为可执行的机器指令。

4.JVM指令集：JVM指令集定义了Java语言的许多操作。

5.垃圾回收器：JVM垃圾回收器负责回收无用的对象，给新的对象腾出空间。

以上是JVM底层原理的基本内容，掌握了这些原理可以更好地理解Java程序的运行机制。要深入了解JVM的底层原理，还需要懂Java编译原理、内存模型、线程调度、类文件格式等技术。

分析 Java I/O 的工作机制

网络 I/O 优化

网络 I/O 优化通常有一些基本处理原则

一个是减少网络交互的次数要减少网络交互的次数通常我们在需要网络交互的两端会设置缓存比如 Oracle 的 JDBC 驱动程序就提供了对查询的 SQL 结果的缓存在客户端和数据库端都有可以有效的减少对数据库的访问关于 Oracle JDBC 的内存管理可以参考《 Oracle JDBC 内存管理》除了设置缓存还有一个办法是合并访问请求如在查询数据库时我们要查个 id 我可以每次查一个 id 也可以一次查个 id 再比如在访问一个页面时通过会有多个 js 或 css 的文件我们可以将多个 js 文件合并在一个 HTTP 链接中每个文件用逗号隔开然后发送到后端 Web 服务器根据这个 URL 链接再拆分出各个文件然后打包再一并发回给前端浏览器这些都是常用的减少网络 I/O 的办法

减少网络传输数据量的大小减少网络数据量的办法通常是将数据压缩后再传输如 HTTP 请求中通常 Web 服务器将请求的 Web 页面 gzip 压缩后在传输给浏览器还有就是通过设计简单的协议尽量通过读取协议头来获取有用的价值信息比如在代理程序设计时有层代理和层代理都是来尽量避免要读取整个通信数据来取得需要的信息

尽量减少编码通常在网络 I/O 中数据传输都是以字节形式的也就是通常要序列化但是我们发送要传输的数据都是字符形式的从字符到字节必须编码但是这个编码过程是比较耗时的所以在要经过网络 I/O 传输时尽量直接以字节形式发送也就是尽量提前将字符转化为字节或者减少字符到字节的转化过程

根据应用场景设计合适的交互方式所谓的交互场景主要包括同步与异步阻塞与非阻塞方式下面将详细介绍

同步与异步

所谓同步就是一个任务的完成需要依赖另外一个任务时只有等待被依赖的任务完成后依赖的任务才能算完成这是一种可靠的任务序列要么成功都成功失败都失败两个任务的状态可以保持一致而异步是不需要等待被依赖的任务完成只是通知被依赖的任务要完成什么工作依赖的任务也立即执行只要自己完成了整个任务就算完成了至于被依赖的任务最终是否真正完成依赖它的任务无法确定所以它是不可靠的任务序列我们可以用打电话和发短信来很好的比喻同步与异步操作

在设计到 IO 处理时通常都会遇到一个是同步还是异步的处理方式的选择问题因为同步与异步的 I/O 处理方式对调用者的影响很大在数据库产品中都会遇到这个问题因为 I/O 操作通常是一个非常耗时的操作在一个任务序列中 I/O 通常都是性能瓶颈但是同步与异步的处理方式对程序的可靠性影响非常大同步能够保证程序的可靠性而异步可以提升程序的性能必须在可靠性和性能之间做个平衡没有完美的解决办法

阻塞与非阻塞

阻塞与非阻塞主要是从 CPU 的消耗上来说的阻塞就是 CPU 停下来等待一个慢的操作完成 CPU 才接着完成其它的事非阻塞就是在这个慢的操作在执行时 CPU 去干其它别的事等这个慢的操作完成时 CPU 再接着完成后续的操作虽然表面上看非阻塞的方式可以明显的提高 CPU 的利用率但是也带了另外一种后果就是系统的线程切换增加增加的 CPU 使用时间能不能补偿系统的切换成本需要好好评估

两种的方式的组合

组合的方式可以由四种分别是同步阻塞同步非阻塞异步阻塞异步非阻塞这四种方式都对 I/O 性能有影响下面给出分析并有一些常用的设计用例参考

表四种组合方式

组合方式

性能分析

同步阻塞

最常用的一种用法使用也是最简单的但是 I/O 性能一般很差 CPU 大部分在空闲状态

同步非阻塞

提升 I/O 性能的常用手段就是将 I/O 的阻塞改成非阻塞方式尤其在网络 I/O 是长连接同时传输数据也不是很多的情况下提升性能非常有效这种方式通常能提升 I/O 性能但是会增加 CPU 消耗要考虑增加的 I/O 性能能不能补偿 CPU 的消耗也就是系统的瓶颈是在 I/O 还是在 CPU 上

异步阻塞

这种方式在分布式数据库中经常用到例如在网一个分布式数据库中写一条记录通常会有一份是同步阻塞的记录而还有两至三份是备份记录会写到其它机器上这些备份记录通常都是采用异步阻塞的方式写 I/O 异步阻塞对网络 I/O 能够提升效率尤其像上面这种同时写多份相同数据的情况

异步非阻塞

这种组合方式用起来比较复杂只有在一些非常复杂的分布式情况下使用像集群之间的消息同步机制一般用这种 I/O 组合方式如 Cassandra 的Gossip 通信机制就是采用异步非阻塞的方式它适合同时要传多份相同的数据到集群中不同的机器同时数据的传输量虽然不大但是却非常频繁这种网络 I/O 用这个方式性能能达到最高

虽然异步和非阻塞能够提升 I/O 的性能但是也会带来一些额外的性能成本例如会增加线程数量从而增加 CPU 的消耗同时也会导致程序设计的复杂度上升如果设计的不合理的话反而会导致性能下降在实际设计时要根据应用场景综合评估一下

下面举一些异步和阻塞的操作实例

在 Cassandra 中要查询数据通常会往多个数据节点发送查询命令但是要检查每个节点返回数据的完整性所以需要一个异步查询同步结果的应用场景部分代码如下

清单异步查询同步结果

class AsyncResult implements IAsyncResult{

private byte[] result_;

private AtomicBoolean done_ = new AtomicBoolean（false）

private Lock lock_ = new ReentrantLock（）

private Condition condition_;

private long startTime_;

public AsyncResult（）{

condition_ = lock_ newCondition（） // 创建一个锁

startTime_ = System currentTimeMillis（）

}

/*** 检查需要的数据是否已经返回如果没有返回阻塞 */

public byte[] get（）{

lock_ lock（）

try{

if （！done_ get（））{condition_ await（） }

}catch （InterruptedException ex）{

throw new AssertionError（ex）

}finally{lock_ unlock（） }

return result_;

}

/*** 检查需要的数据是否已经返回 */

public boolean isDone（）{return done_ get（） }

/*** 检查在指定的时间内需要的数据是否已经返回如果没有返回抛出超时异常 */

public byte[] get（long timeout TimeUnit tu） throws TimeoutException{

lock_ lock（）

try{ boolean bVal = true;

try{

if （ !done_ get（））{

long overall_timeout = timeout （System currentTimeMillis（） startTime_）

if（overall_timeout ）// 设置等待超时的时间

bVal = condition_ await（overall_timeout TimeUnit MILLISECONDS）

else bVal = false;

}

}catch （InterruptedException ex）{

throw new AssertionError（ex）

}

if （ !bVal !done_ get（））{// 抛出超时异常

throw new TimeoutException（ Operation timed out ）

}

}finally{lock_ unlock（） }

return result_;

}

/*** 该函数拱另外一个线程设置要返回的数据并唤醒在阻塞的线程 */

public void result（Message response）{

try{

lock_ lock（）

if （ !done_ get（））{

result_ = response getMessageBody（） // 设置返回的数据

done_ set（true）

condition_ signal（） // 唤醒阻塞的线程

}

}finally{lock_ unlock（） }

}

总结

lishixinzhi/Article/program/Java/hx/201311/26096

Java中的I/O流的基本知识

1、与外部设备和其它计算机进行交流的输入输出操作，尤其是对磁盘的文件操作，是计算机程序重要的功能，任何计算机语言都必须对输入输出提供支持。Java也不例外，它的输入输出类库中包含了丰富的系统工具，这些类被放在java.io包中。在该类库中，除了定义文件输入输出操作外，还定义了许多用来和其他外设进行信息交换的类。

2、流(Stream)指的是在计算机的输入与输出之间运动的数据序列：输入流代表从外设流入计算机的数据序列；输出流代表从计算机流向外设的数据序列。

流式输入输出是一种很常见的输入输出方式，它最大的特点是数据的获取和发送均沿数据序列顺序进行：每一个数据都必须等待排在它前面的数据读入或输出之后才能被读写，每次读写操作处理的都是序列中剩余的未读写数据中的第一个，而不能够随意选择输入输出的位置。磁带机是实现流式输入输出的典型设备

3、InputStream和OutputStream是java.io包中的两个抽象类，他们分别是其他所有输入、输出流类的父类。其他所有输入流类都是继承了InputStream的基本输入功能并根据自身属性对这些功能加以扩充；同样，其他所有输出流类也都是继承了OutputStream类的基本输出功能并加以扩展的

4、File类是IO包中惟一代表磁盘文件本身的对象，File对象定义了一些与平台无关的方法来操纵文件

创建File类对象时需指明它所对应的文件或目录名。File类共提供了4个不同的构造方法，以不同的参数形式灵活地接收文件和目录名信息

5、FileReader和FileWrite类分别继承自Reader类和Writer类，继承关系如图6-2所示。FileReader类用于读取文件；FileWrite类用于将数据写入文件。在使用这两个类之前，必须调用其构造方法创建相应的对象，然后才能调用相应的read()或write()方法进行文件的读写操作

6、BufferedReader和BufferedWrite类分别继承自Reader类和Writer类，BufferedReader类用来从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。BufferedWrite类用于将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。

7、LineNumberReader类是BufferedReader类的直接子类。该类允许对文本输入数据流加入行号。

8、LineNumberReader类是BufferedReader类的直接子类。该类允许对文本输入数据流加入行号。

此类定义了方法setLineNumber(int)和getLineNumber()，它们可分别用于设置和获取当前行号。默认情况下，行编号从0开始。该行号随数据读取在每个行结束符处递增，并且可以通过调用setLineNumber(int)更改行号。但要注意的是，setLineNumber(int)不会实际更改流中的当前位置；它只更改将由getLineNumber()返回的值使用RandomAccessFile类随机读写文件时，在创建了一个RandomAccessFile对象之后，该文件即对文件描述句柄处于打开状态。此时，文件的指针处于文件开始位置。可以通过seek(long pos)方法设置文件指针的当前位置，以进行文件的快速定位，然后使用相应的read()和write()方法对文件进行读写操作。在对文件的读写操作完成后，调用close()方法关闭文件

9、FileInputStream和FileOutputStream类主要用来处理以“位为主”的输入输出操作。其中，FileInputStream类继承于InputStream类；FileOutputStream类继承于OutputStream类。

与RandomAccessFile类所不同的是，FileInputStream和FileOutputStream类中提供的文件处理方式是文件中数据流的顺序读写，而不是利用文件指针进行定位的随机读写

10、Java中的PipedInputStream和PipedOutputStream类提供了利用管道方式进行数据输入输出管理。管道流用来将一个程序或者线程的输出连接到另外一个程序或线程作为输入，使得相连线程能够通过PipedInputStream和PipedOutputStream类进行数据交换。

PipedInputStream和PipedOutputStream类也是InputStream和OutputStream类的直接子类。这两个类必须结合使用，其中，管道输入流作为管道的接收端、管道输出流作为管道的发送端，在程序设计中应注意数据的传输方向

顺序输入流SequenceInputStream是InputStream的直接子类，其功能是将多个输入流连接在一起，形成单一的输入数据流，没有对应的输出数据流存在。

顺序输入流SequenceInputStream由多个输入流构造而成，它从输入流的有序集合开始，并从第一个输入流开始读取，直到文件末尾，接着从第二个输入流读取，依次类推，直到到达顺序输入流包含的最后一个输入流的文件末尾为止

Java中IO缓冲区的原理是什么

如果是边读边写，就会很慢，也伤硬盘。缓冲区就是内存里的一块区域，把数据先存内存里，然后一次性写入，类似数据库的批量操作，这样效率比较高。

调用I\O操作的时候，实际上还是一个一个的读或者写，关键就在，CPU只有一个，不论是几个核心。CPU在系统调用时，会不会还要参与主要操作？参与多次就会花更多的时间。

系统调用时，若不用缓冲，CPU会酌情考虑使用中断。此时CPU是主动地，每个周期中都要花去一部分去询问I\O设备是否读完数据，这段时间CPU不能做任何其他的事情（至少负责执行这段模块的核不能）。所以，调用一次读了一个字，通报一次，CPU腾出时间处理一次。

而设置缓冲，CPU通常会使用 DMA 方式去执行 I\O 操作。CPU 将这个工作交给DMA控制器来做，自己腾出时间做其他的事，当DMA完成工作时，DMA会主动告诉CPU“操作完成”。这时，CPU接管后续工作。在此，CPU 是被动的。DMA是专门做 I＼O 与内存数据交换的，不仅自身效率高，也节约了CPU时间，CPU在DMA开始和结束时做了一些设置罢了。

所以，调用一次，不必通报CPU，等缓冲区满了，DMA 会对C PU 说 “嘿，伙计！快过来看看，把他们都搬走吧”。

综上，设置缓冲，就建立了数据块，使得DMA执行更方便，CPU也有空闲，而不是呆呆地候着I\O数据读来。从微观角度来说，设置缓冲效率要高很多。尽管，不能从这个程序上看出来。几万字的读写\就能看到差距

java反射机制的实现原理

反射机制:所谓的反射机制就是java语言在运行时拥有一项自观的能力。通过这种能力可以彻底的了解自身的情况为下一步的动作做准备。下面具体介绍一下java的反射机制。这里你将颠覆原来对java的理解。

Java的反射机制的实现要借助于4个类：class，Constructor，Field，Method；其中class代表的时类对象，Constructor－类的构造器对象，Field－类的属性对象，Method－类的方法对象。通过这四个对象我们可以粗略的看到一个类的各个组成部分。

Class：程序运行时，java运行时系统会对所有的对象进行运行时类型的处理。这项信息记录了每个对象所属的类，虚拟机通常使用运行时类型信息选择正确的方法来执行（摘自：白皮书）。但是这些信息我们怎么得到啊，就要借助于class类对象了啊。在Object类中定义了getClass()方法。我们可以通过这个方法获得指定对象的类对象。然后我们通过分析这个对象就可以得到我们要的信息了。

比如：ArrayList arrayList;

Class clazz = arrayList.getClass();

然后我来处理这个对象clazz。

当然了Class类具有很多的方法，这里重点将和Constructor，Field，Method类有关系的方法。

Reflection 是 Java 程序开发语言的特征之一，它允许运行中的 Java 程序对自身进行检查，或者说“自审”，并能直接操作程序的内部属性。Java 的这一能力在实际应用中也许用得不是很多，但是个人认为要想对java有个更加深入的了解还是应该掌握的。

1．检测类：

reflection的工作机制

考虑下面这个简单的例子，让我们看看 reflection 是如何工作的。

import java.lang.reflect.*;

public class DumpMethods {

public static void main(String args[]) {

try {

Class c = Class.forName(args[0]);

Method m[] = c.getDeclaredMethods();

for (int i = 0; i m.length; i++)

System.out.println(m[i].toString());

} catch (Throwable e) {

System.err.println(e);

}

按如下语句执行：

java DumpMethods java.util.ArrayList

这个程序使用 Class.forName 载入指定的类，然后调用 getDeclaredMethods 来获取这个类中定义了的方法列表。java.lang.reflect.Methods 是用来描述某个类中单个方法的一个类。

Java类反射中的主要方法

对于以下三类组件中的任何一类来说 -- 构造函数、字段和方法 -- java.lang.Class 提供四种独立的反射调用，以不同的方式来获得信息。调用都遵循一种标准格式。以下是用于查找构造函数的一组反射调用：

Constructor getConstructor(Class[] params) -- 获得使用特殊的参数类型的公共构造函数，

Constructor[] getConstructors() -- 获得类的所有公共构造函数

Constructor getDeclaredConstructor(Class[] params) -- 获得使用特定参数类型的构造函数(与接入级别无关)

Constructor[] getDeclaredConstructors() -- 获得类的所有构造函数(与接入级别无关)

获得字段信息的Class 反射调用不同于那些用于接入构造函数的调用，在参数类型数组中使用了字段名：

Field getField(String name) -- 获得命名的公共字段

Field[] getFields() -- 获得类的所有公共字段

Field getDeclaredField(String name) -- 获得类声明的命名的字段

Field[] getDeclaredFields() -- 获得类声明的所有字段

用于获得方法信息函数：

Method getMethod(String name, Class[] params) -- 使用特定的参数类型，获得命名的公共方法

Method[] getMethods() -- 获得类的所有公共方法

Method getDeclaredMethod(String name, Class[] params) -- 使用特写的参数类型，获得类声明的命名的方法

Method[] getDeclaredMethods() -- 获得类声明的所有方法

使用 Reflection：

用于 reflection 的类，如 Method，可以在 java.lang.relfect 包中找到。使用这些类的时候必须要遵循三个步骤：第一步是获得你想操作的类的 java.lang.Class 对象。在运行中的 Java 程序中，用 java.lang.Class 类来描述类和接口等。

下面就是获得一个 Class 对象的方法之一：

Class c = Class.forName("java.lang.String");

这条语句得到一个 String 类的类对象。还有另一种方法，如下面的语句：

Class c = int.class;

或者

Class c = Integer.TYPE;

它们可获得基本类型的类信息。其中后一种方法中访问的是基本类型的封装类 (如 Intege ) 中预先定义好的 TYPE 字段。

第二步是调用诸如 getDeclaredMethods 的方法，以取得该类中定义的所有方法的列表。

一旦取得这个信息，就可以进行第三步了——使用 reflection API 来操作这些信息，如下面这段代码：

Class c = Class.forName("java.lang.String");

Method m[] = c.getDeclaredMethods();

System.out.println(m[0].toString());

它将以文本方式打印出 String 中定义的第一个方法的原型。

处理对象：

a.创建一个Class对象

b.通过getField 创建一个Field对象

c.调用Field.getXXX(Object)方法(XXX是Int,Float等，如果是对象就省略；Object是指实例).

例如：

import java.lang.reflect.*;

import java.awt.*;

class SampleGet {

public static void main(String[] args) {

Rectangle r = new Rectangle(100, 325);

printHeight(r);

}

static void printHeight(Rectangle r) {

Field heightField;

Integer heightValue;

Class c = r.getClass();

try {

heightField = c.getField("height");

heightValue = (Integer) heightField.get(r);

System.out.println("Height: " + heightValue.toString());

} catch (NoSuchFieldException e) {

System.out.println(e);

} catch (SecurityException e) {

System.out.println(e);

} catch (IllegalAccessException e) {

System.out.println(e);

}

安全性和反射：

在处理反射时安全性是一个较复杂的问题。反射经常由框架型代码使用，由于这一点，我们可能希望框架能够全面接入代码，无需考虑常规的接入限制。但是，在其它情况下，不受控制的接入会带来严重的安全性风险，例如当代码在不值得信任的代码共享的环境中运行时。

由于这些互相矛盾的需求，Java编程语言定义一种多级别方法来处理反射的安全性。基本模式是对反射实施与应用于源代码接入相同的限制：

从任意位置到类公共组件的接入

类自身外部无任何到私有组件的接入

受保护和打包（缺省接入）组件的有限接入

不过至少有些时候，围绕这些限制还有一种简单的方法。我们可以在我们所写的类中，扩展一个普通的基本类 java.lang.reflect.AccessibleObject 类。这个类定义了一种setAccessible方法，使我们能够启动或关闭对这些类中其中一个类的实例的接入检测。唯一的问题在于如果使用了安全性管理器，它将检测正在关闭接入检测的代码是否许可了这样做。如果未许可，安全性管理器抛出一个例外。

下面是一段程序，在TwoString 类的一个实例上使用反射来显示安全性正在运行：

public class ReflectSecurity {

public static void main(String[] args) {

try {

TwoString ts = new TwoString("a", "b");

Field field = clas.getDeclaredField("m_s1");

// field.setAccessible(true);

System.out.println("Retrieved value is " +

field.get(inst));

} catch (Exception ex) {

ex.printStackTrace(System.out);

}

如果我们编译这一程序时，不使用任何特定参数直接从命令行运行，它将在field .get(inst)调用中抛出一个IllegalAccessException异常。如果我们不注释 field.setAccessible(true)代码行，那么重新编译并重新运行该代码，它将编译成功。最后，如果我们在命令行添加了JVM参数 -Djava.security.manager以实现安全性管理器，它仍然将不能通过编译，除非我们定义了ReflectSecurity类的许可权限。

反射性能：（转录别人的啊）

反射是一种强大的工具，但也存在一些不足。一个主要的缺点是对性能有影响。使用反射基本上是一种解释操作，我们可以告诉JVM，我们希望做什么并且它满足我们的要求。这类操作总是慢于只直接执行相同的操作。

下面的程序是字段接入性能测试的一个例子，包括基本的测试方法。每种方法测试字段接入的一种形式 -- accessSame 与同一对象的成员字段协作，accessOther 使用可直接接入的另一对象的字段，accessReflection 使用可通过反射接入的另一对象的字段。在每种情况下，方法执行相同的计算 -- 循环中简单的加/乘顺序。

程序如下：

public int accessSame(int loops) {

m_value = 0;

for (int index = 0; index loops; index++) {

m_value = (m_value + ADDITIVE_VALUE) *

MULTIPLIER_VALUE;

}

return m_value;

}

public int acces

sReference(int loops) {

TimingClass timing = new TimingClass();

for (int index = 0; index loops; index++) {

timing.m_value = (timing.m_value + ADDITIVE_VALUE) *

MULTIPLIER_VALUE;

}

return timing.m_value;

}

public int accessReflection(int loops) throws Exception {

TimingClass timing = new TimingClass();

try {

Field field = TimingClass.class.

getDeclaredField("m_value");

for (int index = 0; index loops; index++) {

int value = (field.getInt(timing) +

ADDITIVE_VALUE) * MULTIPLIER_VALUE;

field.setInt(timing, value);

}

return timing.m_value;

} catch (Exception ex) {

System.out.println("Error using reflection");

throw ex;

}

在上面的例子中，测试程序重复调用每种方法，使用一个大循环数，从而平均多次调用的时间衡量结果。平均值中不包括每种方法第一次调用的时间，因此初始化时间不是结果中的一个因素。下面的图清楚的向我们展示了每种方法字段接入的时间：

图 1：字段接入时间：

我们可以看出：在前两副图中(Sun JVM)，使用反射的执行时间超过使用直接接入的1000倍以上。通过比较，IBM JVM可能稍好一些，但反射方法仍旧需要比其它方法长700倍以上的时间。任何JVM上其它两种方法之间时间方面无任何显著差异，但IBM JVM几乎比Sun JVM快一倍。最有可能的是这种差异反映了Sun Hot Spot JVM的专业优化，它在简单基准方面表现得很糟糕。反射性能是Sun开发1.4 JVM时关注的一个方面，它在反射方法调用结果中显示。在这类操作的性能方面，Sun 1.4.1 JVM显示了比1.3.1版本很大的改进。

如果为为创建使用反射的对象编写了类似的计时测试程序，我们会发现这种情况下的差异不象字段和方法调用情况下那么显著。使用newInstance()调用创建一个简单的java.lang.Object实例耗用的时间大约是在Sun 1.3.1 JVM上使用new Object()的12倍，是在IBM 1.4.0 JVM的四倍，只是Sun 1.4.1 JVM上的两部。使用Array.newInstance(type, size)创建一个数组耗用的时间是任何测试的JVM上使用new type[size]的两倍，随着数组大小的增加，差异逐步缩小。随着jdk6.0的推出，反射机制的性能也有了很大的提升。期待中….

总结：

Java语言反射提供一种动态链接程序组件的多功能方法。它允许程序创建和控制任何类的对象(根据安全性限制)，无需提前硬编码目标类。这些特性使得反射特别适用于创建以非常普通的方式与对象协作的库。例如，反射经常在持续存储对象为数据库、XML或其它外部格式的框架中使用。Java reflection 非常有用，它使类和数据结构能按名称动态检索相关信息，并允许在运行着的程序中操作这些信息。Java 的这一特性非常强大，并且是其它一些常用语言，如 C、C++、Fortran 或者 Pascal 等都不具备的。

但反射有两个缺点。第一个是性能问题。用于字段和方法接入时反射要远慢于直接代码。性能问题的程度取决于程序中是如何使用反射的。如果它作为程序运行中相对很少涉及的部分，缓慢的性能将不会是一个问题。即使测试中最坏情况下的计时图显示的反射操作只耗用几微秒。仅反射在性能关键的应用的核心逻辑中使用时性能问题才变得至关重要。

许多应用中更严重的一个缺点是使用反射会模糊程序内部实际要发生的事情。程序人员希望在源代码中看到程序的逻辑，反射等绕过了源代码的技术会带来维护问题。反射代码比相应的直接代码更复杂，正如性能比较的代码实例中看到的一样。解决这些问题的最佳方案是保守地使用反射——仅在它可以真正增加灵活性的地方 ——记录其在目标类中的使用。

一下是对应各个部分的例子：

具体的应用：

1、模仿instanceof 运算符号

class A {}

public class instance1 {

public static void main(String args[])

{

try {

Class cls = Class.forName("A");

boolean b1

= cls.isInstance(new Integer(37));

System.out.println(b1);

boolean b2 = cls.isInstance(new A());

System.out.println(b2);

}

catch (Throwable e) {

System.err.println(e);

}

2、在类中寻找指定的方法，同时获取该方法的参数列表，例外和返回值

import java.lang.reflect.*;

public class method1 {

private int f1(

Object p, int x) throws NullPointerException

{

if (p == null)

throw new NullPointerException();

return x;

}

public static void main(String args[])

{

try {

Class cls = Class.forName("method1");

Method methlist[]

= cls.getDeclaredMethods();

for (int i = 0; i methlist.length;

i++)

Method m = methlist[i];

System.out.println("name

= " + m.getName());

System.out.println("decl class = " +

m.getDeclaringClass());

Class pvec[] = m.getParameterTypes();

for (int j = 0; j pvec.length; j++)

System.out.println("

param #" + j + " " + pvec[j]);

Class evec[] = m.getExceptionTypes();

for (int j = 0; j evec.length; j++)

System.out.println("exc #" + j

+ " " + evec[j]);

System.out.println("return type = " +

m.getReturnType());

System.out.println("-----");

}

catch (Throwable e) {

System.err.println(e);

}

3、获取类的构造函数信息，基本上与获取方法的方式相同

import java.lang.reflect.*;

public class constructor1 {

public constructor1()

{

}

protected constructor1(int i, double d)

{

}

public static void main(String args[])

{

try {

Class cls = Class.forName("constructor1");

Constructor ctorlist[]

= cls.getDeclaredConstructors();

for (int i = 0; i ctorlist.length; i++) {

Constructor ct = ctorlist[i];

System.out.println("name

= " + ct.getName());

System.out.println("decl class = " +

ct.getDeclaringClass());

Class pvec[] = ct.getParameterTypes();

for (int j = 0; j pvec.length; j++)

System.out.println("param #"

+ j + " " + pvec[j]);

Class evec[] = ct.getExceptionTypes();

for (int j = 0; j evec.length; j++)

System.out.println(

"exc #" + j + " " + evec[j]);

System.out.println("-----");

}

catch (Throwable e) {

System.err.println(e);

}

4、获取类中的各个数据成员对象，包括名称。类型和访问修饰符号

import java.lang.reflect.*;

public class field1 {

private double d;

public static final int i = 37;

String s = "testing";

public static void main(String args[])

{

try {

Class cls = Class.forName("field1");

Field fieldlist[]

= cls.getDeclaredFields();

for (int i

= 0; i fieldlist.length; i++) {

Field fld = fieldlist[i];

System.out.println("name

= " + fld.getName());

System.out.println("decl class = " +

fld.getDeclaringClass());

System.out.println("type

= " + fld.getType());

int mod = fld.getModifiers();

System.out.println("modifiers = " +

Modifier.toString(mod));

System.out.println("-----");

}

catch (Throwable e) {

System.err.println(e);

}

5、通过使用方法的名字调用方法

import 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);

}

6、创建新的对象

import java.lang.reflect.*;

public class constructor2 {

public constructor2()

{

}

public constructor2(int a, int b)

{

System.out.println(

"a = " + a + " b = " + b);

}

public static void main(String args[])

{

try {

Class cls = Class.forName("constructor2");

Class partypes[] = new Class[2];

partypes[0] = Integer.TYPE;

partypes[1] = Integer.TYPE;

Constructor ct

= cls.getConstructor(partypes);

Object arglist[] = new Object[2];

arglist[0] = new Integer(37);

arglist[1] = new Integer(47);

Object retobj = ct.newInstance(arglist);

}

catch (Throwable e) {

System.err.println(e);

}

7、变更类实例中的数据的值

import java.lang.reflect.*;

public class field2 {

public double d;

public static void main(String args[])

{

try {

Class cls = Class.forName("field2");

Field fld = cls.getField("d");

field2 f2obj = new field2();

System.out.println("d = " + f2obj.d);

fld.setDouble(f2obj, 12.34);

System.out.println("d = " + f2obj.d);

}

catch (Throwable e) {

System.err.println(e);

}

使用反射创建可重用代码：

1、对象工厂

Object factory(String p) {

Class c;

Object o=null;

try {

c = Class.forName(p);// get class def

o = c.newInstance(); // make a new one

} catch (Exception e) {

System.err.println("Can't make a " + p);

}

return o;

}

public class ObjectFoundry {

public static Object factory(String p)

throws ClassNotFoundException,

InstantiationException,

IllegalAccessException {

Class c = Class.forName(p);

Object o = c.newInstance();

return o;

}

2、动态检测对象的身份，替代instanceof

public static boolean

isKindOf(Object obj, String type)

throws ClassNotFoundException {

// get the class def for obj and type

Class c = obj.getClass();

Class tClass = Class.forName(type);

while ( c!=null ) {

if ( c==tClass ) return true;

c = c.getSuperclass();

}

return false;

}

java++i原理的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java 原理、java++i原理的信息别忘了在本站进行查找喔。

标签：java++i原理