2.反射的基本使用

最新推荐文章于 2024-05-28 22:26:20 发布
最新推荐文章于 2024-05-28 22:26:20 发布
阅读量216 收藏 1
点赞数 1
分类专栏： 测试反射注解 文章标签： 反射 类加载器 双亲委派模型 Class对象 动态编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40454863/article/details/113796299
版权

目录

反射的基本使用

1.前言

2.Java代码在计算机中经历三个阶段

2.反射机制及好处

3.类加载器

3.1.功能

3.2.Java默认三种类加载器

3.3.双亲委派模型

3.获取Class类对象三种方法

4.Class类对象使用

5.反射案例

反射的基本使用

1.前言

  • 反射是java体系中非常重要的部分，也被称为框架设计的灵魂，框架就是半成品的软件，不能独立运行，开发人员会在框架的基础上进一步软件开发，可以简化代码。(比如不用框架需要1万行代码，用框架做同一款软件可能只需要1千行，其中9千行框架已经写好了，)。框架的设计灵魂就是反射，如果我们将来后期在使用框架时，不会反射也没有关系，因为框架已经写好了，但如果自己要开发一套框架，让别人使用自己的框架编程，就需要深入理解和掌握反射。
  • 当然学习反射后，在学习使用框架就比较容易，因为掌握反射后，框架内部原理也就容易掌握，

2.Java代码在计算机中经历三个阶段


第一个阶段:Source源代码阶段

  • 写一个类文件Person.java,在类中定义成员变量，成员方法和构造器，这个java文件就写完了，
  • 这个文件不能独自运行，需要javac命令对文件进行编译，然后在硬盘上生成字节码文件Person.class,
  • 字节码文件中主要是成员变量、构造器和成员方法等，
  • 这就是java代码在计算机中经历的第一阶段称Source源代码阶段，
  • 这个阶段java代码没有进内存，还是在硬盘上存储着。

第二个阶段:Class类对象阶段

  • 将字节码文件通过类加载器ClassLoader加载到内存，在内存中通过Class类对象来描述字节码文件中内容，
  • Class类是java中的一个类，它功能是描述所有字节码文件(物理文件)的共同特征和行为，
  • 只要是字节码文件就有共同的属性，主要包括成员变量、成员方法和构造方法三个部分等，这三个部分都有各自特征，
  • 成员变量可以获取值设置值，构造方法可以用来创建对象，成员方法可以运行执行，
  • 所以把类中这三个部分分别封装成对象，把成员变量部分封装为Field对象，把构造方法部分封装为Constructor对象，把成员方法封装为Method对象
  • 在字节码文件中可能不止一个成员变量，所以在Class类对象中使用Field对象数组来描述所有的成员变量，数组类型就是Field对象，数组中元素都是Field对象。
  • 同理构造方法Constructor[] cons和成员方法Method[] methods,
  • 这就是Class类对象组成成分，将来就可以通过这个Class类对象的一些行为来创建对象，这就是java代码在计算机中经历的第二阶段。
  • 这也就是反射机制，将类的各个组成部分封装为其它对象。

第三个阶段:Runtime运行时阶段

  • 该阶段主要是创建对象new Person

2.反射机制及好处

  • 反射:框架设计的灵魂。
  • 框架:就是个半成品软件。可以在框架的基础上进行软件开发，从而简化编码。

反射:

  • 就是将类中各个组成部分封装为其它对象，可以管理未来未知的对象和类，这就是反射机制。
  • JAVA反射机制是在运行状态中，获取任意一个类的结构 , 创建对象 , 得到方法，执行方法 , 属性 !； 这种在运行状态动态获取信息以及动态调用对象方法的功能被称为java语言的反射机制。

