多纤果冻
多纤果冻

JAVA™教程（甲骨文官方）

JAVA™教程

Java教程是为JDK 8编写的。本页中描述的示例和实践没有利用后面版本中引入的改进。

版权(1995、2017甲骨文和/或其附属公司)。版权所有。

目录

TRAIL：反射API

反射的使用

反射缺陷

线索课

课程：课程

检索类对象

Object.getClass()

.class语法

Class.forName()

基元类型包装器的类型字段

返回类的方法。

检查类修饰符和类型

发现类成员

故障排除

编译器警告：“注意：.使用未经检查或不安全的操作”

当构造器不可访问时引发InstantiationException。

字段

方法

构造函数

域

获取字段类型

字段修饰符的检索与解析

获取和设置字段值

故障排除

因不可转换类型而引发的IllegalArgumentException

非公共字段的NoSuchFieldException

修改最终字段时抛出IllegalAccessException

方法

获取方法类型信息

获取方法参数的名称

隐式和综合参数

检索和解析方法修饰符

调用方法

使用特定声明查找和调用方法

使用可变数量的参数调用方法

故障排除

由于类型擦除而引发的NoSuchMethod异常

调用方法时抛出IllegalAccessException。

IllegalArgumentException来自Method.Invoke()

调用方法失败时异常

建设者

寻找构造器

检索和解析构造修饰符

创建新类实例

故障排除

由于缺少零参数构造器而引发的InstantiationException

newInstance()引发意外异常

查找或调用正确的构造函数时出现问题

试图调用不可访问的构造器时抛出IllegalAccessException

 

TRAIL：反射API

反射的使用

反射通常由需要检查或修改运行在Java虚拟机中的应用程序的运行时行为的程序使用。这是一个相对高级的特性，应该只供对语言的基本知识有很强了解的开发人员使用。考虑到这一点，反射是一种强大的技术，可以使应用程序执行本来是不可能的操作。

可扩展性特征

应用程序可以通过使用可扩展对象的完全限定名创建可扩展对象的实例，从而利用外部的、用户定义的类。

类浏览器和可视化开发环境

类浏览器需要能够枚举类的成员。可视化开发环境可以通过使用反射中可用的类型信息来帮助开发人员编写正确的代码。

调试器和测试工具

调试器需要能够检查类上的私有成员。测试工具可以利用反射系统地调用定义在类上的可发现集API，以确保测试套件中的代码覆盖率很高。

反射缺陷

反射是强大的，但不应任意使用。如果可以在不使用反射的情况下执行操作，则最好避免使用它。在通过反射访问代码时，应该记住以下几点。

性能开销

由于反射涉及动态解析的类型，因此无法执行某些Java虚拟机优化。因此，反射操作的性能比它们的非反射操作要慢，在性能敏感的应用程序中经常调用的代码部分应该避免反射操作。

安全限制

反射需要在安全管理器下运行时可能不存在的运行时权限。这是对必须在受限的安全上下文中运行的代码的一个重要考虑，例如在applet中。

内件暴露

因为反射允许代码执行在非反射代码中为非法的操作，例如访问。private字段和方法中，反射的使用会产生意想不到的副作用，这可能会导致代码功能失调并破坏可移植性。反射代码破坏抽象，因此可能会随着平台的升级而改变行为。

线索课

这条线索涵盖了用于访问和操作类、字段、方法和构造函数的反射的常见用途。每一课都包含代码示例、提示和故障排除信息。

trail icon类

本课展示了获取Class对象，并使用它检查类的属性，包括其声明和内容。

trail icon成员

本课介绍如何使用反射API查找类的字段、方法和构造函数。为设置和获取字段值、调用方法以及使用特定构造函数创建对象的新实例提供了示例。

trail icon数组和枚举类型

本课介绍了两种特殊类型的类：数组，它们是在运行时生成的，以及enum类型，它们定义唯一的命名对象实例。示例代码演示如何检索数组的组件类型，以及如何使用数组或enum类型。

注： 

本实验中的示例是为试验反射API而设计的。因此，异常的处理与在生产代码中使用的不一样。特别是，在生产代码中，不建议转储对用户可见的堆栈跟踪。

课程：课程

每种类型要么是引用，要么是原语。类、枚举和数组(它们都是从java.lang.Object)以及接口都是引用类型。引用类型的示例包括java.lang.String，基本类型的所有包装类，如java.lang.Double，接口java.io.Serializable，以及Enumjavax.swing.SortOrder。有一组固定的基本类型：boolean, byte, short, int, long, char, float，和double.

对于每种类型的对象，Java虚拟机实例化java.lang.Class它提供了检查对象的运行时属性(包括其成员和类型信息)的方法。Class还提供了创建新类和对象的能力。最重要的是，它是所有反射API的入口点。本课程涵盖涉及类的最常用的反射操作：

  • 检索类对象描述获取Class
  • 检查类修饰符和类型演示如何访问类声明信息。
  • 发现类成员说明如何列出类中的构造函数、字段、方法和嵌套类。
  • 故障排除描述在使用Class

检索类对象

所有反射操作的入口点是java.lang.Class。除了.java.lang.reflect.ReflectPermission中的任何一个类java.lang.reflect有公共建设者。要获得这些类，必须在Class。有几种方法可以获得Class取决于代码是否有权访问对象、类名、类型或现有的Class.

Object.getClass()

如果一个对象的实例是可用的，那么获取其Class就是调用Object.getClass()。当然，这只适用于所有继承自Object。下面是一些例子。

Class c = "foo".getClass();

返回Class为String

Class c = System.console().getClass();

有一个与虚拟机关联的唯一控制台，该控制台由static方法System.console()。返回的值getClass()是Class对应于java.io.Console.

enum E { A, B }
Class c = A.getClass();

A是枚举的实例。E因此getClass()返回Class对应于枚举类型E.

byte[] bytes = new byte[1024];
Class c = bytes.getClass();

因为数组是Objects，也可以调用getClass()在数组的实例上。回归Class对应于具有组件类型的数组。byte.

import java.util.HashSet;
import java.util.Set; Set s = new HashSet();
 Class c = s.getClass();

在这种情况下，java.util.Set是类型对象的接口。java.util.HashSet。返回的值getClass()是对应于java.util.HashSet.

.class语法

如果类型可用，但没有实例，则可以获得Class通过附加".class"类型的名称。这也是获取Class对于原始类型。

boolean b;
Class c = b.getClass();   // compile-time error

Class c = boolean.class;  // correct

注意语句boolean.getClass()将产生编译时错误，因为boolean是一个基本类型，不能取消引用。这，这个，那，那个.class语法返回Class对应于类型boolean.

Class c = java.io.PrintStream.class;

变量c将是Class对应于类型java.io.PrintStream.

Class c = int[][][].class;

这，这个，那，那个.class语法可用于检索Class对应于给定类型的多维数组。

Class.forName()

如果类的完全限定名可用，则可以获得相应的Class使用静态方法Class.forName()。这不能用于基本类型。数组类名的语法由Class.getName()。此语法适用于引用和基元类型。

Class c = Class.forName("com.duke.MyLocaleServiceProvider");

此语句将从给定的完全限定名创建一个类。

Class cDoubleArray = Class.forName("[D");

Class cStringArray = Class.forName("[[Ljava.lang.String;");

变量cDoubleArray将包含Class对应于基元类型的数组double(即与double[].class)这，这个，那，那个cStringArray变量将包含Class对应于String(即与String[][].class).

基元类型包装器的类型字段

这，这个，那，那个.class语法是获得Class但是，有另一种方法可以获取Class。每种原语类型和void中有一个包装类。java.lang用于将原始类型装箱为引用类型的。每个包装类包含一个名为TYPE，它等于Class对于正在包装的原始类型。

Class c = Double.TYPE;

有一门课java.lang.Double，它用于包装原语类型。double无论何时Object是必需的。价值Double.TYPE与double.class.

Class c = Void.TYPE;

Void.TYPE是相同的void.class.

返回类的方法。

有几个反射API返回类，但只有在Class已经直接或间接获得了。

Class.getSuperclass()

返回给定类的超类。

Class c = javax.swing.JButton.class.getSuperclass();

超级阶级javax.swing.JButton是javax.swing.AbstractButton.

Class.getClasses()

返回类的所有公共类、接口和枚举，包括继承的成员。

Class[] c = Character.class.getClasses();

Character包含两个成员类。Character.Subset和Character.UnicodeBlock.

Class.getDeclaredClasses()

返回该类中显式声明的所有类接口和枚举。

Class[] c = Character.class.getDeclaredClasses();

Character包含两个公共成员类。Character.Subset和Character.UnicodeBlock还有一个私人班级Character.CharacterCache.

Class.getDeclaringClass()
java.lang.reflect.Field.getDeclaringClass()
java.lang.reflect.Method.getDeclaringClass()
java.lang.reflect.Constructor.getDeclaringClass()

返回Class其中宣布了这些成员。匿名类声明不会有声明类，而是会有一个封闭类。

import java.lang.reflect.Field;

Field f = System.class.getField("out");
Class c = f.getDeclaringClass();

out声明为System.

public class MyClass {
    static Object o = new Object() {
        public void m() {} 
    };
    static Class = o.getClass().getEnclosingClass();
}

定义的匿名类的声明类。o是null.

Class.getEnclosingClass()

返回类的立即封装类。

Class c = Thread.State.class().getEnclosingClass();

围封类Thread.State是Thread.

public class MyClass {
    static Object o = new Object() { 
        public void m() {} 
    };
    static Class = o.getClass().getEnclosingClass();
}

定义的匿名类。o被MyClass.

检查类修饰符和类型

类可以使用影响其运行时行为的一个或多个修饰符声明：

  • 访问修饰符：public, protected，和private
  • 需要重写的修饰符：abstract
  • 仅限于一个实例的修饰符：static
  • 禁止修改价值的改性剂：final
  • 修饰符强制严格的浮点行为：strictfp
  • 注解

并非所有类都允许所有修饰符，例如，接口不能final一个枚举是不可能的abstract. java.lang.reflect.Modifier包含所有可能的修饰符的声明。它还包含方法，这些方法可用于解码由Class.getModifiers().

这，这个，那，那个ClassDeclarationSpy示例演示如何获取类的声明组件，包括修饰符、泛型类型参数、实现的接口和继承路径。自Class实现java.lang.reflect.AnnotatedElement接口也可以查询运行时注释。

import java.lang.annotation.Annotation;
import java.lang.reflect.Modifier;
import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.List;
import static java.lang.System.out;

public class ClassDeclarationSpy {
    public static void main(String... args) {
	try {
	    Class c = Class.forName(args[0]);
	    out.format("Class:%n  %s%n%n", c.getCanonicalName());
	    out.format("Modifiers:%n  %s%n%n",
		       Modifier.toString(c.getModifiers()));

	    out.format("Type Parameters:%n");
	    TypeVariable[] tv = c.getTypeParameters();
	    if (tv.length != 0) {
		out.format("  ");
		for (TypeVariable t : tv)
		    out.format("%s ", t.getName());
		out.format("%n%n");
	    } else {
		out.format("  -- No Type Parameters --%n%n");
	    }

	    out.format("Implemented Interfaces:%n");
	    Type[] intfs = c.getGenericInterfaces();
	    if (intfs.length != 0) {
		for (Type intf : intfs)
		    out.format("  %s%n", intf.toString());
		out.format("%n");
	    } else {
		out.format("  -- No Implemented Interfaces --%n%n");
	    }

	    out.format("Inheritance Path:%n");
	    List l = new ArrayList();
	    printAncestor(c, l);
	    if (l.size() != 0) {
		for (Class cl : l)
		    out.format("  %s%n", cl.getCanonicalName());
		out.format("%n");
	    } else {
		out.format("  -- No Super Classes --%n%n");
	    }

	    out.format("Annotations:%n");
	    Annotation[] ann = c.getAnnotations();
	    if (ann.length != 0) {
		for (Annotation a : ann)
		    out.format("  %s%n", a.toString());
		out.format("%n");
	    } else {
		out.format("  -- No Annotations --%n%n");
	    }

        // production code should handle this exception more gracefully
	} catch (ClassNotFoundException x) {
	    x.printStackTrace();
	}
    }

    private static void printAncestor(Class c, List l) {
	Class ancestor = c.getSuperclass();
 	if (ancestor != null) {
	    l.add(ancestor);
	    printAncestor(ancestor, l);
 	}
    }
}

输出的一些示例如下。用户输入以斜体表示。

$ java ClassDeclarationSpy java.util.concurrent.ConcurrentNavigableMap
Class:
  java.util.concurrent.ConcurrentNavigableMap

Modifiers:
  public abstract interface

Type Parameters:
  K V

Implemented Interfaces:
  java.util.concurrent.ConcurrentMap
  java.util.NavigableMap

Inheritance Path:
  -- No Super Classes --

Annotations:
  -- No Annotations --

这是java.util.concurrent.ConcurrentNavigableMap在源代码中：

public interface ConcurrentNavigableMap
    extends ConcurrentMap, NavigableMap

注意，由于这是一个接口，所以它是隐式的。abstract。编译器为每个接口添加此修饰符。此外，此声明包含两个泛型类型参数，K和V。示例代码只打印这些参数的名称，但是否可以使用java.lang.reflect.TypeVariable。接口还可以实现上面所示的其他接口。

$ java ClassDeclarationSpy "[Ljava.lang.String;"
Class:
  java.lang.String[]

Modifiers:
  public abstract final

Type Parameters:
  -- No Type Parameters --

Implemented Interfaces:
  interface java.lang.Cloneable
  interface java.io.Serializable

Inheritance Path:
  java.lang.Object

Annotations:
  -- No Annotations --

因为数组是运行时对象，所以所有类型信息都由Java虚拟机定义。特别是，数组实现Cloneable和java.io.Serializable他们的直接超类总是Object.

$ java ClassDeclarationSpy java.io.InterruptedIOException
Class:
  java.io.InterruptedIOException

Modifiers:
  public

Type Parameters:
  -- No Type Parameters --

Implemented Interfaces:
  -- No Implemented Interfaces --

