Java基础一 Java对象的引用

关注

原创最新推荐文章于 2026-10-04 10:21:41 发布 454 阅读 AI 写同款· GEO 优化 ›

浅谈一下JAVA对象，对象引用以及对象赋值浅谈一下JAVA对象，对象引用以及对象赋值今天有班级同学问起JAVA对象的引用是什么。正好趁着这次机会，自己总结一下JAVA对象，对象引用以及对象赋值。自己总结了所看到的网上相关方面的不少帖子，整理汇总形成下面的文章。 Java对象及其引用初学Java，总是会自觉或不自觉地把Java和C++相比较。在学习Java类与对象章节的时候，发现教科书和许多参考阅读详情

一.Java 强引用软引用弱引用虚引用的使用场景以及系统调用时机

Java的引用强引用直接使用了对象的地址，软引用弱引用虚引用都在引用对象之间隔了一层通过这些特殊的对象间接引用了我们需要的对象。

1.强引用：

Object object = new Object();

object 这个Object类型的变量直接引用了new Object() 这个类型的在内存中开辟的这块地址空间的地址。这是我们常见的编码方式。使用场景有：方法的局部变量，jni变量，类变量，概括起来就是GC ROOT 可达的都是强引用。

1.object如果前面加上static修饰那么这个Object 类型的变量就会在常量区定义那么会一直引用指着这块开辟的地址内存不会释放。

2.object这个变量在栈内引用已经执行完了并且没有其他地方引用这个地址时这块地址的引用数为0那么这块地址可以被释放。

3.只要有引用在，垃圾回收器永不处理，jvm宁愿自己崩了一般报（OutOfMemoryError）错误，也不去回收这个这类对象使用的内存。所以会造成内存泄漏和内存溢出。

4.源代码

class FinalReference<T> extends Reference<T> {

    public FinalReference(T referent, ReferenceQueue<? super T> q) {
        super(referent, q);
    }
}

2.软引用：

Objext obect = new Object();

SoftReference<Object> sfObject = new SoftReference<Object>(obj);

sfObject.get();//有时候会返回null

1.软引用即在生成的对象和产生的地址之上再封装一层。我们需要使用这个对象时通过软引用间接的获取到这个对象的使用。

2.object的释放在jvm内存不足时object指定的内存块释放。

3.软用可以用在程序中的缓存功能的实现，比如图片缓存，对象缓存等等。

4.在Android中 SoftReference 或者 WeakReference做图片缓存是不推荐的，因为Android内存小会更频繁的对于这些引用的对象进行回收，回收后又会频繁的对这些对象开辟内存空间。所以Android官方推荐最新的解决办法，这个类包含在android-support-v4包中，是采用LruCache以及DiskLruCache。Android中可以使用SoftReference 或者WeakReference 用在把上下文传入静态工具中以免造成activity内存泄漏。后续讲这类工具时在细分讲解。

5.源代码

public class SoftReference<T> extends Reference<T> {

    /**
     * Timestamp clock, updated by the garbage collector
     */
    static private long clock;

    /**
     * Timestamp updated by each invocation of the get method.  The VM may use
     * this field when selecting soft references to be cleared, but it is not
     * required to do so.
     */
    private long timestamp;

    /**
     * Creates a new soft reference that refers to the given object.  The new
     * reference is not registered with any queue.
     *
     * @param referent object the new soft reference will refer to
     */
    public SoftReference(T referent) {
        super(referent);
        this.timestamp = clock;
    }

    /**
     * Creates a new soft reference that refers to the given object and is
     * registered with the given queue.
     *
     * @param referent object the new soft reference will refer to
     * @param q the queue with which the reference is to be registered,
     *          or <tt>null</tt> if registration is not required
     *
     */
    public SoftReference(T referent, ReferenceQueue<? super T> q) {
        super(referent, q);
        this.timestamp = clock;
    }

    /**
     * Returns this reference object's referent.  If this reference object has
     * been cleared, either by the program or by the garbage collector, then
     * this method returns <code>null</code>.
     *
     * @return   The object to which this reference refers, or
     *           <code>null</code> if this reference object has been cleared
     */
    public T get() {
        T o = super.get();
        if (o != null && this.timestamp != clock)
            this.timestamp = clock;
        return o;
    }

}

6.在新建SoftReference对象和调用SoftReference.get时都会使timestamp更新为clock的值。而clock代表的是上次gc的时间。

SoftRefLRUPolicyMSPerMB默认为1000，即1s。代表每1MB空闲空间大小SoftReference保留1s。

-XX:SoftRefLRUPolicyMSPerMB

设置每兆堆空闲空间中SoftReference的存活时间，默认值是1s 。（softly reachable objects will remain alive for some amount of time after the last time they were referenced. The default value is one second of lifetime per free megabyte in the heap）

3.弱引用：

Object object = new Object();

WeakReference<Object> wfObect = new WeakReference<Object>(object);

wfObject.get();//有时返回为null

wfObject.isEnQueued();//返回引用状态返回是否被垃圾回收器标记为即将回收的垃圾

1.弱引用是在第二次垃圾回收时回收，短时间内通过弱引用取对应的数据，可以取到，当执行过第二次垃圾回收时，将返回null。
2.弱引用主要用于监控对象是否已经被垃圾回收器标记为即将回收的垃圾，可以通过弱引用的isEnQueued方法返回对象是否被垃圾回收器标记。

3.只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程，因此不一定会很快发现那些只具有弱引用的对象。

4.源代码

public class WeakReference<T> extends Reference<T> {

    /**
     * Creates a new weak reference that refers to the given object.  The new
     * reference is not registered with any queue.
     *
     * @param referent object the new weak reference will refer to
     */
    public WeakReference(T referent) {
        super(referent);
    }

    /**
     * Creates a new weak reference that refers to the given object and is
     * registered with the given queue.
     *
     * @param referent object the new weak reference will refer to
     * @param q the queue with which the reference is to be registered,
     *          or <tt>null</tt> if registration is not required
     */
    public WeakReference(T referent, ReferenceQueue<? super T> q) {
        super(referent, q);
    }

}

4.虚引用：

Object object = new Object();
PhantomReference<Object> pfObject = new PhantomReference<Object>(object);

pfObject.get() //永远返回为null

pf.isEnQueued();//返回是否从内存中已经删除
1.虚引用是每次垃圾回收的时候都会被回收，通过虚引用的get方法永远获取到的数据为null，因此也被成为幽灵引用。
2.垃圾回收器扫描时即回收内存的使用。

3.虚引用主要用于检测对象是否已经从内存中删除。

4.源代码

public class PhantomReference<T> extends Reference<T> {

    /**
     * Returns this reference object's referent.  Because the referent of a
     * phantom reference is always inaccessible, this method always returns
     * <code>null</code>.
     *
     * @return  <code>null</code>
     */
    public T get() {
        return null;
    }

    /**
     * Creates a new phantom reference that refers to the given object and
     * is registered with the given queue.
     *
     * <p> It is possible to create a phantom reference with a <tt>null</tt>
     * queue, but such a reference is completely useless: Its <tt>get</tt>
     * method will always return null and, since it does not have a queue, it
     * will never be enqueued.
     *
     * @param referent the object the new phantom reference will refer to
     * @param q the queue with which the reference is to be registered,
     *          or <tt>null</tt> if registration is not required
     */
    public PhantomReference(T referent, ReferenceQueue<? super T> q) {
        super(referent, q);
    }

}