反射好处:

  • 1.可以在程序运行过程中，(在内存中)通过class对象操作这些对象。
    • 比如，在软件(应用程序/IDE)中定义String str="abc"字符串对象str,我们可以使用str对象加点运算符即"str."来调用String类中的方法，那么这些方法从哪里来的，怎么知道字符串中有这些方法，其实内部就是用了反射机制，在定义字符串String str="abc"时，就会把String类的字节码文件加载到内存，在内存中的一个Class类对象已经把字节码文件中所有方法抽取出来封装为Method对象，存入Method类型数组中，当调用数组方法时，就把这些方法展示到列表中。IDE程序一直在运行过程，我们却可以知道str中有哪些方法。
  • 2.可以解耦(将一个整体分成多个部分)，提高程序的可扩展性。
  • 3.打破封装，获取私有内容。

3.类加载器

3.1.功能

  • Java类加载器（Java Classloader）是Java运行时环境（Java Runtime Environment）的一部分， 负责动态加载Java类到Java虚拟机的内存空间中。

3.2.Java默认三种类加载器

  • BootstrapClassLoader（引导启动类加载器）
    • 嵌在JVM内核中的加载器，该加载器是用C++语言写的，主要负载加载JAVA_HOME/lib下的类库，引 导启动类加载器无法被应用程序直接使用。
  • ExtensionClassLoader（扩展类加载器）
    • ExtensionClassLoader是用JAVA编写，且它的父类加载器是Bootstrap。 是由sun.misc.Launcher$ExtClassLoader实现的，主要加载JAVA_HOME/lib/ext目录中的类 库。 它的父加载器是BootstrapClassLoader
  • App ClassLoader（应用类加载器）：
    • App ClassLoader是应用程序类加载器，负责加载应用程序classpath目录下的所有jar和class文 件。它的父加载器为Ext ClassLoader

  • 类通常是按需加载，即第一次使用该类时才加载。由于有了类加载器，Java运行时系统不需要知道文件与 文件系统。

3.3.双亲委派模型

面试题:多个类加载器如何避免类被重复加载？

  • 如果一个类加载器收到了一个类加载请求，它不会自己去尝试加载这个类，而是把这个请求 转交给父类加载器去完成。
  • 每一个层次的类加载器都是如此。因此所有的类加载请求都应该传递到最顶层的 启动类加载器中，只有到父类加载器反馈自己无法完成这个加载请求（在它的搜索范围没有找到这个类） 时，子类加载器才会尝试自己去加载。
  • A将加载请求转交给E,E再转交给B,若B能加载就加载，不能则B转交给E来加载，E再不能加载就A来。
  • 委派的好处就是避免有些类被重复加载。

3.获取Class类对象三种方法

class类对象-字节码文件对象-管理字节码文件-将字节码文件内容分别封装成不同对象

我们知道反射机制就是将一个类中各个组成部分封装为其它对象，要获取使用这些对象，关键要获取Class类对象，
下面就聊聊获取内存中字节码Class对象的三种方法:

1.Class.forName("全类名"):

  • 将字节码文件加载进内存，返回Class对象。
  • 该Class类中静态方法forName只适用于java程序第一阶段Source源代码阶段，
  • 即程序还未进内存，只是字节码文件。另外全类名只包名加类名(即src下开始)

2.类名.class:

  • 通过类名的class属性获取
  • 该方法只适用于Java程序第二阶段Class类对象阶段，此时字节码文件已经加载到内存，

3.对象.getClass():

  • 该方法在Object类中定义的，所有对象都可以调用。

结论:

  • 同一个字节码文件(*.class)在一次程序运行过程中，只会被加载一次，无论通过哪一种方式获取的Class对象都是同一个。(在各个阶段获取的都是同一个)
  • 上述的三种方式, 在调用时, 如果类在内存中不存在, 则会加载到内存 ! 如果类已经在内存中存在, 不 会重复加载, 而是重复利用 !
