Java内部类详解(含：成员内部类局部内部类匿名内部类静态内部类)
Posted leaf__yang
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java内部类详解(含：成员内部类局部内部类匿名内部类静态内部类)相关的知识，希望对你有一定的参考价值。
内部类是什么？
字面意思，在类的内部编写的类就叫内部类！即一个类的内部又完整的嵌套了另一个类结构，被嵌套的类称为内部类(inner class),嵌套其他类的类称为外部类(outer class)。
内部类是类的第五大成员→【提示:类的五大成员是哪些?[属性、方法、构造器、代码块、内部类]】
内部类一般来说包括这四种：成员内部类、局部内部类、匿名内部类和静态内部类。
官方给的内部类优点如下：
1.每个内部类都能独立的继承一个接口的实现，所以无论外部类是否已经继承了某个(接口的)实现，对于内部类都没有影响。内部类使得多继承的解决方案变得完整；
2.方便将存在一定逻辑关系的类组织在一起，又可以对外界隐藏；
3.方便编写事件驱动程序；
4.方便编写线程代码。
注意：内部类是学习的难点,同时也是重点,后面看底层源码时，有大量的内部类。
一、成员内部类：（在类的内部方法的外部编写的类就是成员内部类）
成员内部类特点：
1.成员内部类可以无条件访问外部类的所有成员属性和成员方法（包括private成员和静态成员）；
2.同名的属性名/方法名访问外部类时 → 外部类.this.成员名
Outer.this.name
成员内部类是依附外部类而存在的，也就是说，如果要创建成员内部类的对象，前提是必须存在一个外部类的对象。所以在外部类访问内部类的时候必须先实例化外部类对象
Outer outer= new outer();
Inner inner = outer.new Inner();
//或者如下一句代码：
Outer.Inner inner = new Outer().new Inner();注意：
1.成员内部类可以使用四种权限修饰符进行修饰(四种权限修饰符：public（公有的） >protected（受保护的） > (default)（缺省/默认的） > private(私有的))；
2.成员内部类中不能书写静态变量和方法。
详见案例演示：
public class Outer
String name = "外部类的类名";
static String type = "外部类的type属性";
private int item = 1;
public static void show()
System.out.println("掉用外部类中的show方法");
public void print()
System.out.println("调用外部类中的打印方法");
//成员内部类 可以使用权限修饰符进行修饰
public class Inner
//static double weight = 1.8; //成员内部类中不能使用static修饰变量和方法
String name = "内部类的类名";
public void innerShow()
//成员内部类可以直接访问外部类的属性和方法
show();
print();
System.out.println(type);
System.out.println(item);
System.out.println("我是：" + name);
//进行特指访问时 使用类名.this.变量名进行访问
System.out.println("我是：" + Outer.this.name);
public static void main(String[] args)
//成员内部类对象的创建步骤
//1.第一步需要实例化外部类对象
//2.第二步正常实例化内部类对象 但是new关键字要改成 外部类对象名.new
/*Outer outer = new Outer();
Inner inner = outer.new Inner();*/
//或者这样创建
Outer.Inner inner = new Outer().new Inner();
inner.innerShow();
二、局部内部类 (编写在方法的内部的类称之为局部内部类，也可以称为方法内部类)
局部内部类的特点
1.局部内部类是定义在一个方法或者一个作用域里面的类，它和成员内部类的区别在于局部内部类的访问仅限于方法内或者该作用域内；
2.局部内部类不可使用权限修饰符 静态(static)修饰符进行修饰 同局部变量相同；
3.局部内部类可以直接访问方法中的属性；
4.局部内部类 可以直接访问方法外部类中属性和方法；
5.局部内部类 创建对象 要在方法内部 局部内部类的外部声明。
详见案例演示：
public class Partial
String name = "外部类的类名";
String type = "外部类的type属性";
private int item = 1;
public static void show()
System.out.println("掉用外部类中的show方法");
public void print()
System.out.println("调用外部类中的打印方法");
public void demo()
String name = "外部类方法deme()内部的方法名";
String type = "外部类方法deme()内部的type属性";
/*编写在方法的内部的类称之为局部内部类
局部内部类不可使用权限修饰符 静态修饰符进行修饰 同局部变量相同
局部内部类与局部变量使用范围一样 在此方法内部
局部内部类可以直接访问方法中的属性 重名时使用参数传递完成访问*/
class Inner
//局部内部类 可以访问方法外部类中属性和方法
String name = "局部类的类名";
public void showInner(String name)
show();
print();
System.out.println("我是："+ type);
System.out.println("我是："+ Partial.this.type);
System.out.println(item);
System.out.println("我是：" + this.name);
System.out.println("我是：" + name);
System.out.println("我是：" + Partial.this.name);
//局部内部类 创建对象 要在方法内部 局部内部类的外部声明
Inner inner = new Inner();
inner.showInner(name);
public static void main(String[] args)
Partial partial = new Partial();
partial.demo();
三、匿名内部类(注意：匿名内部类只是没有类名，其他的都是具备的)
匿名内部类特点
匿名内部类不能定义任何静态成员、方法和类，只能创建匿名内部类的一个实例。一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。
详见案例演示：
// 实现关系下的匿名内部类：
interface Dao
void show();
public class AnonymousDemo
//编写回调方法 ：callInner
public void callInner()
// 接口关系下的匿名内部类
new Dao()
//实现子类 但是没有名字 所以叫匿名内部类
@Override
public void show()
System.out.println("接口方法...");
.show();
// 测试：
public class Demo
public static void main(String[] args)
AnonymousDemo anonymousDemo = new AnonymousDemo();
anonymousDemo.callInner();
匿名内部类可用于给方法传递实参，演示如下：
interface Dao
void show();
public class AnonymousDemo
//编写回调方法:callInner 参数类型为接口Dao
private static void callInner(Dao d)
d.show();
public static void main(String[] args)
callInner(new Dao() //接口回调
//实现子类 但是没有名字 所以叫匿名内部类
@Override
public void show()
System.out.println("匿名内部类用于给方法传递实参");
);
或许有些难以理解，其实过程并不复杂。
说明：首先有一个接口，然后在使用的类中编写了一个方法（参数类型是接口对象），并使用接口中未实现的方法。
我们调用此方法直接构造一个接口对象传入，此时会自动生成一个此接口的子类（匿名内部类）实现接口中的方法。本质传入的类便是此时的匿名内部类。
四、静态内部类(在类中编写的以static修饰的类称为静态内部类)
静态内部类特点
1.静态内部类也是定义在另一个类里面的类，只不过在类的前面多了一个关键字static;
2.静态内部类是不需要依赖于外部类的，这点和类的静态成员属性有点类似，并且它不能使用外部类的非static成员变量或者方法;
3.静态内部类中即能声明静态成员也可以声明非静态成员。
详见案例演示：
public class Static
static String name = "外部类的类名";
//静态内部类中不能访问外部类非静态成员
String type = "外部类的type属性";
public static class Inner
//四种权限修饰符可以修饰静态内部类
public String name = "静态内部类的类名";
static double weight = 1.8;
String type = "静态内部类的type属性";
public void show()
System.out.println("我是：" + weight);
System.out.println("我是：" + type);
System.out.println("我是：" + name);
//System.out.println("我是：" + Static.type);//静态内部类中不能访问外部类非静态成员
System.out.println("我是：" + Static.name);
public static void main(String[] args)
//静态内部类可以直接实例化 不需要依附于外部类
Inner inner = new Inner();
inner.show();
有问题大家一起提出，我们共同学习、共同成长！！！
欢迎评论区留言***
java-07 内部类匿名内部类局部内部类lambda
本文主要记录内部类、匿名内部类、局部内部类、lambda表达式的用途和lambda表达式的推导及使用
1.直接内部类
直接内部类可以分为两种： 成员内部类和静态内部类
1.1 成员内部类
成员内部类，就如同成员一样存在一个类中，该内部类可以直接访问外部类成员和方法，但是外部类不能使用内部类方法或者属性。
成员内部类访问外部类属性或方法的方式： 外部类名.this.成员名/方法名
成员内部类声明方式： （假设外部类叫Outer 内部类叫Inner） Outer.Inner inner = new Outer().new Inner();
1 public class TestInnerClass { 2 private String name; //外部类属性 3 private int age; 4 5 6 class InnerClass{ //内部类以成员的方式存在外部类中 7 public void test() { 8 TestInnerClass.this.name = "张三"; //内部类修改外部类值 9 } 10 11 public void print() { 12 System.out.println(TestInnerClass.this.name); 13 } 14 } 15 16 public static void main(String[] args) { 17 //声明一个内部类对象 18 TestInnerClass.InnerClass inner = new TestInnerClass().new InnerClass(); 19 inner.test(); 20 inner.print(); //张三 21 } 22 23 }
1.2 静态内部类
顾名思义，静态内部类就是以外部类静态成员的方式存在在一个类中 该内部类不依靠外部类对象（这一点与成员内部类不同！）
同理，静态内部类可以访问外部类的静态成员或方法
声明一个静态内部类的方式： （假设外部类叫Outer 内部类叫Inner） Outer.Inner inner = new Outer().Inner();
1 public class TestInnerClass { 2 private static String name; //外部类属性 3 private int age; 4 5 6 static class InnerClass{ //内部类以成员的方式存在外部类中 7 public void test() { 8 TestInnerClass.name = "张三"; //内部类修改外部类值 9 } 10 11 public void print() { 12 System.out.println(TestInnerClass.name); 13 } 14 } 15 16 public static void main(String[] args) { 17 //声明一个内部类对象 18 TestInnerClass.InnerClass inner = new TestInnerClass.InnerClass(); 19 inner.test(); 20 inner.print(); //张三 21 } 22 23 }
2.匿名内部类
匿名内部类，实际上就是隐式的继承了一个接口或者抽象类，并实现该接口或抽象类的方法。
注意：匿名内部类是不能有构造函数的，这也就决定了每一个匿名内部类是只会用一次的。同时匿名内部类是不能存在任何静态变量或方法的。如果内部类想调用外部变量 则外部变量必须是final的。
语法 new 接口/抽象类 { 类体实现 }.调用方法（）。
interface Test{ public void print(); } public class TestNoName { public static void main(String[] args) { new Test() { @Override public void print() { // TODO Auto-generated method stub System.out.println("我是一个接口的匿名抽象类方法"); } }.print(); } }
3.局部内部类
局部内部类就是方法内部的内部类，基本不使用，这里不介绍，请大家自行了解。
4.lambda表达式
lambda表达式时java8中一个重要的特性，虽然看起来非常高大上，实际上只是java的一个语法糖，最后还是由我们的编译器编译成正常的代码，不过对于程序员来说编写代码会更轻松，代码会更简洁。
基本语法：（params） -> expression 或者 (params) -> {语句；}
// 1. 不需要参数,返回值为 5 () -> 5 // 2. 接收一个参数(数字类型),返回其2倍的值 x -> 2 * x // 3. 接受2个参数(数字),并返回他们的差值 (x, y) -> x – y // 4. 接收2个int型整数,返回他们的和 (int x, int y) -> x + y // 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void) (String s) -> System.out.print(s)
一些例子：
String[] atp = {"Rafael Nadal", "Novak Djokovic",
"Stanislas Wawrinka",
"David Ferrer","Roger Federer",
"Andy Murray","Tomas Berdych",
"Juan Martin Del Potro"};
List<String> players = Arrays.asList(atp);
// 以前的循环方式
for (String player : players) {
System.out.print(player + "; ");
}
// 使用 lambda 表达式以及函数操作(functional operation)
players.forEach((player) -> System.out.print(player + "; "));
// 使用匿名内部类 btn.setOnAction(new EventHandler<ActionEvent>() { @Override public void handle(ActionEvent event) { System.out.println("Hello World!"); } }); // 或者使用 lambda expression btn.setOnAction(event -> System.out.println("Hello World!"));
// 1.1使用匿名内部类 new Thread(new Runnable() { @Override public void run() { System.out.println("Hello world !"); } }).start(); // 1.2使用 lambda expression new Thread(() -> System.out.println("Hello world !")).start(); // 2.1使用匿名内部类 Runnable race1 = new Runnable() { @Override public void run() { System.out.println("Hello world !"); } }; // 2.2使用 lambda expression Runnable race2 = () -> System.out.println("Hello world !"); // 直接调用 run 方法(没开新线程哦!) race1.run(); race2.run();
以上是关于Java内部类详解(含：成员内部类局部内部类匿名内部类静态内部类)的主要内容，如果未能解决你的问题，请参考以下文章
Java学习（十六）成员内部类，静态内部类，匿名内部类，局部内部类
java基础15 内部类(成员内部类局部内部类)和匿名内部类