精华内容
下载资源
问答
  • 提出了使用改进伪逆方法从... 这项研究应用了三个不同光谱反射率数据集和三个不同误差度量。 根据所考虑所有误差度量,该方法非常准确,并且优于伪逆方法和加权伪逆方法,它们在重构光谱反射率方面是有效
  • 反射概念用途(了解)反射基本信息二级目录级目录 概念 对于任意一类,都能够知道这所有属性和方法;对于任 意一对象,都能够调用它任意方法和属性,既然能拿到那么,我们就可以修改部分类型信息;这种...

    概念

    让一个对象在运行时,能够认清自己,例如知道自己有哪些属性,哪些方法,以及每个属性叫什么名字,是什么类型,是私有还是公有等等

    .java文件=>.class(二进制),程序运行时,JVM会加载到对应类到内存中(.class文件),然后可以使用反射获取到对象的更详细细节

    .class文件可以加载出class对象,对象就是类对象(这个对象的图纸,包含了这个对象的内部结构)在方法区中,每个类在使用之前都需要把对应类的的.class文件加载到内存中(类加载)双亲委派模型其实就是一系列的路径查找机制,在合适的目录中找到需要的.class文件,并且要保证同一个类不需要重复加载。

    同一个类不管在代码中实际被使用多少次,对应的类对象一定只有一个(类对象是一个单例)单例:有的类只能被实例化一次。

    用途

    1、当遇到某个类的某个成员变量、方法或是属性是私有的或是只对系统应 用开放,这时候就可以利用Java的反射机制通过反射来获取所需的私有成员或是方法 。
    2、反射最重要的用途就是开发各种通用框架,比如在spring中,我们将所有的类Bean交给spring容器管理,无论 是XML配置Bean还是注解配置,当我们从容器中获取Bean来依赖注入时,容器会读取配置,而配置中给的就是类 的信息,spring根据这些信息,需要创建那些Bean,spring就动态的创建这些类。

    反射基本信息

    Java程序中许多对象在运行时会出现两种类型:运行时类型(RTTI)和编译时类型,例如Person p = new
    Student();这句代码中p在编译时类型为Person,运行时类型为Student。程序需要在运行时发现对象和类的真实信息。而通过使用反射程序就能判断出该对象和类属于哪些类。

    反射相关的类

    在这里插入图片描述
    Class类 是类对象的类型

    获取类对象

    1、直接通过全限定类名获取,使用 Class.forName(“类的全路径名”); 静态方法

    前提:已明确类的全路径名有包的时候就必须加包的路径,还要有异常处理,优点就是在写代码的时候可以不用知道类的具体名字,它可以自动在运行时获取,也可以文本读入、用户输入等方式获得,是最灵活的
    在这里插入图片描述
    2、通过类的实例化获取,每个类都有隐藏的getClass()方法
    在这里插入图片描述
    3、通过类来直接获取(仅适合在编译前就已经明确要操作的 Class,最安全可靠,程序性能更高 这说明任何一个类都有一个隐含的静态成员变量 class)
    在这里插入图片描述
    一个类在 JVM 中只会有一个 Class 实例,即我们对上面获取的三种类对象进行比较,发现都是true
    在这里插入图片描述

    class Cat{
        private String name;
    
        public void eat(String food){
            System.out.println(name + "正在吃" + food);
        }
        public Cat(String name){
            this.name = name;
        }
    }
    public class TestReflect {
        public static void main(String[] args) throws ClassNotFoundException {
            //获取类对象Cat,Cat类的说明书
            //1、直接通过全限定类名获取
            Class catClass = Class.forName("Cat");
            
            //2、通过类的实例化获取
            Cat cat = new Cat("mimi");
            Class catClass2 = cat.getClass();
    
            //3、通过类来直接获取
            Class catClass3 = Cat.class;
    
            System.out.println(catClass == catClass2);
            System.out.println(catClass == catClass3);
            System.out.println(catClass2 == catClass3);
    
        }
    
    }
    
    展开全文
  • 反射 反射是什么 有什么用 反射是动态语言的基本特征。...java中反射的使用都是从内置的Class对象开始的。每类创建好之后都会生成一Class对象。 Class对象获取的三种方式 package com.aaa.reflect.entit

    反射

    反射是什么 有什么用

    反射是动态语言的基本特征。java是不是动态语言?所谓动态语言就是在代码的运行期才知道变量的类型。java是
    静态语言,在反射之前是做不了动态的创建对象这种事的。在jdk1.4之后出现了反射机制,用反射来实现动态语言
    的特性。简单来说,反射就是使用动态的方式,创建对象,调用方法,访问属性。
    java中反射的使用都是从内置的Class对象开始的。每个类创建好之后都会生成一个Class对象。

    Class对象获取的三种方式

    package com.aaa.reflect.entity;
    
    public class Person2 {
    		public static void main(String[] args) throws Exception { 
    			//第一种方式,通过调用Class.forName方法 
    			Class clazz1 = Class.forName("com.aaa.reflect.entity.Person2"); 
    			System.out.println(clazz1); 			  	 
    			//第二种方式 通过调用来的class对象 
    			Class clazz2 = Person2.class; System.out.println(clazz2); 
    			//第三种方式 通过调用对象的getClass方法 
    			Person2 p= new Person2(); Class clazz3 = p.getClass(); 		  
    			System.out.println(clazz3); 
    		}
     }
    
    展开全文
  • 目标描述static变量方法和初始程序描述final类方法和变量列出访问控制级别描述如何应用收集和反射在Java软件程序中确认static方法和变量publicprivateprotected和缺省变量使用abstract类和方法解释如何以及何时使用...
  •  最近也要做一网站,决心用c#,用严格的三层构架+反射工厂来做。于是网上找了一些示例的代码,开始看的是Shangducms和他的开发文档,看完之后,什么感觉没有,一头雾水。连三层构架和反射工厂的含义都没领会。...

    以前做过很多个网站系统,大都是用asp或者php做的,.net也用过,不过是用asp的思路来做.net,基本体现不出vs面向对象的特征。
        最近也要做一个网站,决心用c#,用严格的三层构架+反射工厂来做。于是网上找了一些示例的代码,开始看的是Shangducms和他的开发文档,看完之后,什么感觉没有,一头雾水。连三层构架和反射工厂的含义都没领会。然后听说微软的petshop不错,于是下载petshop4.0,又在csdn找到某大侠写的《petshop详解》,今晚上读了--数据访问层的相关介绍,终于对其构架有了一定的认识。感谢...
       下面吧我认为的精髓部分写下:
        在PetShop中,系统需要处理的数据库对象分为两类:一是数据实体,对应数据库中相应的数据表。它们没有行为,仅用于表现对象的数据。这些实体类都被放到Model程序集中,例如数据表Order对应的实体类OrderInfo,我的理解就是按照数据表的结构创建一个对应的类。这些类的属性分别映射了数据表的列,而每一个对象实例也恰恰对应于数据表的每一行。第二类对象就是对数据表的操作(Select,Insert,Update和Delete)他们仅具有行为而与数据无关,因此它们均被抽象为一个单独的接口模块IDAL,例如数据表Order对应的接口IOrder,其他的都是IXXX,(IXXX)就是接口。
        将数据实体与相关的数据库操作分离出来,符合面向对象的精神。首先,它体现了“职责分离”的原则。将数据实体与其行为分开,使得两者之间依赖减弱,当数据行为发生改变时,并不影响Model模块中的数据实体对象,避免了因一个类职责过多、过大,从而导致该类的引用者发生“灾难性”的影响。其次,它体现了“抽象”的精神,或者说是“面向接口编程”的最佳体现。抽象的接口模块IDAL,与具体的数据库访问实现完全隔离。这种与实现无关的设计,保证了系统的可扩展性,同时也保证了数据库的可移植性。
        现在我们已经有了数据实体,数据对象的抽象接口和实现,可以说有关数据库访问的主体就已经完成了。留待我们的还有两个问题需要解决:
        1、数据对象创建的管理
        2、利于数据库的移植
        在PetShop中,要创建的数据对象包括Order,Product,Category,Inventory,Item。在前面的设计中,这些对象已经被抽象为对应的接口,而其实现则根据数据库的不同而有所不同。也就是说,创建的对象有多种类别,而每种类别又有不同的实现,这是典型的抽象工厂模式的应用场景。
        例如,创建SQL Server的Order对象如下:PetShopFactory factory = new SQLServerFactory();IOrder = factory.CreateOrder();
        要考虑到数据库的可移植性,则factory必须作为一个全局变量,并在主程序运行时被实例化。但这样的设计虽然已经达到了“封装变化”的目的,但在创建PetShopFactory对象时,仍不可避免的出现了具体的类SQLServerFactory,也即是说,程序在这个层面上产生了与SQLServerFactory的强依赖。一旦整个系统要求支持Oracle,那么还需要修改这行代码为:PetShopFactory factory = new OracleFactory();
    修改代码的这种行为显然是不可接受的。解决的办法是“依赖注入”。“依赖注入”的功能通常是用专门的IoC容器提供的,在Java平台下,这样的容器包括Spring,PicoContainer等。而在.Net平台下,最常见的则是Spring.Net。不过,在PetShop系统中,并不需要专门的容器来实现“依赖注入”,简单的做法还是利用配置文件和反射功能来实现。也就是说,我们可以在web.config文件中,配置好具体的Factory对象的完整的类名。然而,当我们利用配置文件和反射功能时,具体工厂的创建就显得有些“画蛇添足”了,我们完全可以在配置文件中,直接指向具体的数据库对象实现类,例如PetShop.SQLServerDAL.IOrder。那么,抽象工厂模式中的相关工厂就可以简化为一个工厂类了,所以我将这种模式称之为“具有简单工厂特质的抽象工厂模式”

     

    展开全文
  • 什么是类反射—原理? ☆什么是反射 (1)Java反射机制是在运行状态中,对于...(2)反射(Reflection)是Java程序开发语言的特征之一,它允许运行中Java程序对自身进行检查, 也称自审,并能直接操作程序内部属...

    什么是类反射—原理?
    ☆什么是反射
    (1)Java反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意一个方法和属性;这种动态获取的信息以及动态调用对象的方法的功能称为Java语言的反射机制。

    (2)反射(Reflection)是Java程序开发语言的特征之一,它允许运行中的Java程序对自身进行检查, 也称自审,并能直接操作程序的内部属性。例如,使用它能获得Java类中各成员的名称并显示出来。

    (3)Java的这一能力在实际应用中应用得很多,在其它的程序语言中根本就不存在这一特性。例如,Pascal、C或者C++中就没有办法在程序中获得函数定义相关的信息。

    (4)JavaBean是类反射的实际应用之一,它能让一些工具可视化的操作软件组件。这些工具通过类反射动态的载入并取得Java组件(类)的属性。后面学习的各种框架,基本上都会有反射的使用。

    ☆反射引例(HelloWorld、USB)
    反射最大的好处就是解耦

    最简单的类反射:(相当于HelloWorld)

    一个ReflectionHelloWorld类演示:

    package cn.hncu.reflect.test;

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

    /**
     * 1、类反射使用的步骤:<br>
     *      (1)Class c=Class.forName("类全名:包名[.子包名].类名");<br>
     *      (2)调用c对象中的成员方法:Field(字段)、Method(方法)、Constructor(构造方法)、Modifier(静态方法和常量)<br>
     *      (3)遍历出所有信息<br>

     *@author <a"283505495@qq.com">lxd</a>
     *@version 1.0 2017-4-15 下午12:30:31
     *@fileName ReflectionHelloWorld.java
     */
    public class ReflectionHelloWorld {
        public static void main(String[] args) {
            try {
                Class c=Class.forName("cn.hncu.reflect.test.UserModel");
                /*
                 * 提供有关类或接口的单个字段信息,以及对他的动态访问权限
                 */
                Field[] flds=c.getDeclaredFields();
                for(Field fild:flds){
                    System.out.println(fild);
                }
                System.out.println("------------------------");
                /*
                 *  提供关于类的单个构造方法的信息以及对它的访问权限。得到的构造方法只能是public类型的。
                 */
                Constructor[] cons=c.getConstructors();
                for(Constructor con:cons){
                    System.out.println(con);
                }
                System.out.println("------------------------");
                /*
                 * 返回 Method 对象的一个数组,这些对象反映此 Class 对象表示的类或接口声明的所有方法,
                 * 包括公共、保护、默认(包)访问和私有方法,但不包括继承的方法。
                 */
                Method[] ms=c.getDeclaredMethods();
                for(Method m:ms){
                    System.out.println(m);
                }
                System.out.println("------------------------");
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    UserModel类:

    package cn.hncu.reflect.test;

    import java.io.Serializable;

    /**
     * 用户uuid,name
     *@author <a"283505495@qq.com">lxd</a>
     *@version 1.0 2017-3-20 下午1:56:33
     *@fileName UserModel.java
     */
    interface Intera{
        public void aa();
    }
    public class UserModel implements Serializable{
        private static final long serialVersionUID = 1L;
        private String uuid;
        private String name;
        private int type;
        private String pwd;

        public UserModel(String uuid, String name, int type, String pwd) {
            super();
            this.uuid = uuid;
            this.name = name;
            this.type = type;
            this.pwd = pwd;
        }

        public UserModel(String uuid, String name, int type) {
            super();
            this.uuid = uuid;
            this.name = name;
            this.type = type;
        }

        public UserModel(){

        }
        public void a(){
            System.out.println("我是接口的抽象方法");
        }
        public String getUuid() {
            return uuid;
        }
        public void setUuid(String uuid) {
            this.uuid = uuid;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public int getType() {
            return type;
        }
        public void setType(int type) {
            this.type = type;
        }
        public String getPwd() {
            return pwd;
        }
        public void setPwd(String pwd) {
            this.pwd = pwd;
        }
        public static long getSerialversionuid() {
            return serialVersionUID;
        }
        @Override
        public int hashCode() {
            final int prime = 31;
            int result = 1;
            result = prime * result + ((uuid == null) ? 0 : uuid.hashCode());
            return result;
        }
        @Override
        public boolean equals(Object obj) {
            if (this == obj)
                return true;
            if (obj == null)
                return false;
            if (getClass() != obj.getClass())
                return false;
            UserModel other = (UserModel) obj;
            if (uuid == null) {
                if (other.uuid != null)
                    return false;
            } else if (!uuid.equals(other.uuid))
                return false;
            return true;
        }
        @Override
        public String toString() {
            return "ID:\t" + uuid + "  , \t" + name + "\t , " + (type);
        }
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    运行结果:

    private static final long cn.hncu.reflect.test.UserModel.serialVersionUID
    private java.lang.String cn.hncu.reflect.test.UserModel.uuid
    private java.lang.String cn.hncu.reflect.test.UserModel.name
    private int cn.hncu.reflect.test.UserModel.type
    private java.lang.String cn.hncu.reflect.test.UserModel.pwd
    ------------------------
    public cn.hncu.reflect.test.UserModel()
    public cn.hncu.reflect.test.UserModel(java.lang.String,java.lang.String,int)
    public cn.hncu.reflect.test.UserModel(java.lang.String,java.lang.String,int,java.lang.String)
    ------------------------
    public java.lang.String cn.hncu.reflect.test.UserModel.toString()
    public int cn.hncu.reflect.test.UserModel.hashCode()
    public boolean cn.hncu.reflect.test.UserModel.equals(java.lang.Object)
    public java.lang.String cn.hncu.reflect.test.UserModel.getName()
    public int cn.hncu.reflect.test.UserModel.getType()
    public void cn.hncu.reflect.test.UserModel.setName(java.lang.String)
    public static long cn.hncu.reflect.test.UserModel.getSerialversionuid()
    public java.lang.String cn.hncu.reflect.test.UserModel.getUuid()
    public void cn.hncu.reflect.test.UserModel.setType(int)
    public void cn.hncu.reflect.test.UserModel.setPwd(java.lang.String)
    public void cn.hncu.reflect.test.UserModel.a()
    public java.lang.String cn.hncu.reflect.test.UserModel.getPwd()
    public void cn.hncu.reflect.test.UserModel.setUuid(java.lang.String)
    ------------------------
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    反射使用的三个步骤
    用于反射的类,如Method,可以在java.lang.reflect包中找到。使用这些类的时候必须要遵循三个步骤:

    第一步:获得你想操作的类的java.lang.Class对象。在运行中的Java程序中,用java.lang.Class类来描述类和接口等。
    第二步:调用诸如getDeclaredMethods的方法,取得该类中定义的所有方法的列表。
    第三步:使用反射的API来操作这些信息。
    如下面这段代码:
    Class c = Class.forName("java.lang.String");
    Method ms[] = c.getDeclaredMethods();
    System.out.println(ms[0].toString());
    1
    2
    3
    4
    它将以文本方式打印出String中定义的第一个方法的原型。

    获取Class对象的三种方式:
    ★ 方式一
    通过对象的getClass方法进行获取。这种方式需要具体的类和该类的对象,以及调用getClass方法。

    ★ 方式二
    任何数据类型(包括基本数据类型)都具备着一个静态的属性class,通过它可直接获取到该类型对应的Class对象。这种方式要使用具体的类,然后调用类中的静态属性class完成,无需调用方法,性能更好。

    ★ 方式三
    通过Class.forName()方法获取。这种方式仅需使用类名,就可以获取该类的Class对象,更有利于扩展。

    代码演示:
    package cn.hncu.reflect.test;
    import org.junit.Test;
    /**
     * 1、演示获取Class c对象的三种方法
     *@author <a"283505495@qq.com">lxd</a>
     *@version 1.0 2017-4-15 下午2:57:05
     *@fileName ReflectGetClass.java
     */
    public class ReflectGetClass {

        /**
         * 法1:通过对象---对象.getClass()来获取c(一个Class对象)
         */
        @Test
        public void get1(){
            Person p=new Person("Jack", 23);
            Class c=p.getClass();//来自Object方法
        }

        /**
         * 法2:通过类(类型)---任何数据类型包括(基本数据类型)都有一个静态的属性class ,他就是c 一个Class对象
         */
        @Test
        public void get2(){
            Class c=Person.class;
            Class c2=int.class;
        }

        /**
         * 法3:通过字符串(类全名 )---能够实现解耦:Class.forName(str)
         */
        @Test
        public void get3(){
            try {
                Class c=Class.forName("cn.hncu.reflect.test.Person");
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }

    }
     

    展开全文
  • Java的反射

    2020-05-30 15:09:22
    Java代码在计算机中经历三个阶段: 1.Source源代码阶段:(代码没进内存还在硬盘上)Java源码 通过编译器 javac编译 编译成Java字节码 .class文件 2.Class类对象阶段:将字节码文件通过类加载器ClassLoader加载到...
  • (2)反射(Reflection)是Java程序开发语言的特征之一,它允许运行中Java程序对自身进行检查, 也称自审,并能直接操作程序内部属性。例如,使用它能获得Java类中各成员名称并显示出来。 (3)Java这一能力在...
  • JAVA-反射的应用

    2020-11-30 15:17:39
    在Java语言里之所以会有如此众多开源技术支撑,很大一部分来自于java最大的特征——反射机制,项目开发与设计不能灵活使用反射机制,则并未接触到java精髓。后期自定义开发框架 二、所有技术实现目标...
  • 反射是Java程序开发语言的特征之一,它允许运行中java程序对自身进行检查,并能直接操作程序内部属性和方法 一.获取Class对象 获取Class对象就是让Class对象获得一类内部属性和方法,有种方式 方式一 通过...
  • 代理类与委托类之间通常会存在关联关系,一代理类对象与一委托类对象关联,代理类对象本身并不真正实现服务,而是通过调用委托类对象相关方法,来提供特定服务。  按照代理创建时期,代理类可以...
  • 通过Java反射机制剖析(一)和Java反射机制剖析(二)学习,已经对反射有了一定了解,这一篇通过动态代理例子来进一步学习反射机制。 1.代理模式 代理模式就是为其他对象提供一种代理来控制对这对象...
  • Java反射

    2019-07-16 22:47:10
    1、定义 Java的反射技术是java程序的特征之一,它允许运行中的Java程序对自身进行检查,或者说“自审”,并能直接操作程序的内部属性。...对象创建过程:比如要创建Dog类的三个对象   &nbs...
  • 他定义了三个损失函数,分别衡量的是特征损失Lfeat(还原后无反射图像的信息的特征准确度),Ladv,对抗损失,其实用的只是GAN的descirmator衡量图像真实性的值来做损失函数,Lexcl,衡量去反射的...
  • 反射

    2009-11-02 15:24:00
    Reflection 是 Java 程序开发语言的特征之一,它允许运行中 Java 程序对自身进行检查,或者说“自审”,并能直接操作程序内部属性。...使用这些类时候必须要遵循三个步骤:1.第一步是获得你想操作
  • 二、反射的用途 、reflectionDemoTest 3.1 新建一测试bo 3.2 写测试Demo 3.3 运行demo 一、java反射机制概念 反射 (Reflection) 是 Java 的特征之一,它允许运行中的 Java 程序获取自身的信息,并且可以...
  • 反射学习

    2019-01-27 23:57:07
    反射的概念和特点:  java的三大特性:封装 继承 多态  java的核心思想: 面向对象 万事万物皆对象  java的类: 具备相同特征的对象的模板  一类的具体对象可以存储一类的所有信息; 可以 创建一类...
  • 通过反射灵敏度分析从15个最佳波长中选出的三个集成特征的分类模型(仅占全波长的16.0%)实现了97.4%的测试集分类精度。 配对t检验表明,使用三个积分特征的十五个波长分类模型与使用三个积分特征的全光谱模型...
  • 在面向对象中有特征:继承、多态、封装 这里对继承和封装就不做说明了。 什么是多态?这里说一下我理解。 多态就是同一方法在不同参数下不同形态,例如方法重载 多态明显体现就是在我们连接数据库...
  • 反射1

    2016-05-08 18:08:41
    反射: 基本特征: 允许运行中Java程序对自身进行检查,或者说自审,并能直接操作程序内部属性 ...通过class对象探究这信息 操作探究出信息 获取class对象: 种方式: New
  • 多态是OOP的三特征之一 字面意思:多种形态 多种状态 官方描述:不同的对象可以响应(调用)同一方法 产生不同的结果(例如水的三相特征) 多态不是什么新技术 我们编写面向对象的程序时 其实就有多态存在...

空空如也

空空如也

1 2 3 4 5 ... 15
收藏数 286
精华内容 114
关键字:

反射的三个特征