java 内部类

本文主要是介绍java 内部类，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

简称

类都对应于一个独立的Java源文件，但是一个类还可以放在另一个类的内部，称之为内部类，相对而言，包含它的类称为外部类

一般而言，内部类与包含它的外部类有比较密切的关系，而与其他类关系不大，定义在类内部，可以实现对外部完全隐藏，可以有更好的封装性，代码实现上也往往更为简洁

内部类只是Java编译器的概念，对于java虚拟机而言，它是不知道内部类的，每个内部类最后都会被编译为一个独立的类，生成一个独立的字节码文件

静态内部类

示例

public class StaticInner {
    private static int shared=100;
    public static class In{
        public void inMethod(){
            System.out.println("inner"+shared);

        }
    }

    public  void test(){
        In in = new In();
        in.inMethod();
    }
}

静态内部类除了位置上在其他类内部外，与一个独立类差别不大，可以有静态变量、静态方法、成员方法、成员变量、构造方法等。

静态内部类与外部内部类的关系不大。它可以访问外部类的静态方法和变量，但不可以访问实例 变量和方法

public修饰的静态内部类可以被外部使用，不过需要通过"new 外部类.静态内部类"的方式

StaticInner.In in = new StaticInner.In(); in.inMethod()

显示原理

public class StaticInner {
	private static int shared = 100;
	public void test(){
		StaticInner$In si = new StaticInner$In();
		si.inMethod();
	}
	static int access$0(){
		return shared;
	}
}
public class StaticInner$In {
	public void inMethod() {
	System.out.println("inner " + StaticInner.access$0());
	}
}

内部类访问了外部类的一个私有静态变量shared，因为私有静态变量是不能被类外部访问的，java的解决方法是：自动为StaticInner生成一个非私有访问方法access$0，然后返回私有静态变量

例子

Integer类内部有一个私有静态内部类IntegerCache，用于支持整数的自动装箱

LinkedList类内部有一个私有静态内部类Node，表示链表中的节点

Character类内部有个一public静态内部类UnicodeBlock，用于表示一个Unicode block

成员内部类

示例

public class MemberInner {
    private  int  a=100;
    public class In{
        public void inMethod(){
            System.out.println("outer a"+a);
            MemberInner.this.action();
        }
    }
    private void action(){
        System.out.println("action");
    }

    public void test(){
        In in = new In();
        in.inMethod();

    }
}

成员内部类除了可以直接访问外部静态变量和方法，还可以直接访问外部实例变量和方法

成员内部类还可以通过"外部类.this.xxx"的方法引用外部类的实例变量和方法，这中写法一般是在重名的情况下使用，如果没有重名，那么这种写法是多余的。

在外部类中，使用成员内部类和静态内部类都是一样的直接使用new。与静态内部类不同，"成员内部类对象总是与一个外部类对象相连的"，在使用时不能直接通过new MemberInner.In(),而是要创建一个MemberInner对象

MemberInner m=new MemberInner(); m.In.in=m.new In();

与静态内部类不同，成员内部类中不可以定义静态变量和方法(final变量例外，它等同于常量)

成员内部类是与外部实例相连的,不应独立使用，而静态变量和方法作为类型的属性和方法，一般是独立使用的，在成员内部类中的 意义不大，如果成员内部类确实需要静态变量和方法，也可以在外部定义

显示原理

public class MemberInner {
	private int a = 100;
	private void action() {
		System.out.println("action");
	}
	public void test() {
		MemberInner$In inner = new MemberInner$In(this);
		inner.innerMethod();
	}
	static int access$0(MemberInner memberInner) {
		return outer.a;
	}
	static void access$1(MemberInner memberInner) {
		MemberInner.action();
	}
}
public class MemberInner$In {
	final MemberInner memberInner;
	public MemberInner$In(MemberInner memberInner){
		ths.memberInner = memberInner;
	}
	public void innerMethod() {
		System.out.println("outer a " + MemberInner.access$0(outer));
		MemberInner.access$1(outer);
	}
}

MemberInner\(In类有个实例变量memberInner指向外部类的对象，他在构造方法中被初始化，MemberInner在新建MemberInner\)In对象时给它传递了当前对象，由于内部类访问了外部类的私有变量和方法，外部类MemberInner生成了两个非私有静态方法：access&0用于访问变量a，access&1用法访问方法action

如果内部类和外部类关系密切，需要访问外部类的实例变量或方法，则可以考虑定义为成员内部类。外部类的一些方法的返回值可能是某个接口，为了返回这个接口，外部类方法可能使用内部类实现这个接口，这个内部类可以设为private对外隐藏

例子

在LinkedList中，它的listIterator和descendingIterator的返回值都是接口Iterator，可以通过Iterator接口对链表遍历，listIterator和descend-ingIterator内部分别使用了成员内部类ListItr和DescendingIterator，这两个内部类都实现了接口Iterator

方法内部类(局部内部类)

public class MethodInner {
    private int a=100;
    public void test(final int param){
        final  String str="hello";
        class In{
            public void inMethod(){
                System.out.println("methodInner a"+a);
                System.out.println("param"+param);
                System.out.println("local var"+str);
            }
        }

        In in = new In();
        in.inMethod();
    }
}

