「java引用方式」java引用放在哪个区域
今天给各位分享java引用方式的知识，其中也会对java引用放在哪个区域进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！
本文目录一览：
java.base下的文件怎么引用
1、打开要操作的java.base文档，然后单击上面工具栏上的“引用”选项卡。
2、将光标停在需要添加参考标记的位置，找到脚注选项，然后单击“插入脚注”。
3、可以发现相应的序列号会自动添加到该位置。同时，光标跳到页面的末尾，相关引用的文档可以在序号后输入。
4、返回主文档，发现java.base已经完成添加引用文档的标注操作。
5、以上就是java.base下的文件引用方法。
java三个引用类型
四种引用类型
所以在 JDK.1.2 之后，Java 对引用的概念进行了扩充，将引用分为了：强引用（Strong Reference）、软引用（Soft Reference）、弱引用（Weak Reference）、虚引用（Phantom Reference）4 种，这 4 种引用的强度依次减弱。
一，强引用
Java中默认声明的就是强引用，比如：
Object obj = new Object(); //只要obj还指向Object对象，Object对象就不会被回收
obj = null; //手动置null
只要强引用存在，垃圾回收器将永远不会回收被引用的对象，哪怕内存不足时，JVM也会直接抛出OutOfMemoryError，不会去回收。如果想中断强引用与对象之间的联系，可以显示的将强引用赋值为null，这样一来，JVM就可以适时的回收对象了
二，软引用
软引用是用来描述一些非必需但仍有用的对象。在内存足够的时候，软引用对象不会被回收，只有在内存不足时，系统则会回收软引用对象，如果回收了软引用对象之后仍然没有足够的内存，才会抛出内存溢出异常。这种特性常常被用来实现缓存技术，比如网页缓存，图片缓存等。
在 JDK1.2 之后，用java.lang.ref.SoftReference类来表示软引用。
下面以一个例子来进一步说明强引用和软引用的区别：
在运行下面的Java代码之前，需要先配置参数 -Xms2M -Xmx3M，将 JVM 的初始内存设为2M，最大可用内存为 3M。
首先先来测试一下强引用，在限制了 JVM 内存的前提下，下面的代码运行正常
public class TestOOM {
public static void main(String[] args) {
testStrongReference();
}
private static void testStrongReference() {
// 当 new byte为 1M 时，程序运行正常
byte[] buff = new byte[1024 * 1024 * 1];
}
}
但是如果我们将
byte[] buff = new byte[1024 * 1024 * 1];
替换为创建一个大小为 2M 的字节数组
byte[] buff = new byte[1024 * 1024 * 2];
则内存不够使用，程序直接报错，强引用并不会被回收
接着来看一下软引用会有什么不一样，在下面的示例中连续创建了 10 个大小为 1M 的字节数组，并赋值给了软引用，然后循环遍历将这些对象打印出来。
public class TestOOM {
private static ListObject list = new ArrayList();
public static void main(String[] args) {
testSoftReference();
}
private static void testSoftReference() {
for (int i = 0; i 10; i++) {
byte[] buff = new byte[1024 * 1024];
SoftReferencebyte[] sr = new SoftReference(buff);
list.add(sr);
}
System.gc(); //主动通知垃圾回收
for(int i=0; i list.size(); i++){
Object obj = ((SoftReference) list.get(i)).get();
System.out.println(obj);
}
}
}
打印结果：
我们发现无论循环创建多少个软引用对象，打印结果总是只有最后一个对象被保留，其他的obj全都被置空回收了。
这里就说明了在内存不足的情况下，软引用将会被自动回收。
值得注意的一点 , 即使有 byte[] buff 引用指向对象, 且 buff 是一个strong reference, 但是 SoftReference sr 指向的对象仍然被回收了，这是因为Java的编译器发现了在之后的代码中, buff 已经没有被使用了, 所以自动进行了优化。
如果我们将上面示例稍微修改一下：
private static void testSoftReference() {
byte[] buff = null;
for (int i = 0; i 10; i++) {
buff = new byte[1024 * 1024];
SoftReferencebyte[] sr = new SoftReference(buff);
list.add(sr);
}
System.gc(); //主动通知垃圾回收
for(int i=0; i list.size(); i++){
Object obj = ((SoftReference) list.get(i)).get();
System.out.println(obj);
}
System.out.println("buff: " + buff.toString());
}
则 buff 会因为强引用的存在，而无法被垃圾回收，从而抛出OOM的错误。
如果一个对象惟一剩下的引用是软引用，那么该对象是软可及的（softly reachable）。垃圾收集器并不像其收集弱可及的对象一样尽量地收集软可及的对象，相反，它只在真正 “需要” 内存时才收集软可及的对象。
三，弱引用
弱引用的引用强度比软引用要更弱一些，无论内存是否足够，只要 JVM 开始进行垃圾回收，那些被弱引用关联的对象都会被回收。在 JDK1.2 之后，用 java.lang.ref.WeakReference 来表示弱引用。
我们以与软引用同样的方式来测试一下弱引用：
private static void testWeakReference() {
for (int i = 0; i 10; i++) {
byte[] buff = new byte[1024 * 1024];
WeakReferencebyte[] sr = new WeakReference(buff);
list.add(sr);
}
System.gc(); //主动通知垃圾回收
for(int i=0; i list.size(); i++){
Object obj = ((WeakReference) list.get(i)).get();
System.out.println(obj);
}
}
打印结果：
可以发现所有被弱引用关联的对象都被垃圾回收了。
四，虚引用
虚引用是最弱的一种引用关系，如果一个对象仅持有虚引用，那么它就和没有任何引用一样，它随时可能会被回收，在 JDK1.2 之后，用 PhantomReference 类来表示，通过查看这个类的源码，发现它只有一个构造函数和一个 get() 方法，而且它的 get() 方法仅仅是返回一个null，也就是说将永远无法通过虚引用来获取对象，虚引用必须要和 ReferenceQueue 引用队列一起使用。
public class PhantomReferenceT extends ReferenceT {
/**
* Returns this reference object's referent. Because the referent of a
* phantom reference is always inaccessible, this method always returns
* codenull/code.
*
* @return codenull/code
*/
public T get() {
return null;
}
public PhantomReference(T referent, ReferenceQueue? super T q) {
super(referent, q);
}
}
那么传入它的构造方法中的 ReferenceQueue 又是如何使用的呢？
五，引用队列（ReferenceQueue）
引用队列可以与软引用、弱引用以及虚引用一起配合使用，当垃圾回收器准备回收一个对象时，如果发现它还有引用，那么就会在回收对象之前，把这个引用加入到与之关联的引用队列中去。程序可以通过判断引用队列中是否已经加入了引用，来判断被引用的对象是否将要被垃圾回收，这样就可以在对象被回收之前采取一些必要的措施。
java方法参数怎么引用传递boolean
Java中的参数传递：分为值传递和引用传递
但本质上，Java中只有值传递。引用传递，其实可以理解为传的是类似指针的东西。
值传递就是把基本变量的值拷贝一份，传递这个拷贝。引用传递则是传递的引用的地址，也就是该变量在内存空间的地址。
1.值传递
只有基本数据类型采用值传递，特点是传递的是值的拷贝，传递完后两者就没有关系了。也就是说方法内和方法外的值互不相干
基本数据类型：
·整型：int,long,byte,short
浮点型：float,double
字符型：char
布尔型：boolean
注：8种基本数据类型以外的数据类型都为引用类型。
2.引用传递
指的是在方法调用时，传递的参数是按引用进行传递，其实传递的引用的地址，也就是变量所对应的内存空间的地址。
传递的是一个拷贝，即副本。也就是说，对于一个参数传递，存在两个地址指向同一个内存空间。这里我们可以用内存分配示意图来体现
3.String类型传递
先说结论，String类型传递与基本数据类型的传递效果相似。
说明：
String类对象一旦创建，其内容不可更改:
String类的所有方法都不会改变String类对象内容，要改变String类对象的值就必须创建一个新的String对象。
也就是说，当进行参数传递时，如果方法内对String类对象的值进行了修改，那么实际上是创建了一个新的String类对象，然后让原来的变量指向它而已。但是这个“原来的变量”是一份拷贝副本，只是一开始创建的时候与主方法中的传递的值相同而已，现在改变之后，两者就毫无关系了。
java中的引用数据类型是怎样的？
java中有两种数据类型：基本类型和引用类型。\x0d\x0a基本类型有8个：\x0d\x0a 整数类型 byte、short、int、long\x0d\x0a 浮点数类型 float、double\x0d\x0a 字符型 char\x0d\x0a 布尔类型 boolean\x0d\x0a引用类型包括三种：\x0d\x0a 类 Class\x0d\x0a 接口 Interface\x0d\x0a 数组 Array\x0d\x0a基本类型是通过诸如 int a = 5; long b = 6L;的形式来定义的，称为自动变量，自动变量存放的是字面值，不是类的实例，它存放在内存的堆栈中，数据大小和生存期必须是确定的，存取速度比较快，在堆栈中的字面值可以共享，也就是说我们定义一个int a = 5;然后又定义了一个int b = 5;这时a与b在内存中指向的是同一个字面常量。\x0d\x0a引用类型一般是通过new关键字来创建，比如Integer num = new Integer(3);它存放在内存的堆中，可以在运行时动态的分配内存大小，生存期也不必事先告诉编译器，当引用类型变量不被使用时，Java内部的垃圾回收器GC会自动回收走。引用变量中存放的不是变量的内容，而是存放变量内容的地址。\x0d\x0a在参数传递时，基本类型都是传值，也就是传递的都是原变量的值得拷贝，改变这个值不会改变原变量，而引用类型传递的是地址，也就是参数与原变量指向的是同一个地址，所以如果改变参数的值，原变量的值也会改变。这点要注意。\x0d\x0a在java中，8种基本类型在java中都有对应的封装类型，也就是引用类型：\x0d\x0a 整数类型 Byte、Short、Integer、Long\x0d\x0a 浮点数类型 Float、Double\x0d\x0a 字符型 Character\x0d\x0a 布尔类型 Boolean\x0d\x0a有时候我们会看到这样的语句 Integer num = 3;Boolean b = true;这样定义也能行得通，其实这里面有一个自动装箱的问题，即java自动把3这个字面常量封装成了Integer对象，同理也有自动拆箱。\x0d\x0a还有些需要注意的比较特殊的地方：\x0d\x0a1.Integer类型\x0d\x0aInteger i1 = 3;\x0d\x0aInteger i2 = 3;\x0d\x0a此时i1 == i2 返回的是true\x0d\x0aInteger i1 = 128;\x0d\x0aInteger i2 = 128;\x0d\x0a此时i1 == i2返回的是false，\x0d\x0a这时因为Integer的数值在-128～127之间时，即在int的范围内，默认是按照基本类型int来存放的，仍旧存在堆栈中，如果超出了int的范围，就按照对象的方式来存放和比较了。\x0d\x0a \x0d\x0a2、String类型\x0d\x0aString类型我们有时候也会直接这样定义：\x0d\x0aString s = "abc";\x0d\x0a这里的"abc"称为字符串常量，也是存在堆栈中的，s中存放的就是指向这个堆栈地址的引用，如果再定义一个\x0d\x0aString s1 = "abc";\x0d\x0a这时，s与s1存放的是同一个地址的引用，即s与s1指向的是同一个字符串常量，\x0d\x0as == s1的值是true，\x0d\x0a但是如果有\x0d\x0aString s2 = new String("abc");\x0d\x0a这时s == s2则为false，因为使用new之后，每次生成的对象都不是同一个，即使存储的内容相同。\x0d\x0a上面的s == s1，s == s2其实比较的都是地址，并不是里面的内容。如果要比较内容，可以使用equals()方法。\x0d\x0a\x0d\x0a其他的就不多说了，打起来太慢了，可以自己去看一下java编程思想。
java有几种对象引用
1.强引用(StrongReference)
强引用是java中最常见的一种引用方式,当一个程序创建一个对象,并把这个对象赋给一个引用变量,程序通过该引用变量操作实际的对象.当一个对象被一个或一个以上的引用变量所引用时,它处于可达状态,不可能被系统垃圾回收机制回收。
2.软引用(SoftReference)
软引用需要通过SoftReference类来实现，当一个对象只有软引用时，它有可能被垃圾回收机制回收。对于只有软引用的对象而言，当系统内存空间足够时，它不会被系统回收，程序也可使用该对象；当系统内存空间不足时，系统可能会回收它。软引用通常用于对内存比较敏感的程序中。
3.弱引用(WeakReference)
弱引用通过WeakReference类实现，弱引用和软引用很像，但弱引用的引用级别更低。对于只有弱引用的对象而言，当系统垃圾回收机制运行时，不管系统内存是否足够，总会回收该对象所占用的内存。当然，并不是说当一个对象只有弱引用时，它就会立即被回收——正如那些失去引用的对象一样，必须等到系统垃圾回收机制运行时才会被回收。
4.虚引用(PhantomReference)
虚引用通过PhantomReference类实现，虚引用完全类似于没有引用。虚引用对对象本身没有太大影响，对象甚至感觉不到虚引用的存在。如果一个对象只有一个虚引用时，那么它和没有引用的效果大致相同。虚引用主要用于跟踪对象被垃圾回收的状态，虚引用不能单独使用，虚引用必须和引用队列联合使用
java引用方式的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java引用放在哪个区域、java引用方式的信息别忘了在本站进行查找喔。