首先创建domain包，在包中创建实体类Person,然后在反射包reflect中写测试类
package reflect;
import domain.Person;
import domain.Student;
public class Demo01Reflect {
    public static void main(String[] args) throws Exception {
        //注意:当在domain包中定义完Person类保存后就会自动编译为Person.class字节码文件

        //1. Class.forName("全类名"):将字节码文件Person加载进内存，返回Class对象
        // 注意该方法经常抛异常ClassNotFoundException，即全类名有问题，
        // 建议全类名通过复制包名和类名组成，不要自己手写。

        Class aClass = Class.forName("domain.Person");
        System.out.println(aClass);//输出class domain.Person


        //2. 类名.class:通过类名的属性class获取Class对象

        Class aClass1 = Person.class;
        System.out.println(aClass1);//输出class domain.Person


        //3.对象.getClass():通过Object类中的定义的getClass方法(任何对象都可以使用)

        Person p = new Person();
        Class aClass2 = p.getClass();
        System.out.println(aClass2);//输出class domain.Person

        /*注意上述三个方法获取Class对象，都是Person.class字节码文件在内存中生成
          的Class对象，输出对象的字符串形式是一样的，也是同一个Class对象，
          下面来验证
        */
        //使用==来比较，比较的是对象地址
        System.out.println(aClass==aClass1);//true
        System.out.println(aClass==aClass2);//true

       /*结论:同一个字节码文件(*.class)在一次程序运行过程中，只会被加载一次，
         无论通过哪一种方式获取的Class对象都是同一个。
       */

       //每一个字节码文件对应的Class对象都不相同,下面是Person和student两个
        //字节码文件对应的Class对象比较
        Class aClass3 = Student.class;
        System.out.println(aClass==aClass3);//false
    }
}

4.Class类对象使用

Class对象功能: 该对象中的常用方法的使用
1.获取成员变量们

Field[] getFields():获取所有public修饰的成员变量到Field对象数组中，不需指定对象
Field getField(String name):获取指定的public变量(Field类型)，不需指定对象

Field[] getDeclaredFields():获取所有的成员变量，不考虑修饰符--反射技术打破封装，可以获取私有
Field getDeclaredField(String name):获取指定的成员变量，不考虑修饰符

获取Class对象中的Field后，可进行设置值和获取值
Field对象操作:

1.设置值:void set(Object object,Object value)指定给哪个对象设置什么样变量值p.set(obj,value)
2.获取值:get(Object obj)需要指定是获取哪个对象的变量值p.get(obj)
3.忽略访问权限修饰符的安全检查(暴力反射)setAccessible(true)

2.获取构造方法们

Constructor<?>[] getConstructors()获取所有public类型的无参数构造方法存入Constructor对象数组中
Constructor<T> getConstructor(类<?>...parameterTypes)获取指定参数类型的构造方法

Constructor<?>[] getDeclaredConstructor()获取所有的构造方法存入对象数组中，不限修饰符
Constructor<T> getDeclaredConstructor(类<?>...parameterTypes)获取指定参数类型构造方法，不限制修饰符

在访问私有类型构造器会抛出异常，需要忽略访问权限修饰符的安全检查(暴力反射)
setAccessible(true)

Class对象获取构造器后，创建对象

获取到构造方法(即构造器对象)后就是使用构造方法创建对象了
构造器对象中的创建对象方法是: newInstance(Object...initargs)
构造方法的对象调用该方法并传递参数来创建对象，
 
但若是空参构造方法创建对象时可以简化上述创建构造器然后调用构造器newInstance(Object...initargs)
方法创建对象

在Class对象中也有newInstance()方法，不过只能创建无参数构造方法的对象
Object person=personClass.newInstance();

3.获取成员方法们

Method[] getMethods()获取所有public类型的成员方法存入Method对象数组中
Method getMethod(String name,类<?>...parameterTypes)
获取指定的方法名name和参数的成员方法 (方法名+参数=确定方法)

