Java 内部类使用详解

最新推荐文章于 2023-03-07 19:20:48 发布
最新推荐文章于 2023-03-07 19:20:48 发布
阅读量103 收藏
点赞数
文章标签： java 移动开发
原文链接：https://juejin.im/post/5a69a2ad6fb9a01c9658559c
版权

这个系列是帮助复习 Java 的基础知识的，但是并不会按照一个特定的顺序。现在开始复习下内部类的相关知识。

0. 简介

内部类的定义很简单，它其实就是在一个类里面定义了另一个类，但是这个定义还是有很多细节需要掌握的。

1. 非静态内部类

1.1 定义

非静态内部类就是在一个类的内部里面定义了一个没有用 static 修饰的类。

1.2 访问控制符

内部类的访问控制符访问范围
private同一个类
default同一个类，同一包中
protected同一个类，子类，同一包中
public任何位置

1.3 非静态内部类访问外部类元素

非静态内部类是可以访问外部类的任何实例变量和方法，包括 private 修饰的成员变量。现在用一个例子来说明一下，代码如下：

public class Outer {

	private int a = 10;
	
	private void innerCall() {
		
		System.out.println("Inner Call");
		
	}

	private class Inner {

		public void printInfo() {
			System.out.println("a = " + a);
			innerCall();
		}

	}

	public void test() {

		Inner inner = new Inner();
		inner.printInfo();

	}

	public static void main(String[] args) {

		Outer outer = new Outer();
		outer.test();
		
	}

}
复制代码

输出结果：

a = 10
Inner Call
复制代码

从输出的结果就可以看到，非静态内部类是可以访问到外部类的任何实例变量和方法的。 那为什么内部类可以直接访问外部类的实例变量和方法呢？因为内部类里面是持有外部类的实例引用，一个非静态内部类创建时必然会有其外部类实例的引用。也就是说上面的 printInfo() 方法也可以写成如下：

public void printInfo() {
    System.out.println("a = " + Outer.this.a);
    Outer.this.innerCall();
}
复制代码

上述代码中的 Outer.this 就是非静态内部类持有外部类的实例引用。

1.3.1 非静态内部类方法访问某个变量的检查顺序

当非静态内部类的方法访问某个变量是按一定顺序来查找的，顺序如下

  1. 在该方法的局部变量找
  2. 方法所在的内部类找
  3. 内部类所在的外部类找
  4. 如果都没有则编译报错

举个例子，代码如下：


public class Outer {

	private int a = 10;

	private class Inner {

		private int a = 9;

		public void printInfo(int a) {
			System.out.println("a = " + a);
		}

	}

	public void test() {

		Inner inner = new Inner();
		inner.printInfo(8);

	}

	public static void main(String[] args) {

		Outer outer = new Outer();
		outer.test();

	}

}

复制代码

以上代码的输出结果就是 a = 8。 如果把 printInfo(int a) 的形参 a 去掉，则输出的结果为 a = 9。 再把 Inner 类中的成员变量 a 去掉，则输出的结果为 a = 10。 各位可以自己尝试一下，这里就不再讲解。

1.4 外部类访问非静态内部类的元素

外部类不能直接访问非静态内部类的实例变量和方法，如果想要访问的话，必须要创建非静态内部类的实例进而调用该实例的成员。如下代码所示：



public class Outer {

	private int a = 10;

	private class Inner {

		public void printInfo() {
			System.out.println("a = " + a);
		}

	}

	public void test() {

		//这句会编译错误
		printInfo();

	}

	public static void main(String[] args) {

		Outer outer = new Outer();
		outer.test();

	}

}


复制代码

以上代码会编译错误，如果想要访问的话只能创建 Inner 的实例访问该方法，这里有两种方式，一种就是在 test() 方法里面创建 Inner 对象，另一种就是在 main 方法创建，以下两种方法都用代码试一下：

public class Outer {

	private int a = 10;

	private class Inner {

		public void printInfo() {
			System.out.println("a = " + a);
		}

	}

	public void test() {

		new Inner().printInfo(); 

	}

