Java复习(3)-内部类

在Java复习(2)中，发现对内部类的不太理解。特意针对性整理下。

1.什么是内部类（what）

1.1 定义

就是类的内部再定义类，就叫做内部类。

例1内部类定义，代码如下：

/*
* 内部类的访问特定：
* 1.内部类可以之间访问外部类的成员，包括私有。
* 2.外部累要访问内部类的成员，必须创建对象。
*/

//内部类定义
class Outer{
private int num = 10;

class Inner{
public void show(){
System.out.println(num);
}
}

//外部类调用内部类
public void method(){
//show();//这样会报错，不能直接使用
//正确的调用方式：
Inner i = new Inner();
i.show();
}
}

public class InnerClassDemo {
public static void main(String[] args){
Outer a = new Outer();
a.method();
}
}

运行结果：

10

1.2 内部类分类

内部类放在不同的位置，有所不同。

内部类放的位置有2种：

1.成员位置：在成员位置定义的类，被称为成员内部类

2.局部位置：在局部位置定义的类，被称为局部内部类

2.为什么要有内部类（why）

举个例子：人的体内有心脏。这里人是一个类，心脏也是一个类。但是心脏一定再人里面。所以就有了内部类。

3.如何使用内部类（how）

内部类放在不同的位置，会有不同的使用方法。

这里介绍，成员内部类和局部内部类2种方法。

3.1 成员内部类

内部类的访问特点：

1.内部类可以之间访问外部类的成员，包括私有。

2.外部累要访问内部类的成员，必须创建对象。

3.1.1 最简单的成员内部类写法

例2：最简单的成员内部类写法

/*
*  成员内部类
*/

class Outer1{
private int num = 10;

class Inter{
public void show(){
System.out.println(num);
}
}

}

public class InnerClassDemo2 {
public static void main(String[] args){
//访问内部类的格式：外部类名.内部类名 对象名 ＝ 外部类对象.内部类对象；
Outer1.Inter a = new Outer1().new Inter();
a.show();
}
}

运行结果：

10

3.1.2 成员内部类的修饰符

成员内部类的修饰符常见2种：

1.private（因为内部类一般不让直接访问）

2. static（注意静态内部类访问的外部类数据必须用静态）

例3：private修饰内部类

/*
* 创建一个类，要求：我有一个人，人有身体，身体内有心脏。
*/
class Body{
//用private修饰的内部类
private class Heart{
public void operator(){
System.out.println("心脏搭桥");
}
}

}
public class InnerClassDemo3 {
public static void main(String[] args){
Body.Heart bh = new Body().new Heart();
bh.operator();
}

}

运行结果：

Exception in thread "main" java.lang.Error: Unresolved compilation problems:
The type Body.Heart is not visible
The type Body.Heart is not visible
The type Body.Heart is not visible

at com.xxm.javaLange.test.InnerClassDemo3.main(InnerClassDemo3.java:20)

所以说明加了private修饰的内部类，调用方法不同。

正确但调用方法，例子4：

class Body{
//用private修饰的内部类
private class Heart{
public void operator(){
System.out.println("心脏搭桥");
}
}
//用外部类中的方法才能调用
public void method(){
Heart h = new Heart();
h.operator();
}

}
public class InnerClassDemo3 {
public static void main(String[] args){
Body a = new Body();
a.method();
}
}

运行结果：

心脏搭桥

例子5：static修饰内部类

package com.xxm.javaLange.test;

class Outer2{
private int num = 10;
private static int num2 = 100;
//内部类用静态修饰，为了可以用外部访问，所以也不会加上private，而是用public修饰
public static class Inner{
//非静态方法
public void show(){
//System.out.println(num);//直接调用num会报错，因为静态类只能访问静态变量,所以调用num2才正确
System.out.println(num2);
}

//静态方法
public static void show2(){
System.out.println(num2);
}
}
}