Inheritance Path:
  java.io.IOException
  java.lang.Exception
  java.lang.Throwable
  java.lang.Object

Annotations:
  -- No Annotations --

从继承路径可以推断java.io.InterruptedIOException是选中的异常，因为RuntimeException不存在。

$ java ClassDeclarationSpy java.security.Identity
Class:
  java.security.Identity

Modifiers:
  public abstract

Type Parameters:
  -- No Type Parameters --

Implemented Interfaces:
  interface java.security.Principal
  interface java.io.Serializable

Inheritance Path:
  java.lang.Object

Annotations:
  @java.lang.Deprecated()

这个输出显示java.security.Identity，不推荐的api拥有注释。java.lang.Deprecated。反射代码可以使用这一点来检测不推荐的API。

注：并不是所有的注释都可以通过反射获得。只有那些有java.lang.annotation.RetentionPolicy的RUNTIME是可以接近的。语言中预定义的三个注释。@Deprecated, @Override，和@SuppressWarnings只@Deprecated在运行时可用。

发现类成员

中提供了两类方法。Class用于访问字段、方法和构造函数：枚举这些成员的方法和搜索特定成员的方法。此外，有不同的方法可以直接访问类上声明的成员，而不是在超接口和超类中搜索继承的成员。下表提供了所有成员定位方法及其特性的摘要。

 

字段定位的类方法
ClassAPI 成员名单？ 继承的成员？ 私人会员？
getDeclaredField() 否 否 是
getField() 否 是 否
getDeclaredFields() 是 否 是
getFields() 是 是 否

 

用于定位方法的类方法
ClassAPI 成员名单？ 继承的成员？ 私人会员？
getDeclaredMethod() 否 否 是
getMethod() 否 是 否
getDeclaredMethods() 是 否 是
getMethods() 是 是 否

 

构造函数定位的类方法
ClassAPI 成员名单？ 继承的成员？ 私人会员？
getDeclaredConstructor() 否 N/A1 是
getConstructor() 否 N/A1 否
getDeclaredConstructors() 是 N/A1 是
getConstructors() 是 N/A1 否

1构造函数不是继承的。

给定一个类名和哪个成员感兴趣的指示，ClassSpy示例使用get*s()方法确定所有公共元素的列表，包括继承的任何元素。

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Member;
import static java.lang.System.out;

enum ClassMember { CONSTRUCTOR, FIELD, METHOD, CLASS, ALL }

public class ClassSpy {
    public static void main(String... args) {
	try {
	    Class c = Class.forName(args[0]);
	    out.format("Class:%n  %s%n%n", c.getCanonicalName());

	    Package p = c.getPackage();
	    out.format("Package:%n  %s%n%n",
		       (p != null ? p.getName() : "-- No Package --"));

	    for (int i = 1; i < args.length; i++) {
		switch (ClassMember.valueOf(args[i])) {
		case CONSTRUCTOR:
		    printMembers(c.getConstructors(), "Constructor");
		    break;
		case FIELD:
		    printMembers(c.getFields(), "Fields");
		    break;
		case METHOD:
		    printMembers(c.getMethods(), "Methods");
		    break;
		case CLASS:
		    printClasses(c);
		    break;
		case ALL:
		    printMembers(c.getConstructors(), "Constuctors");
		    printMembers(c.getFields(), "Fields");
		    printMembers(c.getMethods(), "Methods");
		    printClasses(c);
		    break;
		default:
		    assert false;
		}
	    }

        // production code should handle these exceptions more gracefully
	} catch (ClassNotFoundException x) {
	    x.printStackTrace();
	}
    }

    private static void printMembers(Member[] mbrs, String s) {
	out.format("%s:%n", s);
	for (Member mbr : mbrs) {
	    if (mbr instanceof Field)
		out.format("  %s%n", ((Field)mbr).toGenericString());
	    else if (mbr instanceof Constructor)
		out.format("  %s%n", ((Constructor)mbr).toGenericString());
	    else if (mbr instanceof Method)
		out.format("  %s%n", ((Method)mbr).toGenericString());
	}
	if (mbrs.length == 0)
	    out.format("  -- No %s --%n", s);
	out.format("%n");
    }

    private static void printClasses(Class c) {
	out.format("Classes:%n");
	Class[] clss = c.getClasses();
	for (Class cls : clss)
	    out.format("  %s%n", cls.getCanonicalName());
	if (clss.length == 0)
	    out.format("  -- No member interfaces, classes, or enums --%n");
	out.format("%n");
    }
}

此示例相对紧凑；但是printMembers()方法稍微有些尴尬，因为java.lang.reflect.Member接口自最早的反射实现以来就已经存在，它不能被修改以包含更有用的接口。getGenericString()方法：引入仿制药。唯一的替代方法是测试和强制转换，如下图所示，将此方法替换为printConstructors(), printFields()，和printMethods()，或对相对较少的结果感到满意。Member.getName().

输出的样本及其解释如下。用户输入以斜体表示。

$ java ClassSpy java.lang.ClassCastException CONSTRUCTOR
Class:
  java.lang.ClassCastException

Package:
  java.lang

Constructor:
  public java.lang.ClassCastException()
  public java.lang.ClassCastException(java.lang.String)

由于构造函数不是继承的，所以异常链接机制构造函数(那些具有Throwable参数)，该参数是在直接超类中定义的。RuntimeException其他超类也找不到。

$ java ClassSpy java.nio.channels.ReadableByteChannel METHOD
Class:
  java.nio.channels.ReadableByteChannel

Package:
  java.nio.channels

Methods:
  public abstract int java.nio.channels.ReadableByteChannel.read
    (java.nio.ByteBuffer) throws java.io.IOException
  public abstract void java.nio.channels.Channel.close() throws
    java.io.IOException
  public abstract boolean java.nio.channels.Channel.isOpen()

接口java.nio.channels.ReadableByteChannel定义read()。其余的方法是从超级接口继承的。可以轻松地修改此代码，使其只列出实际在类中声明的方法，方法是get*s()带着getDeclared*s().

$ java ClassSpy ClassMember FIELD METHOD
Class:
  ClassMember

Package:
  -- No Package --

Fields:
  public static final ClassMember ClassMember.CONSTRUCTOR
  public static final ClassMember ClassMember.FIELD
  public static final ClassMember ClassMember.METHOD
  public static final ClassMember ClassMember.CLASS
  public static final ClassMember ClassMember.ALL

Methods:
  public static ClassMember ClassMember.valueOf(java.lang.String)
  public static ClassMember[] ClassMember.values()
  public final int java.lang.Enum.hashCode()
  public final int java.lang.Enum.compareTo(E)
  public int java.lang.Enum.compareTo(java.lang.Object)
  public final java.lang.String java.lang.Enum.name()
  public final boolean java.lang.Enum.equals(java.lang.Object)
  public java.lang.String java.lang.Enum.toString()
  public static  T java.lang.Enum.valueOf
    (java.lang.Class,java.lang.String)
  public final java.lang.Class java.lang.Enum.getDeclaringClass()
  public final int java.lang.Enum.ordinal()
  public final native java.lang.Class java.lang.Object.getClass()
  public final native void java.lang.Object.wait(long) throws
    java.lang.InterruptedException
  public final void java.lang.Object.wait(long,int) throws
    java.lang.InterruptedException
  public final void java.lang.Object.wait() hrows java.lang.InterruptedException
  public final native void java.lang.Object.notify()
  public final native void java.lang.Object.notifyAll()

在这些结果的字段部分，列出了枚举常数。虽然这些都是技术领域，但将它们与其他领域区分开来可能是有用的。此示例可修改为使用java.lang.reflect.Field.isEnumConstant()为了这个目的。这，这个，那，那个EnumSpy在这条线索的后面一节中，检查Enum，包含可能的实现。

在输出的“方法”部分中，注意到方法名称包括声明类的名称。因此，toString()方法由Enum，不是从Object。代码可以通过使用Field.getDeclaringClass()。下面的片段说明了潜在解决方案的一部分。

if (mbr instanceof Field) {
    Field f = (Field)mbr;
    out.format("  %s%n", f.toGenericString());
    out.format("  -- declared in: %s%n", f.getDeclaringClass());
}

故障排除

下面的示例显示了在对类进行反思时可能遇到的典型错误。

编译器警告：“注意：.使用未经检查或不安全的操作”

调用方法时，将检查参数值的类型，并可能对其进行转换。ClassWarning调用getMethod()若要导致典型的未选中转换警告，请执行以下操作：

import java.lang.reflect.Method;

public class ClassWarning {
    void m() {
	try {
	    Class c = ClassWarning.class;
	    Method m = c.getMethod("m");  // warning

        // production code should handle this exception more gracefully
	} catch (NoSuchMethodException x) {
    	    x.printStackTrace();
    	}
    }
}
$ javac ClassWarning.java
Note: ClassWarning.java uses unchecked or unsafe operations.
Note: Recompile with -Xlint:unchecked for details.
$ javac -Xlint:unchecked ClassWarning.java
ClassWarning.java:6: warning: [unchecked] unchecked call to getMethod
  (String,Class...) as a member of the raw type Class
Method m = c.getMethod("m");  // warning
                      ^
1 warning

许多库方法都经过了泛型声明的修改，其中包括Class。自c被声明为生类型(没有类型参数)和相应的getMethod()是参数化类型，则会发生未经检查的转换。编译器需要生成警告。(见Java语言规范，JavaSE 7版、分段未检查转换和方法调用转换.)

有两种可能的解决办法。的声明修改得越好。c若要包含适当的泛型类型，请执行以下操作。在这种情况下，声明应是：

Class c = warn.getClass();

或者，可以使用预定义的注释显式地抑制警告。@SuppressWarnings在有问题的语句之前。

Class c = ClassWarning.class;
@SuppressWarnings("unchecked")
Method m = c.getMethod("m");  
// warning gone

提示：作为一般原则，警告不应被忽略，因为它们可能表明存在bug。应酌情使用参数化声明。如果这是不可能的(可能是因为应用程序必须与库供应商的代码交互)，则使用@SuppressWarnings.

当构造器不可访问时引发InstantiationException。

Class.newInstance()抛出InstantiationException如果尝试创建类的新实例，而零参数构造函数是不可见的。这，这个，那，那个ClassTrouble示例说明了结果堆栈跟踪。

class Cls {
    private Cls() {}
}

public class ClassTrouble {
    public static void main(String... args) {
	try {
	    Class c = Class.forName("Cls");
	    c.newInstance();  // InstantiationException

        // production code should handle these exceptions more gracefully
	} catch (InstantiationException x) {
	    x.printStackTrace();
	} catch (IllegalAccessException x) {
	    x.printStackTrace();
	} catch (ClassNotFoundException x) {
	    x.printStackTrace();
	}
    }
}
$ java ClassTrouble
java.lang.IllegalAccessException: Class ClassTrouble can not access a member of
  class Cls with modifiers "private"
        at sun.reflect.Reflection.ensureMemberAccess(Reflection.java:65)
        at java.lang.Class.newInstance0(Class.java:349)
        at java.lang.Class.newInstance(Class.java:308)
        at ClassTrouble.main(ClassTrouble.java:9)

Class.newInstance()行为非常类似于new关键字，并将基于相同的原因失败。new都会失败。反射中的典型解决方案是利用java.lang.reflect.AccessibleObject类，它提供了抑制访问控制检查的能力；但是，此方法将无法工作，因为java.lang.Class不扩展AccessibleObject。唯一的解决方案是修改要使用的代码。Constructor.newInstance()它确实扩展了AccessibleObject.

提示：一般来说，最好使用Constructor.newInstance()中描述的原因创建新类实例部分成员教训。

使用的潜在问题的附加示例Constructor.newInstance()可以在构造器故障排除的一节成员教训。

 

反射定义接口java.lang.reflect.Member它由java.lang.reflect.Field, java.lang.reflect.Method，和java.lang.reflect.Constructor。这些对象将在本课中讨论。对于每个成员，本课程将描述用于检索声明和类型信息的相关API、成员特有的任何操作(例如，设置字段的值或调用方法)，以及常见的错误。每个概念都将用代码示例和相关输出来说明，这些输出与一些预期的反射用途大致相同。

注：根据Java语言规范，JavaSE 7版，成员类的继承组件，包括字段、方法、嵌套类、接口和枚举类型。因为构造函数不是继承的，所以它们不是成员。的实现类不同。java.lang.reflect.Member.

字段

字段有类型和值。这，这个，那，那个java.lang.reflect.Field类提供用于访问类型信息以及设置和获取给定对象上字段的值的方法。

  • 获取字段类型描述如何获取字段的声明类型和泛型类型。
  • 字段修饰符的检索与解析演示如何获取字段声明的某些部分，如public或transient
  • 获取和设置字段值说明如何访问字段值。
  • 故障排除描述一些可能导致混淆的常见编码错误。

方法

方法具有返回值、参数，并可能引发异常。这，这个，那，那个java.lang.reflect.Method类提供用于获取参数和返回值的类型信息的方法。它还可以用于调用给定对象上的方法。

  • 获取方法类型信息演示如何枚举类中声明的方法并获取类型信息。
  • 获取方法参数的名称演示如何检索方法或构造函数参数的名称和其他信息。
  • 检索和解析方法修饰符描述如何访问和解码修饰符以及与该方法关联的其他信息。
  • 调用方法说明如何执行方法并获取其返回值。
  • 故障排除介绍在查找或调用方法时遇到的常见错误。

构造函数

构造函数的反射api定义在java.lang.reflect.Constructor与方法类似，只有两个主要的例外：第一，构造函数没有返回值；第二，构造函数的调用为给定类创建对象的新实例。

  • 寻找构造器说明如何检索具有特定参数的构造函数。
  • 检索和解析构造修饰符演示如何获取构造函数声明的修饰符和有关构造函数的其他信息。
  • 创建新类实例演示如何通过调用对象的构造函数来实例化对象的实例。
  • 故障排除描述在查找或调用构造函数时可能遇到的常见错误。

 

域