Method[] getDeclaredMethods()获取所有的成员方法存入对象数组，不考虑修饰符
Method getDeclaredMethod(String name,类<?>...parameterTypes)
获取指定方法名和参数的成员方法，不考虑修饰符
 
setAccessible(true)

获取到Method对象(即方法对象)后，调用invoke(obj,args)方法来执行这个方法，
Object invoke(Object obj,Object...args):传递指定对象和参数来执行方法

调用getName()方法来获取方法对象的方法名
String getName();

获取类名的方法:获取的是全类名(包名+类名)
String className=personClass.getName();

4.获取类名

 String getName()

5.Demo

以下统一使用的Person类:

package domain;
//domain实体类 
public class Person {
    private String name;
    private int age;
    public String a1;
    public String a2;
    protected String b;
    String c;  //默认私有
    private String d;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person() { }
    public String getA1() { return a1; }
    public void setA1(String a1) { this.a1 = a1; }
    public String getA2() { return a2; }
    public void setA2(String a2) { this.a2 = a2; }
    public String getB() { return b; }
    public void setB(String b) { this.b = b; }
    public String getC() { return c; }
    public void setC(String c) { this.c = c; }
    public String getD() { return d; }
    public void setD(String d) { this.d = d; }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", a1='" + a1 + '\'' +
                ", a2='" + a2 + '\'' +
                ", b='" + b + '\'' +
                ", c='" + c + '\'' +
                ", d='" + d + '\'' +
                '}';
    }

    public void eat(){
        System.out.println("eat....");
    }
    public void eat(String food){
        System.out.println("eat...."+food);
    }
}

Class对象获取Field变量对象以及Field对象自身方法使用

package reflect;
import com.sun.org.apache.bcel.internal.classfile.ClassParser;
import domain.Person;
import java.lang.reflect.Field;
public class Demo02Reflect {
    public static void main(String[] args) throws Exception {
        //0.获取Person类的Class对象(字节码文件对象)
        Class personClass = Person.class;

        //1.Field[] getFields():获取所有public修饰的成员变量到Field对象数组中
        Field[] fields = personClass.getFields();
        for (Field f:fields){
            System.out.println(f);
        }

        /*public java.lang.String domain.Person.a1
          public java.lang.String domain.Person.a2
        */
        System.out.println("1.................");

        //2.Field getField(String name):获取指定的public成员变量a1
        Field a1 = personClass.getField("a1");
        System.out.println(a1);//public java.lang.String domain.Person.a1
        System.out.println("2.................");

        /**3.
         * 获取(指定对象obj的)成员变量的值: *get(Object obj)
         * 获取Person类中成员变量a1的'值'，初始化变量是null,需要指定哪个对象
         */
        //对变量操作时(获取/设置值)要指定是哪个对象的变量，所以要创建对象
        Person p = new Person();
        Object value = a1.get(p);//指定获取p对象中的a1变量的值
        System.out.println("初始化时成员变量a1的值:"+value);//null
        System.out.println("3.................");

        /**4.
         * 设置(指定对象的)成员变量的值:*void set(Object object,Object value)
         * 设置p对象中成员变量a1的值为:韩非
         */
        a1.set(p,"韩非"); //给p对象中a1变量设置值
        Object value1=a1.get(p);//获取p对象中a1变量的值
        System.out.println(value1);//韩非
        System.out.println(p);
        /*此时的p对象中成员变量如下
        Person{a1='韩非', a2='null', b='null', c='null', d='null'}
        */
        System.out.println("4.................");

        /**5.
         *Field[] getDeclaredFields():获取所有的成员变量，不考虑修饰符
         *Field getDeclaredField(String name):获取指定的成员变量，不考虑修饰符
         *这些方法都是Class对象personClass中的方法
         */
        //Class对象调用getDeclaredFields()方法获取所有成员变量存入Field对象数组中
        Field[] declaredFields = personClass.getDeclaredFields();
        for (Field f:declaredFields){ //遍历数组输出所有变量
            System.out.println(f);
        }
        /*以下为Person类中所有成员变量(不考虑修饰符)
        public java.lang.String domain.Person.a1
        public java.lang.String domain.Person.a2
        protected java.lang.String domain.Person.b
        java.lang.String domain.Person.c
        private java.lang.String domain.Person.d
      */
        //Class对象调用Field getDeclaredField(String name)方法获取指定变量d
        //并访问(获取)这个私有变量d,注意私有变量是无法在类外被访问的，这里需要
        //使用d.setAccessible(true)方法暴力反射，忽略访问权限修饰符的安全检查
        //否则抛出IllegalAccessException异常
        Field d = personClass.getDeclaredField("d");
        //忽略访问权限修饰符的安全检查
        d.setAccessible(true);//暴力反射
        Object value2 = d.get(p);//获取对象p的私有变量d的值
        System.out.println("对象p的私有变量d的值:"+value2);//null
    }
}