类In定义在外部类方法test中，方法内部类只能在定义的方法内被使用，如果方法是实例方法，则除了静态变量和方法，方法内部类还可以直接访问外部类的实例变量和方法。如果test方法是静态方法，则方法内部类只能访问外部类中的静态方法和变量。

方法内部类可以直接访问方法的参数和方法中的局部变量，不过必须声明为final。

原理

public class MethodInner {
	private int a = 100;
	public void test(final int param) {
		final String str = "hello";
		In inner = new In(this, param);
		inner.innerMethod();
	}
	static int access$0(MethodInner methodInner){
		return MethodInner.a;
	}
}
public class In {
	MethodInner methodInner;
	int param;
	In(MethodInner methodInner, int param){
		this.methodInner = methodInner;
		this.param = param;
	}
	public void innerMethod() {
		System.out.println("outer a " + MethodInner.access$0(this.methodInner));
		System.out.println("param " + param);
		System.out.println("local var " + "hello");
	}
}

与成员内部类类似，In类也有一个实例变量methodInner来指向外部对象，在构造方法中被初始化，对外部私有实例变量的访问也是通过methodInner添加的方法access$0来进行

方法内部类可以访问方法中的参数和局部变量，这是通过在构造方法中传递参数来实现的，如In构造方法中有参数int param，在新建In对象时，外部类将方法中的参数传递给了内部类。String str没有作为参数传递，因为被定义为了常量，在生成的代码中可以直接使用它的值

这就解释了为什么方法内部类访问外部方法中的参数和局部变量时，必须为final修饰的，方法内部类操作的并不是外部变量，而是它自己的实例变量，只是这些变量的值和外部变量一样，对这些变量赋值并不会改变外部的值，为避免混淆直接定义为final

如果的确需要修改外部变量，可以将外部变量改为只含该变量的数组，修改数组中的值。

public class MethodInner {
	public void test(){
		final String[] str = new String[]{"hello"};
		class In {
			public void innerMethod(){
				str[0] = "hello world";
			}
	}
	In inner = new In();
	inner.innerMethod();
	System.out.println(str[0]);
	}
}

str是一个只含一个元素的数组，方法内部类不能改变str本身，但是可以修改它数组的元素

例子

方法内部类可以用成员内部类替换，至于方法参数，也可以作为参数传递给成员内部类，如果类只在某个方法内被使用，则方法内部类可以更好的封装。

匿名内部类

匿名内部类没有单独的类定义，他在创建对象的同时定义类

new 父类(参数){//匿名内部类实现}或者 new 父接口(){//匿名内部类实现 }

public class AnonymousInner {
    public void test(final int x,final int y){
        Anonymous anonymous=new Anonymous(2,3){
            @Override
            public double distance() {
                return distance(new Anonymous(x,y));
            }
        };
        System.out.println(anonymous.distance());
    }
}

public class Anonymous {
   private int x;
   private int y;
    public double distance(){
        return x+y;
    }

    public double distance(Anonymous anonymous){
        return x+y;
    }

    public Anonymous(int x,int y){
        this.x=x;
        this.y=y;
    }
}

匿名内部类只能被使用一次,用来创建一个对象。它没有名字，没有构造方法。但可以根据参数，调用对应的父类构造方法。

它可以定义实例变量和方法，可以有初始代码块，初始代码块可以起到无参构造方法的作用，但是初始代码块只能由一个。

和方法内部类一样，当方法是实例时，可以调用外部类所有的变量和方法，也可以访问方法中的final参数和局部变量

原理

public class AnonymousInner {
    public void test(final int x, final int y){
        Anonymous p = new AnonymousInner$1(this,2,3,x,y);
        System.out.println(p.distance());
    }
}

public class AnonymousInner$1 extends Anonymous {
    int x2;
    int y2;
    AnonymousInner anonymousInner;
    AnonymousInner$1(AnonymousInner anonymousInner, int x1, int y1, int x2, int y2){
        super(x1,y1);
        this.anonymousInner = anonymousInner;
        this.x2 = x2;
        this.y2 = y2;
    }
    @Override
    public double distance() {
        return distance(new Anonymous(this.x2,y2));
    }
}

与方法内部类类似，外部实例this，方法参数x和y都作为参数传递给了内部类构造方法。此外，new时参数2和3也传递给了构造方法，内部类构造方法又将它们传递给了父类构造器

例子

匿名内部类能做的，方法内部类都能做。如果对象只会创建一次，而且不需要构造方法来接受参数，则可以使用匿名内部类。

在调用方法时，很多方法都需要一个接口参数，如果Arrays.sort方法，它可以接收以一个数组以及一个Comparator接口参数，

Comparator有一个方法compare用于比较两个对象，比如，要对一个字符串数组不区分大小写排序，可以使用Arrays.sort

public void sortIgnoreCase(String[] strs){
	Arrays.sort(strs, new Comparator<String>() {
		@Override
		public int compare(String o1, String o2) {
			return o1.compareToIgnoreCase(o2);
		}
	});
}

这篇关于java 内部类的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！