场域是具有关联值的类、接口或枚举。方法java.lang.reflect.Field类可以检索有关该字段的信息，如其名称、类型、修饰符和注释。(该款检查类修饰符和类型在.。班课程描述了如何检索注释。)还有一些方法可以动态访问和修改字段的值。这些任务将在以下章节中讨论：

  • 获取字段类型描述如何获取字段的声明类型和泛型类型。
  • 字段修饰符的检索与解析演示如何获取字段声明的某些部分，如public或transient
  • 获取和设置字段值说明如何访问字段值。
  • 故障排除描述一些可能导致混淆的常见编码错误。

在编写应用程序(如类浏览器)时，找出哪些字段属于特定类可能是有用的。类的字段通过调用Class.getFields()。这，这个，那，那个getFields()方法返回一个Field对象，每个可访问的公共字段包含一个对象。

如果公共字段是下列任一项的成员，则可访问该公共字段：

  • 这个班
  • 这类的超级阶级
  • 由该类实现的接口。
  • 从该类实现的接口扩展而来的接口。

字段可以是类(实例)字段，如java.io.Reader.lock，静态字段，如java.lang.Integer.MAX_VALUE，或枚举常量，如java.lang.Thread.State.WAITING.

 

获取字段类型

字段可以是原始类型的，也可以是引用类型的。有八种原始类型：boolean, byte, short, int, long, char, float，和double。的直接或间接子类。java.lang.Object包括接口、数组和枚举类型。

这，这个，那，那个FieldSpy示例打印给定完全限定的二进制类名和字段名的字段的类型和泛型类型。

import java.lang.reflect.Field;
import java.util.List;

public class FieldSpy {
    public boolean[][] b = {{ false, false }, { true, true } };
    public String name  = "Alice";
    public List list;
    public T val;

    public static void main(String... args) {
	try {
	    Class c = Class.forName(args[0]);
	    Field f = c.getField(args[1]);
	    System.out.format("Type: %s%n", f.getType());
	    System.out.format("GenericType: %s%n", f.getGenericType());

        // production code should handle these exceptions more gracefully
	} catch (ClassNotFoundException x) {
	    x.printStackTrace();
	} catch (NoSuchFieldException x) {
	    x.printStackTrace();
	}
    }
}

获取该类中三个公共字段的类型的示例输出(b, name，和参数化类型list)，如下。用户输入以斜体表示。