public class InnerClassDemo4 {
public static void main(String[] args){
//错误的调用方法
//      Outer2.Inner a = new Outer2().new Inner();//new Outer2()是创建对象，Inner是静态的，不能被类调用
//      a.show();
//      a.show2();

//调用方法
Outer2.Inner b = new Outer2.Inner();
b.show();
b.show2();

//show2的另一种调用方法
Outer2.Inner.show2();
}
}

运行结果：

100
100
100

3.2 局部内部类

局部内部类就是放在类的方法里面的内部类。

3.2.1 局部内部类定义

例6：局部内部类定义

/*
* 局部内部类
*/
class Outer3{
private int num = 10;

public void method(){
//局部内部类
class Inner{
public void show(){
System.out.println(num);

}
}

Inner i = new Inner();
i.show();
}
}
public class InnerClassDemo5 {
public static void main(String[] args){
Outer3 a = new Outer3();
a.method();
}
}

运行结果：

10

3.2.2 局部内部类访问局部变量

例7：局部内部类访问局部变量

class Outer3{
private int num = 10;

public void method(){
final int num2 = 20;
/*
* 局部内部类如何访问局部变量，一定要加final。
* 因为局部变量会随着method方法的调用结束而消失，
* Inner类放在堆内存中，不会因为method的结束而结束，
* 调用num2时候，其实际已经消失，所以加上final，作为常量
*/
//局部内部类
class Inner{
public void show(){
System.out.println(num);
System.out.println(num2);
}
}

Inner i = new Inner();
i.show();
}
}
public class InnerClassDemo5 {
public static void main(String[] args){
Outer3 a = new Outer3();
a.method();
}
}

运行结果：

10
20

3.2.3 匿名内部类

下面举4个例子。

例8：匿名内部类中一个方法时

interface Inter{
public abstract void show();
}

class Outer4{
public void method(){
new Inter(){
//一个方法
public void show(){
System.out.println("show");
}
}.show();
}
}
public class InnerClassDemo6 {
public static void main(String[] args){
Outer4 a = new Outer4();
a.method();
}
}

运行结果：

show

例9：匿名内部类中2个方法时

interface Inter{
public abstract void show();
public abstract void show2();
}

class Outer4{
public void method(){
new Inter(){
//第一个方法
public void show(){
System.out.println("show");
}
//第二个方法
public void show2(){
System.out.println("show2");
}
}.show();//调用第一个方法

//因为匿名对象只能调用一次，所以只能重新调用
new Inter(){
//第一个方法
public void show(){
System.out.println("show");
}
//第二个方法
public void show2(){
System.out.println("show2");
}
}.show2();//调用第二个方法
}
}
public class InnerClassDemo6 {
public static void main(String[] args){
Outer4 a = new Outer4();
a.method();
}
}

运行结果：

show
show2

例10：匿名内部类中有多个方法

例子里是3个方法

interface Inter{
public abstract void show();
public abstract void show2();
public abstract void show3();
}

class Outer4{
public void method(){
Inter i = new Inter(){//多态
public void show(){
System.out.println("show");
}

public void show2(){
System.out.println("show2");
}

public void show3(){
System.out.println("show3");
}
};

i.show();
i.show2();
i.show3();

}
}
public class InnerClassDemo6 {
public static void main(String[] args){
Outer4 a = new Outer4();
a.method();
}
}

运行结果：

show
show2
show3

例10：匿名内部类在开发中多使用

interface Person{
public abstract void study();

}

class PersonDemo{
public void method(Person P){
P.study();
}
}

public class InnerClassDemo7 {
public static void main(String[] args){

//用匿名内部类使用
PersonDemo pd = new PersonDemo();
pd.method(new Person(){
/*
*优点：能随着method方法的结束而被回收内存，
*适合安卓上的开发。
*缺点：每次使用都要new一下，
*若使用多次，就不建议这样用类。
*/
public void study(){
System.out.println("好好学习！");
}
});
}
}

运行结果：

好好学习！