	public static void main(String[] args) {

		Outer outer = new Outer();
		outer.new Inner().printInfo();
		outer.test();

	}

}

复制代码

从以上代码可以看到，test() 方法里面直接 new Inner() 即可调用 Inner 方法。不过在 main 方法里要先创建 Outer 对象才可以再调用 new Inner()。

1.4.1 外部类的静态方法不可以创建非静态内部类

根据 Java 的规则，静态成员是不可以访问非静态成员的。非静态内部类其实就是类实例中的一个成员，所以在外部类的静态方法不可以创建非静态内部类，现用代码举例：


public class Outer {

	private int a = 10;

	private class Inner {

		public void printInfo() {
			System.out.println("a = " + a);
		}

	}

	public static void main(String[] args) {

		//这句代码会编译报错
		Inner inner = new Inner();

	}

}

复制代码

1.4.2 非静态内部类不可以创建静态成员

同样的，非静态内部类不可以创建静态代码块，静态方法和静态成员变量。代码举例如下：

public class Outer {

	private int a = 10;

	private class Inner {
		
		
		//以下三个静态声明都会编译报错
		static {
			
		}
		public static int a = 0;
		public static void printInfo() {
			System.out.println("a = " + a);
		}

	}

	public static void main(String[] args) {


	}

}
复制代码

1.5 非静态内部类子类的规则

非静态内部类的子类必须要存在外部类的实例引用。代码举例如下：

public class SubInner extends Outer.Inner {

	public SubInner(Outer outer) {
		outer.super();
	}	
	
}
复制代码

这里解释一下为什么非静态内部类的子类需要外部类的实例引用，因为由以上就可以知道非静态内部类一定会有外部类的实例引用，所以该子类也应该要有外部类的实例引用，只是这个外部类的引用是创建该子类的时候传入的。

2. 静态内部类

2.1 定义

静态内部类就是在一个类的内部里面定义了一个使用用 static 修饰的类。

2.2 静态内部类访问外部类

静态内部类不可以访问外部类的非静态成员，但是可以访问外部类的静态成员。代码如下：

public class Outer {

	private int a = 10;
	private static int b = 10;

	private static class Inner {
		
		public void printInfo() {
			
			//这句会编译错误
			System.out.println("a = " + a);
			
			System.out.println("b = " + b);
		}

	}

	public static void main(String[] args) {


	}

}
复制代码

可以看到当静态内部类 Inner 访问外部类的非静态成员变量 a 时，代码会编译错误，但访问外部类的静态成员变量 b 时，则不会报错。

2.3 外部类访问静态内部类

外部类可以使用静态内部类的类名调用静态内部类的类成员，也可以使用静态内部类的实例调用内部类的的实例成员。代码举例如下：


public class Outer {

	private int a = 10;
	private static int b = 10;

	private static class Inner {
		
		
		public static void staticPrintInfo() {
			
			System.out.println("静态方法");
		
		}
		
		public void printInfo() {
			
			System.out.println("实例方法");
		}

	}
	
	private static void test() {
		
		Inner.staticPrintInfo();
		new Inner().printInfo();
		
	}

	public static void main(String[] args) {

		Outer outer = new Outer();
		outer.test();
		

	}

}

复制代码

要注意的是，Inner 实例不可以调用 staticPrintInfo() 方法。

其实这里的难点就是要理解内部类与外部类成员之间的访问，现在把这些关系总结为一张思维导图来帮助理解。

上图的非就是非静态的意思。

3. 局部内部类

3.1 定义

局部内部类就是把一个类放在方法内定义。 因为局部内部类的上一级程序单元是方法，所以不能使用 static 修饰。 并且不能使用任何访问控制符修饰，因为它的作用域只能在方法内。 这里就不再细说这个概念，因为在实际开发中很少使用。

4. 匿名内部类

4.1 定义

匿名内部类就是一种没有名字的内部类，它只会使用一次。 匿名内部类必须必须是继承一个父类或者实现一个接口，但最多只能继承一个父类或实现一个接口。