$ java FieldSpy FieldSpy b
Type: class [[Z
GenericType: class [[Z
$ java FieldSpy FieldSpy name
Type: class java.lang.String
GenericType: class java.lang.String
$ java FieldSpy FieldSpy list
Type: interface java.util.List
GenericType: java.util.List
$ java FieldSpy FieldSpy val
Type: class java.lang.Object
GenericType: T

字段的类型。b是二维布尔数组。类型名称的语法将在Class.getName().

字段的类型。val报告为java.lang.Object因为泛型是通过类型擦除它删除编译期间有关泛型类型的所有信息。因此T被类型变量的上限替换，在这种情况下，java.lang.Object.

Field.getGenericType()将咨询类文件中的签名属性(如果存在的话)。如果该属性不可用，则返回Field.getType()这并没有因为仿制药的引入而改变。在反射中使用名称的其他方法getGenericFoo有价值的，有价值的福都以类似的方式实现。

 

字段修饰符的检索与解析

有几个修饰符可能是字段声明的一部分：

  • 访问修饰符：public, protected，和private
  • 控制运行时行为的特定字段修饰符：transient和volatile
  • 仅限于一个实例的修饰符：static
  • 禁止修改价值的改性剂：final
  • 注解

方法Field.getModifiers()可用于返回表示该字段的声明修饰符集的整数。表示此整数中的修饰符的位是在java.lang.reflect.Modifier.

这，这个，那，那个FieldModifierSpy示例说明如何使用给定修饰符搜索字段。它还通过调用来确定定位字段是合成的(编译器生成的)还是枚举常量。Field.isSynthetic()和Field.isEnumCostant()分别。

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import static java.lang.System.out;

enum Spy { BLACK , WHITE }

public class FieldModifierSpy {
    volatile int share;
    int instance;
    class Inner {}

    public static void main(String... args) {
	try {
	    Class c = Class.forName(args[0]);
	    int searchMods = 0x0;
	    for (int i = 1; i < args.length; i++) {
		searchMods |= modifierFromString(args[i]);
	    }

	    Field[] flds = c.getDeclaredFields();
	    out.format("Fields in Class '%s' containing modifiers:  %s%n",
		       c.getName(),
		       Modifier.toString(searchMods));
	    boolean found = false;
	    for (Field f : flds) {
		int foundMods = f.getModifiers();
		// Require all of the requested modifiers to be present
		if ((foundMods & searchMods) == searchMods) {
		    out.format("%-8s [ synthetic=%-5b enum_constant=%-5b ]%n",
			       f.getName(), f.isSynthetic(),
			       f.isEnumConstant());
		    found = true;
		}
	    }

	    if (!found) {
		out.format("No matching fields%n");
	    }

        // production code should handle this exception more gracefully
	} catch (ClassNotFoundException x) {
	    x.printStackTrace();
	}
    }

    private static int modifierFromString(String s) {
	int m = 0x0;
	if ("public".equals(s))           m |= Modifier.PUBLIC;
	else if ("protected".equals(s))   m |= Modifier.PROTECTED;
	else if ("private".equals(s))     m |= Modifier.PRIVATE;
	else if ("static".equals(s))      m |= Modifier.STATIC;
	else if ("final".equals(s))       m |= Modifier.FINAL;
	else if ("transient".equals(s))   m |= Modifier.TRANSIENT;
	else if ("volatile".equals(s))    m |= Modifier.VOLATILE;
	return m;
    }
}

样本输出如下：

$ java FieldModifierSpy FieldModifierSpy volatile
Fields in Class 'FieldModifierSpy' containing modifiers:  volatile
share    [ synthetic=false enum_constant=false ]

$ java FieldModifierSpy Spy public
Fields in Class 'Spy' containing modifiers:  public
BLACK    [ synthetic=false enum_constant=true  ]
WHITE    [ synthetic=false enum_constant=true  ]

$ java FieldModifierSpy FieldModifierSpy\$Inner final
Fields in Class 'FieldModifierSpy$Inner' containing modifiers:  final
this$0   [ synthetic=true  enum_constant=false ]

$ java FieldModifierSpy Spy private static final
Fields in Class 'Spy' containing modifiers:  private static final
$VALUES  [ synthetic=true  enum_constant=false ]

请注意，即使未在原始代码中声明某些字段，也会报告它们。这是因为编译器将生成一些合成场它们在运行时是需要的。要测试字段是否是合成的，示例调用Field.isSynthetic()。合成字段集依赖于编译器；但是常用的字段包括this$0对于内部类(即不是静态成员类的嵌套类)，可以引用最外层的封闭类和$VALUES枚举用于实现隐式定义的静态方法。values()。合成类成员的名称未指定，在所有编译器实现或发行版中也可能不相同。这些和其他合成字段将包含在由Class.getDeclaredFields()但没有被Class.getField()因为合成成员通常不是public.

因为Field实现接口java.lang.reflect.AnnotatedElement，则可以使用以下方法检索任何运行时注释java.lang.annotation.RetentionPolicy.RUNTIME。有关获取注释的示例，请参见检查类修饰符和类型.

 

获取和设置字段值

给定类的实例，可以使用反射设置该类中字段的值。通常只有在不可能以通常方式设置值的特殊情况下才会这样做。因为这种访问通常违反类的设计意图，所以使用时应该非常谨慎。

这，这个，那，那个Book类说明如何为long、Array和enum字段类型设置值。获取和设置其他基本类型的方法将在Field.

import java.lang.reflect.Field;
import java.util.Arrays;
import static java.lang.System.out;

enum Tweedle { DEE, DUM }

public class Book {
    public long chapters = 0;
    public String[] characters = { "Alice", "White Rabbit" };
    public Tweedle twin = Tweedle.DEE;

    public static void main(String... args) {
	Book book = new Book();
	String fmt = "%6S:  %-12s = %s%n";

	try {
	    Class c = book.getClass();

	    Field chap = c.getDeclaredField("chapters");
	    out.format(fmt, "before", "chapters", book.chapters);
  	    chap.setLong(book, 12);
	    out.format(fmt, "after", "chapters", chap.getLong(book));

	    Field chars = c.getDeclaredField("characters");
	    out.format(fmt, "before", "characters",
		       Arrays.asList(book.characters));
	    String[] newChars = { "Queen", "King" };
	    chars.set(book, newChars);
	    out.format(fmt, "after", "characters",
		       Arrays.asList(book.characters));

	    Field t = c.getDeclaredField("twin");
	    out.format(fmt, "before", "twin", book.twin);
	    t.set(book, Tweedle.DUM);
	    out.format(fmt, "after", "twin", t.get(book));

        // production code should handle these exceptions more gracefully
	} catch (NoSuchFieldException x) {
	    x.printStackTrace();
	} catch (IllegalAccessException x) {
	    x.printStackTrace();
	}
    }
}

这是相应的输出：

$ java Book
BEFORE:  chapters     = 0
 AFTER:  chapters     = 12
BEFORE:  characters   = [Alice, White Rabbit]
 AFTER:  characters   = [Queen, King]
BEFORE:  twin         = DEE
 AFTER:  twin         = DUM

注：通过反射设置字段的值具有一定的性能开销，因为必须执行各种操作，例如验证访问权限。从运行时的角度来看，效果是相同的，操作就像在类代码中直接更改了值一样是原子的。

使用反射会导致某些运行时优化丢失。例如，以下代码很可能是由Java虚拟机优化的：

int x = 1;
x = 2;
x = 3;

等效代码Field.set*()也许不会。

故障排除

下面是开发人员遇到的几个常见问题，并解释了为什么会发生这种情况，以及如何解决这些问题。

因不可转换类型而引发的IllegalArgumentException

这，这个，那，那个FieldTrouble示例将生成一个IllegalArgumentException. Field.setInt()调用以设置引用类型的字段。Integer具有基元类型的值。在非反射等价物中Integer val = 42，编译器将转换(或盒、箱（子）)原语类型42引用类型为new Integer(42)以便其类型检查将接受该语句。当使用反射时，类型检查只在运行时进行，因此没有机会将值框起来。

import java.lang.reflect.Field;

public class FieldTrouble {
    public Integer val;

    public static void main(String... args) {
	FieldTrouble ft = new FieldTrouble();
	try {
	    Class c = ft.getClass();
	    Field f = c.getDeclaredField("val");
  	    f.setInt(ft, 42);               // IllegalArgumentException

        // production code should handle these exceptions more gracefully
	} catch (NoSuchFieldException x) {
	    x.printStackTrace();
 	} catch (IllegalAccessException x) {
 	    x.printStackTrace();
	}
    }
}
$ java FieldTrouble
Exception in thread "main" java.lang.IllegalArgumentException: Can not set
  java.lang.Object field FieldTrouble.val to (long)42
        at sun.reflect.UnsafeFieldAccessorImpl.throwSetIllegalArgumentException
          (UnsafeFieldAccessorImpl.java:146)
        at sun.reflect.UnsafeFieldAccessorImpl.throwSetIllegalArgumentException
          (UnsafeFieldAccessorImpl.java:174)
        at sun.reflect.UnsafeObjectFieldAccessorImpl.setLong
          (UnsafeObjectFieldAccessorImpl.java:102)
        at java.lang.reflect.Field.setLong(Field.java:831)
        at FieldTrouble.main(FieldTrouble.java:11)

若要消除此异常，应将有问题的行替换为Field.set(Object obj, Object value):

f.set(ft, new Integer(43));

提示：当使用反射设置或获取字段时，编译器没有机会执行装箱操作。的规范所描述的关联类型。Class.isAssignableFrom()。该示例预计将失败，因为isAssignableFrom()会回来false在此测试中，可以编程方式使用该测试来验证是否可以进行特定的转换：

Integer.class.isAssignableFrom(int.class) == false

同样，从原语到引用类型的自动转换在反射中也是不可能的。

int.class.isAssignableFrom(Integer.class) == false

非公共字段的NoSuchFieldException

精明的读者可能会注意到，如果FieldSpy前面显示的示例用于获取非公共字段的信息，它将失败：

$ java FieldSpy java.lang.String count
java.lang.NoSuchFieldException: count
        at java.lang.Class.getField(Class.java:1519)
        at FieldSpy.main(FieldSpy.java:12)

提示：这，这个，那，那个Class.getField()和Class.getFields()方法返回公众类、枚举或接口的成员字段。Class对象。中声明(但未继承)的所有字段。Class，使用Class.getDeclaredFields()方法。

修改最终字段时抛出IllegalAccessException

阿IllegalAccessException如果尝试获取或设置private或以其他方式无法访问字段或设置final字段(不管其访问修饰符如何)。

这，这个，那，那个FieldTroubleToo示例说明了试图设置最终字段所导致的堆栈跟踪的类型。

import java.lang.reflect.Field;

public class FieldTroubleToo {
    public final boolean b = true;

    public static void main(String... args) {
	FieldTroubleToo ft = new FieldTroubleToo();
	try {
	    Class c = ft.getClass();
	    Field f = c.getDeclaredField("b");
// 	    f.setAccessible(true);  // solution
	    f.setBoolean(ft, Boolean.FALSE);   // IllegalAccessException

        // production code should handle these exceptions more gracefully
	} catch (NoSuchFieldException x) {
	    x.printStackTrace();
	} catch (IllegalArgumentException x) {
	    x.printStackTrace();
	} catch (IllegalAccessException x) {
	    x.printStackTrace();
	}
    }
}
$ java FieldTroubleToo
java.lang.IllegalAccessException: Can not set final boolean field
  FieldTroubleToo.b to (boolean)false
        at sun.reflect.UnsafeFieldAccessorImpl.
          throwFinalFieldIllegalAccessException(UnsafeFieldAccessorImpl.java:55)
        at sun.reflect.UnsafeFieldAccessorImpl.
          throwFinalFieldIllegalAccessException(UnsafeFieldAccessorImpl.java:63)
        at sun.reflect.UnsafeQualifiedBooleanFieldAccessorImpl.setBoolean
          (UnsafeQualifiedBooleanFieldAccessorImpl.java:78)
        at java.lang.reflect.Field.setBoolean(Field.java:686)
        at FieldTroubleToo.main(FieldTroubleToo.java:12)

提示：存在访问限制，以防止final在类初始化后设置字段。然而，Field被声明为扩展AccessibleObject它提供了抑制此检查的能力。

如果AccessibleObject.setAccessible()成功，则对此字段值的后续操作不会失败。这可能会产生意想不到的副作用；例如，有时应用程序的某些部分将继续使用原始值，即使该值已被修改。AccessibleObject.setAccessible()只有在安全上下文允许操作时才能成功。

 

方法

A 方法包含可被调用的可执行代码。方法是继承的，在非反射代码中，诸如重载、重写和隐藏等行为由编译器强制执行。相反，反射代码可以将方法选择限制在特定的类中，而不考虑它的超类。可以访问超类方法，但可以确定它们的声明类；这是不可能在没有反射的情况下以编程方式发现的，并且是许多细微错误的来源。

这，这个，那，那个java.lang.reflect.Method类提供API来访问有关方法的修饰符、返回类型、参数、注释和抛出异常的信息。它还用于调用方法。以下各节将讨论这些主题：

  • 获取方法类型信息演示如何枚举类中声明的方法并获取类型信息。
  • 获取方法参数的名称演示如何检索方法或构造函数参数的名称和其他信息。
  • 检索和解析方法修饰符描述如何访问和解码修饰符以及与该方法关联的其他信息。
  • 调用方法说明如何执行方法并获取其返回值。
  • 故障排除介绍在查找或调用方法时遇到的常见错误。

获取方法类型信息

方法声明包括名称、修饰符、参数、返回类型和可抛异常列表。这，这个，那，那个java.lang.reflect.Method类提供了获取此信息的方法。

这，这个，那，那个MethodSpy示例说明如何枚举给定类中所有声明的方法，并检索给定名称的所有方法的返回、参数和异常类型。

import java.lang.reflect.Method;
import java.lang.reflect.Type;
import static java.lang.System.out;

public class MethodSpy {
    private static final String  fmt = "%24s: %s%n";

    // for the morbidly curious
     void genericThrow() throws E {}

    public static void main(String... args) {
	try {
	    Class c = Class.forName(args[0]);
	    Method[] allMethods = c.getDeclaredMethods();
	    for (Method m : allMethods) {
		if (!m.getName().equals(args[1])) {
		    continue;
		}
		out.format("%s%n", m.toGenericString());

		out.format(fmt, "ReturnType", m.getReturnType());
		out.format(fmt, "GenericReturnType", m.getGenericReturnType());

		Class[] pType  = m.getParameterTypes();
		Type[] gpType = m.getGenericParameterTypes();
		for (int i = 0; i < pType.length; i++) {
		    out.format(fmt,"ParameterType", pType[i]);
		    out.format(fmt,"GenericParameterType", gpType[i]);
		}

		Class[] xType  = m.getExceptionTypes();
		Type[] gxType = m.getGenericExceptionTypes();
		for (int i = 0; i < xType.length; i++) {
		    out.format(fmt,"ExceptionType", xType[i]);
		    out.format(fmt,"GenericExceptionType", gxType[i]);
		}
	    }

        // production code should handle these exceptions more gracefully
	} catch (ClassNotFoundException x) {
	    x.printStackTrace();
	}
    }
}

这是输出Class.getConstructor()它是一个具有参数化类型和可变参数的方法的示例。

$ java MethodSpy java.lang.Class getConstructor
public java.lang.reflect.Constructor java.lang.Class.getConstructor
  (java.lang.Class[]) throws java.lang.NoSuchMethodException,
  java.lang.SecurityException
              ReturnType: class java.lang.reflect.Constructor
       GenericReturnType: java.lang.reflect.Constructor
           ParameterType: class [Ljava.lang.Class;
    GenericParameterType: java.lang.Class[]
           ExceptionType: class java.lang.NoSuchMethodException
    GenericExceptionType: class java.lang.NoSuchMethodException
           ExceptionType: class java.lang.SecurityException
    GenericExceptionType: class java.lang.SecurityException

这是源代码中方法的实际声明：

public Constructor getConstructor(Class... parameterTypes)

首先，请注意返回类型和参数类型是泛型的。Method.getGenericReturnType()将咨询类文件中的签名属性(如果存在的话)。如果该属性不可用，则返回Method.getReturnType()这并没有因为仿制药的引入而改变。其他有名称的方法getGenericFoo()有价值的，有价值的福在反射中实现类似的。

接下来，注意最后一个(也是唯一的)参数，parameterType类型的变量(有可变的参数)。java.lang.Class。它表示为类型的一维数组。java.lang.Class。可以将其与显式地表示为java.lang.Class通过调用Method.isVarArgs()。的返回值的语法。Method.get*Types()在Class.getName().

下面的示例说明具有泛型返回类型的方法。

$ java MethodSpy java.lang.Class cast
public T java.lang.Class.cast(java.lang.Object)
              ReturnType: class java.lang.Object
       GenericReturnType: T
           ParameterType: class java.lang.Object
    GenericParameterType: class java.lang.Object

方法的泛型返回类型。Class.cast()报告为java.lang.Object因为泛型是通过类型擦除它删除编译期间有关泛型类型的所有信息。擦除T的声明所定义的Class:

public final class Class implements ...

因此T被类型变量的上限替换，在这种情况下，java.lang.Object.

最后一个示例说明了具有多个重载的方法的输出。

$ java MethodSpy java.io.PrintStream format
public java.io.PrintStream java.io.PrintStream.format
  (java.util.Locale,java.lang.String,java.lang.Object[])
              ReturnType: class java.io.PrintStream
       GenericReturnType: class java.io.PrintStream
           ParameterType: class java.util.Locale
    GenericParameterType: class java.util.Locale
           ParameterType: class java.lang.String
    GenericParameterType: class java.lang.String
           ParameterType: class [Ljava.lang.Object;
    GenericParameterType: class [Ljava.lang.Object;
public java.io.PrintStream java.io.PrintStream.format
  (java.lang.String,java.lang.Object[])
              ReturnType: class java.io.PrintStream
       GenericReturnType: class java.io.PrintStream
           ParameterType: class java.lang.String
    GenericParameterType: class java.lang.String
           ParameterType: class [Ljava.lang.Object;
    GenericParameterType: class [Ljava.lang.Object;

如果发现多个相同方法名称的重载，则它们都将由Class.getDeclaredMethods()。自format()有两个重载(Locale而其中一个没有)，两者都由MethodSpy.

注： Method.getGenericExceptionTypes()之所以存在，是因为实际上可以声明具有泛型异常类型的方法。但是，这很少被使用，因为不可能捕获泛型异常类型。

获取方法参数的名称

您可以使用该方法获取任何方法或构造函数的形式参数的名称。java.lang.reflect.Executable.getParameters。(班级)Method和Constructor扩展类Executable从而继承该方法Executable.getParameters)然而，.class默认情况下，文件不存储正式参数名称。这是因为许多生成和使用类文件的工具可能不会期望使用更大的静态和动态占用空间。.class包含参数名称的文件。特别是，这些工具必须处理更大的.class文件和Java虚拟机(JVM)将使用更多的内存。此外，一些参数名称，如secret或password，则可能公开有关安全敏感方法的信息。

将形式参数名称存储在特定的.class文件，从而使反射API能够检索形式参数名称，则使用-parameters选项的javac编译器。

这，这个，那，那个MethodParameterSpy示例说明了如何检索给定类的所有构造函数和方法的形式参数的名称。该示例还打印有关每个参数的其他信息。

下面的命令打印构造函数的形式参数名称和类的方法ExampleMethods. 注*请记住编译示例ExampleMethods带着-parameters编译器选项：

java MethodParameterSpy ExampleMethods

此命令打印以下内容：

Number of constructors: 1

Constructor #1
public ExampleMethods()

Number of declared constructors: 1

Declared constructor #1
public ExampleMethods()

Number of methods: 4

Method #1
public boolean ExampleMethods.simpleMethod(java.lang.String,int)
             Return type: boolean
     Generic return type: boolean
         Parameter class: class java.lang.String
          Parameter name: stringParam
               Modifiers: 0
            Is implicit?: false
        Is name present?: true
           Is synthetic?: false
         Parameter class: int
          Parameter name: intParam
               Modifiers: 0
            Is implicit?: false
        Is name present?: true
           Is synthetic?: false

Method #2
public int ExampleMethods.varArgsMethod(java.lang.String...)
             Return type: int
     Generic return type: int
         Parameter class: class [Ljava.lang.String;
          Parameter name: manyStrings
               Modifiers: 0
            Is implicit?: false
        Is name present?: true
           Is synthetic?: false

Method #3
public boolean ExampleMethods.methodWithList(java.util.List)
             Return type: boolean
     Generic return type: boolean
         Parameter class: interface java.util.List
          Parameter name: listParam
               Modifiers: 0
            Is implicit?: false
        Is name present?: true
           Is synthetic?: false

Method #4
public  void ExampleMethods.genericMethod(T[],java.util.Collection)
             Return type: void
     Generic return type: void
         Parameter class: class [Ljava.lang.Object;
          Parameter name: a
               Modifiers: 0
            Is implicit?: false
        Is name present?: true
           Is synthetic?: false
         Parameter class: interface java.util.Collection
          Parameter name: c
               Modifiers: 0
            Is implicit?: false
        Is name present?: true
           Is synthetic?: false

这，这个，那，那个MethodParameterSpy示例中的Parameter班级：

  • getType*返回Class对象，该对象标识参数的声明类型。

  • getName：返回参数的名称。如果存在参数的名称，则此方法将返回.class档案。否则，此方法将合成窗体的名称。argN，在哪里N声明参数的方法的描述符中参数的索引。

    例如，假设您编译了类ExampleMethods而不指定-parameters编译器选项。例子MethodParameterSpy将为该方法打印以下内容ExampleMethods.simpleMethod:

    public boolean ExampleMethods.simpleMethod(java.lang.String,int)
             Return type: boolean
     Generic return type: boolean
         Parameter class: class java.lang.String
          Parameter name: arg0
               Modifiers: 0
            Is implicit?: false
        Is name present?: false
           Is synthetic?: false
         Parameter class: int
          Parameter name: arg1
               Modifiers: 0
            Is implicit?: false
        Is name present?: false
           Is synthetic?: false

  • getModifiers：返回一个整数，该整数表示形式参数所具有的各种特征。如果适用于形式参数，此值是下列值的之和：

    值(小数) 值(以十六进制为单位) 描述
    16 0x0010 形式参数声明final
    4096 0x1000 形式参数是合成的。或者，您可以调用该方法。isSynthetic.
    32768 0x8000 该参数在源代码中隐式声明。或者，您可以调用该方法。isImplicit

  • isImplicit*回返true如果此参数是在源代码中隐式声明的。见本节隐式和综合参数想了解更多信息。

  • isNamePresent*回返true如果参数有一个名称，则根据.class档案。

  • isSynthetic*回返true如果该参数既不是隐式的，也不是在源代码中显式声明的。见本节隐式和综合参数想了解更多信息。

隐式和综合参数

如果没有显式编写某些构造，则在源代码中隐式声明它们。例如，ExampleMethods示例不包含构造函数。默认构造函数被隐式声明。这，这个，那，那个MethodParameterSpy的隐式声明构造函数的信息。ExampleMethods:

Number of declared constructors: 1
public ExampleMethods()

请考虑以下摘录MethodParameterExamples:

public class MethodParameterExamples {
    public class InnerClass { }
}

全班InnerClass是非静态的嵌套类或者内在阶级。内部类的构造函数也被隐式声明。但是，此构造函数将包含一个参数。当Java编译器编译InnerClass，它创建了一个.class表示类似于以下代码的文件：

public class MethodParameterExamples {
    public class InnerClass {
        final MethodParameterExamples parent;
        InnerClass(final MethodParameterExamples this$0) {
            parent = this$0; 
        }
    }
}

这，这个，那，那个InnerClass构造函数包含一个参数，其类型是括起来的类。InnerClass，也就是MethodParameterExamples。因此，这个例子MethodParameterExamples印刷如下：

public MethodParameterExamples$InnerClass(MethodParameterExamples)
         Parameter class: class MethodParameterExamples
          Parameter name: this$0
               Modifiers: 32784
            Is implicit?: true
        Is name present?: true
           Is synthetic?: false

因为类的构造函数InnerClass是隐式声明的，其参数也是隐式的。

注:

  • Java编译器为内部类的构造函数创建一个正式参数，以使编译器能够将一个引用(表示立即包围的实例)从创建表达式传递给成员类的构造函数。
  • 值32784表示InnerClass构造函数既是最终构造函数(16)，也是隐式构造函数(32768)。
  • Java编程语言允许带有美元符号的变量名($)；但是，按照惯例，美元符号不用于变量名称。

Java编译器发出的构造标记为合成如果它们不对应于源代码中显式或隐式声明的构造，除非它们是类初始化方法。合成构造是由编译器生成的工件，在不同的实现中各不相同。请考虑以下摘录MethodParameterExamples:

public class MethodParameterExamples {
    enum Colors {
        RED, WHITE;
    }
}

当Java编译器遇到enum构造时，它创建了几个与.class文件结构，并提供enum构造。例如，Java编译器将创建一个.class的文件enum构造Colors表示类似于以下代码的代码：

final class Colors extends java.lang.Enum {
    public final static Colors RED = new Colors("RED", 0);
    public final static Colors BLUE = new Colors("WHITE", 1);
 
    private final static values = new Colors[]{ RED, BLUE };
 
    private Colors(String name, int ordinal) {
        super(name, ordinal);
    }
 
    public static Colors[] values(){
        return values;
    }
 
    public static Colors valueOf(String name){
        return (Colors)java.lang.Enum.valueOf(Colors.class, name);
    }
}

Java编译器为此创建三个构造函数和方法。enum建造：Colors(String name, int ordinal), Colors[] values()，和Colors valueOf(String name)。方法values和valueOf被隐式宣布。因此，它们的形式参数名称也被隐式声明。

这，这个，那，那个enum构造器Colors(String name, int ordinal)是默认构造函数，并被隐式声明。但是，此构造函数的形式参数(name和ordinal)是不含蓄地宣布。因为这些形式参数既不是显式的，也不是隐式的，所以它们是合成的。的默认构造函数的形式参数。enum构造没有被隐式声明，因为不同的编译器不需要就这个构造函数的形式达成一致；另一个Java编译器可能会为它指定不同的形式参数。编译器编译使用enum常量，它们仅依赖于enum构造，它是隐式声明的，而不是它们的构造函数或这些常量是如何初始化的。)

因此，这个例子MethodParameterExample打印有关enum构造Colors:

enum Colors:

Number of constructors: 0

Number of declared constructors: 1

Declared constructor #1
private MethodParameterExamples$Colors()
         Parameter class: class java.lang.String
          Parameter name: $enum$name
               Modifiers: 4096
            Is implicit?: false
        Is name present?: true
           Is synthetic?: true
         Parameter class: int
          Parameter name: $enum$ordinal
               Modifiers: 4096
            Is implicit?: false
        Is name present?: true
           Is synthetic?: true

Number of methods: 2

Method #1
public static MethodParameterExamples$Colors[]
    MethodParameterExamples$Colors.values()
             Return type: class [LMethodParameterExamples$Colors;
     Generic return type: class [LMethodParameterExamples$Colors;

Method #2
public static MethodParameterExamples$Colors
    MethodParameterExamples$Colors.valueOf(java.lang.String)
             Return type: class MethodParameterExamples$Colors
     Generic return type: class MethodParameterExamples$Colors
         Parameter class: class java.lang.String
          Parameter name: name
               Modifiers: 32768
            Is implicit?: true
        Is name present?: true
           Is synthetic?: false

 

检索和解析方法修饰符

有几个修饰符可能是方法声明的一部分：

  • 访问修饰符：public, protected，和private
  • 仅限于一个实例的修饰符：static
  • 禁止修改价值的改性剂：final
  • 需要重写的修饰符：abstract
  • 防止重入的改性剂：synchronized
  • 用另一种编程语言表示实现的修饰符：native
  • 修饰符强制严格的浮点行为：strictfp
  • 注解

这，这个，那，那个MethodModifierSpy示例列出具有给定名称的方法的修饰符。它还显示该方法是合成的(编译器生成的)、变量性的，还是桥方法(编译器生成的以支持通用接口)。

import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import static java.lang.System.out;

public class MethodModifierSpy {

    private static int count;
    private static synchronized void inc() { count++; }
    private static synchronized int cnt() { return count; }

    public static void main(String... args) {
	try {
	    Class c = Class.forName(args[0]);
	    Method[] allMethods = c.getDeclaredMethods();
	    for (Method m : allMethods) {
		if (!m.getName().equals(args[1])) {
		    continue;
		}
		out.format("%s%n", m.toGenericString());
		out.format("  Modifiers:  %s%n",
			   Modifier.toString(m.getModifiers()));
		out.format("  [ synthetic=%-5b var_args=%-5b bridge=%-5b ]%n",
			   m.isSynthetic(), m.isVarArgs(), m.isBridge());
		inc();
	    }
	    out.format("%d matching overload%s found%n", cnt(),
		       (cnt() == 1 ? "" : "s"));

        // production code should handle this exception more gracefully
	} catch (ClassNotFoundException x) {
	    x.printStackTrace();
	}
    }
}

输出的几个例子MethodModifierSpy产生跟随。

$ java MethodModifierSpy java.lang.Object wait
public final void java.lang.Object.wait() throws java.lang.InterruptedException
  Modifiers:  public final
  [ synthetic=false var_args=false bridge=false ]
public final void java.lang.Object.wait(long,int)
  throws java.lang.InterruptedException
  Modifiers:  public final
  [ synthetic=false var_args=false bridge=false ]
public final native void java.lang.Object.wait(long)
  throws java.lang.InterruptedException
  Modifiers:  public final native
  [ synthetic=false var_args=false bridge=false ]
3 matching overloads found

$ java MethodModifierSpy java.lang.StrictMath toRadians
public static double java.lang.StrictMath.toRadians(double)
  Modifiers:  public static strictfp
  [ synthetic=false var_args=false bridge=false ]
1 matching overload found

$ java MethodModifierSpy MethodModifierSpy inc
private synchronized void MethodModifierSpy.inc()
  Modifiers: private synchronized
  [ synthetic=false var_args=false bridge=false ]
1 matching overload found

$ java MethodModifierSpy java.lang.Class getConstructor
public java.lang.reflect.Constructor java.lang.Class.getConstructor
  (java.lang.Class[]) throws java.lang.NoSuchMethodException,
  java.lang.SecurityException
  Modifiers: public transient
  [ synthetic=false var_args=true bridge=false ]
1 matching overload found

$ java MethodModifierSpy java.lang.String compareTo
public int java.lang.String.compareTo(java.lang.String)
  Modifiers: public
  [ synthetic=false var_args=false bridge=false ]
public int java.lang.String.compareTo(java.lang.Object)
  Modifiers: public volatile
  [ synthetic=true  var_args=false bridge=true  ]
2 matching overloads found

请注意Method.isVarArgs()回报true为Class.getConstructor()。这表明方法声明如下所示：

public Constructor getConstructor(Class... parameterTypes)

不是这样的：

public Constructor getConstructor(Class [] parameterTypes)

注意，String.compareTo()包含两个方法。中声明的方法String.java:

public int compareTo(String anotherString);

一秒合成或编译器生成的桥牌方法。这是因为String实现参数化接口Comparable。在类型删除期间，继承方法的参数类型。Comparable.compareTo()从java.lang.Object到java.lang.String。的参数类型compareTo方法Comparable和String擦除后不再匹配，不可能发生重写。在所有其他情况下，这将产生编译时错误，因为接口没有实现。增加的桥梁方法避免了这个问题。

Method实施器java.lang.reflect.AnnotatedElement。因此，任何运行时注释java.lang.annotation.RetentionPolicy.RUNTIME可能会被取回。有关获取注释的示例，请参见检查类修饰符和类型.

 

参考Java语言规范有关隐式声明结构的更多信息，包括在反射API中显示为隐式的参数。

 

调用方法

反射提供了在类上调用方法的方法。通常，只有当无法在非反射代码中将类的实例强制转换为所需类型时，才需要这样做。方法调用java.lang.reflect.Method.invoke()。第一个参数是要调用此特定方法的对象实例。(如果方法是static，第一个论点应该是null)后续参数是方法的参数。如果基础方法引发异常，则它将由java.lang.reflect.InvocationTargetException。方法的原始异常可以使用异常链接机制的InvocationTargetException.getCause()方法。

使用特定声明查找和调用方法

考虑使用反射在给定类中调用私有测试方法的测试套件。这，这个，那，那个Deet示例搜索public类中以字符串开头的test“，有一个布尔返回类型，并且有一个Locale参数。然后调用每个匹配方法。

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Type;
import java.util.Locale;
import static java.lang.System.out;
import static java.lang.System.err;

public class Deet {
    private boolean testDeet(Locale l) {
	// getISO3Language() may throw a MissingResourceException
	out.format("Locale = %s, ISO Language Code = %s%n", l.getDisplayName(), l.getISO3Language());
	return true;
    }

    private int testFoo(Locale l) { return 0; }
    private boolean testBar() { return true; }

    public static void main(String... args) {
	if (args.length != 4) {
	    err.format("Usage: java Deet    %n");
	    return;
	}

	try {
	    Class c = Class.forName(args[0]);
	    Object t = c.newInstance();

	    Method[] allMethods = c.getDeclaredMethods();
	    for (Method m : allMethods) {
		String mname = m.getName();
		if (!mname.startsWith("test")
		    || (m.getGenericReturnType() != boolean.class)) {
		    continue;
		}
 		Type[] pType = m.getGenericParameterTypes();
 		if ((pType.length != 1)
		    || Locale.class.isAssignableFrom(pType[0].getClass())) {
 		    continue;
 		}

		out.format("invoking %s()%n", mname);
		try {
		    m.setAccessible(true);
		    Object o = m.invoke(t, new Locale(args[1], args[2], args[3]));
		    out.format("%s() returned %b%n", mname, (Boolean) o);

		// Handle any exceptions thrown by method to be invoked.
		} catch (InvocationTargetException x) {
		    Throwable cause = x.getCause();
		    err.format("invocation of %s failed: %s%n",
			       mname, cause.getMessage());
		}
	    }

        // production code should handle these exceptions more gracefully
	} catch (ClassNotFoundException x) {
	    x.printStackTrace();
	} catch (InstantiationException x) {
	    x.printStackTrace();
	} catch (IllegalAccessException x) {
	    x.printStackTrace();
	}
    }
}

Deet调用getDeclaredMethods()它将返回类中显式声明的所有方法。还有，Class.isAssignableFrom()用于确定定位方法的参数是否与所需的调用兼容。从技术上讲，代码可以测试以下语句是否是true自Locale是final:

Locale.class == pType[0].getClass()

然而，Class.isAssignableFrom()更普遍。

$ java Deet Deet ja JP JP
invoking testDeet()
Locale = Japanese (Japan,JP), 
ISO Language Code = jpn
testDeet() returned true

$ java Deet Deet xx XX XX
invoking testDeet()
invocation of testDeet failed: 
Couldn't find 3-letter language code for xx

首先，请注意，只有testDeet()符合代码强制执行的声明限制。接下来，什么时候testDeet()传递无效的参数，它会抛出未经检查的java.util.MissingResourceException。在反射中，对检查异常和未检查异常的处理没有区别。它们都被包裹在一个InvocationTargetException

使用可变数量的参数调用方法

Method.invoke()可用于将可变数量的参数传递给方法。需要理解的关键概念是，变量性方法的实现就好像变量参数被打包在数组中一样。

这，这个，那，那个InvokeMain示例演示如何调用main()任何类的入口点，并传递在运行时确定的一组参数。

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Arrays;

public class InvokeMain {
    public static void main(String... args) {
	try {
	    Class c = Class.forName(args[0]);
	    Class[] argTypes = new Class[] { String[].class };
	    Method main = c.getDeclaredMethod("main", argTypes);
  	    String[] mainArgs = Arrays.copyOfRange(args, 1, args.length);
	    System.out.format("invoking %s.main()%n", c.getName());
	    main.invoke(null, (Object)mainArgs);

        // production code should handle these exceptions more gracefully
	} catch (ClassNotFoundException x) {
	    x.printStackTrace();
	} catch (NoSuchMethodException x) {
	    x.printStackTrace();
	} catch (IllegalAccessException x) {
	    x.printStackTrace();
	} catch (InvocationTargetException x) {
	    x.printStackTrace();
	}
    }
}

首先，找到main()方法搜索名称为“main”的类，其参数为String自main()是static, null的第一个参数Method.invoke()。第二个参数是要传递的参数数组。

$ java InvokeMain Deet Deet ja JP JP
invoking Deet.main()
invoking testDeet()
Locale = Japanese (Japan,JP), 
ISO Language Code = jpn
testDeet() returned true

 

故障排除

本节包含开发人员在使用反射定位、调用或获取有关方法的信息时可能遇到的问题。

由于类型擦除而引发的NoSuchMethod异常

这，这个，那，那个MethodTrouble示例说明了在类中搜索特定方法的代码不考虑类型擦除时会发生什么情况。

import java.lang.reflect.Method;

public class MethodTrouble  {
    public void lookup(T t) {}
    public void find(Integer i) {}

    public static void main(String... args) {
	try {
	    String mName = args[0];
	    Class cArg = Class.forName(args[1]);
	    Class c = (new MethodTrouble()).getClass();
	    Method m = c.getMethod(mName, cArg);
	    System.out.format("Found:%n  %s%n", m.toGenericString());

        // production code should handle these exceptions more gracefully
	} catch (NoSuchMethodException x) {
	    x.printStackTrace();
	} catch (ClassNotFoundException x) {
	    x.printStackTrace();
	}
    }
}
$ java MethodTrouble lookup java.lang.Integer
java.lang.NoSuchMethodException: MethodTrouble.lookup(java.lang.Integer)
        at java.lang.Class.getMethod(Class.java:1605)
        at MethodTrouble.main(MethodTrouble.java:12)

$ java MethodTrouble lookup java.lang.Object
Found:
  public void MethodTrouble.lookup(T)

当使用泛型参数类型声明方法时，编译器将用其上限替换泛型类型，在本例中，T是Object。因此，当代码搜索lookup(Integer)，尽管事实是MethodTrouble创建如下：

Class c = (new MethodTrouble()).getClass();

寻觅lookup(Object)如预期的那样成功。

$ java MethodTrouble find java.lang.Integer
Found:
  public void MethodTrouble.find(java.lang.Integer)
$ java MethodTrouble find java.lang.Object
java.lang.NoSuchMethodException: MethodTrouble.find(java.lang.Object)
        at java.lang.Class.getMethod(Class.java:1605)
        at MethodTrouble.main(MethodTrouble.java:12)

在这种情况下，find()没有泛型参数，因此getMethod()必须完全匹配。

提示：在搜索方法时，始终传递参数化类型的上限。

调用方法时抛出IllegalAccessException。

阿IllegalAccessException如果尝试调用private或者其他无法访问的方法。

这，这个，那，那个MethodTroubleAgain示例显示了一个典型的堆栈跟踪，它是试图在另一个类中调用私有方法的结果。

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

class AnotherClass {
    private void m() {}
}

public class MethodTroubleAgain {
    public static void main(String... args) {
	AnotherClass ac = new AnotherClass();
	try {
	    Class c = ac.getClass();
 	    Method m = c.getDeclaredMethod("m");
//  	    m.setAccessible(true);      // solution
 	    Object o = m.invoke(ac);    // IllegalAccessException

        // production code should handle these exceptions more gracefully
	} catch (NoSuchMethodException x) {
	    x.printStackTrace();
	} catch (InvocationTargetException x) {
	    x.printStackTrace();
	} catch (IllegalAccessException x) {
	    x.printStackTrace();
	}
    }
}

引发的异常的堆栈跟踪如下。

$ java MethodTroubleAgain
java.lang.IllegalAccessException: Class MethodTroubleAgain can not access a
  member of class AnotherClass with modifiers "private"
        at sun.reflect.Reflection.ensureMemberAccess(Reflection.java:65)
        at java.lang.reflect.Method.invoke(Method.java:588)
        at MethodTroubleAgain.main(MethodTroubleAgain.java:15)

提示：存在访问限制，它阻止对通常无法通过直接调用访问的方法的反射调用。(这包括-但不限于private方法在单独的类中使用，在单独的私有类中使用公共方法。)然而，Method被声明为扩展AccessibleObject，它提供了通过AccessibleObject.setAccessible()。如果成功，则此方法对象的后续调用不会因此问题而失败。

IllegalArgumentException来自Method.Invoke()

Method.invoke()已经被改造成一种可变的方法。这是一个巨大的方便，但它会导致意想不到的行为。这，这个，那，那个MethodTroubleToo示例显示了各种方法Method.invoke()会产生混乱的结果。

import java.lang.reflect.Method;

public class MethodTroubleToo {
    public void ping() { System.out.format("PONG!%n"); }

    public static void main(String... args) {
	try {
	    MethodTroubleToo mtt = new MethodTroubleToo();
	    Method m = MethodTroubleToo.class.getMethod("ping");

 	    switch(Integer.parseInt(args[0])) {
	    case 0:
  		m.invoke(mtt);                 // works
		break;
	    case 1:
 		m.invoke(mtt, null);           // works (expect compiler warning)
		break;
	    case 2:
		Object arg2 = null;
		m.invoke(mtt, arg2);           // IllegalArgumentException
		break;
	    case 3:
		m.invoke(mtt, new Object[0]);  // works
		break;
	    case 4:
		Object arg4 = new Object[0];
		m.invoke(mtt, arg4);           // IllegalArgumentException
		break;
	    default:
		System.out.format("Test not found%n");
	    }

        // production code should handle these exceptions more gracefully
	} catch (Exception x) {
	    x.printStackTrace();
	}
    }
}
$ java MethodTroubleToo 0
PONG!

的所有参数Method.invoke()都是可选的，除非第一种方法是可选的，如果要调用的方法没有参数，则可以省略它们。

$ java MethodTroubleToo 1
PONG!

本例中的代码生成此编译器警告，因为null是模棱两可的。

$ javac MethodTroubleToo.java
MethodTroubleToo.java:16: warning: non-varargs call of varargs method with
  inexact argument type for last parameter;
 		m.invoke(mtt, null);           // works (expect compiler warning)
 		              ^
  cast to Object for a varargs call
  cast to Object[] for a non-varargs call and to suppress this warning
1 warning

无法确定是否null表示参数的空数组或null.

$ java MethodTroubleToo 2
java.lang.IllegalArgumentException: wrong number of arguments
        at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
        at sun.reflect.NativeMethodAccessorImpl.invoke
          (NativeMethodAccessorImpl.java:39)
        at sun.reflect.DelegatingMethodAccessorImpl.invoke
          (DelegatingMethodAccessorImpl.java:25)
        at java.lang.reflect.Method.invoke(Method.java:597)
        at MethodTroubleToo.main(MethodTroubleToo.java:21)

尽管争论是null，因为类型是Object和ping()根本没有任何争论。

$ java MethodTroubleToo 3
PONG!

这是因为new Object[0]创建一个空数组，而对于varargs方法，这相当于不传递任何可选参数。

$ java MethodTroubleToo 4
java.lang.IllegalArgumentException: wrong number of arguments
        at sun.reflect.NativeMethodAccessorImpl.invoke0
          (Native Method)
        at sun.reflect.NativeMethodAccessorImpl.invoke
          (NativeMethodAccessorImpl.java:39)
        at sun.reflect.DelegatingMethodAccessorImpl.invoke
          (DelegatingMethodAccessorImpl.java:25)
        at java.lang.reflect.Method.invoke(Method.java:597)
        at MethodTroubleToo.main(MethodTroubleToo.java:28)

与前面的示例不同，如果空数组存储在Object，则将其视为Object。这个失败的原因和第二个案子失败的原因一样，ping()不会有争论。

提示：当一种方法foo(Object... o)，则编译器将传递给foo()在类型数组中Object。执行foo()与声明的内容相同。foo(Object[] o)。了解这一点可能有助于避免上述问题的类型。

调用方法失败时异常

阿InvocationTargetException包装调用方法对象时产生的所有异常(检查和未检查)。这，这个，那，那个MethodTroubleReturns示例演示如何检索被调用的方法引发的原始异常。

 
$ java MethodTroubleReturns
drinkMe() failed: I can't drink a negative amount of liquid

提示：如果InvocationTargetException则调用该方法。对该问题的诊断将与直接调用该方法并抛出由getCause()。此异常并不表示反射包或其使用出现问题。

 

建设者

A 构造器用于创建作为类实例的对象。通常，它在调用方法或访问字段之前执行初始化类所需的操作。构造函数从不被继承。

与方法类似，反射提供API来发现和检索类的构造函数，并获得声明信息，例如修饰符、参数、注释和抛出的异常。还可以使用指定的构造函数创建类的新实例。在使用构造函数时使用的键类为Class和java.lang.reflect.Constructor。涉及构造函数的常见操作将在以下各节中讨论：

  • 寻找构造器说明如何检索具有特定参数的构造函数。
  • 检索和解析构造修饰符演示如何获取构造函数声明的修饰符和有关构造函数的其他信息。
  • 创建新类实例演示如何通过调用对象的构造函数来实例化对象的实例。
  • 故障排除描述在查找或调用构造函数时可能遇到的常见错误。

寻找构造器

构造函数声明包括名称、修饰符、参数和可抛异常列表。这，这个，那，那个java.lang.reflect.Constructor类提供了获取此信息的方法。

这，这个，那，那个ConstructorSift示例说明如何在类的声明构造函数中搜索具有给定类型参数的构造函数。

import java.lang.reflect.Constructor;
import java.lang.reflect.Type;
import static java.lang.System.out;

public class ConstructorSift {
    public static void main(String... args) {
	try {
	    Class cArg = Class.forName(args[1]);

	    Class c = Class.forName(args[0]);
	    Constructor[] allConstructors = c.getDeclaredConstructors();
	    for (Constructor ctor : allConstructors) {
		Class[] pType  = ctor.getParameterTypes();
		for (int i = 0; i < pType.length; i++) {
		    if (pType[i].equals(cArg)) {
			out.format("%s%n", ctor.toGenericString());

			Type[] gpType = ctor.getGenericParameterTypes();
			for (int j = 0; j < gpType.length; j++) {
			    char ch = (pType[j].equals(cArg) ? '*' : ' ');
			    out.format("%7c%s[%d]: %s%n", ch,
				       "GenericParameterType", j, gpType[j]);
			}
			break;
		    }
		}
	    }

        // production code should handle this exception more gracefully
	} catch (ClassNotFoundException x) {
	    x.printStackTrace();
	}
    }
}

Method.getGenericParameterTypes()将咨询类文件中的签名属性(如果存在的话)。如果该属性不可用，则返回Method.getParameterType()这并没有因为仿制药的引入而改变。其他有名称的方法getGenericFoo()有价值的，有价值的福在反射中实现类似的。的返回值的语法。Method.get*Types()在Class.getName().

中的所有构造函数的输出如下java.util.Formatter其中有一个Locale争论。

$ java ConstructorSift java.util.Formatter java.util.Locale
public
java.util.Formatter(java.io.OutputStream,java.lang.String,java.util.Locale)
throws java.io.UnsupportedEncodingException
       GenericParameterType[0]: class java.io.OutputStream
       GenericParameterType[1]: class java.lang.String
      *GenericParameterType[2]: class java.util.Locale
public java.util.Formatter(java.lang.String,java.lang.String,java.util.Locale)
throws java.io.FileNotFoundException,java.io.UnsupportedEncodingException
       GenericParameterType[0]: class java.lang.String
       GenericParameterType[1]: class java.lang.String
      *GenericParameterType[2]: class java.util.Locale
public java.util.Formatter(java.lang.Appendable,java.util.Locale)
       GenericParameterType[0]: interface java.lang.Appendable
      *GenericParameterType[1]: class java.util.Locale
public java.util.Formatter(java.util.Locale)
      *GenericParameterType[0]: class java.util.Locale
public java.util.Formatter(java.io.File,java.lang.String,java.util.Locale)
throws java.io.FileNotFoundException,java.io.UnsupportedEncodingException
       GenericParameterType[0]: class java.io.File
       GenericParameterType[1]: class java.lang.String
      *GenericParameterType[2]: class java.util.Locale

下一个示例输出说明如何搜索类型为char[]在……里面String.

$ java ConstructorSift java.lang.String "[C"
java.lang.String(int,int,char[])
       GenericParameterType[0]: int
       GenericParameterType[1]: int
      *GenericParameterType[2]: class [C
public java.lang.String(char[],int,int)
      *GenericParameterType[0]: class [C
       GenericParameterType[1]: int
       GenericParameterType[2]: int
public java.lang.String(char[])
      *GenericParameterType[0]: class [C

表示引用数组和基元类型数组的语法。Class.forName()在Class.getName()。注意，第一个列出的构造函数是package-private，不是public。因为示例代码使用Class.getDeclaredConstructors()而不是Class.getConstructors()，它只返回public建筑工人。

这个例子显示，搜索变量性的参数(它有可变的参数)需要使用数组语法：

$ java ConstructorSift java.lang.ProcessBuilder "[Ljava.lang.String;"
public java.lang.ProcessBuilder(java.lang.String[])
      *GenericParameterType[0]: class [Ljava.lang.String;

这是ProcessBuilder构造函数在源代码中：

public ProcessBuilder(String... command)

该参数表示为类型为一维数组。java.lang.String。可以将其与显式地表示为java.lang.String通过调用Constructor.isVarArgs().

最后一个示例报告了用泛型参数类型声明的构造函数的输出：

$ java ConstructorSift java.util.HashMap java.util.Map
public java.util.HashMap(java.util.Map)
      *GenericParameterType[0]: java.util.Map

可以与方法类似的方式检索构造函数的异常类型。见MethodSpy中描述的示例获取方法类型信息一节以了解更多细节。

 

检索和解析构造修饰符

由于构造函数在语言中的作用，比方法更少的修饰符是有意义的：

  • 访问修饰符：public, protected，和private
  • 注解

这，这个，那，那个ConstructorAccess示例使用指定的访问修饰符搜索给定类中的构造函数。它还显示构造函数是合成的(编译器生成的)还是可变的。

import java.lang.reflect.Constructor;
import java.lang.reflect.Modifier;
import java.lang.reflect.Type;
import static java.lang.System.out;

public class ConstructorAccess {
    public static void main(String... args) {
	try {
	    Class c = Class.forName(args[0]);
	    Constructor[] allConstructors = c.getDeclaredConstructors();
	    for (Constructor ctor : allConstructors) {
		int searchMod = modifierFromString(args[1]);
		int mods = accessModifiers(ctor.getModifiers());
		if (searchMod == mods) {
		    out.format("%s%n", ctor.toGenericString());
		    out.format("  [ synthetic=%-5b var_args=%-5b ]%n",
			       ctor.isSynthetic(), ctor.isVarArgs());
		}
	    }

        // production code should handle this exception more gracefully
	} catch (ClassNotFoundException x) {
	    x.printStackTrace();
	}
    }

    private static int accessModifiers(int m) {
	return m & (Modifier.PUBLIC | Modifier.PRIVATE | Modifier.PROTECTED);
    }

    private static int modifierFromString(String s) {
	if ("public".equals(s))               return Modifier.PUBLIC;
	else if ("protected".equals(s))       return Modifier.PROTECTED;
	else if ("private".equals(s))         return Modifier.PRIVATE;
	else if ("package-private".equals(s)) return 0;
	else return -1;
    }
}

没有明确的Modifier常量，它对应于“包-私有”访问，因此有必要检查是否没有所有三个访问修饰符来标识包-私有构造函数。

此输出显示java.io.File:

$ java ConstructorAccess java.io.File private
private java.io.File(java.lang.String,int)
  [ synthetic=false var_args=false ]
private java.io.File(java.lang.String,java.io.File)
  [ synthetic=false var_args=false ]

合成构造器很少，但是SyntheticConstructor示例说明了可能发生这种情况的典型情况：

public class SyntheticConstructor {
    private SyntheticConstructor() {}
    class Inner {
	// Compiler will generate a synthetic constructor since
	// SyntheticConstructor() is private.
	Inner() { new SyntheticConstructor(); }
    }
}
$ java ConstructorAccess SyntheticConstructor package-private
SyntheticConstructor(SyntheticConstructor$1)
  [ synthetic=true  var_args=false ]

由于内部类的构造函数引用了封闭类的私有构造函数，所以编译器必须生成包私有构造函数。参数类型SyntheticConstructor$1是任意的，并且依赖于编译器实现。依赖于任何合成或非公共类成员的代码可能是不可移植的。

构造器实现java.lang.reflect.AnnotatedElement，它提供了用于检索运行时注释的方法。java.lang.annotation.RetentionPolicy.RUNTIME。有关获取注释的示例，请参见检查类修饰符和类型部分。

 

创建新类实例

有两种创建类实例的反射方法：java.lang.reflect.Constructor.newInstance()和Class.newInstance()。前者是首选的，因此在这些例子中被使用，因为：

  • Class.newInstance()只能调用零参数构造函数，而Constructor.newInstance()可以调用任何构造函数，而不管参数的数量。
  • Class.newInstance()引发由构造函数引发的任何异常，无论是否选中它。Constructor.newInstance()始终将抛出的异常包装为InvocationTargetException.
  • Class.newInstance()要求构造函数是可见的；Constructor.newInstance()可调用private在某些情况下。

有时，从只在构造后设置的对象中检索内部状态可能是可取的。考虑一种情况，在这种情况下，有必要获得以下内容所使用的内部字符集：java.io.Console。()Console字符集存储在私有字段中，不一定与Java虚拟机默认字符集相同。java.nio.charset.Charset.defaultCharset())这，这个，那，那个ConsoleCharset示例显示了如何实现这一目标：

import java.io.Console;
import java.nio.charset.Charset;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import static java.lang.System.out;

public class ConsoleCharset {
    public static void main(String... args) {
	Constructor[] ctors = Console.class.getDeclaredConstructors();
	Constructor ctor = null;
	for (int i = 0; i < ctors.length; i++) {
	    ctor = ctors[i];
	    if (ctor.getGenericParameterTypes().length == 0)
		break;
	}

	try {
	    ctor.setAccessible(true);
 	    Console c = (Console)ctor.newInstance();
	    Field f = c.getClass().getDeclaredField("cs");
	    f.setAccessible(true);
	    out.format("Console charset         :  %s%n", f.get(c));
	    out.format("Charset.defaultCharset():  %s%n",
		       Charset.defaultCharset());

        // production code should handle these exceptions more gracefully
	} catch (InstantiationException x) {
	    x.printStackTrace();
 	} catch (InvocationTargetException x) {
 	    x.printStackTrace();
	} catch (IllegalAccessException x) {
	    x.printStackTrace();
	} catch (NoSuchFieldException x) {
	    x.printStackTrace();
	}
    }
}

注： 

Class.newInstance()只有在构造函数为零参数且已可访问的情况下才会成功。否则，就必须使用Constructor.newInstance()如上例所示。

UNIX系统的示例输出：

$ java ConsoleCharset
Console charset          :  ISO-8859-1
Charset.defaultCharset() :  ISO-8859-1

Windows系统的示例输出：

C:\> java ConsoleCharset
Console charset          :  IBM437
Charset.defaultCharset() :  windows-1252

的另一种常见应用Constructor.newInstance()调用接受参数的构造函数。这，这个，那，那个RestoreAliases示例找到一个特定的单参数构造函数并调用它：

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import static java.lang.System.out;

class EmailAliases {
    private Set aliases;
    private EmailAliases(HashMap h) {
	aliases = h.keySet();
    }

    public void printKeys() {
	out.format("Mail keys:%n");
	for (String k : aliases)
	    out.format("  %s%n", k);
    }
}

public class RestoreAliases {

    private static Map defaultAliases = new HashMap();
    static {
	defaultAliases.put("Duke", "duke@i-love-java");
	defaultAliases.put("Fang", "fang@evil-jealous-twin");
    }

    public static void main(String... args) {
	try {
	    Constructor ctor = EmailAliases.class.getDeclaredConstructor(HashMap.class);
	    ctor.setAccessible(true);
	    EmailAliases email = (EmailAliases)ctor.newInstance(defaultAliases);
	    email.printKeys();

        // production code should handle these exceptions more gracefully
	} catch (InstantiationException x) {
	    x.printStackTrace();
	} catch (IllegalAccessException x) {
	    x.printStackTrace();
	} catch (InvocationTargetException x) {
	    x.printStackTrace();
	} catch (NoSuchMethodException x) {
	    x.printStackTrace();
	}
    }
}

此示例使用Class.getDeclaredConstructor()若要查找具有单个类型参数的构造函数，请执行以下操作java.util.HashMap。请注意，它已经足够通过。HashMap.class因为参数到任何get*Constructor()方法仅为类型目的需要类。由于类型擦除，下面的表达式计算为true:

HashMap.class == defaultAliases.getClass()

然后，该示例使用以下构造函数创建类的新实例Constructor.newInstance().

$ java RestoreAliases
Mail keys:
  Duke
  Fang

 

故障排除

开发人员在试图通过反射调用构造函数时有时会遇到以下问题。

由于缺少零参数构造器而引发的InstantiationException

这，这个，那，那个ConstructorTrouble示例说明了当代码试图使用Class.newInstance()并且没有可访问的零参数构造函数：

public class ConstructorTrouble {
    private ConstructorTrouble(int i) {}

    public static void main(String... args){
	try {
	    Class c = Class.forName("ConstructorTrouble");
	    Object o = c.newInstance();  // InstantiationException

        // production code should handle these exceptions more gracefully
	} catch (ClassNotFoundException x) {
	    x.printStackTrace();
	} catch (InstantiationException x) {
	    x.printStackTrace();
	} catch (IllegalAccessException x) {
	    x.printStackTrace();
	}
    }
}
$ java ConstructorTrouble
java.lang.InstantiationException: ConstructorTrouble
        at java.lang.Class.newInstance0(Class.java:340)
        at java.lang.Class.newInstance(Class.java:308)
        at ConstructorTrouble.main(ConstructorTrouble.java:7)

提示：有许多不同的原因InstantiationException可能会发生。在这种情况下，问题是构造函数的存在与int参数阻止编译器生成默认(或零参数)构造函数，代码中也没有显式的零参数构造函数。记住Class.newInstance()行为非常类似于new关键字，并且在任何时候都会失败。new都会失败。

newInstance()引发意外异常

这，这个，那，那个ConstructorTroubleToo示例显示了一个无法解决的问题。Class.newInstance()。也就是说，它传播由构造函数引发的任何异常检查或未检查。

import java.lang.reflect.InvocationTargetException;
import static java.lang.System.err;

public class ConstructorTroubleToo {
    public ConstructorTroubleToo() {
 	throw new RuntimeException("exception in constructor");
    }

    public static void main(String... args) {
	try {
	    Class c = Class.forName("ConstructorTroubleToo");
	    // Method propagetes any exception thrown by the constructor
	    // (including checked exceptions).
	    if (args.length > 0 && args[0].equals("class")) {
		Object o = c.newInstance();
	    } else {
		Object o = c.getConstructor().newInstance();
	    }

        // production code should handle these exceptions more gracefully
	} catch (ClassNotFoundException x) {
	    x.printStackTrace();
	} catch (InstantiationException x) {
	    x.printStackTrace();
	} catch (IllegalAccessException x) {
	    x.printStackTrace();
	} catch (NoSuchMethodException x) {
	    x.printStackTrace();
	} catch (InvocationTargetException x) {
	    x.printStackTrace();
	    err.format("%n%nCaught exception: %s%n", x.getCause());
	}
    }
}
$ java ConstructorTroubleToo class
Exception in thread "main" java.lang.RuntimeException: exception in constructor
        at ConstructorTroubleToo.(ConstructorTroubleToo.java:6)
        at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
        at sun.reflect.NativeConstructorAccessorImpl.newInstance
          (NativeConstructorAccessorImpl.java:39)
        at sun.reflect.DelegatingConstructorAccessorImpl.newInstance
          (DelegatingConstructorAccessorImpl.java:27)
        at java.lang.reflect.Constructor.newInstance(Constructor.java:513)
        at java.lang.Class.newInstance0(Class.java:355)
        at java.lang.Class.newInstance(Class.java:308)
        at ConstructorTroubleToo.main(ConstructorTroubleToo.java:15)

这种情况对反思来说是独一无二的。通常，不可能编写忽略检查异常的代码，因为它不会编译。可以将构造函数引发的任何异常包装为Constructor.newInstance()而不是Class.newInstance().

$ java ConstructorTroubleToo
java.lang.reflect.InvocationTargetException
        at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
        at sun.reflect.NativeConstructorAccessorImpl.newInstance
          (NativeConstructorAccessorImpl.java:39)
        at sun.reflect.DelegatingConstructorAccessorImpl.newInstance
          (DelegatingConstructorAccessorImpl.java:27)
        at java.lang.reflect.Constructor.newInstance(Constructor.java:513)
        at ConstructorTroubleToo.main(ConstructorTroubleToo.java:17)
Caused by: java.lang.RuntimeException: exception in constructor
        at ConstructorTroubleToo.(ConstructorTroubleToo.java:6)
        ... 5 more


Caught exception: java.lang.RuntimeException: exception in constructor

如果InvocationTargetException则调用该方法。对问题的诊断将与直接调用构造函数并抛出由InvocationTargetException.getCause()。此异常并不表示反射包或其使用出现问题。

提示：最好用Constructor.newInstance()过关Class.newInstance()因为前一个API允许检查和处理由构造函数引发的任意异常。

查找或调用正确的构造函数时出现问题

这，这个，那，那个ConstructorTroubleAgain类说明错误代码可能无法定位或调用预期构造函数的各种方法。

import java.lang.reflect.InvocationTargetException;
import static java.lang.System.out;

public class ConstructorTroubleAgain {
    public ConstructorTroubleAgain() {}

    public ConstructorTroubleAgain(Integer i) {}

    public ConstructorTroubleAgain(Object o) {
	out.format("Constructor passed Object%n");
    }

    public ConstructorTroubleAgain(String s) {
	out.format("Constructor passed String%n");
    }

    public static void main(String... args){
	String argType = (args.length == 0 ? "" : args[0]);
	try {
	    Class c = Class.forName("ConstructorTroubleAgain");
	    if ("".equals(argType)) {
		// IllegalArgumentException: wrong number of arguments
		Object o = c.getConstructor().newInstance("foo");
	    } else if ("int".equals(argType)) {
		// NoSuchMethodException - looking for int, have Integer
		Object o = c.getConstructor(int.class);
	    } else if ("Object".equals(argType)) {
		// newInstance() does not perform method resolution
		Object o = c.getConstructor(Object.class).newInstance("foo");
	    } else {
		assert false;
	    }

        // production code should handle these exceptions more gracefully
	} catch (ClassNotFoundException x) {
	    x.printStackTrace();
	} catch (NoSuchMethodException x) {
	    x.printStackTrace();
	} catch (InvocationTargetException x) {
	    x.printStackTrace();
	} catch (InstantiationException x) {
	    x.printStackTrace();
	} catch (IllegalAccessException x) {
	    x.printStackTrace();
	}
    }
}
$ java ConstructorTroubleAgain
Exception in thread "main" java.lang.IllegalArgumentException: wrong number of
  arguments
        at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
        at sun.reflect.NativeConstructorAccessorImpl.newInstance
          (NativeConstructorAccessorImpl.java:39)
        at sun.reflect.DelegatingConstructorAccessorImpl.newInstance
          (DelegatingConstructorAccessorImpl.java:27)
        at java.lang.reflect.Constructor.newInstance(Constructor.java:513)
        at ConstructorTroubleAgain.main(ConstructorTroubleAgain.java:23)

阿IllegalArgumentException引发，因为请求了零参数构造函数，并且试图传递参数。如果传递了错误类型的参数，则将引发相同的异常。

$ java ConstructorTroubleAgain int
java.lang.NoSuchMethodException: ConstructorTroubleAgain.(int)
        at java.lang.Class.getConstructor0(Class.java:2706)
        at java.lang.Class.getConstructor(Class.java:1657)
        at ConstructorTroubleAgain.main(ConstructorTroubleAgain.java:26)

如果开发人员错误地认为反射将自动装箱或打开框类型，则可能发生此异常。装箱(将原语转换为引用类型)仅在编译期间发生。反射中没有发生此操作的机会，因此在定位构造函数时必须使用特定类型。

$ java ConstructorTroubleAgain Object
Constructor passed Object

在这里，可能会期望构造函数采用String参数将被引用，因为newInstance()使用更具体的String类型。但是已经太晚了！找到的构造函数已经是具有Object争论。newInstance()不尝试执行方法解析；它只是对现有的构造函数对象进行操作。

提示：一个重要的区别new和Constructor.newInstance()那是new执行方法参数类型检查、装箱和方法解析。所有这些都不是在反思中发生的，必须作出明确的选择。

试图调用不可访问的构造器时抛出IllegalAccessException

阿IllegalAccessException如果试图调用私有或其他不可访问的构造函数，则可能引发。这，这个，那，那个ConstructorTroubleAccess示例说明了结果堆栈跟踪。

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

class Deny {
    private Deny() {
	System.out.format("Deny constructor%n");
    }
}

public class ConstructorTroubleAccess {
    public static void main(String... args) {
	try {
	    Constructor c = Deny.class.getDeclaredConstructor();
//  	    c.setAccessible(true);   // solution
	    c.newInstance();

        // production code should handle these exceptions more gracefully
	} catch (InvocationTargetException x) {
	    x.printStackTrace();
	} catch (NoSuchMethodException x) {
	    x.printStackTrace();
	} catch (InstantiationException x) {
	    x.printStackTrace();
	} catch (IllegalAccessException x) {
	    x.printStackTrace();
	}
    }
}
$ java ConstructorTroubleAccess
java.lang.IllegalAccessException: Class ConstructorTroubleAccess can not access
  a member of class Deny with modifiers "private"
        at sun.reflect.Reflection.ensureMemberAccess(Reflection.java:65)
        at java.lang.reflect.Constructor.newInstance(Constructor.java:505)
        at ConstructorTroubleAccess.main(ConstructorTroubleAccess.java:15)

提示：存在一个访问限制，它阻止对通常无法通过直接调用访问的构造函数的反射调用。(这包括但不限于单独类中的私有构造函数和单独私有类中的公共构造函数。)然而，Constructor被声明为扩展AccessibleObject，它提供了通过AccessibleObject.setAccessible().

你可能感兴趣的:(java)

  • Long类型前后端数据不一致 igotyback 前端
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
  • LocalDateTime 转 String igotyback java开发语言
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计 网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team 若博豆 java算法华为javascript
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业javascripthtmlcss旅游风景
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动 二挡起步 web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
  • node.js学习 小猿L node.jsnode.js学习vim
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
  • Java 重写(Override)与重载(Overload) 叨唧唧的
    Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
  • 简单了解 JVM 记得开心一点啊 jvm
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
  • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven Energet!c 开发语言
    1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
  • Java企业面试题3 马龙强_ java
    1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
  • JVM、JRE和 JDK：理解Java开发的三大核心组件 Y雨何时停T Javajava
    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
  • Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选javakafka
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
  • 白骑士的Java教学基础篇 2.5 控制流语句 白骑士所长 Java教学java开发语言
    欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
  • python语法——三目运算符 HappyRocking pythonpython三目运算符
    在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
  • ArrayList 源码解析 程序猿进阶 Java基础ArrayListListjava面试性能优化架构设计idea
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
  • Java爬虫框架（一）--架构设计 狼图腾-狼之传说 java框架java任务html解析器存储电子商务
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
  • Java：爬虫框架 dingcho Javajava爬虫
    一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
  • python怎么将png转为tif_png转tif weixin_39977276
    发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
  • JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy） 跳房子的前端 前端面试javascript开发语言ecmascript
    在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
  • JAVA·一个简单的登录窗口 MortalTom java开发语言学习
    文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
  • WebMagic：强大的Java爬虫框架解析与实战 Aaron_945 Javajava爬虫开发语言
    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
  • 博客网站制作教程 2401_85194651 javamaven
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
  • 00. 这里整理了最全的爬虫框架（Java + Python） 有一只柴犬 爬虫系列爬虫javapython
    目录1、前言2、什么是网络爬虫3、常见的爬虫框架3.1、java框架3.1.1、WebMagic3.1.2、Jsoup3.1.3、HttpClient3.1.4、Crawler4j3.1.5、HtmlUnit3.1.6、Selenium3.2、Python框架3.2.1、Scrapy3.2.2、BeautifulSoup+Requests3.2.3、Selenium3.2.4、PyQuery3.2
  • JAVA学习笔记之23种设计模式学习 victorfreedom Java技术设计模式androidjava常用设计模式
    博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
  • JavaScript `Map` 和 `WeakMap`详细解释 跳房子的前端 JavaScript原生方法javascript前端开发语言
    在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
  • 切换淘宝最新npm镜像源是 hai40587 npm前端node.js
    切换淘宝最新npm镜像源是一个相对简单的过程，但首先需要明确当前淘宝npm镜像源的状态和最新的镜像地址。由于网络环境和服务更新，镜像源的具体地址可能会发生变化，因此，我将基于当前可获取的信息，提供一个通用的切换步骤，并附上最新的镜像地址（截至回答时）。一、了解npm镜像源npm（NodePackageManager）是JavaScript的包管理器，用于安装、更新和管理项目依赖。由于npm官方仓库
  • 【Java】已解决：java.util.concurrent.CompletionException 屿小夏 java开发语言
    文章目录一、分析问题背景出现问题的场景代码片段二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：java.util.concurrent.CompletionException一、分析问题背景在Java并发编程中，java.util.concurrent.CompletionException是一种常见的运行时异常，通常在使用CompletableFuture进行异步计算时出现
  • 设计模式之建造者模式(通俗易懂--代码辅助理解【Java版】） ok!ko 设计模式设计模式建造者模式java
    文章目录设计模式概述1、建造者模式2、建造者模式使用场景3、优点4、缺点5、主要角色6、代码示例：1）实现要求2）UML图3)实现步骤：1）创建一个表示食物条目和食物包装的接口2）创建实现Packing接口的实体类3）创建实现Item接口的抽象类，该类提供了默认的功能4）创建扩展了Burger和ColdDrink的实体类5）创建一个Meal类，带有上面定义的Item对象6）创建一个MealBuil
  • eclipse maven IXHONG eclipse
    eclipse中使用maven插件的时候，运行run as maven build的时候报错 -Dmaven.multiModuleProjectDirectory system propery is not set. Check $M2_HOME environment variable and mvn script match.   可以设一个环境变量M2_HOME指
  • timer cancel方法的一个小实例 alleni123 多线程timer
    package com.lj.timer; import java.util.Date; import java.util.Timer; import java.util.TimerTask; public class MyTimer extends TimerTask { private int a; private Timer timer; pub
  • MySQL数据库在Linux下的安装 ducklsl mysql
    1.建好一个专门放置MySQL的目录 /mysql/db数据库目录 /mysql/data数据库数据文件目录 2.配置用户，添加专门的MySQL管理用户 >groupadd mysql ----添加用户组 >useradd -g mysql mysql ----在mysql用户组中添加一个mysql用户 3.配置，生成并安装MySQL >cmake -D
  • spring------>>cvc-elt.1: Cannot find the declaration of element Array_06 springbean
    将-------- <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans"     xmlns:xsi="http://www.w3
  • maven发布第三方jar的一些问题 cugfy maven
    maven中发布 第三方jar到nexus仓库使用的是 deploy:deploy-file命令 有许多参数，具体可查看 http://maven.apache.org/plugins/maven-deploy-plugin/deploy-file-mojo.html 以下是一个例子： mvn  deploy:deploy-file -DgroupId=xpp3
  • MYSQL下载及安装 357029540 mysql
        好久没有去安装过MYSQL，今天自己在安装完MYSQL过后用navicat for mysql去厕测试链接的时候出现了10061的问题，因为的的MYSQL是最新版本为5.6.24，所以下载的文件夹里没有my.ini文件，所以在网上找了很多方法还是没有找到怎么解决问题，最后看到了一篇百度经验里有这个的介绍，按照其步骤也完成了安装，在这里给大家分享下这个链接的地址
  • ios TableView cell的布局 张亚雄 tableview
      cell.imageView.image = [UIImage imageNamed:[imageArray objectAtIndex:[indexPath row]]];           CGSize itemSize = CGSizeMake(60, 50);   &nbs
  • Java编码转义 adminjun java编码转义
    import java.io.UnsupportedEncodingException; /** * 转换字符串的编码 */ public class ChangeCharset { /** 7位ASCII字符，也叫作ISO646-US、Unicode字符集的基本拉丁块 */ public static final Strin
  • Tomcat 配置和spring aijuans spring
    简介 Tomcat启动时，先找系统变量CATALINA_BASE，如果没有，则找CATALINA_HOME。然后找这个变量所指的目录下的conf文件夹，从中读取配置文件。最重要的配置文件：server.xml 。要配置tomcat，基本上了解server.xml，context.xml和web.xml。 Server.xml --  tomcat主
  • Java打印当前目录下的所有子目录和文件 ayaoxinchao 递归File
    其实这个没啥技术含量，大湿们不要操笑哦，只是做一个简单的记录，简单用了一下递归算法。   import java.io.File; /** * @author Perlin * @date 2014-6-30 */ public class PrintDirectory { public static void printDirectory(File f
  • linux安装mysql出现libs报冲突解决 BigBird2012 linux
    linux安装mysql出现libs报冲突解决 安装mysql出现 file /usr/share/mysql/ukrainian/errmsg.sys from install of MySQL-server-5.5.33-1.linux2.6.i386 conflicts with file from package mysql-libs-5.1.61-4.el6.i686  
  • jedis连接池使用实例 bijian1013 redisjedis连接池jedis
    实例代码： package com.bijian.study; import java.util.ArrayList; import java.util.List; import redis.clients.jedis.Jedis; import redis.clients.jedis.JedisPool; import redis.clients.jedis.JedisPoo
  • 关于朋友 bingyingao 朋友兴趣爱好维持
      成为朋友的必要条件：    志相同，道不合，可以成为朋友。譬如马云、周星驰一个是商人，一个是影星，可谓道不同，但都很有梦想，都要在各自领域里做到最好，当他们遇到一起，互相欣赏，可以畅谈两个小时。     志不同，道相合，也可以成为朋友。譬如有时候看到两个一个成绩很好每次考试争做第一，一个成绩很差的同学是好朋友。他们志向不相同，但他
  • 【Spark七十九】Spark RDD API一 bit1129 spark
    aggregate package spark.examples.rddapi import org.apache.spark.{SparkConf, SparkContext} //测试RDD的aggregate方法 object AggregateTest { def main(args: Array[String]) { val conf = new Spar
  • ktap 0.1 released bookjovi kerneltracing
    Dear, I'm pleased to announce that ktap release v0.1, this is the first official release of ktap project, it is expected that this release is not fully functional or very stable and we welcome bu
  • 能保存Properties文件注释的Properties工具类 BrokenDreams properties
            今天遇到一个小需求：由于java.util.Properties读取属性文件时会忽略注释，当写回去的时候，注释都没了。恰好一个项目中的配置文件会在部署后被某个Java程序修改一下，但修改了之后注释全没了，可能会给以后的参数调整带来困难。所以要解决这个问题。     &nb
  • 读《研磨设计模式》-代码笔记-外观模式-Facade bylijinnan java设计模式
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ /* * 百度百科的定义： * Facade（外观）模式为子系统中的各类（或结构与方法）提供一个简明一致的界面， * 隐藏子系统的复杂性，使子系统更加容易使用。他是为子系统中的一组接口所提供的一个一致的界面 * * 可简单地
  • After Effects教程收集 cherishLC After Effects
    1、中文入门 http://study.163.com/course/courseMain.htm?courseId=730009 2、videocopilot英文入门教程（中文字幕） http://www.youku.com/playlist_show/id_17893193.html 英文原址： http://www.videocopilot.net/basic/ 素
  • Linux Apache 安装过程 crabdave apache
    Linux Apache 安装过程   下载新版本： apr-1.4.2.tar.gz（下载网站：http://apr.apache.org/download.cgi） apr-util-1.3.9.tar.gz（下载网站：http://apr.apache.org/download.cgi） httpd-2.2.15.tar.gz（下载网站：http://httpd.apac
  • Shell学习 之 变量赋值和引用 daizj shell变量引用赋值
    本文转自：http://www.cnblogs.com/papam/articles/1548679.html Shell编程中，使用变量无需事先声明，同时变量名的命名须遵循如下规则： 首个字符必须为字母（a-z，A-Z） 中间不能有空格，可以使用下划线（_） 不能使用标点符号 不能使用bash里的关键字（可用help命令查看保留关键字） 需要给变量赋值时，可以这么写：
  • Java SE 第一讲（Java SE入门、JDK的下载与安装、第一个Java程序、Java程序的编译与执行） dcj3sjt126com javajdk
    Java SE 第一讲： Java SE：Java Standard Edition Java ME: Java Mobile Edition Java EE：Java Enterprise Edition Java是由Sun公司推出的（今年初被Oracle公司收购）。 收购价格：74亿美金 J2SE、J2ME、J2EE JDK：Java Development
  • YII给用户登录加上验证码 dcj3sjt126com yii
    1、在SiteController中添加如下代码： /** * Declares class-based actions. */ public function actions() { return array( // captcha action renders the CAPTCHA image displ
  • Lucene使用说明 dyy_gusi Lucenesearch分词器
    Lucene使用说明 1、lucene简介 1.1、什么是lucene     Lucene是一个全文搜索框架，而不是应用产品。因此它并不像baidu或者googleDesktop那种拿来就能用，它只是提供了一种工具让你能实现这些产品和功能。 1.2、lucene能做什么     要回答这个问题，先要了解lucene的本质。实际
  • 学习编程并不难,做到以下几点即可! gcq511120594 数据结构编程算法
    不论你是想自己设计游戏，还是开发iPhone或安卓手机上的应用，还是仅仅为了娱乐，学习编程语言都是一条必经之路。编程语言种类繁多，用途各 异，然而一旦掌握其中之一，其他的也就迎刃而解。作为初学者，你可能要先从Java或HTML开始学，一旦掌握了一门编程语言，你就发挥无穷的想象，开发 各种神奇的软件啦。 1、确定目标 学习编程语言既充满乐趣，又充满挑战。有些花费多年时间学习一门编程语言的大学生到
  • Java面试十问之三：Java与C++内存回收机制的差别 HNUlanwei javaC++finalize()堆栈内存回收
    大家知道， Java 除了那 8 种基本类型以外，其他都是对象类型（又称为引用类型）的数据。 JVM 会把程序创建的对象存放在堆空间中，那什么又是堆空间呢？其实，堆（ Heap）是一个运行时的数据存储区，从它可以分配大小各异的空间。一般，运行时的数据存储区有堆（ Heap）和堆栈（ Stack），所以要先看它们里面可以分配哪些类型的对象实体，然后才知道如何均衡使用这两种存储区。一般来说，栈中存放的
  • 第二章 Nginx+Lua开发入门 jinnianshilongnian nginxlua
    Nginx入门 本文目的是学习Nginx+Lua开发，对于Nginx基本知识可以参考如下文章： nginx启动、关闭、重启 http://www.cnblogs.com/derekchen/archive/2011/02/17/1957209.html agentzh 的 Nginx 教程 http://openresty.org/download/agentzh-nginx-tutor
  • MongoDB windows安装 基本命令 liyonghui160com
      windows安装    安装目录：   D:\MongoDB\   新建目录   D:\MongoDB\data\db   4.启动进城：   cd D:\MongoDB\bin   mongod -dbpath D:\MongoDB\data\db   &n
  • Linux下通过源码编译安装程序 pda158 linux
    一、程序的组成部分 　　Linux下程序大都是由以下几部分组成： 　　二进制文件：也就是可以运行的程序文件 　　库文件：就是通常我们见到的lib目录下的文件 　　配置文件：这个不必多说，都知道 　　帮助文档：通常是我们在linux下用man命令查看的命令的文档 　　 二、linux下程序的存放目录 　　linux程序的存放目录大致有三个地方： 　　/etc, /b
  • WEB开发编程的职业生涯４个阶段 shw3588 编程Web工作生活
    觉得自己什么都会 2007年从学校毕业，凭借自己原创的ASP毕业设计，以为自己很厉害似的，信心满满去东莞找工作，找面试成功率确实很高，只是工资不高，但依旧无法磨灭那过分的自信，那时候什么考勤系统、什么OA系统、什么ERP，什么都觉得有信心，这样的生涯大概持续了约一年。 根本不是自己想的那样 2008年开始接触很多工作相关的东西，发现太多东西自己根本不会，都需要去学，不管是asp还是js，
  • 遭遇jsonp同域下变作post请求的坑 vb2005xu jsonp同域post
    今天迁移一个站点时遇到一个坑爹问题,同一个jsonp接口在跨域时都能调用成功,但是在同域下调用虽然成功,但是数据却有问题. 此处贴出我的后端代码片段 $mi_id = htmlspecialchars(trim($_GET['mi_id '])); $mi_cv = htmlspecialchars(trim($_GET['mi_cv ']));  贴出我前端代码片段: $.aj
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他