Java引用和内部类

引用

引用变量

引用相当于一个 “别名”, 也可以理解成一个指针.

创建一个引用只是相当于创建了一个很小的变量, 这个变量保存了一个整数, 这个整数表示内存中的一个地址.

new 出来的数组肯定是在堆上开辟的空间,那么在栈中存放的就是引用,引用存放的的就是一个对象的地址,代表指向关系.

int[]array2=array1;

就是在栈中再开辟一个空间作为引用,这两个引用存放的都是那个数组的地址.

总结: 所谓的 “引用” 本质上只是存了一个地址. Java 将数组设定成引用类型, 这样的话后续进行数组参数传参, 其实只是将数组的地址传入到函数形参中. 这样可以避免对整个数组的拷贝(数组可能比较长, 那么拷贝开销就会很大).

java中引用必须初始化

如果确实不知道是哪块空间的引用,可以初始化为null

JVM内存空间分布

虚拟机栈(JVM Stack): 重点是存储局部变量表(当然也有其他信息). 我们刚才创建的 int[] arr 这样的存储地址的引用就是在这里保存.
本地方法栈(Native Method Stack): 本地方法栈与虚拟机栈的作用类似. 只不过保存的内容是Native方法的局部变量. 在有些版本的 JVM 实现中(例如HotSpot), 本地方法栈和虚拟机栈是一起的.
堆(Heap): JVM所管理的最大内存区域. 使用 new 创建的对象都是在堆上保存 (例如前面的 new int[]{1, 2,3} )
方法区(Method Area): 用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据. 方法编译出的的字节码就是保存在这个区域.
运行时常量池(Runtime Constant Pool): 是方法区的一部分, 存放字面量(字符串常量)与符号引用. (注意从 JDK1.7 开始, 运行时常量池在堆上)
程序计数器 (PC Register): 只是一个很小的空间, 保存下一条执行的指令的地址.

public class myArray {public static void main(String[] args) {int[] arr1={1,2,3,4,5};int []arr2=new int[]{5,4,3,2,1};int[]p1=arr1;int[]p2=arr2;p1[0]=100;p2[0]=100;System.out.println(arr1[0]);//100System.out.println(arr2[0]);//100}public static int[] tranform(int[]arr){//传的是引用,会将堆中数据改变int[] ret=new int[arr.length];//要想不被改变,再开一个空间计算返回for(int i=0;i<arr.length;i++){ret[i]=arr[i]*2;}return ret;}
}

多个引用指向同一个对象

引用传参

import java.util.Arrays;
public class myArray {public static void func1(int[]arr){//生成arr形参,引用中和arr1中指向同一个对象arr=new int[]{15,16,17,18};//arr更改指向对象}public static void func2(int[]arr){arr[0]=100;}public static void main(String[] args) {int[]arr1=new int[]{1,2,3,4};
//        func1(arr1);func2(arr1);System.out.println(Arrays.toString(arr1));//func1之后: 1 2 3 4//func2后: 100 2 3 4}
}

内部类

静态内部类

无法直接访问外部类的非静态方法.
可以创建外部类的对象,使用引用访问.

外部类可以访问静态内部类中的所有的成员,即使在静态内部类中是private修饰的.

package demo1;class OuterClass{public int data1=10;private int data2=20;public static int data3=30;public void test1(){System.out.println(data1);System.out.println(data2);System.out.println(data3);InnerClass innerClass =new InnerClass();System.out.println(innerClass.data4);System.out.println(innerClass.data5);System.out.println(InnerClass.data6);//静态的用内部类类名访问,尽量避免使用对象}static class InnerClass{//静态内部类public int data4=40;private int data5=50;public static int data6=60;public void func(){//所有静态的,都是不依赖于对象的,所以无法访问OuterClass需要用引用访问的成员
//            System.out.println(data1);
//            System.out.println(data2);//errorOuterClass outerClass =new OuterClass();System.out.println(outerClass.data1);System.out.println(outerClass.data2);System.out.println(data3);System.out.println(data4);System.out.println(data5);System.out.println(data6);}}
}
public class test1 {public static void main(String[] args) {OuterClass.InnerClass innerClass = new OuterClass.InnerClass();innerClass.func();//10//20//30//40//50//60}
}

实例内部类

在实例内部类中不能定义静态成员.彼此产生矛盾.

实例内部类的实例化对象需要外部类对象调用才能实现.

当内部类中存在和外部类成员变量名字冲突时,this肯定是内部类的.如果想要访问外部类的,需要使用

OuterClass.this.data1

当外部类加载时,这个非静态内部类是不会加载的

class OuterClass2{public int data1=10;private int data2=20;public static int data3=30;public void test1(){System.out.println(data1);System.out.println(data2);System.out.println(data3);InnerClass2 innerClass2 =new InnerClass2();System.out.println(innerClass2.data4);System.out.println(innerClass2.data5);System.out.println(InnerClass2.data6);//使用类名访问}class InnerClass2{//非静态内部类(实例内部类)public int data1 = 1111;public int data4=40;private int data5=50;
//        public static int data6=60;//内部类是依赖于外部类对象的,静态的是不依赖于对象的,产生矛盾public static final int data6=60;//此时data6是常量,是在程序编译时就已经确定的public void func(){System.out.println(data1);//1111 this是内部类的thisSystem.out.println(OuterClass2.this.data1);System.out.println(data2);System.out.println(data3);System.out.println(data4);System.out.println(data5);System.out.println(data6);}}
}
public class test1{public static void main(String[] args) {OuterClass2 outerClass2 = new OuterClass2();//此时的实力内部类可以理解为外部类的一个成员,需要对象调用OuterClass2.InnerClass2 innerClass2 =outerClass2. new InnerClass2();innerClass2.func();outerClass2.test1();}
}

匿名内部类

interface IA{void func();
}
class AA implements IA{@Overridepublic void func() {System.out.println("AA func!");}
}
public class test1{public static void main(String[] args) {new IA(){//有一个类,实现了IA接口,重写了func函数,但是这个类没有名字.不会生成字节码文件@Overridepublic void func() {System.out.println("hello 匿名内部类!");}}.func();//hello 匿名内部类!}public static void main1(String[] args) {//正常实现接口IA ia = new AA();ia.func();//AA func!}
}