4.2 实现接口的匿名内部类

代码如下：

interface Person {
	
	void eat();
	
}

public class AnonymousInnerClass {
	
	public void test(Person p) {
		p.eat();
	}

	public static void main(String[] args) {
		
		AnonymousInnerClass a = new AnonymousInnerClass();
		
		a.test(new Person() {
			
			@Override
			public void eat() {
				System.out.println("eat someting");
				
			}
		});
		
	}
}
复制代码

可以看到 test() 方法需要一个 Person 的对象，但是可以使用匿名内部类直接实现 Person 接口的方法即可使用。

4.3 继承抽象类的匿名内部类

通过继承抽象类来创建的匿名内部类，可以使用抽象类当中的任何构造器，并且也可以重写抽象父类当中的普通方法。代码如下：

abstract class Person {
	
	private String name = "Zede";

	public Person() {

	}

	public Person(String name) {
		this.name = name;
	}

	public abstract void eat();

	public String getName() {
		return name;
	}
}

public class AnonymousInnerClass {

	public void test(Person p) {
		p.eat();
		System.out.println(p.getName());
	}

	public static void main(String[] args) {

		AnonymousInnerClass a = new AnonymousInnerClass();

		a.test(new Person() {

			@Override
			public void eat() {
				System.out.println("eat someting");

			}
		});

		a.test(new Person("Zede") {

			@Override
			public void eat() {
				System.out.println("eat someting");

			}
			
			
			@Override
			public String getName() {
				return "xiaoming";
			}
			
		});

	}

}

复制代码

输入结果为：

eat someting
Zede
eat someting
xiaoming
复制代码

可以看到的是，继承抽象类的匿名内部类可以使用任何该抽象类的任何方法并且可以重写该抽象类的普通方法。

4.4 继承普通类的匿名内部类

class Person {
	
}

public class AnonymousInnerClass {

	public static void main(String[] args) {

		new Person() {
			public void eat() {
				System.out.println("eat someting");
			}
		}.eat();

	}

}
复制代码

上述代码可以看到，在 main() 方法中直接创建一个 Person 类型 的匿名内部类，这个匿名内部类其实就是继承了一个 Person 类，然后在这个内部类当中创建 eat() 方法。运行结果如下：

eat someting
复制代码

4.5 匿名内部类访问局部变量

当匿名内部类访问局部变量的时候，这个局部变量必须使用 final 修饰。 但是在 Java 8 开始会自动帮这个局部变量使用 final 修饰。举例代码如下：

abstract class Person {

	public abstract void getAge();
}

public class AnonymousInnerClass {

	public void test(Person p) {
		p.getAge();
	}

	public static void main(String[] args) {

		int age = 18;
		
		//这段代码会编译报错
		age = 20;

		AnonymousInnerClass a = new AnonymousInnerClass();

		a.test(new Person() {

			@Override
			public void getAge() {

				System.out.println("age: " + age);

			}
		});

	}

}
复制代码

可以看到上面那段代码因为 age 已经被匿名内部类使用了，所以会被自动使用 final 修饰，如果改变了 age 的值就会编译报错。

为什么匿名内部类访问的局部变量要用 final 修饰呢？在解答这个问题之前，首先看一下上面的代码编译出来的 class 文件：

AnonymousInnerClass.class：

public class AnonymousInnerClass
{
  public void test(Person p)
  {
    p.getAge();
  }
  
  public static void main(String[] args)
  {
    int age = 18;
    
    AnonymousInnerClass a = new AnonymousInnerClass();
    
    a.test(new Person()
    {
      public void getAge()
      {
        System.out.println("age: " + this.val$age);
      }
    });
  }
}
复制代码

AnonymousInnerClass$1.class：

class AnonymousInnerClass$1
  extends Person
{
  AnonymousInnerClass$1(int paramInt) {}
  
  public void getAge()
  {
    System.out.println("age: " + this.val$age);
  }
}
复制代码

