精华内容
下载资源
问答
  • 当你想在你的程序中使用类时,你会从类中创建一个对象也是面向对象由来。Python 并不总是面向对象的,但是你会在你的项目中用到对象。为了理解类,你需要理解面向对象的一些基础术语。 常用术语 class:类...
  • 浅谈一下JAVA对象对象引用以及对象赋值

    万次阅读 多人点赞 2013-09-19 00:50:29
    浅谈一下JAVA对象对象引用以及对象赋值   今天有班级同学问起JAVA对象的引用是什么。正好趁着这次机会,自己总结一下JAVA对象对象引用以及对象赋值。自己总结了所看到的网上相关方面的不少帖子,整理汇总形成...
     
    

       浅谈一下JAVA对象,对象引用以及对象赋值

             今天有班级同学问起JAVA对象的引用是什么。正好趁着这次机会,自己总结一下JAVA对象,对象引用以及对象赋值。自己总结了所看到的网上相关方面的不少帖子,整理汇总形成下面的文章。

     

    Java对象及其引用

        初学Java,总是会自觉或不自觉地把Java和C++相比较。在学习Java类与对象章节的时候,发现教科书和许多参考书把对象和对象的引用混为一谈。可是,如果分不清对象与对象引用, 那实在没法很好地理解下面的面向对象技术。把自己的一点认识写下来,或许能让初学Java的朋友们少走一点弯路。

        为便于说明,我们先定义一个简单的类:

        class Vehicle {

            int passengers;      

            int fuelcap;

            int mpg;

         }

        有了这个模板,就可以用它来创建对象:

           Vehicle veh1 = new Vehicle();

        通常把这条语句的动作称之为创建一个对象,其实,它包含了四个动作。

        1)右边的“new Vehicle”,是以Vehicle类为模板,在堆空间里创建一个Vehicle类对象(也简称为Vehicle对象)。

        2)末尾的()意味着,在对象创建后,立即调用Vehicle类的构造函数,对刚生成的对象进行初始化。构造函数是肯定有的。如果你没写,Java会给你补上一个默认的构造函数。

        3)左边的“Vehicle veh 1”创建了一个Vehicle类引用变量。所谓Vehicle类引用,就是以后可以用来指向Vehicle对象的对象引用。

        4)“=”操作符使对象引用指向刚创建的那个Vehicle对象。

        我们可以把这条语句拆成两部分:

        Vehicle veh1;

        veh1 = new Vehicle();

    效果是一样的。这样写,就比较清楚了,有两个实体:一是对象引用变量,一是对象本身。

        在堆空间里创建的实体,与在数据段以及栈空间里创建的实体不同。尽管它们也是确确实实存在的实体,但是,我们看不见,也摸不着。不仅如此,我们仔细研究一下第二句,找找刚创建的对象叫什么名字?有人说,它叫“Vehicle”。不对,“Vehicle”是类(对象的创建模板)的名字。

        一个Vehicle类可以据此创建出无数个对象,这些对象不可能全叫“Vehicle”。

        对象连名都没有,没法直接访问它。我们只能通过对象引用来间接访问对象。

        为了形象地说明对象、引用及它们之间的关系,可以做一个或许不很妥当的比喻。对象好比是一只很大的气球,大到我们抓不住它。引用变量是一根绳, 可以用来系汽球。

        如果只执行了第一条语句,还没执行第二条,此时创建的引用变量veh1还没指向任何一个对象,它的值是null。引用变量可以指向某个对象,或者为null。

        它是一根绳,一根还没有系上任何一个汽球的绳。执行了第二句后,一只新汽球做出来了,并被系在veh1这根绳上。我们抓住这根绳,就等于抓住了那只汽球。

        再来一句:

        Vehicle veh2;

    就又做了一根绳,还没系上汽球。如果再加一句:

           veh2 = veh1;

    系上了。这里,发生了复制行为。但是,要说明的是,对象本身并没有被复制,被复制的只是对象引用。结果是,veh2也指向了veh1所指向的对象。两根绳系的是同一只汽球。

        如果用下句再创建一个对象:

    veh2 = new Vehicle();

    则引用变量veh2改指向第二个对象。

        从以上叙述再推演下去,我们可以获得以下结论:

        (1)一个对象引用可以指向0个或1个对象(一根绳子可以不系汽球,也可以系一个汽球);

        (2)一个对象可以有N个引用指向它(可以有N条绳子系住一个汽球)。

        如果再来下面语句:

           veh1 = veh2;

        按上面的推断,veh1也指向了第二个对象。这个没问题。问题是第一个对象呢?没有一条绳子系住它,它飞了。多数书里说,它被Java的垃圾回收机制回收了。这不确切。正确地说,它已成为垃圾回收机制的处理对象。至于什么时候真正被回收,那要看垃圾回收机制的心情了。

        由此看来,下面的语句应该不合法吧?至少是没用的吧?

        new Vehicle();

    不对。它是合法的,而且可用的。譬如,如果我们仅仅为了打印而生成一个对象,就不需要用引用变量来系住它。最常见的就是打印字符串:

        System.out.println(“I am Java!”);

    字符串对象“I am Java!”在打印后即被丢弃。有人把这种对象称之为临时对象。对象与引用的关系将持续到对象回收。

      

    另一个角度分析Java对象和引用以及与其密切相关的参数传递

        先看下面的程序:

        StringBuffer s;

        s = new StringBuffer("Hello World!");

        第一个语句仅为引用(reference)分配了空间,而第二个语句则通过调用类(StringBuffer)的构造函数StringBuffer(String str)为类生成了一个实例(或称为对象)。这两个操作被完成后,对象的内容则可通过s进行访问——在Java里都是通过引用来操纵对象的。

        Java对象和引用的关系可以说是互相关联,却又彼此独立。彼此独立主要表现在:引用是可以改变的,它可以指向别的对象,譬如上面的s,你可以给它另外的对象,如:

    s = new StringBuffer("Java");这样一来,s就和它指向的第一个对象脱离关系。

        从存储空间上来说,对象和引用也是独立的,它们存储在不同的地方,对象一般存储在堆中,而引用存储在速度更快的堆栈中。

        引用可以指向不同的对象,对象也可以被多个引用操纵,如:

        StringBuffer s1 = s;

    这条语句使得s1和s指向同一个对象。既然两个引用指向同一个对象,那么不管使用哪个引用操纵对象,对象的内容都发生改变,并且只有一份,通过s1和s得到的内容自然也一样,(String除外,因为String始终不变,String s1=”AAAA”; String s=s1,操作s,s1由于始终不变,所以为s另外开辟了空间来存储s,)如下面的程序:

        StringBuffer s;

        s = new StringBuffer("Java");

        StringBuffer s1 = s;

        s1.append(" World");

        System.out.println("s1=" + s1.toString());//打印结果为:s1=Java World

        System.out.println("s=" + s.toString());//打印结果为:s=Java World

        上面的程序表明,s1和s打印出来的内容是一样的,这样的结果看起来让人非常疑惑,但是仔细想想,s1和s只是两个引用,它们只是操纵杆而已,它们指向同一个对象,操纵的也是同一个对象,通过它们得到的是同一个对象的内容。这就像汽车的刹车和油门,它们操纵的都是车速,假如汽车开始的速度是80,然后你踩了一次油门,汽车加速了,假如车速升到了120,然后你踩一下刹车,此时车速是从120开始下降的,假如下降到60,再踩一次油门,车速则从60开始上升,而不是从第一次踩油门后的120开始。也就是说车速同时受油门和刹车影响,它们的影响是累积起来的,而不是各自独立(除非刹车和油门不在一辆车上)。所以,在上面的程序中,不管使用s1还是s操纵对象,它们对对象的影响也是累积起来的(更多的引用同理)。

     

        只有理解了对象和引用的关系,才能理解参数传递。

        一般面试题中都会考Java传参的问题,并且它的标准答案是Java只有一种参数传递方式:那就是按值传递,即Java中传递任何东西都是传值。如果传入方法的是基本类型的东西,你就得到此基本类型的一份拷贝。如果是传递引用,就得到引用的拷贝。

        一般来说,对于基本类型的传递,我们很容易理解,而对于对象,总让人感觉是按引用传递,看下面的程序:

        public class ObjectRef {

        //基本类型的参数传递

            public static void testBasicType(int m) {

                 System.out.println("m=" + m);//m=50

                 m = 100;

                 System.out.println("m=" + m);//m=100

            }

        //参数为对象,不改变引用的值

            public static void add(StringBuffer s) {

                s.append("_add");

            }

        //参数为对象,改变引用的值

           public static void changeRef(StringBuffer s) {

               s = new StringBuffer("Java");

           }

        public static void main(String[] args) {

            int i = 50;

            testBasicType(i);

            System.out.println(i);//i=50

            StringBuffer sMain = new StringBuffer("init");

            System.out.println("sMain=" + sMain.toString());//sMain=init

            add(sMain);

            System.out.println("sMain=" + sMain.toString());//sMain=init_add

            changeRef(sMain);

            System.out.println("sMain=" + sMain.toString());//sMain=init_add

        }

    }

    以上程序的允许结果显示出,testBasicType方法的参数是基本类型,尽管参数m的值发生改变,但并不影响i。

        add方法的参数是一个对象,当把sMain传给参数s时,s得到的是sMain的拷贝,所以s和sMain指向同一个对象,因此,使用s操作影响的其实就是sMain指向的对象,故调用add方法后,sMain指向的对象的内容发生了改变。

        在changeRef方法中,参数也是对象,当把sMain传给参数s时,s得到的是sMain的拷贝,但与add方法不同的是,在方法体内改变了s指向的对象(也就是s指向了别的对象,牵着气球的绳子换气球了),给s重新赋值后,s与sMain已经毫无关联,它和sMain指向了不同的对象,所以不管对s做什么操作,都不会影响sMain指向的对象,故调用changeRef方法前后sMain指向的对象内容并未发生改变。

        对于add方法的调用结果,可能很多人会有这种感觉:这不明明是按引用传递吗?对于这种问题,还是套用Bruce Eckel的话:这依赖于你如何看待引用,最终你会明白,这个争论并没那么重要。真正重要的是,你要理解,传引用使得(调用者的)对象的修改变得不可预期。

     public   class   Test

      public int   i,j;  
        public   void   test_m(Test   a){    

              Test   b   =  new   Test();
              b.i   =   1;
              b.j   =   2;
              a   =   b;
        }
        public   void   test_m1(Test a){   

            a.i   =   1;
            a.j   =   2;
        }
        public   static   void   main(String   argv[]){ 

              Test  t =  new   Test();
              t.i   =   5;
              t.j   =   6;
              System.out.println( "t.i   =   "+   t.i   +   "   t.j=   "   +   t.j); //5,6
              t.test_m(t);
              System.out.println( "t.i   =   "+   t.i   +   "   t.j=   "   +   t.j); //5,6,a和t都指向了一个对象,而在test_m中s又指向了另一个对象,所以对象t不变!!!

              t.test_m1(t);

              System.out.println( "t.i   =   "+   t.i   +   "   t.j=   "   +   t.j); //1,2

        }

    }

    答案只有一个:Java里都是按值传递参数。而实际上,我们要明白,当参数是对象时,传引用会发生什么状况(就像上面的add方法)。

    =========================================================================

        楼主,这样来记这个问题
        如下表达式:
    A a1 = new A();
    它代表A是类,a1是引用,a1不是对象,new A()才是对象,a1引用指向new A()这个对象。

        在JAVA里,“=”不能被看成是一个赋值语句,它不是在把一个对象赋给另外一个对象,它的执行过程实质上是将右边对象的地址传给了左边的引用,使得左边的引用指向了右边的对象。JAVA表面上看起来没有指针,但它的引用其实质就是一个指针,引用里面存放的并不是对象,而是该对象的地址,使得该引用指向了对象。在JAVA里,“=”语句不应该被翻译成赋值语句,因为它所执行的确实不是一个赋值的过程,而是一个传地址的过程,被译成赋值语句会造成很多误解,译得不准确。 

        再如:
    A a2;
    它代表A是类,a2是引用,a2不是对象,a2所指向的对象为空null;

        再如:
    a2 = a1;
    它代表,a2是引用,a1也是引用,a1所指向的对象的地址传给了a2(传址),使得a2和a1指向了同一对象。

        综上所述,可以简单的记为,在初始化时,“=”语句左边的是引用,右边new出来的是对象。
    在后面的左右都是引用的“=”语句时,左右的引用同时指向了右边引用所指向的对象。

        再所谓实例,其实就是对象的同义词。

     

        如果需要赋值,就需要类实现Cloneable接口,实现clone()方法。

     
    class D implements Cloneable{//实现Cloneable接口
     String sex;
     D(String sex){
      this.sex=sex;
     }
     @Override
     protected Object clone() throws CloneNotSupportedException {
      // 实现clone方法
      return super.clone();
     }
    }

      赋值的时候:

     
    D d=new D("男");
    D d2=(D) d.clone();//把d赋值给d2

        如果类中的变量不是主类型,而是对象,也需要调用该对象的clone()方法
    下面是一个完整的例子:

     

    public class Test2 {  public static void main(String[] args) throws CloneNotSupportedException {   // TODO Auto-generated method stub   D d=new D("男");   C c=new C("张三","20",d);   C new_c=(C) c.clone();//调用clone方法来赋值   new_c.name="李四";   d.sex="女";//d   System.out.println(c.d.sex);   System.out.println(c.name);    }   }   class C implements Cloneable{  String name;  String age;  D d;  C(String name,String age,D d) throws CloneNotSupportedException{   this.name=name;   this.age=age;   this.d=(D) d.clone();//调用clone方法来赋值,这样即便外部的d发生变化,c里的也不会变  }  @Override  protected Object clone() throws CloneNotSupportedException {   // TODO Auto-generated method stub   return super.clone();  } } class D implements Cloneable{//实现Cloneable接口  String sex;  D(String sex){   this.sex=sex;  }  @Override  protected Object clone() throws CloneNotSupportedException {   // 实现clone方法   return super.clone();  } }

     

     

     

    Java强引用、 软引用、 弱引用、虚引用

          既然讨论到了java的引用问题,自然就会想到java的引用分为几种情况,下面详细说一下Java的四种引用。

     1、对象的强、软、弱和虚引用
        在JDK 1.2以前的版本中,若一个对象不被任何变量引用,那么程序就无法再使用这个对象。也就是说,只有对象处于可触及(reachable)状态,程序才能使用它。从JDK 1.2版本开始,把对象的引用分为4种级别,从而使程序能更加灵活地控制对象的生命周期。这4种级别由高到低依次为:强引用、软引用、弱引用和虚引用。

                  图1

    图1为对象应用类层次
        1)强引用(StrongReference)
        强引用是使用最普遍的引用。如果一个对象具有强引用,那垃圾回收器绝不会回收它。当内存空间不足,Java
    虚拟机宁愿抛出OutOfMemoryError错误,使程序异常终止,也不会靠随意回收具有强引用的对象来解决内存不足的问题。
        2)软引用(SoftReference)
        如果一个对象只具有软引用,则内存空间足够,垃圾回收器就不会回收它;如果内存空间不足了,就会回收这些对象的内存。只要垃圾回收器没有回收它,该对象就可以被程序使用。软引用可用来实现内存敏感的高速缓存(下文给出示例)。
        软引用可以和一个引用队列(ReferenceQueue)联合使用,如果软引用所引用的对象被垃圾回收器回收,Java虚拟机就会把这个软引用加入到与之关联的引用队列中。

    3) 弱引用(WeakReference)
        弱引用与软引用的区别在于:弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程中,一旦发现了只具有弱引用的对象,不管当前内存空间足够与否,都会回收它的内存。不过,由于垃圾回收器是一个优先级很低的线程,因此不一定会很快发现那些只具有弱引用的对象。
        弱引用可以和一个引用队列(ReferenceQueue)联合使用,如果弱引用所引用的对象被垃圾回收,Java虚拟机就会把这个弱引用加入到与之关联的引用队列中。

     4)虚引用(PhantomReference)
        “虚引用”顾名思义,就是形同虚设,与其他几种引用都不同,虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用,那么它就和没有任何引用一样,在任何时候都可能被垃圾回收器回收。虚引用主要用来跟踪对象被垃圾回收器回收的活动。虚引用与软引用和弱引用的一个区别在于:虚引用必须和引用队列(ReferenceQueue)联合使用。当垃圾回收器准备回收一个对象时,如果发现它还有虚引用,就会在回收对象的内存之前,把这个虚引用加入到与之 关联的引用队列中。
     
        程序可以通过判断引用队列中是否已经加入了虚引用,来了解被引用的对象是否将要被垃圾回收。如果程序发现某个虚引用已经被加入到引用队列,那么就可以在所引用的对象的内存被回收之前采取必要的行动。
    2、对象可及性的判断
        在很多时候,一个对象并不是从根集直接引用的,而是一个对象被其他对象引用,甚至同时被几个对象所引用,从而构成一个以根集为顶的树形结构。如图2所示

        在这个树形的引用链中,箭头的方向代表了引用的方向,所指向的对象是被引用对象。由图可以看出,从根集到一个对象可以由很多条路径。比如到达对象5的路径就有①-⑤,③-⑦两条路径。由此带来了一个问题,那就是某个对象的可达性如何判断:
        单条引用路径可达性判断:在这条路径中,最弱的一个引用决定对象的可达性。
        多条引用路径可达性判断:几条路径中,最强的一条的引用决定对象的可达性。
        比如,我们假设图2中引用①和③为强引用,⑤为软引用,⑦为弱引用,对于对象5按照这两个判断原则,路径①-⑤取最弱的引用⑤,因此该路径对对象5的引用为软引用。同样,③-⑦为弱引用。在这两条路径之间取最强的引用,于是对象5是一个软可达对象。


    3、使用软引用构建敏感数据的缓存


    3.1 为什么需要使用软引用

        首先,我们看一个雇员信息查询系统的实例。我们将使用一个Java语言实现的雇员信息查询系统查询存储在磁盘文件或者
    数据库中的雇员人事档案信息。作为一个用户,我们完全有可能需要回头去查看几分钟甚至几秒钟前查看过的雇员档案信息(同样,我们在浏览WEB页面的时候也经常会使用“后退”按钮)。这时我们通常会有两种程序实现方式:一种是把过去查看过的雇员信息保存在内存中,每一个存储了雇员档案信息的Java对象的生命周期贯穿整个应用程序始终;另一种是当用户开始查看其他雇员的档案信息的时候,把存储了当前所查看的雇员档案信息的Java对象结束引用,使得垃圾收集线程可以回收其所占用的内存空间,当用户再次需要浏览该雇员的档案信息的时候,重新构建该雇员的信息。很显然,第一种实现方法将造成大量的内存浪费,而第二种实现的缺陷在于即使垃圾收集线程还没有进行垃圾收集,包含雇员档案信息的对象仍然完好地保存在内存中,应用程序也要重新构建一个对象。我们知道,访问磁盘文件、访问网络资源、查询数据库等操作都是影响应用程序执行性能的重要因素,如果能重新获取那些尚未被回收的Java对象的引用,必将减少不必要的访问,大大提高程序的运行速度。

     
    3.2 如果使用软引用
        SoftReference的特点是它的一个实例保存对一个Java对象的软引用,该软引用的存在不妨碍垃圾收集线程对该Java对象的回收。也就是说,一旦SoftReference保存了对一个Java对象的软引用后,在垃圾线程对这个Java对象回收前,SoftReference类所提供的get()方法返回Java对象的强引用。另外,一旦垃圾线程回收该Java对象之后,get()方法将返回null。看下面代码:
        MyObject  aRef  =  new   MyObject();
        SoftReference  aSoftRef = new  SoftReference( aRef );
        此时,对于这个MyObject对象,有两个引用路径,一个是来自SoftReference对象的软引用,一个来自变量aRef的强引用,所以这个MyObject对象是强可及对象。
    随即,我们可以结束aRef对这个MyObject实例的强引用:
        aRef  =  null ;
        此后,这个MyObject对象成为了软可达对象。如果垃圾收集线程进行内存垃圾收集,并不会因为有一个SoftReference对该对象的引用而始终保留该对象。Java虚拟机的垃圾收集线程对软可达对象和其他一般Java对象进行了区别对待:软可及对象的清理是由垃圾收集线程根据其特定算法按照内存需求决定的。也就是说,垃圾收集线程会在虚拟机抛出OutOfMemoryError之前回收软可及对象,而且虚拟机会尽可能优先回收长时间闲置不用的软可达对象,对那些刚刚构建的或刚刚使用过的软可达对象会被虚拟机尽可能保留。在回收这些对象之前,我们可以通过:
        MyObject  anotherRef =(MyObject) aSoftRef .get()
        重新获得对该实例的强引用。而回收之后,调用get()方法就只能得到null了。
     
    3.3 使用ReferenceQueue清除失去了软引用对象的SoftReference
        作为一个Java对象,SoftReference对象除了具有保存软引用的特殊性之外,也具有Java对象的一般性。所以,当软可及对象被回收之后,虽然这个SoftReference对象的get()方法返回null,但这个SoftReference对象已经不再具有存在的价值,需要一个适当的清除机制,避免大量SoftReference对象带来的内存泄漏。在java.lang.ref包里还提供了ReferenceQueue。如果在创建SoftReference对象的时候,使用了一个ReferenceQueue对象作为参数提供给SoftReference的构造方法,如:
        ReferenceQueue  queue  =  new   ReferenceQueue();
        SoftReference   ref = new   SoftReference( aMyObject ,  queue );
        那么当这个SoftReference所软引用的aMyOhject被垃圾收集器回收的同时,ref所强引用的SoftReference对象被列入ReferenceQueue。也就是说,ReferenceQueue中保存的对象是Reference对象,而且是已经失去了它所软引用的对象的Reference对象。另外从ReferenceQueue这个名字也可以看出,它是一个队列,当我们调用它的poll()方法的时候,如果这个队列中不是空队列,那么将返回队列前面的那个Reference对象。
        在任何时候,我们都可以调用ReferenceQueue的poll()方法来检查是否有它所关心的非强可达对象被回收。如果队列为空,将返回一个null,否则该方法返回队列中前面的一个Reference对象。利用这个方法,我们可以检查哪个SoftReference所软引用的对象已经被回收。于是我们可以把这些失去所软引用的对象的SoftReference对象清除掉。常用的方式为:
        SoftReference ref =  null ;
        while  ((ref = (SoftReference)q .poll()) !=  null ) {
         // 清除 ref
        }
        理解了ReferenceQueue的工作机制之后,我们就可以开始构造一个Java对象的高速缓存器了。
     
    3.4通过软可及对象重获方法实现Java对象的高速缓存
        利用Java2平台垃圾收集机制的特性以及前述的垃圾对象重获方法,我们通过一个雇员信息查询
    系统的小例子来说明如何构建一种高速缓存器来避免重复构建同一个对象带来的性能损失。我们将一个雇员的档案信息定义为一个Employee类:
    public   class  Employee {
         private  String  id ; // 雇员的标识号码
         private  String  name ; // 雇员姓名
         private  String  department ; // 该雇员所在部门
         private  String  Phone ; // 该雇员联系电话
         private   int   salary ; // 该雇员薪资
         private  String  origin ; // 该雇员信息的来源


         // 构造方法
         public  Employee(String id) {
            this . id  = id;
           getDataFromlnfoCenter();
        }


         // 到数据库中取得雇员信息
         private   void  getDataFromlnfoCenter() {
            // 和数据库建立连接井查询该雇员的信息,将查询结果赋值
            // 给 name, department, plone, salary等变量
            // 同时将 origin赋值为 "From DataBase"
        }
    ……
    }
        这个Employee类的构造方法中我们可以预见,如果每次需要查询一个雇员的信息。哪怕是几秒中之前刚刚查询过的,都要重新构建一个实例,这是需要消耗很多时间的。下面是一个对Employee对象进行缓存的缓存器的定义:
     
    import  java.lang.ref.ReferenceQueue;
    import  java.lang.ref.SoftReference;
    import  java.util.Hashtable;


    public   class  EmployeeCache {
         static  private  EmployeeCache  cache ; // 一个 Cache实例
         private  Hashtable<String, EmployeeRef>  employeeRefs ; // 用于 Chche内容的存储
         private  ReferenceQueue<Employee>  q ; // 垃圾 Reference的队列

         // 继承 SoftReference,使得每一个实例都具有可识别的标识,
         // 并且该标识与其在 HashMap内的 key相同。
         private class EmployeeRef extends SoftReference<Employee> {
            private  String  _key  =  "" ;


            public  EmployeeRef(Employee em, ReferenceQueue<Employee> q) {
                super (em, q);
                _key  = em.getID();
           }
        }

         // 构建一个缓存器实例
         private  EmployeeCache() {
            employeeRefs  =  new  Hashtable<String,EmployeeRef>();
            q  =  new  ReferenceQueue<Employee>();
        }

         // 取得缓存器实例
         public   static synchronized EmployeeCache getInstance() {
           if  (cache == null){
                cache = new EmployeeCache();
           }
           return cache ;
        }


         // 以软引用的方式对一个 Employee对象的实例进行引用并保存该引用
         private   void  cacheEmployee(Employee em) {
           cleanCache(); // 清除垃圾引用
           EmployeeRef ref =  new  EmployeeRef(em,  q );
            employeeRefs .put(em.getID(), ref);
        }

         // 依据所指定的 ID号,重新获取相应 Employee对象的实例
         public  Employee getEmployee(String ID) {
           Employee em =  null ;
            // 缓存中是否有该 Employee实例的软引用,如果有,从软引用中取得。
            if  ( employeeRefs .containsKey(ID)) {
               EmployeeRef ref = (EmployeeRef)  employeeRefs .get(ID);
               em = (Employee) ref.get();
           }
            // 如果没有软引用,或者从软引用中得到的实例是 null,重新构建一个实例,
            // 并保存对这个新建实例的软引用
            if  (em ==  null ) {
               em =  new  Employee(ID);
               System. out .println( "Retrieve From EmployeeInfoCenter. ID="  + ID);
                this .cacheEmployee(em);
           }
            return  em;
        }


         // 清除那些所软引用的 Employee对象已经被回收的 EmployeeRef对象
         private   void  cleanCache() {
           EmployeeRef ref =  null ;
            while  ((ref = (EmployeeRef)  q .poll()) !=  null ) {
                employeeRefs .remove(ref. _key );
           }
        }

    }

    结语:

           上述是从自己见过的感觉对理解Java对象,对象引用以及对象赋值,目前最优价值的帖子中挑选而来。希望对大家有用。

     

     

    主要参考资料

    http://blog.sina.com.cn/s/blog_4cd5d2bb0100ve9r.html

    http://bxkqzjt521.blog.163.com/blog/static/202818420119102362458/

    http://www.2cto.com/kf/201207/139522.html

     

     

    展开全文
  • 在讨论这个问题之前,我们先探讨一下类的由来。“类”在英语对应的单词是“Class”,如果大家翻一翻英语词典就可以查到“Class”的原意是指“种类、把...分类(或分等级)”。Class的概念最早应该是从分类学来的,
  • 在整个程序执行期间拥有着不同状态而其她方面都相相似的对象会被分组到对象的一集合中,而这个集合就是类(也是class的由来)。创建抽象数据类型(类)是面向对象程序设计的思想。 抽象数据类型的运行方式与...

    所有对象都是唯一的,但同时也是具有相同的特性和行为的特性和行为的对象所归属的类的一部分。
    在整个程序执行期间拥有着不同状态而其她方面都相相似的对象会被分组到对象的一个集合中,而这个集合就是类(这也是class的由来)。创建抽象数据类型(类)是面向对象程序设计的思想。
    抽象数据类型的运行方式与内置(built in)类型几乎一致:{这里提示一下内置数据类型又称为源生数据类型(例如int float double 等等)而抽象数据类型则是指自己建立的class或者是Java中自带的class。}
    你可以创建某一个类型的变量,然后操作这些变量。
    每个类的成员或者元素都有具有某种共性、同时,每个成员都有其自身的状态、这些实体就是对象,每一个对象都属于定义了特性的行为的某个特定的类。
    尽管我们在面相对象程序设计中实际上进行的是创建行的数据类型,但事实上所有的面向对象的承续设计语言都是用class这个关键词来表示数据类型。但看到类型一词的时候,可以将其看作类(class)来考虑,反之亦然。
    这里他别强调,对某些人而言会区别对待,他们认为:类型决定了接口,而类是该接口的一个特定现实。
    类描述了具有相同特性(数据元素)和行为(功能)的对象集合,所以一个类实际上就是一个数据类型。二者的差异在于,程序员通过定义类来适应问题,为不在被迫的只能使用现有的用来表示机器中的存储单元数据类型可以更换句需求,通过添加新的数据类型来扩展编程语言。编程系统接受类,并且像内置数据类型一样地照管它们和进行类型检查。
    面对对象方法并不是仅局限与构建仿真程序。任何程序都是你所设计的系统的一种仿真。
    类一旦建立,你可以随意的创建类的无数个对象,之后去操作它们,。事实上,面向对象程序设计的问题是在问题空间的元素和解空间的对象之间创建一一对应的映射。
    每个对象都只能满足某些请求,这些请求有对象的接口(interface)所定义,决定接口的便是类型。
    接口确定对某一个特定对象所能发出的请求,,但是在程序中必须有满足这些请求的的代码。这些代码与隐藏的数据一起构建成现实。

    展开全文
  • 深入理解Java类型信息(Class对象)与反射机制

    万次阅读 多人点赞 2017-05-01 23:19:19
    【版权申明】未经博主同意,谢绝转载!(请尊重原创,博主保留追究权) ...深入理解Java类型信息(Class对象)与反射机制 深入理解Java枚举类型(enum) 深入理解Java注解类型(@Annotation) 深入理解

    【版权申明】未经博主同意,谢绝转载!(请尊重原创,博主保留追究权)
    http://blog.csdn.net/javazejian/article/details/70768369
    出自【zejian的博客】

    关联文章:

    深入理解Java类型信息(Class对象)与反射机制

    深入理解Java枚举类型(enum)

    深入理解Java注解类型(@Annotation)

    深入理解Java并发之synchronized实现原理

    深入理解Java内存模型(JMM)及volatile关键字

    深入理解Java类加载器(ClassLoader)

    本篇主要是深入对Java中的Class对象进行分析,这对后续深入理解反射技术非常重要,主要内容如下:

    深入理解Class对象

    RRTI的概念以及Class对象作用

    认识Class对象之前,先来了解一个概念,RTTI(Run-Time Type Identification)运行时类型识别,对于这个词一直是 C++ 中的概念,至于Java中出现RRTI的说法则是源于《Thinking in Java》一书,其作用是在运行时识别一个对象的类型和类的信息,这里分两种:传统的”RRTI”,它假定我们在编译期已知道了所有类型(在没有反射机制创建和使用类对象时,一般都是编译期已确定其类型,如new对象时该类必须已定义好),另外一种是反射机制,它允许我们在运行时发现和使用类型的信息。在Java中用来表示运行时类型信息的对应类就是Class类,Class类也是一个实实在在的类,存在于JDK的java.lang包中,其部分源码如下:

    public final class Class<T> implements java.io.Serializable,GenericDeclaration,Type, AnnotatedElement {
        private static final int ANNOTATION= 0x00002000;
        private static final int ENUM      = 0x00004000;
        private static final int SYNTHETIC = 0x00001000;
    
        private static native void registerNatives();
        static {
            registerNatives();
        }
    
        /*
         * Private constructor. Only the Java Virtual Machine creates Class objects.(私有构造,只能由JVM创建该类)
         * This constructor is not used and prevents the default constructor being
         * generated.
         */
        private Class(ClassLoader loader) {
            // Initialize final field for classLoader.  The initialization value of non-null
            // prevents future JIT optimizations from assuming this final field is null.
            classLoader = loader;
        }

    Class类被创建后的对象就是Class对象,注意,Class对象表示的是自己手动编写类的类型信息,比如创建一个Shapes类,那么,JVM就会创建一个Shapes对应Class类的Class对象,该Class对象保存了Shapes类相关的类型信息。实际上在Java中每个类都有一个Class对象,每当我们编写并且编译一个新创建的类就会产生一个对应Class对象并且这个Class对象会被保存在同名.class文件里(编译后的字节码文件保存的就是Class对象),那为什么需要这样一个Class对象呢?是这样的,当我们new一个新对象或者引用静态成员变量时,Java虚拟机(JVM)中的类加载器子系统会将对应Class对象加载到JVM中,然后JVM再根据这个类型信息相关的Class对象创建我们需要实例对象或者提供静态变量的引用值。需要特别注意的是,手动编写的每个class类,无论创建多少个实例对象,在JVM中都只有一个Class对象,即在内存中每个类有且只有一个相对应的Class对象,挺拗口,通过下图理解(内存中的简易现象图):

    到这我们也就可以得出以下几点信息:

    • Class类也是类的一种,与class关键字是不一样的。

    • 手动编写的类被编译后会产生一个Class对象,其表示的是创建的类的类型信息,而且这个Class对象保存在同名.class的文件中(字节码文件),比如创建一个Shapes类,编译Shapes类后就会创建其包含Shapes类相关类型信息的Class对象,并保存在Shapes.class字节码文件中。

    • 每个通过关键字class标识的类,在内存中有且只有一个与之对应的Class对象来描述其类型信息,无论创建多少个实例对象,其依据的都是用一个Class对象。

    • Class类只存私有构造函数,因此对应Class对象只能有JVM创建和加载

    • Class类的对象作用是运行时提供或获得某个对象的类型信息,这点对于反射技术很重要(关于反射稍后分析)。

    Class对象的加载及其获取方式

    Class对象的加载

    前面我们已提到过,Class对象是由JVM加载的,那么其加载时机是?实际上所有的类都是在对其第一次使用时动态加载到JVM中的,当程序创建第一个对类的静态成员引用时,就会加载这个被使用的类(实际上加载的就是这个类的字节码文件),注意,使用new操作符创建类的新实例对象也会被当作对类的静态成员的引用(构造函数也是类的静态方法),由此看来Java程序在它们开始运行之前并非被完全加载到内存的,其各个部分是按需加载,所以在使用该类时,类加载器首先会检查这个类的Class对象是否已被加载(类的实例对象创建时依据Class对象中类型信息完成的),如果还没有加载,默认的类加载器就会先根据类名查找.class文件(编译后Class对象被保存在同名的.class文件中),在这个类的字节码文件被加载时,它们必须接受相关验证,以确保其没有被破坏并且不包含不良Java代码(这是java的安全机制检测),完全没有问题后就会被动态加载到内存中,此时相当于Class对象也就被载入内存了(毕竟.class字节码文件保存的就是Class对象),同时也就可以被用来创建这个类的所有实例对象。下面通过一个简单例子来说明Class对象被加载的时机问题(例子引用自Thinking in Java):

    package com.zejian;
    
    class Candy {
      static {   System.out.println("Loading Candy"); }
    }
    
    class Gum {
      static {   System.out.println("Loading Gum"); }
    }
    
    class Cookie {
      static {   System.out.println("Loading Cookie"); }
    }
    
    public class SweetShop {
      public static void print(Object obj) {
        System.out.println(obj);
      }
      public static void main(String[] args) {  
        print("inside main");
        new Candy();
        print("After creating Candy");
        try {
          Class.forName("com.zejian.Gum");
        } catch(ClassNotFoundException e) {
          print("Couldn't find Gum");
        }
        print("After Class.forName(\"com.zejian.Gum\")");
        new Cookie();
        print("After creating Cookie");
      }
    }

    在上述代码中,每个类Candy、Gum、Cookie都存在一个static语句,这个语句会在类第一次被加载时执行,这个语句的作用就是告诉我们该类在什么时候被加载,执行结果:

    inside main
    Loading Candy
    After creating Candy
    Loading Gum
    After Class.forName("com.zejian.Gum")
    Loading Cookie
    After creating Cookie
    
    Process finished with exit code 0

    从结果来看,new一个Candy对象和Cookie对象,构造函数将被调用,属于静态方法的引用,Candy类的Class对象和Cookie的Class对象肯定会被加载,毕竟Candy实例对象的创建依据其Class对象。比较有意思的是

    Class.forName("com.zejian.Gum");

    其中forName方法是Class类的一个static成员方法,记住所有的Class对象都源于这个Class类,因此Class类中定义的方法将适应所有Class对象。这里通过forName方法,我们可以获取到Gum类对应的Class对象引用。从打印结果来看,调用forName方法将会导致Gum类被加载(前提是Gum类从来没有被加载过)。

    Class.forName方法

    通过上述的案例,我们也就知道Class.forName()方法的调用将会返回一个对应类的Class对象,因此如果我们想获取一个类的运行时类型信息并加以使用时,可以调用Class.forName()方法获取Class对象的引用,这样做的好处是无需通过持有该类的实例对象引用而去获取Class对象,如下的第2种方式是通过一个实例对象获取一个类的Class对象,其中的getClass()是从顶级类Object继承而来的,它将返回表示该对象的实际类型的Class对象引用。

    public static void main(String[] args) {
    
        try{
          //通过Class.forName获取Gum类的Class对象
          Class clazz=Class.forName("com.zejian.Gum");
          System.out.println("forName=clazz:"+clazz.getName());
        }catch (ClassNotFoundException e){
          e.printStackTrace();
        }
    
        //通过实例对象获取Gum的Class对象
        Gum gum = new Gum();
        Class clazz2=gum.getClass();
        System.out.println("new=clazz2:"+clazz2.getName());
    
      }

    注意调用forName方法时需要捕获一个名称为ClassNotFoundException的异常,因为forName方法在编译器是无法检测到其传递的字符串对应的类是否存在的,只能在程序运行时进行检查,如果不存在就会抛出ClassNotFoundException异常。

    Class字面常量

    在Java中存在另一种方式来生成Class对象的引用,它就是Class字面常量,如下:

    //字面常量的方式获取Class对象
    Class clazz = Gum.class;

    这种方式相对前面两种方法更加简单,更安全。因为它在编译器就会受到编译器的检查同时由于无需调用forName方法效率也会更高,因为通过字面量的方法获取Class对象的引用不会自动初始化该类。更加有趣的是字面常量的获取Class对象引用方式不仅可以应用于普通的类,也可以应用用接口,数组以及基本数据类型,这点在反射技术应用传递参数时很有帮助,关于反射技术稍后会分析,由于基本数据类型还有对应的基本包装类型,其包装类型有一个标准字段TYPE,而这个TYPE就是一个引用,指向基本数据类型的Class对象,其等价转换如下,一般情况下更倾向使用.class的形式,这样可以保持与普通类的形式统一。

    boolean.class = Boolean.TYPE;
    char.class = Character.TYPE;
    byte.class = Byte.TYPE;
    short.class = Short.TYPE;
    int.class = Integer.TYPE;
    long.class = Long.TYPE;
    float.class = Float.TYPE;
    double.class = Double.TYPE;
    void.class = Void.TYPE;

    前面提到过,使用字面常量的方式获取Class对象的引用不会触发类的初始化,这里我们可能需要简单了解一下类加载的过程,如下:

    • 加载:类加载过程的一个阶段:通过一个类的完全限定查找此类字节码文件,并利用字节码文件创建一个Class对象

    • 链接:验证字节码的安全性和完整性,准备阶段正式为静态域分配存储空间,注意此时只是分配静态成员变量的存储空间,不包含实例成员变量,如果必要的话,解析这个类创建的对其他类的所有引用。

    • 初始化:类加载最后阶段,若该类具有超类,则对其进行初始化,执行静态初始化器和静态初始化成员变量。

    由此可知,我们获取字面常量的Class引用时,触发的应该是加载阶段,因为在这个阶段Class对象已创建完成,获取其引用并不困难,而无需触发类的最后阶段初始化。下面通过小例子来验证这个过程:

    import java.util.*;
    
    class Initable {
      //编译期静态常量
      static final int staticFinal = 47;
      //非编期静态常量
      static final int staticFinal2 =
        ClassInitialization.rand.nextInt(1000);
      static {
        System.out.println("Initializing Initable");
      }
    }
    
    class Initable2 {
      //静态成员变量
      static int staticNonFinal = 147;
      static {
        System.out.println("Initializing Initable2");
      }
    }
    
    class Initable3 {
      //静态成员变量
      static int staticNonFinal = 74;
      static {
        System.out.println("Initializing Initable3");
      }
    }
    
    public class ClassInitialization {
      public static Random rand = new Random(47);
      public static void main(String[] args) throws Exception {
        //字面常量获取方式获取Class对象
        Class initable = Initable.class;
        System.out.println("After creating Initable ref");
        //不触发类初始化
        System.out.println(Initable.staticFinal);
        //会触发类初始化
        System.out.println(Initable.staticFinal2);
        //会触发类初始化
        System.out.println(Initable2.staticNonFinal);
        //forName方法获取Class对象
        Class initable3 = Class.forName("Initable3");
        System.out.println("After creating Initable3 ref");
        System.out.println(Initable3.staticNonFinal);
      }
    }

    执行结果:

    After creating Initable ref
    47
    Initializing Initable
    258
    Initializing Initable2
    147
    Initializing Initable3
    After creating Initable3 ref
    74

    从输出结果来看,可以发现,通过字面常量获取方式获取Initable类的Class对象并没有触发Initable类的初始化,这点也验证了前面的分析,同时发现调用Initable.staticFinal变量时也没有触发初始化,这是因为staticFinal属于编译期静态常量,在编译阶段通过常量传播优化的方式将Initable类的常量staticFinal存储到了一个称为NotInitialization类的常量池中,在以后对Initable类常量staticFinal的引用实际都转化为对NotInitialization类对自身常量池的引用,所以在编译期后,对编译期常量的引用都将在NotInitialization类的常量池获取,这也就是引用编译期静态常量不会触发Initable类初始化的重要原因。但在之后调用了Initable.staticFinal2变量后就触发了Initable类的初始化,注意staticFinal2虽然被static和final修饰,但其值在编译期并不能确定,因此staticFinal2并不是编译期常量,使用该变量必须先初始化Initable类。Initable2和Initable3类中都是静态成员变量并非编译期常量,引用都会触发初始化。至于forName方法获取Class对象,肯定会触发初始化,这点在前面已分析过。到这几种获取Class对象的方式也都分析完,ok~,到此这里可以得出小结论:

    • 获取Class对象引用的方式3种,通过继承自Object类的getClass方法,Class类的静态方法forName以及字面常量的方式”.class”。

    • 其中实例类的getClass方法和Class类的静态方法forName都将会触发类的初始化阶段,而字面常量获取Class对象的方式则不会触发初始化。

    • 初始化是类加载的最后一个阶段,也就是说完成这个阶段后类也就加载到内存中(Class对象在加载阶段已被创建),此时可以对类进行各种必要的操作了(如new对象,调用静态成员等),注意在这个阶段,才真正开始执行类中定义的Java程序代码或者字节码。

    关于类加载的初始化阶段,在虚拟机规范严格规定了有且只有5种场景必须对类进行初始化

    • 使用new关键字实例化对象时、读取或者设置一个类的静态字段(不包含编译期常量)以及调用静态方法的时候,必须触发类加载的初始化过程(类加载过程最终阶段)。

    • 使用反射包(java.lang.reflect)的方法对类进行反射调用时,如果类还没有被初始化,则需先进行初始化,这点对反射很重要。

    • 当初始化一个类的时候,如果其父类还没进行初始化则需先触发其父类的初始化。

    • 当Java虚拟机启动时,用户需要指定一个要执行的主类(包含main方法的类),虚拟机会先初始化这个主类

    • 当使用JDK 1.7 的动态语言支持时,如果一个java.lang.invoke.MethodHandle 实例最后解析结果为REF_getStatic、REF_putStatic、REF_invokeStatic的方法句柄,并且这个方法句柄对应类没有初始化时,必须触发其初始化(这点看不懂就算了,这是1.7的新增的动态语言支持,其关键特征是它的类型检查的主体过程是在运行期而不是编译期进行的,这是一个比较大点的话题,这里暂且打住)

    理解泛化的Class对象引用

    由于Class的引用总数指向某个类的Class对象,利用Class对象可以创建实例类,这也就足以说明Class对象的引用指向的对象确切的类型。在Java SE5引入泛型后,使用我们可以利用泛型来表示Class对象更具体的类型,即使在运行期间会被擦除,但编译期足以确保我们使用正确的对象类型。如下:

    /**
     * Created by zejian on 2017/4/30.
     * Blog : http://blog.csdn.net/javazejian [原文地址,请尊重原创]
     */
    public class ClazzDemo {
    
        public static void main(String[] args){
            //没有泛型
            Class intClass = int.class;
    
            //带泛型的Class对象
            Class<Integer> integerClass = int.class;
    
            integerClass = Integer.class;
    
            //没有泛型的约束,可以随意赋值
            intClass= double.class;
    
            //编译期错误,无法编译通过
            //integerClass = double.class
        }
    }
    

    从代码可以看出,声明普通的Class对象,在编译器并不会检查Class对象的确切类型是否符合要求,如果存在错误只有在运行时才得以暴露出来。但是通过泛型声明指明类型的Class对象,编译器在编译期将对带泛型的类进行额外的类型检查,确保在编译期就能保证类型的正确性,实际上Integer.class就是一个Class<Integer>类的对象。面对下述语句,确实可能令人困惑,但该语句确实是无法编译通过的。

    //编译无法通过
    Class<Number> numberClass=Integer.class;

    我们或许会想Integer不就是Number的子类吗?然而事实并非这般简单,毕竟Integer的Class对象并非Number的Class对象的子类,前面提到过,所有的Class对象都只来源于Class类,看来事实确实如此。当然我们可以利用通配符“?”来解决问题:

    Class<?> intClass = int.class;
    intClass = double.class;

    这样的语句并没有什么问题,毕竟通配符指明所有类型都适用,那么为什么不直接使用Class还要使用Class<?>呢?这样做的好处是告诉编译器,我们是确实是采用任意类型的泛型,而非忘记使用泛型约束,因此Class<?>总是优于直接使用Class,至少前者在编译器检查时不会产生警告信息。当然我们还可以使用extends关键字告诉编译器接收某个类型的子类,如解决前面Number与Integer的问题:

    //编译通过!
    Class<? extends Number> clazz = Integer.class;
    //赋予其他类型
    clazz = double.class;
    clazz = Number.class;

    上述的代码是行得通的,extends关键字的作用是告诉编译器,只要是Number的子类都可以赋值。这点与前面直接使用Class<Number>是不一样的。实际上,应该时刻记住向Class引用添加泛型约束仅仅是为了提供编译期类型的检查从而避免将错误延续到运行时期。

    关于类型转换的问题

    在许多需要强制类型转换的场景,我们更多的做法是直接强制转换类型:

    package com.zejian;
    
    /**
     * Created by zejian on 2017/4/30.
     * Blog : http://blog.csdn.net/javazejian [原文地址,请尊重原创]
     */
    public class ClassCast {
    
     public void cast(){
    
         Animal animal= new Dog();
         //强制转换
         Dog dog = (Dog) animal;
     }
    }
    
    interface Animal{ }
    
    class Dog implements  Animal{ }

    之所可以强制转换,这得归功于RRTI,要知道在Java中,所有类型转换都是在运行时进行正确性检查的,利用RRTI进行判断类型是否正确从而确保强制转换的完成,如果类型转换失败,将会抛出类型转换异常。除了强制转换外,在Java SE5中新增一种使用Class对象进行类型转换的方式,如下:

    Animal animal= new Dog();
    //这两句等同于Dog dog = (Dog) animal;
    Class<Dog> dogType = Dog.class;
    Dog dog = dogType.cast(animal)

    利用Class对象的cast方法,其参数接收一个参数对象并将其转换为Class引用的类型。这种方式似乎比之前的强制转换更麻烦些,确实如此,而且当类型不能正确转换时,仍然会抛出ClassCastException异常。源码如下:

    public T cast(Object obj) {
        if (obj != null && !isInstance(obj))
             throw new ClassCastException(cannotCastMsg(obj));
         return (T) obj;
      }

    instanceof 关键字与isInstance方法

    关于instanceof 关键字,它返回一个boolean类型的值,意在告诉我们对象是不是某个特定的类型实例。如下,在强制转换前利用instanceof检测obj是不是Animal类型的实例对象,如果返回true再进行类型转换,这样可以避免抛出类型转换的异常(ClassCastException)

    public void cast2(Object obj){
        if(obj instanceof Animal){
              Animal animal= (Animal) obj;
          }
    }

    而isInstance方法则是Class类中的一个Native方法,也是用于判断对象类型的,看个简单例子:

    public void cast2(Object obj){
            //instanceof关键字
            if(obj instanceof Animal){
                Animal animal= (Animal) obj;
            }
    
            //isInstance方法
            if(Animal.class.isInstance(obj)){
                Animal animal= (Animal) obj;
            }
      }

    事实上instanceOf 与isInstance方法产生的结果是相同的。对于instanceOf是关键字只被用于对象引用变量,检查左边对象是不是右边类或接口的实例化。如果被测对象是null值,则测试结果总是false。一般形式:

    //判断这个对象是不是这种类型
    obj.instanceof(class)

    而isInstance方法则是Class类的Native方法,其中obj是被测试的对象或者变量,如果obj是调用这个方法的class或接口的实例,则返回true。如果被检测的对象是null或者基本类型,那么返回值是false;一般形式如下:

    //判断这个对象能不能被转化为这个类
    class.inInstance(obj)

    最后这里给出一个简单实例,验证isInstance方法与instanceof等价性:

    class A {}
    
    class B extends A {}
    
    public class C {
      static void test(Object x) {
        print("Testing x of type " + x.getClass());
        print("x instanceof A " + (x instanceof A));
        print("x instanceof B "+ (x instanceof B));
        print("A.isInstance(x) "+ A.class.isInstance(x));
        print("B.isInstance(x) " +
          B.class.isInstance(x));
        print("x.getClass() == A.class " +
          (x.getClass() == A.class));
        print("x.getClass() == B.class " +
          (x.getClass() == B.class));
        print("x.getClass().equals(A.class)) "+
          (x.getClass().equals(A.class)));
        print("x.getClass().equals(B.class)) " +
          (x.getClass().equals(B.class)));
      }
      public static void main(String[] args) {
        test(new A());
        test(new B());
      } 
    }

    执行结果:

    Testing x of type class com.zejian.A
    x instanceof A true
    x instanceof B false //父类不一定是子类的某个类型
    A.isInstance(x) true
    B.isInstance(x) false
    x.getClass() == A.class true
    x.getClass() == B.class false
    x.getClass().equals(A.class)) true
    x.getClass().equals(B.class)) false
    ---------------------------------------------
    Testing x of type class com.zejian.B
    x instanceof A true
    x instanceof B true
    A.isInstance(x) true
    B.isInstance(x) true
    x.getClass() == A.class false
    x.getClass() == B.class true
    x.getClass().equals(A.class)) false
    x.getClass().equals(B.class)) true

    到此关于Class对象相关的知识点都分析完了,下面将结合Class对象的知识点分析反射技术。

    理解反射技术

    反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意一个方法和属性,这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。一直以来反射技术都是Java中的闪亮点,这也是目前大部分框架(如Spring/Mybatis等)得以实现的支柱。在Java中,Class类与java.lang.reflect类库一起对反射技术进行了全力的支持。在反射包中,我们常用的类主要有Constructor类表示的是Class 对象所表示的类的构造方法,利用它可以在运行时动态创建对象、Field表示Class对象所表示的类的成员变量,通过它可以在运行时动态修改成员变量的属性值(包含private)、Method表示Class对象所表示的类的成员方法,通过它可以动态调用对象的方法(包含private),下面将对这几个重要类进行分别说明。

    Constructor类及其用法

    Constructor类存在于反射包(java.lang.reflect)中,反映的是Class 对象所表示的类的构造方法。获取Constructor对象是通过Class类中的方法获取的,Class类与Constructor相关的主要方法如下:

    方法返回值方法名称方法说明
    static Class<?>forName(String className)返回与带有给定字符串名的类或接口相关联的 Class 对象。
    Constructor<T>getConstructor(Class<?>... parameterTypes)返回指定参数类型、具有public访问权限的构造函数对象
    Constructor<?>[]getConstructors()返回所有具有public访问权限的构造函数的Constructor对象数组
    Constructor<T>getDeclaredConstructor(Class<?>... parameterTypes)返回指定参数类型、所有声明的(包括private)构造函数对象
    Constructor<?>[]getDeclaredConstructor()返回所有声明的(包括private)构造函数对象
    TnewInstance()创建此 Class 对象所表示的类的一个新实例。

    下面看一个简单例子来了解Constructor对象的使用:

    package reflect;
    
    import java.io.Serializable;
    import java.lang.reflect.Constructor;
    
    /**
     * Created by zejian on 2017/5/1.
     * Blog : http://blog.csdn.net/javazejian [原文地址,请尊重原创]
     */
    public class ReflectDemo implements Serializable{
        public static void main(String[] args) throws Exception {
    
            Class<?> clazz = null;
    
            //获取Class对象的引用
            clazz = Class.forName("reflect.User");
    
            //第一种方法,实例化默认构造方法,User必须无参构造函数,否则将抛异常
            User user = (User) clazz.newInstance();
            user.setAge(20);
            user.setName("Rollen");
            System.out.println(user);
    
            System.out.println("--------------------------------------------");
    
            //获取带String参数的public构造函数
            Constructor cs1 =clazz.getConstructor(String.class);
            //创建User
            User user1= (User) cs1.newInstance("xiaolong");
            user1.setAge(22);
            System.out.println("user1:"+user1.toString());
    
            System.out.println("--------------------------------------------");
    
            //取得指定带int和String参数构造函数,该方法是私有构造private
            Constructor cs2=clazz.getDeclaredConstructor(int.class,String.class);
            //由于是private必须设置可访问
            cs2.setAccessible(true);
            //创建user对象
            User user2= (User) cs2.newInstance(25,"lidakang");
            System.out.println("user2:"+user2.toString());
    
            System.out.println("--------------------------------------------");
    
            //获取所有构造包含private
            Constructor<?> cons[] = clazz.getDeclaredConstructors();
            // 查看每个构造方法需要的参数
            for (int i = 0; i < cons.length; i++) {
                //获取构造函数参数类型
                Class<?> clazzs[] = cons[i].getParameterTypes();
                System.out.println("构造函数["+i+"]:"+cons[i].toString() );
                System.out.print("参数类型["+i+"]:(");
                for (int j = 0; j < clazzs.length; j++) {
                    if (j == clazzs.length - 1)
                        System.out.print(clazzs[j].getName());
                    else
                        System.out.print(clazzs[j].getName() + ",");
                }
                System.out.println(")");
            }
        }
    }
    
    
    class User {
        private int age;
        private String name;
        public User() {
            super();
        }
        public User(String name) {
            super();
            this.name = name;
        }
    
        /**
         * 私有构造
         * @param age
         * @param name
         */
        private User(int age, String name) {
            super();
            this.age = age;
            this.name = name;
        }
    
      //..........省略set 和 get方法
    }

    运行结果:

    User [age=20, name=Rollen]
    --------------------------------------------
    user1:User [age=22, name=xiaolong]
    --------------------------------------------
    user2:User [age=25, name=lidakang]
    --------------------------------------------
    构造函数[0]:private reflect.User(int,java.lang.String)
    参数类型[0]:(int,java.lang.String)
    构造函数[1]:public reflect.User(java.lang.String)
    参数类型[1]:(java.lang.String)
    构造函数[2]:public reflect.User()
    参数类型[2]:()

    关于Constructor类本身一些常用方法如下(仅部分,其他可查API),

    方法返回值方法名称方法说明
    Class<T>getDeclaringClass()返回 Class 对象,该对象表示声明由此 Constructor 对象表示的构造方法的类,其实就是返回真实类型(不包含参数)
    Type[]getGenericParameterTypes()按照声明顺序返回一组 Type 对象,返回的就是 Constructor对象构造函数的形参类型。
    StringgetName()以字符串形式返回此构造方法的名称。
    Class<?>[]getParameterTypes()按照声明顺序返回一组 Class 对象,即返回Constructor 对象所表示构造方法的形参类型
    TnewInstance(Object... initargs)使用此 Constructor对象表示的构造函数来创建新实例
    StringtoGenericString()返回描述此 Constructor 的字符串,其中包括类型参数。

    代码演示如下:

    Constructor cs3=clazz.getDeclaredConstructor(int.class,String.class);
    
    System.out.println("-----getDeclaringClass-----");
    Class uclazz=cs3.getDeclaringClass();
    //Constructor对象表示的构造方法的类
    System.out.println("构造方法的类:"+uclazz.getName());
    
    System.out.println("-----getGenericParameterTypes-----");
    //对象表示此 Constructor 对象所表示的方法的形参类型
    Type[] tps=cs3.getGenericParameterTypes();
    for (Type tp:tps) {
        System.out.println("参数名称tp:"+tp);
    }
    System.out.println("-----getParameterTypes-----");
    //获取构造函数参数类型
    Class<?> clazzs[] = cs3.getParameterTypes();
    for (Class claz:clazzs) {
        System.out.println("参数名称:"+claz.getName());
    }
    System.out.println("-----getName-----");
    //以字符串形式返回此构造方法的名称
    System.out.println("getName:"+cs3.getName());
    
    System.out.println("-----getoGenericString-----");
    //返回描述此 Constructor 的字符串,其中包括类型参数。
    System.out.println("getoGenericString():"+cs3.toGenericString());
    /**
     输出结果:
     -----getDeclaringClass-----
     构造方法的类:reflect.User
     -----getGenericParameterTypes-----
     参数名称tp:int
     参数名称tp:class java.lang.String
     -----getParameterTypes-----
     参数名称:int
     参数名称:java.lang.String
     -----getName-----
     getName:reflect.User
     -----getoGenericString-----
     getoGenericString():private reflect.User(int,java.lang.String)
     */

    其中关于Type类型这里简单说明一下,Type 是 Java 编程语言中所有类型的公共高级接口。它们包括原始类型、参数化类型、数组类型、类型变量和基本类型。getGenericParameterTypesgetParameterTypes 都是获取构成函数的参数类型,前者返回的是Type类型,后者返回的是Class类型,由于Type顶级接口,Class也实现了该接口,因此Class类是Type的子类,Type 表示的全部类型而每个Class对象表示一个具体类型的实例,如String.class仅代表String类型。由此看来Type与 Class 表示类型几乎是相同的,只不过 Type表示的范围比Class要广得多而已。当然Type还有其他子类,如:

    • TypeVariable:表示类型参数,可以有上界,比如:T extends Number

    • ParameterizedType:表示参数化的类型,有原始类型和具体的类型参数,比如:List<String>

    • WildcardType:表示通配符类型,比如:?, ? extends Number, ? super Integer

    通过以上的分析,对于Constructor类已有比较清晰的理解,利用好Class类和Constructor类,我们可以在运行时动态创建任意对象,从而突破必须在编译期知道确切类型的障碍。

    Field类及其用法

    Field 提供有关类或接口的单个字段的信息,以及对它的动态访问权限。反射的字段可能是一个类(静态)字段或实例字段。同样的道理,我们可以通过Class类的提供的方法来获取代表字段信息的Field对象,Class类与Field对象相关方法如下:

    方法返回值方法名称方法说明
    FieldgetDeclaredField(String name)获取指定name名称的(包含private修饰的)字段,不包括继承的字段
    Field[]getDeclaredField()获取Class对象所表示的类或接口的所有(包含private修饰的)字段,不包括继承的字段
    FieldgetField(String name)获取指定name名称、具有public修饰的字段,包含继承字段
    Field[]getField()获取修饰符为public的字段,包含继承字段

     
    下面的代码演示了上述方法的使用过程

    /**
     * Created by zejian on 2017/5/1.
     * Blog : http://blog.csdn.net/javazejian [原文地址,请尊重原创]
     */
    public class ReflectField {
    
        public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
            Class<?> clazz = Class.forName("reflect.Student");
            //获取指定字段名称的Field类,注意字段修饰符必须为public而且存在该字段,
            // 否则抛NoSuchFieldException
            Field field = clazz.getField("age");
            System.out.println("field:"+field);
    
            //获取所有修饰符为public的字段,包含父类字段,注意修饰符为public才会获取
            Field fields[] = clazz.getFields();
            for (Field f:fields) {
                System.out.println("f:"+f.getDeclaringClass());
            }
    
            System.out.println("================getDeclaredFields====================");
            //获取当前类所字段(包含private字段),注意不包含父类的字段
            Field fields2[] = clazz.getDeclaredFields();
            for (Field f:fields2) {
                System.out.println("f2:"+f.getDeclaringClass());
            }
            //获取指定字段名称的Field类,可以是任意修饰符的自动,注意不包含父类的字段
            Field field2 = clazz.getDeclaredField("desc");
            System.out.println("field2:"+field2);
        }
        /**
          输出结果: 
         field:public int reflect.Person.age
         f:public java.lang.String reflect.Student.desc
         f:public int reflect.Person.age
         f:public java.lang.String reflect.Person.name
    
         ================getDeclaredFields====================
         f2:public java.lang.String reflect.Student.desc
         f2:private int reflect.Student.score
         field2:public java.lang.String reflect.Student.desc
         */
    }
    
    class Person{
        public int age;
        public String name;
        //省略set和get方法
    }
    
    class Student extends Person{
        public String desc;
        private int score;
        //省略set和get方法
    }

    上述方法需要注意的是,如果我们不期望获取其父类的字段,则需使用Class类的getDeclaredField/getDeclaredFields方法来获取字段即可,倘若需要连带获取到父类的字段,那么请使用Class类的getField/getFields,但是也只能获取到public修饰的的字段,无法获取父类的私有字段。下面将通过Field类本身的方法对指定类属性赋值,代码演示如下:

    //获取Class对象引用
    Class<?> clazz = Class.forName("reflect.Student");
    
    Student st= (Student) clazz.newInstance();
    //获取父类public字段并赋值
    Field ageField = clazz.getField("age");
    ageField.set(st,18);
    Field nameField = clazz.getField("name");
    nameField.set(st,"Lily");
    
    //只获取当前类的字段,不获取父类的字段
    Field descField = clazz.getDeclaredField("desc");
    descField.set(st,"I am student");
    Field scoreField = clazz.getDeclaredField("score");
    //设置可访问,score是private的
    scoreField.setAccessible(true);
    scoreField.set(st,88);
    System.out.println(st.toString());
    
    //输出结果:Student{age=18, name='Lily ,desc='I am student', score=88} 
    
    //获取字段值
    System.out.println(scoreField.get(st));
    // 88

    其中的set(Object obj, Object value)方法是Field类本身的方法,用于设置字段的值,而get(Object obj)则是获取字段的值,当然关于Field类还有其他常用的方法如下:

    方法返回值方法名称方法说明
    voidset(Object obj, Object value)将指定对象变量上此 Field 对象表示的字段设置为指定的新值。
    Objectget(Object obj)返回指定对象上此 Field 表示的字段的值
    Class<?>getType()返回一个 Class 对象,它标识了此Field 对象所表示字段的声明类型。
    booleanisEnumConstant()如果此字段表示枚举类型的元素则返回 true;否则返回 false
    StringtoGenericString()返回一个描述此 Field(包括其一般类型)的字符串
    StringgetName()返回此 Field 对象表示的字段的名称
    Class<?>getDeclaringClass()返回表示类或接口的 Class 对象,该类或接口声明由此 Field 对象表示的字段
    voidsetAccessible(boolean flag)将此对象的 accessible 标志设置为指示的布尔值,即设置其可访问性

     
    上述方法可能是较为常用的,事实上在设置值的方法上,Field类还提供了专门针对基本数据类型的方法,如setInt()/getInt()、setBoolean()/getBoolean、setChar()/getChar()等等方法,这里就不全部列出了,需要时查API文档即可。需要特别注意的是被final关键字修饰的Field字段是安全的,在运行时可以接收任何修改,但最终其实际值是不会发生改变的。

    Method类及其用法

    Method 提供关于类或接口上单独某个方法(以及如何访问该方法)的信息,所反映的方法可能是类方法或实例方法(包括抽象方法)。下面是Class类获取Method对象相关的方法:

    方法返回值方法名称方法说明
    MethodgetDeclaredMethod(String name, Class<?>... parameterTypes)返回一个指定参数的Method对象,该对象反映此 Class 对象所表示的类或接口的指定已声明方法。
    Method[]getDeclaredMethod()返回 Method 对象的一个数组,这些对象反映此 Class 对象表示的类或接口声明的所有方法,包括公共、保护、默认(包)访问和私有方法,但不包括继承的方法。
    MethodgetMethod(String name, Class<?>... parameterTypes)返回一个 Method 对象,它反映此 Class 对象所表示的类或接口的指定公共成员方法。
    Method[]getMethods()返回一个包含某些 Method 对象的数组,这些对象反映此 Class 对象所表示的类或接口(包括那些由该类或接口声明的以及从超类和超接口继承的那些的类或接口)的公共 member 方法。

    同样通过案例演示上述方法:

    import java.lang.reflect.Method;
    
    /**
     * Created by zejian on 2017/5/1.
     * Blog : http://blog.csdn.net/javazejian [原文地址,请尊重原创]
     */
    public class ReflectMethod  {
    
    
        public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
    
            Class clazz = Class.forName("reflect.Circle");
    
            //根据参数获取public的Method,包含继承自父类的方法
            Method method = clazz.getMethod("draw",int.class,String.class);
    
            System.out.println("method:"+method);
    
            //获取所有public的方法:
            Method[] methods =clazz.getMethods();
            for (Method m:methods){
                System.out.println("m::"+m);
            }
    
            System.out.println("=========================================");
    
            //获取当前类的方法包含private,该方法无法获取继承自父类的method
            Method method1 = clazz.getDeclaredMethod("drawCircle");
            System.out.println("method1::"+method1);
            //获取当前类的所有方法包含private,该方法无法获取继承自父类的method
            Method[] methods1=clazz.getDeclaredMethods();
            for (Method m:methods1){
                System.out.println("m1::"+m);
            }
        }
    
    /**
         输出结果:
         method:public void reflect.Shape.draw(int,java.lang.String)
    
         m::public int reflect.Circle.getAllCount()
         m::public void reflect.Shape.draw()
         m::public void reflect.Shape.draw(int,java.lang.String)
         m::public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
         m::public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
         m::public final void java.lang.Object.wait() throws java.lang.InterruptedException
         m::public boolean java.lang.Object.equals(java.lang.Object)
         m::public java.lang.String java.lang.Object.toString()
         m::public native int java.lang.Object.hashCode()
         m::public final native java.lang.Class java.lang.Object.getClass()
         m::public final native void java.lang.Object.notify()
         m::public final native void java.lang.Object.notifyAll()
    
         =========================================
         method1::private void reflect.Circle.drawCircle()
    
         m1::public int reflect.Circle.getAllCount()
         m1::private void reflect.Circle.drawCircle()
         */
    }
    
    class Shape {
        public void draw(){
            System.out.println("draw");
        }
    
        public void draw(int count , String name){
            System.out.println("draw "+ name +",count="+count);
        }
    
    }
    class Circle extends Shape{
    
        private void drawCircle(){
            System.out.println("drawCircle");
        }
        public int getAllCount(){
            return 100;
        }
    }

    在通过getMethods方法获取Method对象时,会把父类的方法也获取到,如上的输出结果,把Object类的方法都打印出来了。而getDeclaredMethod/getDeclaredMethods方法都只能获取当前类的方法。我们在使用时根据情况选择即可。下面将演示通过Method对象调用指定类的方法:

    Class clazz = Class.forName("reflect.Circle");
    //创建对象
    Circle circle = (Circle) clazz.newInstance();
    
    //获取指定参数的方法对象Method
    Method method = clazz.getMethod("draw",int.class,String.class);
    
    //通过Method对象的invoke(Object obj,Object... args)方法调用
    method.invoke(circle,15,"圈圈");
    
    //对私有无参方法的操作
    Method method1 = clazz.getDeclaredMethod("drawCircle");
    //修改私有方法的访问标识
    method1.setAccessible(true);
    method1.invoke(circle);
    
    //对有返回值得方法操作
    Method method2 =clazz.getDeclaredMethod("getAllCount");
    Integer count = (Integer) method2.invoke(circle);
    System.out.println("count:"+count);
    
    /**
        输出结果:
        draw 圈圈,count=15
        drawCircle
        count:100
    */

    在上述代码中调用方法,使用了Method类的invoke(Object obj,Object... args)第一个参数代表调用的对象,第二个参数传递的调用方法的参数。这样就完成了类方法的动态调用。

    方法返回值方法名称方法说明
    Objectinvoke(Object obj, Object... args)对带有指定参数的指定对象调用由此 Method 对象表示的底层方法。
    Class<?>getReturnType()返回一个 Class 对象,该对象描述了此 Method 对象所表示的方法的正式返回类型,即方法的返回类型
    TypegetGenericReturnType()返回表示由此 Method 对象所表示方法的正式返回类型的 Type 对象,也是方法的返回类型。
    Class<?>[]getParameterTypes()按照声明顺序返回 Class 对象的数组,这些对象描述了此 Method 对象所表示的方法的形参类型。即返回方法的参数类型组成的数组
    Type[]getGenericParameterTypes()按照声明顺序返回 Type 对象的数组,这些对象描述了此 Method 对象所表示的方法的形参类型的,也是返回方法的参数类型
    StringgetName()以 String 形式返回此 Method 对象表示的方法名称,即返回方法的名称
    booleanisVarArgs()判断方法是否带可变参数,如果将此方法声明为带有可变数量的参数,则返回 true;否则,返回 false。
    StringtoGenericString()返回描述此 Method 的字符串,包括类型参数。

     
    getReturnType方法/getGenericReturnType方法都是获取Method对象表示的方法的返回类型,只不过前者返回的Class类型后者返回的Type(前面已分析过),Type就是一个接口而已,在Java8中新增一个默认的方法实现,返回的就参数类型信息

    public interface Type {
        //1.8新增
        default String getTypeName() {
            return toString();
        }
    }

    而getParameterTypes/getGenericParameterTypes也是同样的道理,都是获取Method对象所表示的方法的参数类型,其他方法与前面的Field和Constructor是类似的。

    反射包中的Array类

    在Java的java.lang.reflect包中存在着一个可以动态操作数组的类,Array,它提供了动态创建和访问 Java 数组的方法。Array 允许在执行 get 或 set 操作进行取值和赋值。在Class类中与数组关联的方法是:

    方法返回值方法名称方法说明
    Class<?>getComponentType()返回表示数组元素类型的 Class,即数组的类型
    booleanisArray()判定此 Class 对象是否表示一个数组类。

    java.lang.reflect.Array中的常用静态方法如下:

    方法返回值方法名称方法说明
    static Objectset(Object array, int index)返回指定数组对象中索引组件的值。
    static intgetLength(Object array)以 int 形式返回指定数组对象的长度
    static objectnewInstance(Class<?> componentType, int... dimensions)创建一个具有指定类型和维度的新数组。
    static ObjectnewInstance(Class<?> componentType, int length)创建一个具有指定的组件类型和长度的新数组。
    static voidset(Object array, int index, Object value)将指定数组对象中索引组件的值设置为指定的新值。

    下面通过一个简单例子来演示这些方法

    package reflect;
    
    import java.lang.reflect.Array;
    
    /**
     * Created by zejian on 2017/5/1.
     * Blog : http://blog.csdn.net/javazejian [原文地址,请尊重原创]
     */
    public class ReflectArray {
    
        public static void main(String[] args) throws ClassNotFoundException {
            int[] array = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
            //获取数组类型的Class 即int.class
            Class<?> clazz = array.getClass().getComponentType();
            //创建一个具有指定的组件类型和长度的新数组。
            //第一个参数:数组的类型,第二个参数:数组的长度
            Object newArr = Array.newInstance(clazz, 15);
            //获取原数组的长度
            int co = Array.getLength(array);
            //赋值原数组到新数组
            System.arraycopy(array, 0, newArr, 0, co);
            for (int i:(int[]) newArr) {
                System.out.print(i+",");
            }
    
            //创建了一个长度为10 的字符串数组,
            //接着把索引位置为6 的元素设为"hello world!",然后再读取索引位置为6 的元素的值
            Class clazz2 = Class.forName("java.lang.String");
    
            //创建一个长度为10的字符串数组,在Java中数组也可以作为Object对象
            Object array2 = Array.newInstance(clazz2, 10);
    
            //把字符串数组对象的索引位置为6的元素设置为"hello"
            Array.set(array2, 6, "hello world!");
    
            //获得字符串数组对象的索引位置为5的元素的值
            String str = (String)Array.get(array2, 6);
            System.out.println();
            System.out.println(str);//hello
        }
        /**
         输出结果:
         1,2,3,4,5,6,7,8,9,0,0,0,0,0,0,
         hello world!
         */
    }

    通过上述代码演示,确实可以利用Array类和反射相结合动态创建数组,也可以在运行时动态获取和设置数组中元素的值,其实除了上的set/get外Array还专门为8种基本数据类型提供特有的方法,如setInt/getInt、setBoolean/getBoolean,其他依次类推,需要使用是可以查看API文档即可。除了上述动态修改数组长度或者动态创建数组或动态获取值或设置值外,可以利用泛型动态创建泛型数组如下:

    /**
      * 接收一个泛型数组,然后创建一个长度与接收的数组长度一样的泛型数组,
      * 并把接收的数组的元素复制到新创建的数组中,
      * 最后找出新数组中的最小元素,并打印出来
      * @param a
      * @param <T>
      */
     public  <T extends Comparable<T>> void min(T[] a) {
         //通过反射创建相同类型的数组
         T[] b = (T[]) Array.newInstance(a.getClass().getComponentType(), a.length);
         for (int i = 0; i < a.length; i++) {
             b[i] = a[i];
         }
         T min = null;
         boolean flag = true;
         for (int i = 0; i < b.length; i++) {
             if (flag) {
                 min = b[i];
                 flag = false;
             }
             if (b[i].compareTo(min) < 0) {
                 min = b[i];
             }
         }
         System.out.println(min);
     }

    毕竟我们无法直接创建泛型数组,有了Array的动态创建数组的方式这个问题也就迎刃而解了。

    //无效语句,编译不通
    T[] a = new T[];

    ok~,到这反射中几个重要并且常用的类我们都基本介绍完了,但更重要是,我们应该认识到反射机制并没有什么神奇之处。当通过反射与一个未知类型的对象打交道时,JVM只会简单地检查这个对象,判断该对象属于那种类型,同时也应该知道,在使用反射机制创建对象前,必须确保已加载了这个类的Class对象,当然这点完全不必由我们操作,毕竟只能JVM加载,但必须确保该类的”.class”文件已存在并且JVM能够正确找到。关于Class类的方法在前面我们只是分析了主要的一些方法,其实Class类的API方法挺多的,建议查看一下API文档,浏览一遍,有个印象也是不错的选择,这里仅列出前面没有介绍过又可能用到的API:

     /** 
      *    修饰符、父类、实现的接口、注解相关 
      */
    
    //获取修饰符,返回值可通过Modifier类进行解读
    public native int getModifiers();
    //获取父类,如果为Object,父类为null
    public native Class<? super T> getSuperclass();
    //对于类,为自己声明实现的所有接口,对于接口,为直接扩展的接口,不包括通过父类间接继承来的
    public native Class<?>[] getInterfaces();
    //自己声明的注解
    public Annotation[] getDeclaredAnnotations();
    //所有的注解,包括继承得到的
    public Annotation[] getAnnotations();
    //获取或检查指定类型的注解,包括继承得到的
    public <A extends Annotation> A getAnnotation(Class<A> annotationClass);
    public boolean isAnnotationPresent(Class<? extends Annotation> annotationClass);
    
    /** 
      *   内部类相关
      */
    //获取所有的public的内部类和接口,包括从父类继承得到的
    public Class<?>[] getClasses();
    //获取自己声明的所有的内部类和接口
    public Class<?>[] getDeclaredClasses();
    //如果当前Class为内部类,获取声明该类的最外部的Class对象
    public Class<?> getDeclaringClass();
    //如果当前Class为内部类,获取直接包含该类的类
    public Class<?> getEnclosingClass();
    //如果当前Class为本地类或匿名内部类,返回包含它的方法
    public Method getEnclosingMethod();
    
    /** 
      *    Class对象类型判断相关
      */
    //是否是数组
    public native boolean isArray();  
    //是否是基本类型
    public native boolean isPrimitive();
    //是否是接口
    public native boolean isInterface();
    //是否是枚举
    public boolean isEnum();
    //是否是注解
    public boolean isAnnotation();
    //是否是匿名内部类
    public boolean isAnonymousClass();
    //是否是成员类
    public boolean isMemberClass();
    //是否是本地类
    public boolean isLocalClass(); 

    ok~,本篇到此完结。


    展开全文
  • Java什么叫面向对象

    万次阅读 多人点赞 2018-08-15 21:56:17
    什么是面向对象呢?...对象这个词你可以理解为一总称,比如男人女人都叫人,蜡烛皮鞭高跟鞋都是道具,所以面向对象原本的意思是“都叫对象”,翻译过来不是原汁原味了而已因此,房子是对象、飞机是对象...

        什么是面向对象呢?这个问题真的是老生常谈,面试的时候经常问。到底什么是面向对象。。。我也不知道啊

        看看百度一下的结果吧:

    世界上有loli控,御姐控,女王控,所以有句话就叫万物皆可控
    面向对象也是一样,万物皆对象
    对象这个词你可以理解为一个总称,比如男人女人都叫人,蜡烛皮鞭高跟鞋都是道具,所以面向对象原本的意思是“都叫对象”,翻译过来不是原汁原味了而已因此,房子是对象、飞机是对象、猫是对象、树是对象、女朋友也是对象,并且对象具有唯一性:你家的房子是你家的,不是我家的,你在国外看到的美女不是我在国内看到的美女,你的身份证号和我的身份证号不一样
    那么一个房子里都有啥呢,有电脑,还有动作片光盘、战争片录像带、人体艺术杂志……现在这些“包含”在房子里的东西就不是东西了,而是叫做“属性”……
    对象、属性都有了,剩下就是方法了方法也很好理解啊,意思就是你想要得到某种结果,就需要用特定的方法比如你女朋友生气了要哄吧,不高兴了要逗她开心吧,“哄”和“逗”这些就是让女朋友死心塌地的方法……诸如此类,发现一个美眉要用“追”这个方法,和女朋友逛街上碰到美女要用“窥”这个方法,恋爱都要用“谈”这个方法……
    ——对象就是一个概念,把所有的事物都称作为“对象”(没有不是对象的东西)——属性就是该事物的组成部分,所有可以被包含的部分都称为“属性”(没有不含属性的对象)——方法就是达成目标的途径,所有可行性的行为都成为方法(没有不存在方法的对象和属性,但是可以选择使用哪些方法)

     

        我想大家很多时候都会看到上面的话吧,上面的是我百度过来的,下面要说的才是我说的:

        在一开始的时候,我也那样的回答,什么万物皆对象啊,什么都是对象什么的。但是真的理解吗,不理解,说白了只是记了下来。工作之后一段时间了,最近对面向对象有所感悟。

       说说感悟过程吧,在我用socket时候,说是绑定数据关系,我去看源码,一层一层翻,一层一层的debug,希望能有所明白,在找的时候说白了,我也不大明白我想找什么东西,最后找到了,最后的最后,竟然只是往socket对象里面填几个数据,socket对象里面的几个成员变量赋值。一下子我的世界就崩溃了,这都什么啊,最后的最后竟然给我看的是这个。我瞬间懵住了,三观被毁,只能思考重建了。

           没错就是这样的。我理解的面向对象的编程到现在就是:对象其实是一个由成员变量组合起来,用于临时存一些数据的一个东西,我们通过调用对象的方法去使用这些数据,这样做的目的一般来说有两个:一是修改了成员变量的值,二是返回一些数据,一般来说,方法都是单功能的,而方法里面的数据来源于三个地方:第一个地方是方法的形参,第二个就是对象的成员变量,第三个就是系统的一些数据,或者是静态的全局变量。通过这样的方法,就能完成一些操作。即使是不知道对象里面的源码,知道这个方法是做什么的就行。      就这么简单,这就是面向对象,其实理解这些话很容易,深刻理解却很难,其实就是两句话:1,对象是有一些数据的东西,,,2,调用对象使用或者修改这些数据,或者返回一个你需要的东西,往往方法都是单功能的便于修改和维护。

         源码中,很多方法都是由说明的,只要看懂说明调用就好了,没必要去死抠一些东西,如果想明白这个方法的用途,单扣这个方法就ok了。我想这也是面向对象的一个好处吧。当对每个类,每个方法都加了注解之后,阅读的人只需要知道简单的流程就可以,如果想单独去研究其中的某个部分,去研究他的类里面的具体方法就好了。

         我以前总以为,一些操作一些东西应该是很难的,调用很多东西怎么怎么样。其实现在有点想明白,其实就是包含数据的对象调用方法去修改对象本身或者其他的对象的数据,或者运用本身数据去运算得到一些数据而已。没有那么多的调用底层的东西,都是表象,本质是数据计算和简单存储数据。当然这样说有点牵强和不严谨。

          即使是java底层真的调用了一些c/c++的东西,那些C啊、C++啊也基本上是数据计算和数据存储,都是这样子的 这就是计算机编程的大的框架,最后的最后归结到高低电平0,1和半导体的应用,,,除了高低电平0,1和半导体之类的硬件的东西,整个编程体系无非就是数据计算和找个地方把数据存起来,以便用于再计算。这只是我一家之言,反驳就不用了,不严谨很牵强,仅供参考。

          但是声明一点,java的编程,很多人只是知道new出来对象,创造对象,却不知道垃圾回收。虽然java提供了很好的垃圾回收机制,但是就空间复杂度而言,还是要控制的,知道每个变量什么时候活的状态不能被回收,什么时候死的状态可以被回收,对于每一个开发都很重要,要在程序到达一个阶段,一个结束去思考一下,哪些变量可以回收了,哪些不能回收了,对不需要但是还在引用的变量进行处理。这样节约了空间。不关注这些敲出来的代码质量很渣,没法看啊。虽然不需要像C那样需要析构函数,但java的垃圾回收还是很重要的。

            That‘s all,thanks!

           

    展开全文
  • 面向对象编程基本概念

    千次阅读 2018-04-18 15:41:53
    面向对象编程(OOP)为软件社区引入了一场革命,以帮助解决这些问题。 OOP专注于模块化,改变容忍度,代码重用,易于理解和分布式开发。今天大多数项目都使用面向对象的概念。由于C ++引入了OOP,因此用户体验已经...
  • 【知识图谱】知识图谱的基础概念与构建流程

    千次阅读 多人点赞 2019-11-09 18:46:49
    从原始数据库和第三方数据库中提取知识事实,并将其存入知识库的数据层和模式层,一过程包含:信息抽取、知识表示、知识融合、知识推理四过程,每一次更新迭代均包含阶段。知识图谱主要有自顶向下(top-...
  • Etymøn将是一包含三主要组成部分的系统:深度学习,带有对象识别的增强现实和生成性梦。 Etymøn的大部分功能都基于深度学习算法将生成的源图。 Etymøn系统最终将包括一可触及的产品,作为基于此源图的...
  • 对象生命周期

    千次阅读 2018-11-01 15:13:23
    对象生命周期 ...下面是在创建对象时的几关键应用规则: (1)避免在循环体中创建对象,即使该对象占用内存空间不大。 (2)尽量及时使对象符合垃圾回收标准。 (3)不要采用过深的继承层次。...
  • 基于情感词典的情感分析

    万次阅读 多人点赞 2018-01-19 23:05:26
    大致说一下使用情感词典进行情感分析的思路:对文档分词,找出文档中的情感、否定以及程度副词,然后判断每情感之前是否有否定及程度副词,将它之前的否定和程度副词划分为一组...
  • 这个模型能帮你 | AAAI 2020。会议之眼参考论文对模型框架、背景知识以及数据来源、评测部分进行了补充。 岂凡超 论文简介和摘要 《Multi-channelReverse Dictionary Model》是由清华大学、华为诺亚方舟合作...
  • 简述每条准则的内容,并说明遵循条准则的必要性。 答: 面向对象设计准则: 1、模块化;把程序整体划分成一个个独立命名且可独立访问的完成单个子功能的模块。采用模块化,软件结构清晰,不仅...
  • 面向对象复习总结

    千次阅读 2016-12-07 21:11:27
    面向对象思想的发展使得在软件开发中使用模式化的方法受到了重视,模式化的思想来源于建筑业。 建筑大师Alexander: 每一模式描述了一在我们周围不断重复发生的问题以及该问题解决方案的核心,这样你就可以一...
  • 面向过程 VS 面向对象

    千次阅读 多人点赞 2016-01-20 14:34:23
    面向过程(Process Oriented)这个词是在面向对象(Object Oriented)出现之后为与之相对而提出的。其实它在以前基本被叫做“结构化编程”。  早期的程序设计,大量使用共享变量(全局变量)和GOTO语句一类的东西...
  • 浅谈java对象引用及对象赋值

    千次阅读 多人点赞 2017-01-05 15:11:46
    一、Java对象及其引用  初学Java,总是会自觉或不自觉地把Java和C++相比较。在学习Java类与对象章节的时候,发现教科书和许多参考书把对象对象的引用混为一谈。... 为便于说明,我们先定义一简单的类:  c
  • 面向对象——事件

    千次阅读 2020-04-14 09:42:54
    CarDealer类提供了一新车到达的事件。Consumer类订阅该事件,以获得新车到达的通知。 事件发布程序。 从CarDealer类开始,它基于事件提供一订阅。CarDealer类用event关键字定义了类型为EventH...
  • java中的对象引用与c++中的对象赋值

    千次阅读 2014-10-05 15:57:47
    JAVA之等号、传类对象参数与c++的区别JAVA之等号、传类对象参数与c++的区别
  • [前端面试]2020 前端面试 | 第一波面试题总结

    千次阅读 多人点赞 2020-02-13 14:31:55
    构造函数都有prototype(原型)属性, 这个prototype(原型)属性是一指针,指向一个对象这个对象的用途是包含特定类型的所有实例共享的 属性和方法,即这个原型对象是用来给实例对象共享属性和方法的。...
  • 类和对象

    千次阅读 2017-09-12 22:03:21
    类和对象 类 声明类Declaring Classes 声明成员变量declaring member variables 为你的类提供构造函数 向构造函数或者方法传递信息 对象 创建对象 使用对象 更多关于类的内容more on class 从方法中返回值 类成员的...
  • c/c++ 类与对象 矩形计算实例

    千次阅读 2019-04-06 20:08:05
    是一高程实验课的代码记录及学习笔记。我将记录一些重要的知识点、易错点。但是作为大学生,水平很低,敬请指点教导、优化代码。 1问题 首先我们来看一下问题 一提到面向对象,就不可避免提到类、封装、继承...
  • 分析

    万次阅读 多人点赞 2017-10-16 11:01:09
    (2)源选择与概念术语提取(确定分析单元的来源并进行术语提取):共分析的分析单元(对象)是从分析数据集中选取表征能力较强的。早期分析单元通常从数据库(如WOS、CNKI等)中提取已有的结构化词汇(如...
  • 面向对象程序设计简介(全)

    千次阅读 2014-09-14 00:48:03
    它将用到一能将现实世界的物件转换成虚拟对象的最常见的隐喻“车”, 它可以是自行车,汽车或者任何其它带轮子的的东西。 比如, 是一辆车: 也是一辆车: 也是一辆车: 还是一辆车: ...
  • 面向对象编程思想

    千次阅读 2018-10-11 07:35:59
    Java面向对象编程思想Java对象什么是对象如何创建对象对象的生命周期继承什么是继承继承语法向上转型继承与初始化多态什么是多态产生正确的行为功能快捷键合理的创建标题,有助于目录的生成如何改变文本的样式插入...
  • 六、对象的秘密 原文:The Secret Life of Objects 译者:飞龙 协议:CC BY-NC-SA 4.0 自豪地采用谷歌翻译 部分参考了《JavaScript 编程精解(第 2 版)》 抽象数据类型是通过编写一种特殊的程序...
  • python中,sys模块里面有一getsizeof函数,其可以获取某个对象的内存占用,但是要注意的是,该函数只能获取对象本身直接占用的内存,该对象所指向的引用所占据的内存并不会被计算在内;python中,比如当对象是一...
  • 模糊PID算法及其MATLAB仿真(1)

    万次阅读 多人点赞 2019-04-15 20:34:35
    另外,在模糊论域的选取过程中,我们常看到的是(-6,6)这样的区间,其实并不重要,你如果想把自己的数据套用到这个算法里面,就可以做一下线性变换,把你的论域映射到这个区间。 3、模糊PID简介 模糊PID其实有...
  • 深入理解Java类型信息(Class对象)

    千次阅读 多人点赞 2019-05-19 19:36:01
    RTTI(Run-Time Type Identification)运行时类型识别,对于这个词一直是 C++ 中的概念,至于Java中出现RRTI的说法则是源于《Thinking in Java》一书,其作用是在运行时识别一个对象的类型和类的信息。这里分两种: ...
  • 1 语料库 1.1 谭松波-酒店评论语料-UTF-8,10000条  现在网上大部分谭松波老师的评论语料资源的编码方式都是gb2312,本资源... 本资源还包含将所有语料分成pos.txt和neg.txt两文件,每文件中的一行代表原始数...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 47,806
精华内容 19,122
关键字:

对象这个词的来源