精华内容
下载资源
问答
  • Java的引用类型转换

    千次阅读 2017-06-14 16:08:15
    1.基本数据类型转换:  自动类型转换: 把小类型数据 赋给 大类型变量. (此时大和小表示容量范围)  byte b = 12; byte是1个字节  int i = b; int是4个字节 ...2.引用类型的转换: 引用类

    1.基本数据类型转换:

      自动类型转换:  把小类型的数据 赋给  大类型的变量. (此时的大和小表示的容量范围)
      byte b = 12;  byte是1个字节
      int    i   = b;   int是4个字节
      强制类型转换: 把大类型的数据赋给  小类型的变量.
      short  s =  (short) i ;short是2个字节

    2.引用类型的转换:

    引用类型的大和小,指的是父类和子类的关系.
    自动类型转换:   把子类对象赋给父类变量(多态).
             Animal a = new Dog();
             Object是所有类的根类:
             Object  obj = new Dog();
    强制类型转换:  把父类类型对象赋给子类类型变量(当时该父类类型变量的真实类型应该是子类类型).
        Animal a = new Dog();

        Dog   d = (Dog)a;

    3.instanceof  运算符:

    判断该对象是否是某一个类的实例.
    语法格式:boolean b = 对象A   instanceof  类B;  // 判断 A对象是否是 B类的实例,如果是,返回true.

    //动物类
    class Animal 
    {
    	public void eat(){
    		System.out.println("吃一般的食物");
    	}
    }
    //猫类
    class Cat extends Animal
    {
    	public void eat(){
    		System.out.println("吃鱼摆摆");
    	}
    
    	public void catchMouse(){
    		System.out.println("抓老鼠");
    	}
    }
    //狗类
    class Dog extends Animal
    {
    	public void eat(){
    		System.out.println("吃骨头");
    	}
    	public void watch(){
    		System.out.println("看门");
    	}
    }
    
    //饲养员
    class Person
    {
    	public void feed(Animal a){
    		a.eat();
    
    		if(a instanceof Dog){		//判断如果传过来的a类型如果是Dog类型,就将a强制转换为Dog,才能调用子类的特殊方法
    			Dog dog = (Dog)a;
    			dog.watch();
    		}else if(a instanceof Cat){  //判断如果传过来的a类型如果是Cat类型,就将a强制转换为Cat,才能调用子类的特殊方法
    			Cat cat = (Cat)a;
    			cat.catchMouse();
    		}
    	}
    }
    //测试类
    class TestDemo
    {
    	public static void main(String[] args){
    		Person p = new Person();
    		Dog dog = new Dog();
    		p.feed(dog);
    		Cat cat = new Cat();
    		p.feed(cat);
    	}
    }

    注意:

    instanceof运算符:
       若对象是类的实例返回true,
       若对象是类的父类的实例也返回true.

    在开发中,有时候,我们只想判断是真实类型的实例,而不想判断为编译类型的实例.我们可以用反射obj.getClass()获取真实类型
    System.out.println(obj instanceof Object);//true
    System.out.println(obj instanceof String);//true

    //测试类
    class TestDemo
    {
    	public static void main(String[] args){
    
    		Object obj = "ABC";//把String类型的对象付给了Object
    		System.out.println(obj instanceof String);//true
    		System.out.println(obj instanceof Object);//true
    
    		System.out.println(obj.getClass());//返回对象的真实类型 class java.lang.String
    		System.out.println(obj.getClass()==String.class);//true
    		System.out.println(obj.getClass()==Object.class);//false
    	}
    }
    


    展开全文
  • Java虽然有内存管理机制,但仍应该警惕内存泄露问题。例如对象池、缓存中过期对象都有可能引发内存泄露问题。 从JDK1.2版本开始,加入了对象几种引用级别,从而使程序能够更好控制对象生命周期,帮助...

    Java虽然有内存管理机制,但仍应该警惕内存泄露的问题。例如对象池、缓存中的过期对象都有可能引发内存泄露的问题。

    从JDK1.2版本开始,加入了对象的几种引用级别,从而使程序能够更好的控制对象的生命周期,帮助开发者能够更好的缓解和处理内存泄露的问题。

    这几种引用级别由高到低分别为:强引用、软引用、弱引用和虚引用。

    强引用:

    平时我们编程的时候例如:Object object=new Object();那object就是一个强引用了。如果一个对象具有强引用,那就类似于必不可少的生活用品,垃圾回收器绝不会回收它。当内存空 间不足,Java虚拟机宁愿抛出OutOfMemoryError错误,使程序异常终止,也不会靠随意回收具有强引用的对象来解决内存不足问题。

    软引用(SoftReference):

    如果一个对象只具有软引用,那就类似于可有可物的生活用品。如果内存空间足够,垃圾回收器就不会回收它,如果内存 空间不足了,就会回收这些对象的内存。只要垃圾回收器没有回收它,该对象就可以被程序使用。软引用可用来实现内存敏感的高速缓存。 软引用可以和一个引用队列(ReferenceQueue)联合使用,如果软引用所引用的对象被垃圾回收,Java虚拟机就会把这个软引用加入到与之关联 的引用队列中。

    弱引用(WeakReference):

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

    虚引用(PhantomReference):

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

    在java.lang.ref包中提供了三个类:SoftReference类、WeakReference类和PhantomReference类,它们分别代表软引用、弱引用和虚引用。ReferenceQueue类表示引用队列,它可以和这三种引用类联合使用,以便跟踪Java虚拟机回收所引用的对象的活动。

    以下程序创建了一个String对象、ReferenceQueue对象和WeakReference对象:

            //创建一个强引用
            String str = "hello";
            //创建引用队列, <String>为范型标记,表明队列中存放String对象的引用
            ReferenceQueue<String> rq = new ReferenceQueue<>();
            //创建一个弱引用,它引用"hello"对象,并且与rq引用队列关联
            //<String>为范型标记,表明WeakReference会弱引用String对象
            WeakReference<String> wf = new WeakReference<>(str, rq);

    以上程序代码执行完毕,内存中引用与对象的关系如图所示,"hello"对象同时具有强引用和弱引用:

    引用

    带实线的箭头表示强引用,带虚线的箭头表示弱引用。从图中可以看出,此时"hello"对象被str强引用,并且被一个WeakReference对象弱引用,因此"hello"对象不会被垃圾回收。

    在以下程序代码中,把引用"hello"对象的str变量置为null,然后再通过WeakReference弱引用的get()方法获得"hello"对象的引用:

            String str = "hello"; //① 
            ReferenceQueue<String> rq = new ReferenceQueue<String>(); //② 
            WeakReference<String> wf = new WeakReference<String>(str, rq); //③
            str=null; //④取消"hello"对象的强引用
            String str1=wf.get(); //⑤假如"hello"对象没有被回收,str1引用"hello"对象
            //假如"hello"对象没有被回收,rq.poll()返回null
            Reference<? extends String> ref=rq.poll(); //⑥

    执行完以上第④行后,内存中引用与对象的关系下图所示:

    20070320103110764

    此时"hello"对象仅仅具有弱引用,因此它有可能被垃圾回收。假如它还没有被垃圾回收,那么接下来在第⑤行执行wf.get()方法会返回 "hello"对象的引用,并且使得这个对象被str1强引用。再接下来在第⑥行执行rq.poll()方法会返回null,因为此时引用队列中没有任何 引用。ReferenceQueue的poll()方法用于返回队列中的引用,如果没有则返回null。

    ,在以下程序代码中,执行完第④行后,"hello"对象仅仅具有弱引用。接下来两次调用System.gc()方法,催促垃圾回收器工作,从而提高 "hello"对象被回收的可能性。假如"hello"对象被回收,那么WeakReference对象的引用被加入到ReferenceQueue中, 接下来wf.get()方法返回null,并且rq.poll()方法返回WeakReference对象的引用。

            String str = "hello"; //①
            ReferenceQueue<String> rq = new ReferenceQueue<String>(); //② 
            WeakReference<String> wf = new WeakReference<String>(str, rq); //③
            str=null; //④
            //两次催促垃圾回收器工作,提高"hello"对象被回收的可能性
            System.gc(); //⑤
            System.gc(); //⑥
            String str1=wf.get(); //⑦ 假如"hello"对象被回收,str1为null
            Reference<? extends String> ref=rq.poll(); //⑧
    在以下例程的References类中,依次创建了10个软引用、10个弱引用和10个虚引用,它们各自引用一个Grocery对象。从程序运行时的打印结果可以看出,虚引用形同虚设,它所引用的对象随时可能被垃圾回收,具有弱引用的对象拥有稍微长的生命周期,当垃圾回收器执行回收操作时,有可能被垃圾回收,具有软引用的对象拥有较长的生命周期,但在Java虚拟机认为内存不足的情况下,也会被垃圾回收。

    import java.lang.ref.*;
    import java.util.*;
    class Grocery {
    	private static final int SIZE = 10000;
    	// 属性d使得每个Grocery对象占用较多内存,有80K左右
    	private double[] d = new double[SIZE];
    	private String id;
    	public Grocery(String id) {
    		this.id = id;
    	}
    	public String toString() {
    		return id;
    	}
    	public void finalize() {
    		System.out.println("Finalizing " + id);
    	}
    }
    public class References {
    	private static ReferenceQueue<Grocery> rq = new ReferenceQueue<Grocery>();
    	public static void checkQueue() {
    		Reference<? extends Grocery> inq = rq.poll(); // 从队列中取出一个引用
    		if (inq != null)
    			System.out.println("In queue: " + inq + " : " + inq.get());
    	}
    	public static void main(String[] args) {
    		final int size = 10;
    		// 创建10个Grocery对象以及10个软引用
    		Set<SoftReference<Grocery>> sa = new HashSet<SoftReference<Grocery>>();
    		for (int i = 0; i < size; i++) {
    			SoftReference<Grocery> ref = new SoftReference<Grocery>(
    					new Grocery("Soft " + i), rq);
    			System.out.println("Just created: " + ref.get());
    			sa.add(ref);
    		}
    		System.gc();
    		checkQueue();
    		// 创建10个Grocery对象以及10个弱引用
    		Set<WeakReference<Grocery>> wa = new HashSet<WeakReference<Grocery>>();
    		for (int i = 0; i < size; i++) {
    			WeakReference<Grocery> ref = new WeakReference<Grocery>(
    					new Grocery("Weak " + i), rq);
    			System.out.println("Just created: " + ref.get());
    			wa.add(ref);
    		}
    		System.gc();
    		checkQueue();
    		// 创建10个Grocery对象以及10个虚引用
    		Set<PhantomReference<Grocery>> pa = new HashSet<PhantomReference<Grocery>>();
    		for (int i = 0; i < size; i++) {
    			PhantomReference<Grocery> ref = new PhantomReference<Grocery>(
    					new Grocery("Phantom " + i), rq);
    			System.out.println("Just created: " + ref.get());
    			pa.add(ref);
    		}
    		System.gc();
    		checkQueue();
    	}
    }


    转载自:http://www.dexcoder.com/selfly/article/313


    展开全文
  • java的引用类型所占用的内存空间

    万次阅读 2015-08-14 15:18:29
    Question:JAVA的引用的内存分配大小是多少? 如,我声明了一个对象,它在栈中就先有了个空间,(用来放地址引用的),这个空间的大小是多少? java规范中并没有强行定义虚拟机中任何一种类型在虚拟机中所占用...

    转:http://blog.sina.com.cn/s/blog_605f5b4f0100qt2t.html

    Question:JAVA中的引用的内存分配大小是多少?

    如,我声明了一个对象,它在栈中就先有了个空间,(用来放地址引用的),这个空间的大小是多少?


    java规范中并没有强行定义虚拟机中任何一种类型在虚拟机中所占用内存的具体大小,但是规范规定了每种类型的取值范围。从这种角度上看,每种类型会有一个最小位宽,或者内存占用大小。


    而且java虚拟机规定中,在方法区中所占用的内存大小与在栈帧所占用的内存大小不同,因为在方法区中占用内存以字节为最小单位,但是在战帧中以字为最小单位。byte类型在方法区中它占用8位,为一个字节,但是在栈帧中以一个字,即32位来处理,其实就是当作一个int类型来处理


    楼主所说的引用类型,其位宽与int型一样,在方法区中它占用32位,4个字节,在栈帧中占用一个字。
    但是虚拟机实现者可以扩大这种内存占用量,因为虚拟机规定只要满足取值范围即可,并没有规定非要32位一个字才行。


    我觉得java的引用相当于c++的指针,C++的指针是占四个字节,java引用应该也是固定的大小。sunhotspot jvm和ibmjvm中都把引用实现为一个指针,因此在64位平台上,占8个字节,在32位平台上占4个字节。别的jvm不清楚。


    1.引用本身的大小和操作系统的位数有关,正如15楼所言在64位平台上,占8个字节,在32位平台上占4个字节,这个应该是很自然的事情,因为32-bit的操作系统,在4G(2^32)的内存空间内找到某个地址,这个地址是用4bytes(32bits)来表示的。

    2. 引用本身是保留在栈中的

    3. 引用所指的对象,是存放在堆中的

     

    整理自:http://topic.csdn.net/u/20090419/11/b90d9a7b-336e-40e1-afbe-0174ebf1144f.html

    展开全文
  • Java四种引用类型 1.引用基本概念 强引用:当我们使用new创建对象时,被创建对象就是强引用,如Object object = new Object(),其中object就是一个强引用了。如果一个对象具有强引用,JVM就不会去GC它,JVM...

    Java四种引用类型 

    1.引用的基本概念 
    强引用:当我们使用new创建对象时,被创建的对象就是强引用,如Object object = new Object(),其中的object就是一个强引用了。如果一个对象具有强引用,JVM就不会去GC它,JVM宁可会报OOM来终止程序,也不回收该对象。 

    软引用: 如果一个对象只具备软引用,如果内存空间足够,那么JVM就不会GC它,如果内存空间不足了,就会GC该对象。 

    弱引用: 如果一个对象只具有弱引用,只要JVM的GC线程检测到了,就会立即回收。弱引用的生命周期要比软引用短很多。不过,如果垃圾回收器是一个优先级很低的线程,也不一定会很快就会释放掉软引用的内存。 

    虚引用:如果一个对象只具有虚引用,那么它就和没有任何引用一样,随时会被JVM当作垃圾进行GC。 

    上面的四种引用对应的是new关键字以及java.lang.ref包中的SoftReference,WeakReference, PhantomReference。我们注意到在java.lang.ref包中,还存在一个类叫做ReferenceQueue。 

    2.理解ReferenceQueue 
    当软引用对象被GC之后,虽然这个SoftReference对象指向的对象已不存在,但这个SoftReference对象本身还占用内存,因此需要一个适当的清除机制,避免大量SoftReference对象带来的OOM。这就需要用到ReferenceQueue。如果在创建SoftReference对象的时候,使用了一个ReferenceQueue对象作为参数提供给SoftReference的构造方法,如下例子: 

    Java代码  收藏代码
    1. ReferenceQueue queue = new ReferenceQueue();  
    2. SoftReference ref=new SoftReference(new MyObject(), queue);  



    那么当这个SoftReference指向的MyOhject对象被垃圾收集器回收的同时,ref对象本身会被放入ReferenceQueue。也就是说,ReferenceQueue中保存的对象是Reference对象,但这些Reference对象引用的对象已经不存在了。 

    我们可以调用ReferenceQueue的poll()方法来检查是否有它所关心的非强引用对象被回收。利用这个方法,我们可以检查哪个SoftReference所软引用的对象已经被回收。于是我们可以把这些失去软引用的对象的清除掉。 


    3.理解WeakHashMap 
    WeakHashMap是以弱引用为键实现的HsahMap。更精确地说,对于一个给定的key对象,其对应的value对象的存在并不能阻止该key对象被GC。GC某个key对象时,它所在的条目会一并被从Map中删除。这是WeakHashMap与其他HashMap最大的不同。看下面的例子: 

    Java代码  收藏代码
      1. import java.util.Iterator;  
      2. import java.util.WeakHashMap;  
      3.   
      4. public class Demo{  
      5.     public static void main(String [] args) throws Exception{  
      6.         WeakHashMap<String,String> weakHashMap=new WeakHashMap<String, String>();  
      7.         String [] sts=new String[10];  
      8.         for(int i=0;i<100;i++){  
      9.             if(i%10==0) {  
      10.                 sts[i/10]=new String(""+i);  
      11.                 weakHashMap.put(sts[i/10], new String(""+i));  
      12.             }  
      13.             else  
      14.                 weakHashMap.put(new String(""+i), new String(""+i));  
      15.         }  
      16.   
      17.         // 催促垃圾回收器工作  
      18.         System.gc();  
      19.         // 把CPU让给垃圾回收器线程  
      20.         Thread.sleep(8000);  
      21.   
      22.         Iterator<String> iterator=weakHashMap.keySet().iterator();  
      23.         while(iterator.hasNext()){  
      24.             System.out.println(iterator.next());  
      25.         }  
      26.     }  
      27. }  

    转载:https://www.cnblogs.com/yaowen/p/6292984.html

    展开全文
  • 有些程序员,认为java对对象采用引用调用,实际上这种理解是不对!!!       举例代码: 先写一个People类 package diaoYong; class People { private String name; public People(String str...
  • Java的引用类型和原始类型

    千次阅读 2007-05-10 23:46:00
    Java 提供两种不同类型:引用类型和原始类型(或内置类型)。另外,Java 还为每个原始类型提供了封装类(Wrapper)。 如果需要一个整型变量,是使用基本 int 型呢,还是使用 Integer 类一个对象呢?如果需要声明...
  • 请问高手,java的引用类型在实际开发中起什么作用?什么情况下才考虑用引用类型?
  • Java引用类型

    千次阅读 2016-03-16 19:12:55
    博主最近在整理Java集合框架时,在整理到WeakHashMap的时候,觉得有必要先阐述一下Java的引用类型,故此先整理的这篇文章,希望各位多提提意见。   闲话不多说,直接进入主题。Java中提供了4个级别的引用:强引用...
  • JAVA 四中引用类型

    万次阅读 2019-07-09 12:22:12
    常见的java引用有四种:强引用、软引用、弱引用、虚引用; 下面分别来介绍一下各种引用: 1、强引用Java 中最常见就是强引用,把一个对象赋给一个引用变量,这个引用变量就是一个强引用。当一个对象被强引用...
  • Java引用数据类型String详解

    万次阅读 2020-07-02 23:54:44
    引用类型,都可以用null值作为值,也就是说可以在初始化时候赋值为null,String是引用类型,也就是说可以使用null作为值。 引用数据类型与基本数据类型差别(举例说明) 使用基本数据类型: int i1 = 1 int i2 ...
  • Java引用类型的参数也是值传递

    千次阅读 2019-03-14 20:28:13
    Java的引用类型作为参数传递给方法的时候,发生的仅仅是将引用类型变量的值复制一份给方法,让方法中的参数变量也指向内存中的对象区域。
  • Java引用类型有哪些

    万次阅读 2019-07-05 16:48:32
    其中,引用数据类型在存储堆中对需要引用的对象进行引用,引用是Java面向对象的一个特点,在Java入门中,我们会接触到四种Java的引用类型,接下来就说说这四种Java引用类型有哪些吧: 1、Java中有哪几种引用?...
  • java引用类型

    2011-07-14 12:15:01
    http://wenku.baidu.com/view/3fc341737fd5360cba1adb60.htmljava的引用类型必须用new才算是分配了数据空间。 引用类型数据是指 ,数据类型 在堆内存中创建的数据,而你拿到的是这个数据的引用。 java中除了 int,do
  • Java的引用类型

    千次阅读 2019-03-18 15:18:40
    Java程序中最常见的引用类型是强引用,也是默认的引用类型。当在Java语言中使用 New 操作符创建一个新的对象,并将其赋给一个变量的时候,这个变量就成为指向该对象的一个强引用。 判断一个对象是否存活的标准为...
  • Java String 引用类型

    千次阅读 2018-04-09 09:58:50
    String 引用类型1,String类型是引用类型。1. String s = "aaa"; 这段代码,JVM创建了一个变量引用S,在堆中创建了一个对象aaa,将aaa放进常量池中,s指向aaa.2,“==”和equals区别 1. ==可以用来...
  • java引用数据类型

    千次阅读 2011-07-14 12:19:20
    http://wenku.baidu.com/view/3fc341737fd5360cba1adb60.htmljava的引用类型必须用new才算是分配了数据空间。引用类型数据是指 ,数据类型 在堆内存中创建的数据,而你拿到的是这个数据的引用。java中除了 int,...
  • java引用类型的变量和对象区别

    千次阅读 2017-05-23 09:07:20
    java引用类型的变量和对象区别。
  • 1.Java的引用类型有哪几种? 2.每种引用类型的特点是什么? 3.每种引用类型的应用场景是什么? 4.ThreadLocal你了解吗 5.ThreadLocal应用在什么地方? Spring事务方面应用到了 6.ThreadLocal会产生内存泄漏你了解吗? ...
  • Java引用类型和值类型不同

    千次阅读 2016-08-13 22:06:33
    Java编程过程中,经常有人会因为没有弄清楚引用类型与值类型区别而导致各种稀奇古怪Bug出现,而且出现了还不知道问题在哪里。这里将简单阐述一下两者区别。 引用数据类型:该类型指向一个对象,而不是原始...
  • 变量类型就是Java数据类型,包括: 基本类型和引用类型。基本类型就8种: boolean – 布尔,就是真 true 或假 false byte short int long – 整型,默认整型 int float double – 浮点,就是小数 char ...
  • java的引用数据类型

    2014-05-19 19:33:55
    java的数据类型大的方面包括,基本数据类型引用数据类型
  • Java基本数据类型和引用类型的区别

    千次阅读 2019-05-05 11:17:32
    Java基本数据类型和引用类型的区别
  • Java引用类型的强制类型转换

    千次阅读 2018-07-22 22:30:10
    正如有时候需要将浮点型... 编写Java程序时,引用类型只能调用声明该变量类型方法,也就是编译时类型方法,不允许调用运行时类型所定义方法,即使它实际所引用对象包含该方法。解释一下就是我们说...
  • java引用类型的数据,传递是内存地址,像类,数组,接口,String等等都是引用类型!看下面代码和截图!public class Test2 { // java引用类型的数据传递是内存地址 private Map&lt;String, Student&...
  • java的引用类型概念

    2017-04-10 17:46:11
    标签:  java   引用类型 ...分类: java ...1、什么是引用类型 ... 引用类型(reference type)指向一个对象,不是原始... 在java里面除去基本数据类型其它类型都是引用数据类型,自己定义class类都是引用类型
  • Java 基本类型与引用类型

    千次阅读 2019-03-27 20:55:51
    Java 基本类型与引用类型 一、基本数据类型 java 中一共分为 8 种基本数据类型:byte、short、int、long、float、double、char、boolean, 其中 byte、short、int、long 是整型。float、double 是浮点型,char 是...
  • Java数据类型引用型数据类型

    万次阅读 多人点赞 2018-06-26 23:33:29
    我们接着来说数据类型,上一次我们提到了java中的八种数据类型,没有涉及到引用类型,而java的引用类型只有三种,分别是类(class)、接口(interface)、数组。如下图所示 Java把内存分成两种,一种叫做栈内存,一种...
  • java中值类型和引用类型的区别

    千次阅读 2017-06-21 21:35:33
    java中值类型和引用类型的区别篇一  值类型通常被分配在栈上,它变量直接包含变量实例,使用效率比较高。  java中值类型和引用类型的区别篇二  引用类型分配在托管堆上,引用类型的变量通常包含一个指向...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 58,842
精华内容 23,536
关键字:

java的引用类型

java 订阅