Java 面向对象 - 内部类 - 《Java》

内部类

内部类

内部类的基本使用

内部类概念
- 在一个类中定义一个类。举例：在一个类A的内部定义一个类B，类B就被称为内部类
内部类定义格式
- 格式&举例：
```java /* 格式： class 外部类名{ 修饰符 class 内部类名{

} } */

class Outer { public class Inner {

}


-  内部类的访问特点 
   - 内部类可以直接访问外部类的成员，包括私有
   - 外部类要访问内部类的成员，必须创建对象
-  示例代码：  
```java
/*
    内部类访问特点：
        内部类可以直接访问外部类的成员，包括私有
        外部类要访问内部类的成员，必须创建对象
 */
public class Outer {
    private int num = 10;
    public class Inner {
        public void show() {
            System.out.println(num);
        }
    }
    public void method() {
        Inner i = new Inner();
        i.show();
    }
}

成员内部类

成员内部类的定义位置
- 在类中方法，跟成员变量是一个位置
外界创建成员内部类格式
- 格式：外部类名.内部类名对象名 = 外部类对象.内部类对象;
- 举例：Outer.Inner oi = new Outer().new Inner();

私有成员内部类

将一个类，设计为内部类的目的，大多数都是不想让外界去访问，所以内部类的定义应该私有化，私有化之后，再提供一个可以让外界调用的方法，方法内部创建内部类对象并调用。

示例代码：

class Outer {
private int num = 10;
private class Inner {
  public void show() {
      System.out.println(num);
  }
}
public void method() {
  Inner i = new Inner();
  i.show();
}
}
public class InnerDemo {
public static void main(String[] args) {
  //Outer.Inner oi = new Outer().new Inner();
  //oi.show();
  Outer o = new Outer();
  o.method();
}
}

静态成员内部类
- 静态成员内部类访问格式：外部类名.内部类名对象名 = new 外部类名.内部类名();
- 静态成员内部类中的静态方法：外部类名.内部类名.方法名();
- 示例代码
```java class Outer { static class Inner { public void show(){
```
    System.out.println("inner..show");
```
}

public static void method(){
```
    System.out.println("inner..method");
```
} } }

public class Test3Innerclass { / 静态成员内部类演示 / public static void main(String[] args) { // 外部类名.内部类名对象名 = new 外部类名.内部类名(); Outer.Inner oi = new Outer.Inner(); oi.show();

    Outer.Inner.method();
}

}


<a name="3c39de98"></a>
### 局部内部类

-  局部内部类定义位置 
   - 局部内部类是在方法中定义的类
-  局部内部类方式方式 
   - 局部内部类，外界是无法直接使用，需要在方法内部创建对象并使用
   - 该类可以直接访问外部类的成员，也可以访问方法内的局部变量
-  示例代码  
```java
class Outer {
    private int num = 10;
    public void method() {
        int num2 = 20;
        class Inner {
            public void show() {
                System.out.println(num);
                System.out.println(num2);
            }
        }
        Inner i = new Inner();
        i.show();
    }
}
public class OuterDemo {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();
    }
}

匿名内部类

匿名内部类的前提
- 存在一个类或者接口，这里的类可以是具体类也可以是抽象类
匿名内部类的格式
- 格式：new 类名 ( ) { 重写方法 } new 接口名 ( ) { 重写方法 }
- 举例：
```
new Inter(){
@Override
public void method(){}
}
```
匿名内部类的本质
- 本质：是一个继承了该类或者实现了该接口的子类匿名对象
匿名内部类的细节
- 匿名内部类可以通过多态的形式接受
```
Inter i = new Inter(){
@Override
public void method(){

}
}
```
匿名内部类直接调用方法
```java interface Inter{ void method(); }

class Test{ public static void main(String[] args){ new Inter(){ @Override public void method(){ System.out.println(“我是匿名内部类”); } }.method(); // 直接调用方法 } }


<a name="635b798b"></a>
### 匿名内部类在开发中的使用

-  匿名内部类在开发中的使用 
   - 当发现某个方法需要，接口或抽象类的子类对象，我们就可以传递一个匿名内部类过去，来简化传统的代码
-  示例代码：  
```java
/*
    游泳接口
 */
interface Swimming {
    void swim();
}

public class TestSwimming {
    public static void main(String[] args) {
        goSwimming(new Swimming() {
            @Override
            public void swim() {
                System.out.println("铁汁, 我们去游泳吧");
            }
        });
    }

    /**
     * 使用接口的方法
     */
    public static void goSwimming(Swimming swimming){
        /*
            Swimming swim = new Swimming() {
                @Override
                public void swim() {
                    System.out.println("铁汁, 我们去游泳吧");
                }
            }
         */
        swimming.swim();
    }
}