精华内容
下载资源
问答
  • java 引用
    千次阅读
    2020-08-25 17:08:24

    结论:

    1)当使用基本数据类型作为方法的形参时,在方法体中对形参的修改不会影响到实参的数值
    2)当使用引用数据类型作为方法的形参时,若在方法体中 修改形参指向的数据内容,则会对实参变量的数值产生影响,因为形参变量和实参变量共享同一块堆区;
    3)当使用引用数据类型作为方法的形参时,若在方法体中 修改形参变量的指向,此时不会对实参变量的数值产生影响,因此形参变量和实参变量分别指向不同的堆区

    例一:基本数据类型作为形参,运行结果不改变实参

    public class Main {
        public static void main(String[] args) {
            Person p = new Person();
            int n = 15; // n的值为15
            p.setAge(n); // 传入n的值
            System.out.println(p.getAge()); // 15
            n = 20; // n的值改为20
            System.out.println(p.getAge()); // 15
        }
    }
    
    class Person {
        private int age;
    
        public int getAge() {
            return this.age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    }
    

    例二:引用类型–修改形参指向的数据内容,运行结果改变实参指向的数值,不改变实参地址

    public class Main {
        public static void main(String[] args) {
            Person p = new Person();
            String[] fullname = new String[] { "Homer", "Simpson" };
            p.setName(fullname); // 传入fullname数组
            System.out.println(p.getName()); // "Homer Simpson"
            fullname[0] = "Bart"; // fullname数组的第一个元素修改为"Bart"
            System.out.println(p.getName()); // 是"Bart Simpson"
        }
    }
    
    class Person {
        private String[] name;
    
        public String getName() {
            return this.name[0] + " " + this.name[1];
        }
    
        public void setName(String[] name) {
            this.name = name;
        }
    }
    

    例三:引用类型–修改形参的指向,运行结果,不改变实参的任何东西

    public class Main {
        public static void main(String[] args) {
            Person p = new Person();
            String bob = "Bob";
            p.setName(bob); // 传入bob变量
            System.out.println(p.getName()); // "Bob"
            bob = "Alice"; // bob改名为Alice
            System.out.println(p.getName()); // "Bob"
        }
    }
    
    class Person {
        private String name;
    
        public String getName() {
            return this.name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    }
    
    更多相关内容
  • Java引用类型用法总结(重点)

    千次阅读 2022-01-27 16:28:43
    Java引用类型 引用数据类型:数组,类,接口。 class作为成员变量 类作为成员变量时,对它进行赋值的操作,实际上,是赋给它该类的一个对象。 在这里插入代码片 interface作为成员变量 在这里插入代码片 ...

    Java引用类型

    引用数据类型:数组,类(String),接口。

    class作为成员变量

    类作为成员变量时,对它进行赋值的操作,实际上,是赋给它该类的一个对象。

    Role.java

    package referenceType2;
    
    public class Role {
        private String name;
        private int blood;
        private Weapon weapon;
        private Armour armour;
    
        public Role(String name, int blood) {
            this.name = name;
            this.blood = blood;
            // this.armour = armour;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public Weapon getWeapon() {
            return weapon;
        }
    
        public void setWeapon(Weapon weapon) {
            this.weapon = weapon;
        }
    
        public Armour getArmour() {
            return armour;
        }
    
        public void setArmour(Armour armour) {
            this.armour = armour;
        }
    
        public void attack() {
            System.out.println(weapon.getName() + " ------ " + weapon.getDamage());
        }
    
        public void defend() {
            System.out.println(armour.getName() + " ------- " + armour.getProtect());
        }
    
        public void life() {
            //不写this.getName()也可以了,默认this调用
            System.out.println(getName() + "的初始生命值 = " + blood);
            System.out.println("穿上防弹衣后生命值 = " + (this.blood + armour.getProtect()));
            System.out.println("穿上防弹衣,挨了一刀");
            blood += armour.getProtect() - weapon.getDamage();
            System.out.println(getName() + "的剩余生命值 = " + blood);
        }
    }
    

    Weapon.java

    package referenceType2;
    
    public class Weapon {
        private String name;
        private int damage;
    
        public Weapon(String name, int damage) {
            this.name = name;
            this.damage = damage;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getDamage() {
            return damage;
        }
    
        public void setDamage(int damage) {
            this.damage = damage;
        }
    }
    

    Armour.java

    package referenceType2;
    
    public class Armour {
        private String name;
        private int protect;
    
        public Armour(String name, int protect) {
            this.name = name;
            this.protect = protect;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getProtect() {
            return protect;
        }
    
        public void setProtect(int protect) {
            this.protect = protect;
        }
    }
    

    Test.java

    package referenceType2;
    
    public class Test {
        public static void main(String[] args) {
            Weapon weapon = new Weapon("刀(伤害)", 80);
            Armour armour = new Armour("Bulletproof Vest(增加防护)", 50);
    
            Role role = new Role("张三", 100);
            //Role role = new Role("张三",100,armour);
            role.setWeapon(weapon);
            role.setArmour(armour);
    
            //打印武器伤害
            role.attack();
            //打印防弹衣保护
            role.defend();
            System.out.println("");
            role.life();
        }
    }
    

    在这里插入图片描述

    interface作为成员变量

    接口是对方法的封装,对应游戏当中,可以看作是扩展游戏角色的技能。如果想扩展更强大技能,我们在Role中,可以增加接口作为成员变量,来设置不同的技能。

    我们使用一个接口,作为成员变量,以便随时更换技能,这样的设计更为灵活,增强了程序的扩展性。
    接口作为成员变量时,对它进行赋值的操作,实际上,是赋给它该接口的一个子类对象

    set()方法中可以传入匿名内部类

    Role.java

    package referenceType3;
    
    public class Role {
        MagicAttack magicAttack;
    
        public void setMagicAttack(MagicAttack magicAttack) {
            this.magicAttack = magicAttack;
        }
    
        public void skillAttack(){
            magicAttack.magicAttack();
        }
    }
    

    MagicAttack.java(接口)

    package referenceType3;
    
    public interface MagicAttack {
        void magicAttack();
    }
    

    Test.java

    package referenceType3;
    
    public class Test {
        public static void main(String[] args) {
            Role role = new Role();
            //set()方法中传入匿名内部类
            role.setMagicAttack(new MagicAttack() {
                @Override
                public void magicAttack() {
                    System.out.println("火雨");
                }
            });
            role.skillAttack();
            System.out.println("");
    
            System.out.println("更换技能。。。");
    
            System.out.println("");
    
            //更换技能攻击
            role.setMagicAttack(new MagicAttack() {
                @Override
                public void magicAttack() {
                    System.out.println("闪电链");
                }
            });
            role.skillAttack();
        }
    }
    

    在这里插入图片描述

    interface作为方法参数和返回值类型

    接口作为参数时,传递它的子类对象。
    接口作为返回值类型时,返回它的子类对象。

    ArrayList类我们并不陌生,查看API我们发现,实际上,它是 java.util.List 接口的实现类。所以,当我们看见List 接口作为参数或者返回值类型时,当然可以将ArrayList的对象进行传递或返回。

    1.List接口做参数类型,返回值也是List接口类型
    2.方法参数,返回值类型的List如果用List< Integer>泛型表示的话,集合获取元素时就不用强转了

    package referenceType4;
    
    import java.util.ArrayList;
    import java.util.List;
    
    public class Test {
        public static void main(String[] args) {
            ArrayList<Integer> aList = new ArrayList<>(10);
            /**
             * 错误写法,foreach中不能用list.add(i)
             *  for (Integer i : aList) {
             aList.add(i);
             }*/
            for (int i = 1; i <= 10; i++) {
                aList.add(i);
            }
            aList.add(0);
            aList.add(-1);
            aList.add(-2);
            aList.add(-3);
            aList.add(-4);
            System.out.println("aList = " + aList);
    
            //List list = new Test().getEvenNum(aList);
            List list = getEvenNum(aList);
            System.out.println("list = " + list);
        }
    
        //获取集合中所有偶数方法
        //不写静态方法也可以
        // public List getEvenNum(List list){
        //List接口做参数类型,返回值也是List接口类型
        public static List getEvenNum(List list) {    
            // public static List<Integer> getEvenNum(List<Integer> list) {
            List<Integer> evenNumList = new ArrayList<>();
            for (int i = 0; i < list.size(); i++) {
              //加List泛型后就不用强制转换了
              // Integer integer = list.get(i);
                Integer integer = (Integer) list.get(i);
                //Integer integer = list.get(i);
                /**
                 * if (integer % 2 == 0) {
                 evenNumList.add(integer);
                 }*/
                //按位与更快
                if ((integer & 1) != 1) {
                    evenNumList.add(integer);
                }
            }
            return evenNumList;
        }
    }
    

    ()

    展开全文
  • 然而上例使用的java with kotlin ,因此可能是kotlin的引用错误导致。 参考官网文档:https://developer.android.com/kotlin/add-kotlin?hl=zh-cn 项目迁移到kotlin,需要在project根目录build.gradle 添.
    1. 首先在application 创建test class
      在这里插入图片描述
    2. 在application 中引用
      在这里插入图片描述
      如图所示,在IDE中,并没有提示错误
      然后我们编译一下项目在这里插入图片描述
      出现了错误提示
      在这里插入图片描述
      仔细观察会发现 使用的编译是javac

    然而上例使用的java with kotlin ,因此可能是kotlin的引用错误导致。

    参考官网文档:https://developer.android.com/kotlin/add-kotlin?hl=zh-cn

    项目迁移到kotlin,需要在project根目录build.gradle 添加 kotlin的引用,并且,

    展开全文
  • Java引用类型

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

    欢迎支持笔者新作:《深入理解Kafka:核心设计与实践原理》和《RabbitMQ实战指南》,同时欢迎关注笔者的微信公众号:朱小厮的博客。


    欢迎跳转到本文的原文链接:https://honeypps.com/java/java-reference-type/

      博主最近在整理Java集合框架时,在整理到WeakHashMap的时候,觉得有必要先阐述一下Java的引用类型,故此先整理的这篇文章,希望各位多提提意见。
      闲话不多说,直接进入主题。Java中提供了4个级别的引用:强引用、软引用、弱引用和虚引用。这四个引用定义在java.lang.ref的包下。
    这里写图片描述


    ##强引用( Final Reference)
      就是指在程序代码中普遍存在的,类似Object obj = new Object()这类的引用,只要强引用还存在,垃圾收集器永远不会回收掉被引用的对象。
      强引用具备以下三个个特点:

    1. 强引用可以直接访问目标对象;
    2. 强引用锁指向的对象在任何时候都不会被系统回收。JVM宁愿抛出OOM异常也不回收强引用所指向的对象;
    3. 强应用可能导致内存泄露;
    

      整个FinalReference类的定义如下(有些API中并没有加入FinalReference类的说明,只能看源码了):

    package java.lang.ref;
    /* Final references, used to implement finalization */
    class FinalReference<T> extends Reference<T> {
        public FinalReference(T referent, ReferenceQueue<? super T> q) {
            super(referent, q);
        }
    }
    

      从类定义中可以看出,只有一个构造函数,根据所给的对象的应用和应用队列构造一个强引用。


    ##软引用(Soft Reference)
      是用来描述一些还有用但并非必须的对象。对于软引用关联着的对象,在系统将要发生内存溢出异常之前,将会把这些对象列进回收范围之中进行第二次回收。如果这次回收还没有足够的内存,才会抛出内存溢出异常。
      对于软引用关联着的对象,如果内存充足,则垃圾回收器不会回收该对象,如果内存不够了,就会回收这些对象的内存。在 JDK 1.2 之后,提供了 SoftReference 类来实现软引用。软引用可用来实现内存敏感的高速缓存。软引用可以和一个引用队列(ReferenceQueue)联合使用,如果软引用所引用的对象被垃圾回收器回收,Java虚拟机就会把这个软引用加入到与之关联的引用队列中。
      案例1:

    package collections.ref;
    
    import java.lang.ref.Reference;
    import java.lang.ref.ReferenceQueue;
    import java.lang.ref.SoftReference;
    
    public class SoftRefTest
    {
        private static ReferenceQueue<MyObject> softQueue = new ReferenceQueue<>();
    
        public static class MyObject{
    
            @Override
            protected void finalize() throws Throwable
            {
                super.finalize();
                System.out.println("MyObject's finalize called");
            }
    
            @Override
            public String toString()
            {
                return "I am MyObject";
            }
        }
    
        public static class CheckRefQueue implements Runnable
        {
            Reference<MyObject> obj = null;
            @Override
            public void run()
            {
                try
                {
                    obj = (Reference<MyObject>)softQueue.remove();
                }
                catch (InterruptedException e)
                {
                    e.printStackTrace();
                }
                if(obj != null)
                {
                    System.out.println("Object for SoftReference is "+obj.get());
                }
            }
        }
    
        public static void main(String[] args)
        {
            MyObject object = new MyObject();
            SoftReference<MyObject> softRef = new SoftReference<>(object,softQueue);
            new Thread(new CheckRefQueue()).start();
    
            object = null;    //删除强引用
            System.gc();
            System.out.println("After GC: Soft Get= "+softRef.get());
            System.out.println("分配大块内存");
            byte[] b = new byte[5*1024*928];
            System.out.println("After new byte[]:Soft Get= "+softRef.get());
            System.gc();
        }
    }
    

      运行参数1:

    -Xmx5M
    

      运行结果1:

    After GC: Soft Get= I am MyObject
    分配大块内存
    MyObject's finalize called
    Object for SoftReference is null
    After new byte[]:Soft Get= null
    

      运行参数2:

    -Xmx5M -XX:PrintGCDetails
    

      运行结果2(关于GC日志可以查看《Java堆内存http://blog.csdn.net/u013256816/article/details/50764532》):

    [GC [PSYoungGen: 680K->504K(2560K)] 680K->512K(6144K), 0.0040658 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
    [Full GC [PSYoungGen: 504K->0K(2560K)] [ParOldGen: 8K->482K(3584K)] 512K->482K(6144K) [PSPermGen: 2491K->2490K(21504K)], 0.0188479 secs] [Times: user=0.01 sys=0.00, real=0.02 secs] 
    After GC: Soft Get= I am MyObject
    分配大块内存
    [GC [PSYoungGen: 123K->64K(2560K)] 605K->546K(7680K), 0.0004285 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
    [GC [PSYoungGen: 64K->64K(2560K)] 546K->546K(7680K), 0.0003019 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
    [Full GC [PSYoungGen: 64K->0K(2560K)] [ParOldGen: 482K->482K(4608K)] 546K->482K(7168K) [PSPermGen: 2493K->2493K(21504K)], 0.0094748 secs] [Times: user=0.02 sys=0.00, real=0.01 secs] 
    [GC [PSYoungGen: 0K->0K(2560K)] 482K->482K(7680K), 0.0003759 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
    [Full GC [PSYoungGen: 0K->0K(2560K)] [ParOldGen: 482K->472K(5120K)] 482K->472K(7680K) [PSPermGen: 2493K->2493K(21504K)], 0.0101017 secs] [Times: user=0.06 sys=0.00, real=0.01 secs] 
    MyObject's finalize called
    Object for SoftReference is null
    After new byte[]:Soft Get= null
    [GC [PSYoungGen: 122K->32K(2560K)] 5235K->5144K(7680K), 0.0004806 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
    [Full GC [PSYoungGen: 32K->0K(2560K)] [ParOldGen: 5112K->5112K(5120K)] 5144K->5112K(7680K) [PSPermGen: 2493K->2493K(21504K)], 0.0136270 secs] [Times: user=0.06 sys=0.00, real=0.01 secs] 
    Heap
     PSYoungGen      total 2560K, used 20K [0x00000000ffd00000, 0x0000000100000000, 0x0000000100000000)
      eden space 2048K, 1% used [0x00000000ffd00000,0x00000000ffd05250,0x00000000fff00000)
      from space 512K, 0% used [0x00000000fff00000,0x00000000fff00000,0x00000000fff80000)
      to   space 512K, 0% used [0x00000000fff80000,0x00000000fff80000,0x0000000100000000)
     ParOldGen       total 5120K, used 5112K [0x00000000ff800000, 0x00000000ffd00000, 0x00000000ffd00000)
      object space 5120K, 99% used [0x00000000ff800000,0x00000000ffcfe188,0x00000000ffd00000)
     PSPermGen       total 21504K, used 2500K [0x00000000fa600000, 0x00000000fbb00000, 0x00000000ff800000)
      object space 21504K, 11% used [0x00000000fa600000,0x00000000fa871190,0x00000000fbb00000)
    

      加入 -XX:PrintGCDetails参数运行可以更形象的看到GC回收的细节。
      这个案例1中,首先构造MyObject对象,并将其赋值给object变量,构成强引用。然后使用SoftReference构造这个MyObject对象的软引用softRef,并注册到softQueue引用队列。当softRef被回收时,会被加入softQueue队列。设置obj=null,删除这个强引用,因此,系统内对MyObject对象的引用只剩下软引用。此时,显示调用GC,通过软引用的get()方法,取得MyObject对象的引用,发现对象并未被回收,这说明GC在内存充足的情况下,不会回收软引用对象。
      接着,请求一块大的堆空间51024928,这个操作会使系统堆内存使用紧张,从而产生新一轮的GC。在这次GC后,softRef.get()不再返回MyObject对象,而是返回null,说明在系统内存紧张的情况下,软引用被回收。软引用被回收时,会被加入注册的引用队列。
      如果将上面案例中的数组再改大点,比如510241024,就会抛出OOM异常:

    After GC: Soft Get= I am MyObject
    分配大块内存
    MyObject's finalize called
    Object for SoftReference is null
    Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
        at collections.ref.SoftRefTest.main(SoftRefTest.java:58)
    

      软引用主要应用于内存敏感的高速缓存,在android系统中经常使用到。一般情况下,Android应用会用到大量的默认图片,这些图片很多地方会用到。如果每次都去读取图片,由于读取文件需要硬件操作,速度较慢,会导致性能较低。所以我们考虑将图片缓存起来,需要的时候直接从内存中读取。但是,由于图片占用内存空间比较大,缓存很多图片需要很多的内存,就可能比较容易发生OutOfMemory异常。这时,我们可以考虑使用软引用技术来避免这个问题发生。SoftReference可以解决oom的问题,每一个对象通过软引用进行实例化,这个对象就以cache的形式保存起来,当再次调用这个对象时,那么直接通过软引用中的get()方法,就可以得到对象中中的资源数据,这样就没必要再次进行读取了,直接从cache中就可以读取得到,当内存将要发生OOM的时候,GC会迅速把所有的软引用清除,防止oom发生。
      案例2:

    public class BitMapManager {
        private Map<String, SoftReference<Bitmap>> imageCache = new HashMap<String, SoftReference<Bitmap>>();
    
        //保存Bitmap的软引用到HashMap
        public void saveBitmapToCache(String path) {
            // 强引用的Bitmap对象
            Bitmap bitmap = BitmapFactory.decodeFile(path);
            // 软引用的Bitmap对象
            SoftReference<Bitmap> softBitmap = new SoftReference<Bitmap>(bitmap);
            // 添加该对象到Map中使其缓存
            imageCache.put(path, softBitmap);
            // 使用完后手动将位图对象置null
            bitmap = null;
        }
    
        public Bitmap getBitmapByPath(String path) {
    
            // 从缓存中取软引用的Bitmap对象
            SoftReference<Bitmap> softBitmap = imageCache.get(path);
            // 判断是否存在软引用
            if (softBitmap == null) {
                return null;
            }
            // 取出Bitmap对象,如果由于内存不足Bitmap被回收,将取得空
            Bitmap bitmap = softBitmap.get();
            return bitmap;
        }
    }
    

    弱引用(Weak Reference)

      用来描述非必须的对象,但是它的强度比软引用更弱一些,被弱引用关联的对象只能生存到下一次垃圾收集发送之前。当垃圾收集器工作时,无论当前内存是否足够,都会回收掉只被弱引用关联的对象。一旦一个弱引用对象被垃圾回收器回收,便会加入到一个注册引用队列中。
      我们略微修改一下案例1的代码,如下:

    package collections.ref;
    
    import java.lang.ref.Reference;
    import java.lang.ref.ReferenceQueue;
    import java.lang.ref.WeakReference;
    
    public class WeakRefTest
    {
        private static ReferenceQueue<MyObject> weakQueue = new ReferenceQueue<>();
    
        public static class MyObject{
    
            @Override
            protected void finalize() throws Throwable
            {
                super.finalize();
                System.out.println("MyObject's finalize called");
            }
    
            @Override
            public String toString()
            {
                return "I am MyObject";
            }
        }
    
        public static class CheckRefQueue implements Runnable
        {
            Reference<MyObject> obj = null;
            @Override
            public void run()
            {
                try
                {
                    obj = (Reference<MyObject>)weakQueue.remove();
                }
                catch (InterruptedException e)
                {
                    e.printStackTrace();
                }
                if(obj != null)
                {
                    System.out.println("删除的弱引用为:"+obj+"  but获取弱引用的对象obj.get()="+obj.get());
                }
            }
        }
    
        public static void main(String[] args)
        {
            MyObject object = new MyObject();
            Reference<MyObject> weakRef = new WeakReference<>(object,weakQueue);
            System.out.println("创建的弱引用为:"+weakRef);
            new Thread(new CheckRefQueue()).start();
    
            object = null;
            System.out.println("Before GC: Weak Get= "+weakRef.get());
            System.gc();
            System.out.println("After GC: Weak Get= "+weakRef.get());
        }
    }
    

      不加参数运行结果:

    创建的弱引用为:java.lang.ref.WeakReference@29e07d3e
    Before GC: Weak Get= I am MyObject
    After GC: Weak Get= null
    MyObject's finalize called
    删除的弱引用为:java.lang.ref.WeakReference@29e07d3e  but获取弱引用的对象obj.get()=null
    

      可以看到,在GC之前,弱引用对象并未被垃圾回收器发现,因此通过 weakRef.get()可以获取对应的对象引用。但是只要进行垃圾回收,弱引用一旦被发现,便会立即被回收,并加入注册引用队列中。此时再试图通过weakRef.get()获取对象的引用就会失败。
      弱引用的相关实际案例可以参考WeakHashMap,博主会在近期整理出相关文档。等不及的小伙伴可以自行度娘之。

    软引用、弱引用都非常适合来保存那些可有可无的缓存数据。如果这么做,当系统内存不足时,这些缓存数据会被回收,不会导致内存溢出。而当内存资源充足时,这些缓存数据又可以存在相当长的时间,从而起来加速系统的作用。


    ##虚引用(Phantom Reference)
      虚引用也称为幽灵引用或者幻影引用,它是最弱的一种引用关系。一个持有虚引用的对象,和没有引用几乎是一样的,随时都有可能被垃圾回收器回收。当试图通过虚引用的get()方法取得强引用时,总是会失败。并且,虚引用必须和引用队列一起使用,它的作用在于跟踪垃圾回收过程。
      虚引用中get方法的实现如下:

        public T get() {
            return null;
        }
    

      可以看到永远返回null.
      我们再来修改一下案例1的代码:

    package collections.ref;
    
    import java.lang.ref.PhantomReference;
    import java.lang.ref.Reference;
    import java.lang.ref.ReferenceQueue;
    import java.util.concurrent.TimeUnit;
    
    public class PhantomRefTest
    {
        private static ReferenceQueue<MyObject> phanQueue = new ReferenceQueue<>();
    
        public static class MyObject{
    
            @Override
            protected void finalize() throws Throwable
            {
                super.finalize();
                System.out.println("MyObject's finalize called");
            }
    
            @Override
            public String toString()
            {
                return "I am MyObject";
            }
        }
    
        public static class CheckRefQueue implements Runnable
        {
            Reference<MyObject> obj = null;
            @Override
            public void run()
            {
                try
                {
                    obj = (Reference<MyObject>)phanQueue.remove();
                    System.out.println("删除的虚引用为:"+obj+"  but获取虚引用的对象obj.get()="+obj.get());
                    System.exit(0);
                }
                catch (InterruptedException e)
                {
                    e.printStackTrace();
                }
            }
        }
    
        public static void main(String[] args) throws InterruptedException
        {
            MyObject object = new MyObject();
            Reference<MyObject> phanRef = new PhantomReference<>(object,phanQueue);
            System.out.println("创建的虚引用为:"+phanRef);
            new Thread(new CheckRefQueue()).start();
    
            object = null;
            TimeUnit.SECONDS.sleep(1);
            int i =1;
            while(true)
            {
                System.out.println("第"+i+++"次gc");
                System.gc();
                TimeUnit.SECONDS.sleep(1);
            }
        }
    }
    

      运行结果:

    创建的虚引用为:java.lang.ref.PhantomReference@3a6646fc
    第1次gc
    MyObject's finalize called
    第2次gc
    删除的虚引用为:java.lang.ref.PhantomReference@3a6646fc  but获取虚引用的对象obj.get()=null
    

      可以看到,再经过一次GC之后,系统找到了垃圾对象,并调用finalize()方法回收内存,但没有立即加入回收队列。第二次GC时,该对象真正被GC清楚,此时,加入虚引用队列。
      虚引用的最大作用在于跟踪对象回收,清理被销毁对象的相关资源。
      通常当对象不被使用时,重载该对象的类的finalize方法可以回收对象的资源。但是如果使用不慎,会使得对象复活,譬如这么编写finalize方法:

    public class Test{
        public static Test obj;
        
        @Override protected void finalize() throws Throwable{
            super.finalize();
            obj = this;
        }
    }
    

      对上面这个类Test中obj = new Test();然后obj=null;之后调用System.gc()企图销毁对象,但是很抱歉,不管你调用多少次System.gc()都没有什么用,除非你在下面的代码中再就obj=null;这样才能回收对象,这是因为JVM对某一个对象至多只执行一次被重写的finalize方法。
      上面的小片段说明重写finalize的方法并不是很靠谱,可以使用虚引用来清理对象所占用的资源。
      如下代码所示:

        public class PhantomRefTest2
    {
        private static ReferenceQueue<MyObject> phanQueue = new ReferenceQueue<>();
        private static Map<Reference<MyObject>,String> map = new HashMap<>();
    
        public static class MyObject{
    
            @Override
            protected void finalize() throws Throwable
            {
                super.finalize();
                System.out.println("MyObject's finalize called");
            }
    
            @Override
            public String toString()
            {
                return "I am MyObject";
            }
        }
    
        public static class CheckRefQueue implements Runnable
        {
            Reference<MyObject> obj = null;
            @Override
            public void run()
            {
                try
                {
                    obj = (Reference<MyObject>)phanQueue.remove();
                    Object value = map.get(obj);
                    System.out.println("clean resource:"+value);
                    map.remove(obj);
    
                    System.out.println("删除的虚引用为:"+obj+"  but获取虚引用的对象obj.get()="+obj.get());
                    System.exit(0);
                }
                catch (InterruptedException e)
                {
                    e.printStackTrace();
                }
            }
        }
    
        public static void main(String[] args) throws InterruptedException
        {
            MyObject object = new MyObject();
            Reference<MyObject> phanRef = new PhantomReference<>(object,phanQueue);
            System.out.println("创建的虚引用为:"+phanRef);
            new Thread(new CheckRefQueue()).start();
            map.put(phanRef, "Some Resources");
    
            object = null;
            TimeUnit.SECONDS.sleep(1);
            int i =1;
            while(true)
            {
                System.out.println("第"+i+++"次gc");
                System.gc();
                TimeUnit.SECONDS.sleep(1);
            }
        }
    }
    

      运行结果:

    创建的虚引用为:java.lang.ref.PhantomReference@6a07348e
    第1次gc
    MyObject's finalize called
    第2次gc
    clean resource:Some Resources
    删除的虚引用为:java.lang.ref.PhantomReference@6a07348e  but获取虚引用的对象obj.get()=null
    

    参考资料:

    1. 《Java程序性能优化——让你的Java程序更快、更稳定》葛一鸣 等编著。
    2. 《Java堆内存http://blog.csdn.net/u013256816/article/details/50764532》

    欢迎跳转到本文的原文链接:https://honeypps.com/java/java-reference-type/

    欢迎支持笔者新作:《深入理解Kafka:核心设计与实践原理》和《RabbitMQ实战指南》,同时欢迎关注笔者的微信公众号:朱小厮的博客。


    展开全文
  • Java引用类型分类以及详解

    千次阅读 2018-06-11 00:10:46
    Java引用类型分类以及详解 - Java引用类型概述 在JVM之中再好的算法,也敌不过一个好烂的程序员。一个程序要想写好有两点:按照开发标准进行、请写有用代码。 而对于垃圾的产生与回收的处理之中,要想进行更好...
  • public class StandardAction extends ActionSupport implements SessionAware, ApplicationAware, RequestAware { ``` 在import java.util.Map时可以指定个版本号,好比说这样: ``` import java.util.Map 2.5.18;...
  • java引用与指针

    千次阅读 2018-05-06 17:45:30
    没有指针的java语言 java语言中使用了引用代替了指针,引用实质就是指针,但它是受控的、安全的。我们知道,一个引用,比如说person p 等于new person,实际上就是p这个引用指向了这个对象实体,所以本质上就是指针...
  • java 引用本地JAR包

    千次阅读 2019-06-07 15:48:25
    maven 项目引用本地JAR包 写好路径和JAR包, <dependency> <groupId>xx.xx.bis</groupId> <artifactId>xx-xx-dubbo</artifactId> <version>3.5.8...
  • java引用和指针的区别

    千次阅读 2018-05-15 17:50:13
    Java引用和C++的指针的区别Java引用和C++的指针都是指向一块内存地址的,通过引用或指针来完成对内存数据的操作,就好像风筝的线轴一样,通过线轴总是能够找到风筝,但是它们在实现,原理作用等方面却有区别。...
  • Java引用类型有哪些

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

    千次阅读 2020-05-07 10:50:02
    引用: String str = “abc”; list.add(str); 软引用: 如果弱引用对象回收完之后,内存还是报警,继续回收软引用对象 SoftReference<A> sr = new SoftReference<A>(a); 弱引用: ...
  • Java 项目无法引用javax.swing.JOptionPane JAVA引用JOptionPane类报错 解决方案 报错通常以这种方式报错 原因可能是因为eclipse的环境配置过高或过低导致的不能调用java中的一些包 下面我的解决方法如下 第一...
  • JAVA中的引用四种引用类型

    千次阅读 2020-08-30 10:09:38
    关于值类型和引用类型的话题,C++、JAVA、python、go、C#等等高级语言都有相关的概念,只要理解了其底层工作原理,可以说即使是不同的语言,在面试学习工作实践中都可以信手拈来(不要太纠集语言),当然此处我选择了...
  • JAVA 引用类型数组的初始化

    千次阅读 2016-06-30 23:24:35
    引用类型数组的数组元素是 引用. 我们之前学习过的基本类型数组, 它里面的数组元素存放的是具体的值. 可以当作我们现实生活中的买房, 基本类型数组呢, 就像是你直接找到了房主. 而引用类型数组就像是你没有...
  • 深入理解Java引用(一)

    千次阅读 多人点赞 2018-09-22 11:29:33
    约定:本文所讲的内容适用于oracle公司的发布的1.8版本的jdk(hotspot虚拟机),文中例子请在相应的jdk版本下测试。   ... 我们知道Java是一门纯面向对象的语言,我们在使用Java语言编程时,到...
  • Java引用类型与常量

    千次阅读 2017-01-08 08:11:01
    Java引用类型与常量  引用数据类型  Java中,引用类型的变量非常类似于C/C++的指针。  引用类型指向一个对象,指向对象的变量是引用变量,这些变量在声明时被指定为一个特定的类型,比如Employee、Pubby等,...
  • Java引用对象在堆、栈内存中的变化

    千次阅读 2018-09-04 21:18:20
    最近又重新开始学习Java基础,再次学习也对引用、对象使用时内存变化有了进一步的了解。 这里先对Java虚拟机中堆栈功能简单总结; 1、对象主要存放在堆内存中;方法和属性主要存放在栈内存中。 2、栈是运行时单位...
  • java引用类型详解

    千次阅读 2020-02-06 15:53:53
    1.强引用引用所指向的对象,任何时候都不会被系统回收。即使JVM抛出OOM异常 2.软引用 当堆使用临近阈值时,才会回收软引用的对象,可用于对内存敏感的Cache 3.弱引用 4.虚引用 ...
  • java 引用传递三种类型

    万次阅读 2018-09-29 20:52:17
    我这里使用了mldn视频里...对于三种引用传递的理解: 第一种和第三种都好理解:其实就是c语言那样传递的是地址,当然能够修改属性值,对于第二种其实就是因为String类比较特殊,在第二个例子中fun()函数str2="m...
  • Java引用数据类型String详解

    万次阅读 2020-07-02 23:54:44
    Java引用数据类型(String)引用数据类型概述引用数据类型与基本数据类型的差别(举例说明) 引用数据类型概述 说到引用数据类型,那么何为引用数据类型? 引用类型,都可以用null值作为值,也就是说可以在初始化的...
  • Java中的引用传递

    千次阅读 2021-02-27 11:26:54
    我觉得引用传递 真的很好理解,不知道为什么大家觉得这么难,你只要掌握这几点就可以了在Java机制中他自己提供的那些数据类型(String ,Object等)要这样理解:1)在Java引用 说的就是 地址指针,或者叫地址变量,2)...
  • Java引用外部字体即自定义字体文件

    万次阅读 热门讨论 2017-07-20 10:40:54
    有时候我们在程序中,会使用到Java字体,但不是所有的字体系统中都会有,我们就可能会使用外部自定义字体,这样在程序迁移部署中就会少些工作,最近在一个项目中使用到了自定义字体文件,研究清楚了如何是使用了。...
  • Java的方法引用

    千次阅读 2022-01-27 13:57:52
    方法引用2.方法引用与lambda3.方法引用的使用 1.方法引用 方法引用是用来直接访问类或者实例的已经存在的方法或者构造方法。方法引用提供了一种引用而不执行方法的方式,它需要由兼容的函数式接口构成的目标类型上...
  • Java四种引用

    千次阅读 2021-08-15 21:04:59
    在JDK 1.2版之后,Java引用的概念进行了扩充,将引用分为强引用(Strongly Re-ference)、软引用(Soft Reference)、弱引用(Weak Reference)和虚引用(Phantom Reference)4种,这4种引用强 度依次逐渐减弱。...
  • Java中“基本数据类型”和“引用数据类型”变量在内存分配时的不同2. C中“指针”的特点3. Java中“引用”的特点4. Java的参数传递5.参考 前言 在学习Java中变量的数据类型时,发现其分为2大类:基本数据类型、引用...
  • java中的值传递和引用传递

    千次阅读 2021-12-07 20:07:09
    值传递(Pass By Value或者Call By Value)是对基本型变量而言的,传递的是该变量的...一般java中实例(包装)对象的传递是引用传递。 一、基本类型和引用类型在内存中的不同之处 int num = 10; String str = "hello
  • Java方法中的引用传递

    千次阅读 2021-05-18 17:36:13
    Java方法中的引用传递Java方法中的引用传递基础知识探究定义Person类写定义测试类进行测试运行结果分析另一个例子运行结果分析和结论 Java方法中的引用传递 最近复习java相关的知识,看到有一个资料里写道:Java 中...
  • Java的符号引用是什么

    千次阅读 2022-04-27 19:28:18
    在编译时,java类并不知道引用类的实际内存地址,因此只能使用符号引用来代替。 比如org.simple.People类引用org.simple.Tool类,在编译时People类并不知道Tool类的实际内存地址,因此只能使用符号org.simple....
  • Java引用变量调用方法时的

    千次阅读 2017-06-16 09:10:15
    Java引用变量有两个类型,分为:编译时类型和运行时类型 编译时类型:即声明引用变量时的类型 运行时类型:即生成的对象的类型 例如:Animal a=new Dog();其中编译时类型为Animal,运行时类型为Dog. 当相同...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,666,756
精华内容 666,702
关键字:

java 引用

友情链接: skyforces.rar