可以看到 AnonymousInnerClass$1 的生命周期是对象级别的，而变量 age 的生命周期是方法级别的，也就是说局部变量 age 在方法结束后就会被销毁，而 AnonymousInnerClass$1 还可能继续存在。这时候 AnonymousInnerClass$1 访问的 age 变量可能已经被销毁了。所以在匿名内部类中会将引用的局部变量复制一个副本到自己的内部当中，所以匿名内部类访问的其实就是这个局部变量的副本。而且为了副本和原始变量一致所以要用 final 修饰这个局部变量。

5. 内部类一些问题

这节会介绍一些注意事项。

5.1 如果内部类不需要访问外部类的实例，最好把这个内部类变成静态内部类

如果一个内部类不需要访问外部类的任何实例，这个内部类最好是静态内部类。为什么呢？因为非静态内部类会持有外部类的对象引用，所以每次创建非静态内部类的时候，就会与外部类实例进行关联，这种操作是需要耗费时间的。 Android 的一些 Adapter 就会使用 ViewHolder 的内部类。ViewHolder 中并没有引用到外部类的任何实例，所以 ViewHolder 类最好使用 static 修饰。

weixin_34061482
关注
Java内部类详解
08-25
Java内部类详解 Java内部类是Java语言中的一种编程机制，它允许将一个类定义在另一个类的内部。内部类可以访问外部类的成员变量和成员方法，包括private的成员变量和成员方法。内部类也可以被外部类访问，但需要...
JAVA 内部类详解及实例
09-01
Java 内部类详解及实例 Java 内部类是一种特殊类型的类，它定义在一个类的内部。这种设计模式在 Java 中提供了许多便利，比如封装、抽象和代码复用。以下将详细介绍内部类的种类、特性以及如何使用它们。 1. 成员...
java 内部类使用（内部匿名类）
12-12
java 成员内部类使用 内部匿名类 方法参数匿名类 方法匿名类
Java内部类、静态内部类、私有内部类、匿名内部类
微风吹过李子树的博客
11-29 674
内部类: 类中定义类 当一个类中的成员也是另外一个事物的时候,这个事物就可以使用内部类定义 分类: 成员内部类 静态内部类 局部内部类 私有内部类 匿名内部类 ** 成员内部类: 内部类处于外部类的成员位置 是外部的成员,就可以使用成员修饰符 是个类,有类的特性,继承,实现接口… 注意: 内部类中可以使用外部类中所有的内容,包括私有的 除了静态内部类以外的内部类中不可以定义静态的内容,除...
java内部类的使用
mr_mari的博客
01-06 875
Java内部类的使用
java中内部类的使用
qq_45760909的博客
06-10 209
package 内部类; /* 什么是内部类，在一个类中又定义了一个类 ： 内部类的规则： 1，内部类可以直接方法外部类的成员，包括私有。 2，外部类要访问内部类，必须建立内部类对象 在内部类中 内部类可以被私有 什么时候用： 当描述事物时，事物的内部还有事物，该事物用内部类来描述。 因为内部事物在 使用外部事物的内容 */ class A{ private int num = 4; cla
Java中内部类的使用
zjojk的博客
08-29 2479
内部类 一般情况下，类和类之间是相互独立的，内部类的意思是打破这种独立，让一个类成为另外一个类的内部成员，和成员变量、成员方法同等级别。采用内部类可以隐藏细节和内部结构，封装性更好，让程序结构更加合理。基本的内部类还可以在一个方法体内定义。 非静态内部类 package com.dgut.test.demo7; public class OutClass { private String outName; public void display(){ System.ou
java 内部类（匿名类，匿名对象，静态内部类）详解及实例
08-31
Java内部类是Java语言中一个独特且强大的特性，它允许在一个类的定义内定义另一个类。内部类可以访问外部类的所有成员，包括私有成员，这使得内部类成为实现复杂设计和封装的有力工具。本篇文章将深入探讨内部类的三...
java 内部类的详解及实例
08-29
Java内部类是Java语言的一个重要特性，它允许在一个类的内部定义另一个类。这种设计模式为Java提供了强大的面向对象编程能力。本文将深入探讨内部类的概念、类型以及如何使用它们。 1. **内部类的分类**： - 静态...
java中匿名内部类详解
08-30
Java中的匿名内部类是一种特殊的类，它没有名称且通常用于一次性使用的情况，目的是简化代码编写。下面我们将深入探讨匿名内部类的各个方面。 1. **匿名内部类定义**： 匿名内部类，正如其名，是没有名字的类。它...
java内部类使用_java内部类的使用
weixin_30567751的博客
02-12 236
话不多说直接走起1.怎么直接在外部 创建 内部类呢？public classDemo {public static voidmain(String[] args) {Outer.Innerin=new Outer().newInner();in.show();}}classOuter{int a=3;public classInner{voidshow() {System.out.println(...
java各内部类的使用
m0_73668562的博客
02-10 211
java内部类使用
Java 内部类的用法
Rockandrollman的博客
03-01 132
内部类一般用于写监听器，如下，对登录按钮做一个监听。
【Java笔记】内部类的使用
lijibai_的博客
03-27 646
当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，那么整个内部的完整结构最好使用内部类。 在 Java 中，允许一个类的定义位于另一个类的内部，前者称为内部类，后者称为外部类。 目录 内部类的分类 成员内部类 一方面，作为外部类的成员 另一方面，作为一个类 内部类使用注意事项 内部类代码举例 内部类的分类 成员内部类：静态与非静态 成员内部类 一方面，作为外部类的成员 1. 可以调用外部类的结构 2. 可以被 static
Java---内部类的定义与用法
X_H学Java的博客
09-16 1184
目录 一. 内部类概述 二. 成员内部类 2.1 普通内部类 2.2 静态内部类 三. 局部内部类 四.匿名类 五.对象的打印 一. 内部类概述 内部类是定义在另一个类中的类，内部类也是封装的一种的体现。为什么要使用内部类，主要有两个原因： · 内部类可以对同一个包的其他类进行隐藏。 · 内部类方法可以访问定义这个类的作用域中的数据，包括原本私有的数据。 格式： public class OutClass { class InnerClass { ...
Java之内部类
最新发布
qq_64580912的博客
03-07 3418
类比于成员方法,在成员方法中是不可以定义static的属性的,因为方法的调用需要对象来调用,而static的变量是不需要对象调用的,这显然是矛盾的静态内部类可以看做相当于一个普通的类,只不过嵌套在了外部类的里面了而已System.out.println("静态内部类的静态方法method");//通过外部类的对象访问其私有属性和方法//外部类通过对象访问静态内部类中的私有属性和方法System.out.println("外部类的fun方法");3.产生静态内部类的对象。
java 内部类怎么使用_Java-内部类简单使用
weixin_39687422的博客
02-25 290
一、实例内部类(成员内部类)1.成员内部类可以等同看做成员变量2.成员内部类不能有静态声明3.成员内部类可以访问外部类所有的数据public classOuterClass {//静态变量private static String s1 = "Array";//成员变量private String s2 = "keke";//静态方法private static voidm1(){System.o...
Java内部类的使用总结
yygr的博客
01-24 397
https://blog.csdn.net/qq_35995514/article/details/90731394 1 学习内容 为什么使用内部类，内部类在java 源码中的设计； 成员内部类； 静态内部类； 局部内部类； 匿名内部类； 总结 2 具体内容 2.1 为什么使用内部类 为什么要使用内部类？在《Think in java》中有这样一句话：使用内部类最吸引人的原因是：每个内部类都能独立地继承一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响。 在我们程
java内部类使用_java内部类自我总结
weixin_36228334的博客
02-25 53
内部类即是在一个类中定义的一个类。外边的类成为外部类，里面的类成为内部类。外部类前面的修饰符必须是public，内部类的修饰符可以private， public， protected，编译会产生两个类，外部类名.class, 外部类名$内部类名.class一 java内部类的分类和特点java内部类分成四种： 成员内部类， 静态内部类，局部内部类，匿名内部类。成员内部类与外部类的关系，作为外部类...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值