Class对象获取Constructor构造器对象以及该对象自身方法使用

package reflect;
import domain.Person;
import java.lang.reflect.Constructor;
public class Demo03Reflect_Cons {
    public static void main(String[] args) throws Exception {
        //0.获取Person类的Class类对象
        Class personClass = Person.class;
       
        /**1.Constructor<T> getConstructor(类<?>...parameterTypes)
         *   java 反射机制 之 getConstructor获取有参数构造函数(是个对象)
         */
        Constructor constructor = personClass.getConstructor(String.class,int.class);
        System.out.println(constructor);//public domain.Person(java.lang.String,int)
        //构造方法的对象constructor调用newInstance方法并传递参数来创建对象
        Object person = constructor.newInstance("韩非", 22);
        System.out.println(person);
        System.out.println("..................");
        //输出person对象，其中name,age成员变量有值
        //Person{name='韩非', age=22, a1='null', a2='null', b='null', c='null', d='null'}
        

        /*2.Constructor<T> getConstructor()
            java 反射机制 之 getConstructor获取无参数构造函数(是个对象)*/
        Constructor constructor1 = personClass.getConstructor();
        Object person1 = constructor1.newInstance();
        System.out.println(person1);
        System.out.println("..................");
        //无参数构造方法创建的对象
        //Person1{name='null', age=0, a1='null', a2='null', b='null', c='null', d='null'}
        
        //使用Class对象中newInstance方法获取无参数构造器的对象
        Object person2 = personClass.newInstance();
        System.out.println(person2);
        //无参数构造方法创建的对象
        //Person{name='null', age=0, a1='null', a2='null', b='null', c='null', d='null'}
    }
}

Class对象获取Method方法对象以及该对象自身方法使用

package reflect;
import domain.Person;
import java.lang.reflect.Method;
public class Demo04Reflect_Method {
    public static void main(String[] args) throws Exception {
        //0.获取Person类的Class对象
        Class personClass = Person.class;
        /**1.
         * Method getMethod(String name,类<?>...parameterTypes)
         * 获取指定的方法名name和参数的成员方法 (方法名+参数=确定方法)
         * Object invoke(Object obj,Object...args):传递指定对象和参数来执行方法
         */
        //使用CLass对象中getMethod方法获取无参eat()成员方法
        Method eat = personClass.getMethod("eat");
        //使用Method对象中invoke方法传递指定对象来执行这个Method
        Person person = new Person();
        eat.invoke(person);//输出eat....
        //使用CLass对象中getMethod方法获取含参eat(String food)成员方法
        Method eat1 = personClass.getMethod("eat", String.class);
        //使用Method对象中invoke方法传递指定对象和参数来执行这个Method
        eat1.invoke(person,"苹果");//输出eat....苹果
        System.out.println("....................");

        /**2.
         * Method[] getMethods()
         * 获取所有public类型的成员方法存入Method对象数组中
         * getMethods方法获取的不仅是Person类中所有public方法，
         * 还有Object类中的一些方法
         */
        Method[] methods = personClass.getMethods();
        for (Method m:methods){
            System.out.println(m); //输出所有的方法对象Method(每一个都是一个方法的封装)
            System.out.println("方法名:"+m.getName());//输出方法对象中的方法名
        }

        /**3.
         * 获取类名的方法，获取的是全类名(包名+类名)
         * String className=personClass.getName();
         */
        String name = personClass.getName();
        System.out.println("类名为:"+name);//类名为:domain.Person
    }
}

