一、成员内部类
类中的东西都是成员，
1.1、成员内部类定义
定义成员内部类的格式：
class OuterClass {//外部类
class InnerClass{//内部类（内部类实际是外部类的一个属性）
}
}
示例
public class Outer {
private static int radius = 1;
private int count =2;
class Inner {
public void visit() {
System.out.println("visit outer static variable:" + radius);
System.out.println("visit outer variable:" + count);
}
}
public static void main(String[] args) {
Outer outer =new Outer();
Outer.Inner inner = outer.new Inner();
inner.visit();
}
}
//输出
visit outer static variable:1
visit outer variable:2
编译上述代码会产生两个class文件：Outer.class和Outer$Inner.class。
创建内部类对象的格式：
外部类 outer = new 外部类();
外部类.内部类 inner = outer.new 内部类();
1.2、使用 this 关键字获取内部类与外部类的引用
如果在外部类中定义的成员变量与内部类的成员变量名称相同，可以使用 this 关键字。
public class TheSameName {
private int x = 7; // 外部类的x
private class Inner {
private int x = 9;// 内部类的x
public void doit() {
int x = 11; // 局部变量x
this.x++; // 调用内部类的x
TheSameName.this.x++; // 调用外部类的x
}
}
}
二、匿名内部类
匿名内部类就是没有名字的内部类
2.1、继承式的匿名内部类
public class Car {
public void drive(){
System.out.println("Driving a car!");
}
public static void main(String[] args) {
Car car = new Car(){
public void drive() {
System.out.println("Driving another car!");
}
};
car.drive();
}
}
//输出
Driving another car!
- 匿名内部类不能有构造方法。
- 匿名内部类不能定义任何静态成员、静态方法。
- 匿名内部类不能是public,protected,private,static。
- 只能创建匿名内部类的一个实例。
- 一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。
- 因匿名内部类为局部内部类，所以局部内部类的所有限制都对其生效。
2.2、接口式的匿名内部类
interface Vehicle {
public void drive();
}
class Test{
public static void main(String[] args) {
Vehicle v = new Vehicle(){
public void drive(){
System.out.println("Driving a car!");
}
};
v.drive();
}
}
//输出
Driving a car!
2.3、参数式的匿名内部类
class Bar{
void doStuff(Foo f){
f.foo();
}
}
interface Foo{
void foo();
}
class Test{
static void go(){
Bar b = new Bar();
b.doStuff(new Foo(){
public void foo(){
System.out.println("foofy");
}
});
}
}
2.4、抽象式的匿名内部类
abstract class Dog {
String Color;
public abstract void move();
public abstract void call();
}
public class Demo {
public static void main(String args[]) {
Dog maomao = new Dog() {
public void move() {
System.out.println("四腿狂奔");
}
public void call() {
System.out.println("嗷呜~");
}
};
maomao.Color = "灰色";
maomao.move();
maomao.call();
}
}
三、方法内部类
把类放在方法内
class Outer {
public void doSomething(){
final int a =10;
class Inner{
public void seeOuter(){
System.out.println(a);//只能使用该内部类所在方法的final局部变量
}
}
Inner in = new Inner();//方法内部类只能在定义该内部类的方法内实例化
in.seeOuter();
}
public static void main(String[] args) {
Outer out = new Outer();
out.doSomething();
}
}
//输出
10
(1)、方法内部类只能在定义该内部类的方法内实例化，不可以在此方法外对其实例化。
(2)、方法内部类对象不能使用该内部类所在方法的非final局部变量。
四、静态内部类
class Outer {
private static int radius = 1;
static class StaticInner {
public void visit() {
System.out.println("visit outer static variable:" + radius);
}
}
public static void main(String[] args){
Outer.StaticInner inner = new Outer.StaticInner();
inner.visit();
}
}
//输出
visit outer static variable:1
静态内部类可以访问外部类所有的静态变量，而不可访问外部类的非静态变量；
静态内部类的创建方式：
外部类.静态内部类 内部类名 = new 外部类.静态内部类()，
如下： Outer.StaticInner inner = new Outer.StaticInner();
五、为什么需要内部类
内部类（Inner Class）是指在一个类的内部定义的另一个类。在Java中，内部类可以嵌套在其他类中，在外部类的成员变量和方法中，可以直接访问内部类的成员，包括私有成员。以下是使用内部类的几个常见的理由：
-
封装和隐藏：内部类可以将类隐藏在其他类的内部，只对外部类可见。这可以实现更好的封装性和模块化，隐藏内部类的实现细节，仅暴露必要的接口。
-
访问外部类的成员：内部类可以直接访问外部类的成员，包括私有成员。这有助于实现更紧密的类之间的关系，方便数据共享和操作。
-
实现多重继承：内部类可以在不引入多重继承的情况下实现多个接口，提供更灵活的设计选择。一个类可以实现多个接口，并且每个接口都可以有其自己的内部类，从而实现多重功能的组合。
-
回调和事件处理：内部类常常用于实现回调和事件处理机制。例如，一个窗口类可以定义一个内部类来处理按钮的点击事件，内部类可以直接访问外部类的成员和方法，方便事件处理。
-
代码组织和逻辑清晰：内部类可以将相关的类组织在一起，使代码更具可读性和可维护性。当内部类与外部类之间具有紧密的关系时，使用内部类可以提高代码的可读性，并且逻辑更清晰。
需要注意的是，内部类并不是必需的，很多情况下都可以通过其他方式来达到相同的效果。内部类的使用应该根据具体的需求和情况来决定，合理地使用内部类可以带来更灵活、更清晰的代码结构。
