java引用类型参数

⑴ java里什么是引用类型

Java的引用类型：

引用类型是一个对象类型，值是什么呢？它的值是指向内存空间的引用，就是地址，所指向的内存中保存着变量所表示的一个值或一组值。

Java 提供两种不同的类型：引用类型和原始类型（或内置类型）。

引用类型和原始类型的行为完全不同，并且它们具有不同的语义。

引用类型和原始类型具有不同的特征和用法，它们包括：大小和速度问题，这种类型以哪种类型的数据结构存储，当引用类型和原始类型用作某个类的实例数据时所指定的缺省值。

对象引用实例变量的缺省值为 null，而原始类型实例变量的缺省值与它们的类型有关。同时为了面向对象操作的一致性。

这些基本类型都有相应的封装类型：Integer、Short、Long、Byte、Float、Double、Character等。

⑵ Java 引用类型参数（见题注释）

要是这样的话，下面的一个system就会输出7654321，你上面system还是你new的这个date;你下面的方法并没有任何返回值；

⑶ 谁知道Java中参数是引用传递还是值传递

java中方法参数传递方式是按值传递。所谓值传递，就是将实际参数值的副本（复制品）传入方法内，而自己本身不会受到任何影响。
如果参数是基本类型，传递的是基本类型的字面量值的拷贝。

⑷ JAVA的基本数据类型和引用数据类型的区别

一、作用的不同

1、引用类型一般都是通过new关键字创建对象，然后把这个对象赋予给相应的变量，最常用的引用类型是String类型，它也比较特殊，可以直接通过关键字new来创建对象，也可以通过字符串直接赋值，比如：

Strings=newString("abc");

Strings="abc";

2、基本类型就是直接赋值就可以了，比如：

inta=123;

floatb=123.0;

boolean=true;

二、参数方面传递的不同

引用类型是引用传递

基本类型是值传递

三、比较方面的不同

引用类型比较的是引用地址(没有重写equals方法)

基本类型比较的是值

五、类型的不同

1、引用类型分为四种

强引用（StrongReference）

软引用（SoftRefernce）

弱引用（WeakReference）

虚引用（PhantomReference）

强引用-StrongReference

2、八种基本类型

整型byte8位

整型short16位

整型int32位

整型long64位

浮点型float32位

浮点型double64位

字符型char16位

布尔型boolean位数不确定

⑸ java引用类型参数

1.
为什么int
temp
=
p.age;不会提示尚未初始化
这句话不会报错，因为p是做为参数类型传入的，编译器并不知道你到底有没有初始化p，他会当作以创建对象处理。
2.
而main方法却提示未初始化
在main方法中你定义了一个person
per;但没有进行初始化，就直接使用per里的属性是不可以的，因为变量没有进行初始化是不能够使用的。

⑹ java中传的是引用类型的参数怎么传

个人理解是这样的
java 传参有两种类型。传值和传址。8种原始类型（int,long,double,boolean,float,short,byte,char）采用传值方式，类的实体采用传址方式。
如果想采用传址方式，但不想改变里面的内容，就调用clone方法后传过去吧。

如有不对，以教科书为准。

⑺ Java引用类型作为方法参数的问题

java当中类变量都是引用。

方法参数当中的类引用，需要你在调用的时候给出真正的对象，所以不会警告你；

但是局部变量当中的变量，如果不用new创建，自然是没有初始化。

⑻ java引用类型参数的传值

基本类型参数都是值传递，引用类型想数组，集合都是引用传递，值传递后你改变参数的值，原来的数不会改变，就相当于重新开辟一块空间，改变的是新空间的值，引用传递，是吧引用传过去了，没有开辟空间，你改变值还是改变原来空间的值,我这回答满意不，纯手写加工~~~~~~~~

⑼ 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 List<Object> 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];
SoftReference<byte[]> 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];
SoftReference<byte[]> 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];
WeakReference<byte[]> 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 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;
}
public PhantomReference(T referent, ReferenceQueue<? super T> q) {
super(referent, q);
}
}
那么传入它的构造方法中的 ReferenceQueue 又是如何使用的呢？

五，引用队列（ReferenceQueue）
引用队列可以与软引用、弱引用以及虚引用一起配合使用，当垃圾回收器准备回收一个对象时，如果发现它还有引用，那么就会在回收对象之前，把这个引用加入到与之关联的引用队列中去。程序可以通过判断引用队列中是否已经加入了引用，来判断被引用的对象是否将要被垃圾回收，这样就可以在对象被回收之前采取一些必要的措施。

⑽ java中的引用数据类型是什么意思

1. 引用数据类型为java两大数据类型之一

2. 引用数据型在被床架时，首先要在栈上给其引用（句柄）分配一块内存，而对象的具体信息都存储在堆内存上，然后由栈上面的引用指向堆中对象的地址。

3. 引用数据类型包括：类、接口类型、数组类型、枚举类型、注解类型，字符串型；

• java另一大数据类型为基本数据类型，其包括包括数值型，字符型和布尔型。

• 基本数据类型在被创建时，在栈上给其划分一块内存，将数值直接存储在栈上；