5.反射案例

需求:

  • 写一个"框架"，在不改变该类的任何代码的前提下，可以帮我们创建任意类的对象，并且执行其中的任意方法

分析:

  • 像之前创建对象调用方法Person p=new Person();p.eat()这种操作经常做，这种操作的弊端是:如果将来把该类当做框架，框架是半成品软件，是提前写好，不允许改变的，框架的前提是不能改变该类的任何代码，但可以创建任意类的对象，可以执行类中任意方法。若是按上述，则每创建一个类对象就要修改一次程序，就不是框架了。
  • 下面使用配置文件来定义全类名和要执行的方法名，若方法有参数也可以定义，然后使用反射来获取Class对象中的方法对象Method,从而获取字节码文件中要执行的方法

现Person类中的eat()方法和Student类中sleep()方法，要求只修改配置文件中的className全类名和methodName方法名来创建对象调用方法。

实现所需技术:

  • 1.加载配置文件
  • 2.反射

实现步骤:

  • 1.将需要创建的对象的全类名和需要执行的方法定义在配置文件pro.properties
className=domain.Person
methodName=eat
  • 2.在程序中加载读取配置文件pro.properties
  • 3.使用反射技术来加载类文件进内存，获取Class对象
  • 4.Class对象获取构造方法创建对象
  • 5.执行方法

改java代码和改配置文件的区别:

  • 如果将来写的系统非常庞大的话，如果代码被改动，就需要重新测试，
  • 如果修改配置文件就不需要修改代码，也可以提高程序扩展性。
  • 将来很多地方都会使用配置文件，遇到文件中设置了全类名，就需要知道用了反射。
package reflect;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.Properties;

public class Demo05Reflect_Test {
    public static void main(String[] args) throws Exception{
        //1.加载(读取)配置文件
        //1.1.创建Properties对象
        Properties pro = new Properties();
        //1.2加载配置文件，转换为一个集合(双列Map集合)
        //1.2.1.获取class(类)目录下的配置文件(即获取文件路径)
        //首先通过类的class属性获取字节码文件，然后获取类加载器
        ClassLoader cl = Demo05Reflect_Test.class.getClassLoader();
        //类加载器可以找到类(class)目录下的class(字节码)文件，也可以找到配置文件
        //类加载器中有个方法getResource(String name)获取资源的路径
        //还有一个方法getResourceAsStream(String name)直接获取这个资源对应的字节流
        //pro对象调用load()方法加载配置文件时就需要传递字节流。
        //properties文件放置在src文件下
        InputStream is = cl.getResourceAsStream("pro.properties");
        pro.load(is);

        //2.获取配置文件中定义的数据
        String className = pro.getProperty("className");//获取全类名
        String methodName = pro.getProperty("methodName");//获取方法名

        //3.加载该类进内存,获取Class对象
        Class cls = Class.forName(className);
        //4.创建对象(空参构造方法的对象)
        Object obj = cls.newInstance();
        //5.获取方法对象(空参方法)
        Method method = cls.getMethod(methodName);
        //6.执行方法
        method.invoke(obj);
    }
}

你好啊cbw
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java高级练习题 java 高级
02-17
java 课后练习提java 课后练习提java 课后练习提java 课后练习提java 课后练习提java 课后练习提
枚举、注解与反射，入门最全最强
qq_35217284的博客
10-20 212
1. 枚举 1.1 简介 JDK1.5引入了新的类型——枚举。 在JDK1.5 之前，我们定义常量都是： public static fianl… 。很难管理。 枚举，可以把相关的常量分组到一个枚举类型里，而且枚举提供了比常量更多的方法。 用于定义有限数量的一组同类常量， 例如： 错误级别： 低、中、高、急 一年的四季： 春、夏、秋、冬 商品的类型： 美妆、手机、电脑、男装、女装… 在枚举类型中定义的常量是该枚举类型的实例。 1.2 格式定义 权限修饰符 enum 枚举名称 { 实例1,实例2，实例3，实例
反射(超级详细)
最新发布
m0_63464979的博客
05-28 819
Java官方对反射的解释：反射允许对封装类字段（成员变量），方法（成员方法）和构造函数（构造方法）的信息进行编程访问。我们知道在一个类的里面，经常使用的有下面三部分内容，分别是成员变量、构造方法、成员方法。反射可以把他理解成一个人，这个人可以把成员变量、成员方法、构造方法都获取出来，并对他们进行操作。获取出来有什么用？比如idea里面的自动提示功能，其实就是用反射来实现的。
javaweb输出所有学生信息_10道JavaWeb高级面试题助你通过面试(附答案）
weixin_39665847的博客
11-21 218
面试也是一场考试，是考试就有简单的基础题和复杂的难题，对于java面试也是如此，有java的基础面试题，有java的高级面试题。前面已经总结整理了不少各类的java基础面试题，今天来汇总一些javaweb高级面试题，帮助那些不是java零基础的程序员学习回顾javaweb的知识。1、谈谈你对ajax的认识？答：Ajax 是一种创建交互式网页应用的的网页开发技术；“JavaScript and XM...
算法笔记_116:算法集训之代码填空题集三（Java）
weixin_34310785的博客
03-27 265
 目录 1 数组转置 2 文件管理 3 显示为树形 4 杨辉三角系数 5 圆周率与级数 6 整数翻转 7 自行车行程 8 祖冲之割圆法 9 最大5个数 10 最大镜像子串     1 数组转置   编写程序将2行3列的数组行列置换复制给3行2列的数组（即数组的转置）。已经写了如下代码，请完善之： class y{ public...
java填空题
chiyan2167的博客
06-18 3940
1. 一个Java源程序由若干个（类）组成。 2. （class）是Java的关键字，用来定义类。 3. Java应用程序中有多个类时，Java命令后的类名必须是包含了（main）方法的那个类的名字。 4. 一个Java应用程序必须且只有一个类含有（main）方法。 5. 在一个Jav...
时域反射仪TDR的基本原理
01-20
时域反射仪的基本原理是在一条不匹配的传输线上的波形会发生反射。传输线上任何一点的波形都是原有波形和反射波形的叠加。使用TDR测量法时，我们观察的是传输线输入端的波形。 　图为我们设计的TDR基本结构。一个...
C#反射.zip
06-28
四、使用反射的基本步骤 1. 获取Type对象：使用typeof()操作符或者Activator.CreateInstance()方法。 2. 通过Type对象获取成员信息：如GetMethods(), GetFields(), GetProperties()等。 3. 调用成员：使用Invoke()...
Java反射示例代码.rar
05-19
2. 反射操作： - 获取构造器：使用`Constructor[] getConstructors()`获取类的所有公共构造器，`Constructor<T> getConstructor(Class<?>... parameterTypes)`获取指定参数类型的构造器。 - 创建对象：使用`...
FBG反射谱仿真.docx
09-13
FBG的基本原理是基于光在光纤中的布拉格反射现象。 #### 1.2 工作原理 FBG的工作原理主要基于布拉格条件公式： \[ \lambda_{B} = 2n_{eff} \Lambda \] 其中，\(\lambda_{B}\) 是布拉格波长，\(n_{eff}\) 是光纤的...
java反射基本方法测试
06-01
下面我们将详细探讨Java反射的基本方法及其应用。 一、获取类信息 1. `Class` 类：反射的核心是`Class`类，它代表一个Java类。通过`Class`对象，我们可以获取到类的元数据。获取`Class`对象的方法有： - 使用`...
JAVA填空题
08-22
java面试中的java填空题的所有题的集合。但是没有答案
JAVA考试填空题
12-19
定义一个立方体类Cubic，包括长、宽、高三个属性和一个计算体积的方法。 public class Cubic{ double x,y,z; //构造方法，用于完成Cubic的初始化 { this.x = x; this.y = y; this.z = z; } public double volume( ){ //计算体积并返回 }
Java高级（题目+答案）
08-24
此内容在上一个Java基础文档上，是对Java高级部分概念问题的整理，内容不是很多，但是很实用，同样也是面试常见问题。
Java语言程序设计(一)填空题
qq_40907977的博客
08-12 6776
1、在第一次加载 Applet 时，默认最先执行的方法是 ___ int()_____。 2、调用 ___ getParameter()_____方法可以把 HTML 网页中的参数传递给 Applet 。 3、使用 ____getAudioClip()____方法可以从 Web 站点上下载声音，并调用 play()方法和 loop() 方法播放它们。 4、____ 版面管理器_____用于安排容器上的 GUI 组件。 5、GUI 是 ______图形用户界面_________的缩写 6、当释放鼠标按键时，将
【Java】练习题库 填空题
CE00001的博客
04-14 4393
在Java的基本数据类型中，char型采用Unicode编码方案，每个Unicode码占。方法是一种仅有方法头，没有具体方法体和操作实现的方法，该方法必须在抽象类之中定义。若x = 5，y = 10，则x < y和x >= y的逻辑值分别为。设 x = 2 ，则表达式 ( x + + )／3 的值是。9、假设x=13，y=4，则表达式x%y!创建一个名为 MyPackage 的包的语句是。3、Java中布尔类型的常量有两种，它们是（7、导入mypackage包中的所类的命令是。
java的填空题试题_Java练习题(试卷)
weixin_30343429的博客
02-13 1598
Java程序设计练习题(1)一、单项选择题1．下面( B )是合法的Java标识符。A、#_pound B、_underscore C、5Interstate D、class2．下面( D )赋值语句不会出现编译警告或错误。A、float f=1.3; B、char c="a"; C、byte b=257; D、int...
java填空题_Java语言基础知识填空题
weixin_34457571的博客
02-15 1958
Java语言基础知识填空题想学java语言的人，要多做题才能巩固知识，下面小编为大家带来了Java语言基础知识的填空题，欢迎大家阅读!Java语言基础知识填空题。1.浮点型数据根据数据存储长度和数值精度的不同，进一步分为float和( double )两种类型。2.使用关键字( boolean )来定义逻辑变量。3.一个long型数据在内存占( 8 )个字节。4.表示制表符(水平空格)的字符常量是...
java的填空题试题_java 试题练习题(第4套)
weixin_28965731的博客
02-13 219
大学 —— 学年第 学期 《 Java 程序设计 》课程试题 课程号： √ 考试 □ A 卷 √ 闭卷 □ 考查 □ B 卷 □ 开卷一、单项选择题(20题；每题2分，共40分) 1、若数组a 定义为int[][]a=new int[3][4]，则a 是＿＿＿。 A )一维数组 B )二维数组 C )三维数组 D )四维数组 答案：B (难度系数C 知识点： 数组) 2、 Java 语言使用的字符...
反射内存卡RF2G测试与配置指南
"该文档是关于反射内存卡RF2G的测试指南，涵盖了反射内存卡的基本概念、测试环境搭建、驱动安装以及大小端测试实例。主要关注Redhat系统的操作，适用于光纤通信领域的技术人员。" 反射内存卡是用于高速数据共享和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值