07_内部类

内部类

按定义的位置来分：

1. 静态内部类，类定义在了成员位置 (类中方法外称为成员位置，有static修饰的内部类)

2. 实例内部内，类定义在了成员位置 (类中方法外称为成员位置，无static修饰的内部类)

3. 局部内部类，类定义在方法内

4. 匿名内部类。一般定义在方法中，或者可执行代码中

1. 静态内部类(嵌套类)

静态内部类特点：

• 有static修饰的内部类，属于外部类本身的。

• 总结：静态内部类与其他类的用法完全一样。只是访问的时候需要加上外部类.内部类。

• 拓展:静态内部类可以直接访问外部类的静态成员。

静态内部类对象的创建格式：

外部类.内部类 变量 = new 外部类.内部类构造器;

1.1 接口内部的类

正常情况下，不能在接口内部放置任何代码，但嵌套类可以作为接口的一部分，你放到接口中任何类都自动是public和static的。内部类中可以实现其外围接口。

public interface ClassInInterface{
    void howdy();
    class Test implements ClassInInterface{
        public void howdy(){
            System.out.println("dwx!");
        }
        public static void main(String[] args){
            new Test().howdy();
        }
    }
}

2. 实例内部类

实例内部类特点：

• 无static修饰的内部类，属于外部类对象的。

• 宿主：外部类对象。

内部类的使用格式：

 外部类.内部类。 *// 访问内部类的类型都是用 外部类.内部类*

实例内部类创建对象格式：

外部类.内部类 变量 = new 外部类构造器.new 内部类构造器;

• 拓展1：实例内部类不能定义静态成员。

• 拓展2：实例内部类可以直接访问外部类的私有和静态成员。

注意：内部类访问外部类对象的格式是：外部类名.this

public class Demo05 {
  public static void main(String[] *args*) {
    Body.Heart heart = new Body().new Heart();
    heart.jump();
   }
}

class Body {  *// 身体*
  private int weight = 30;
  *// 在成员位置定义一个类*
  class Heart {
    private int weight = 20;
   		public void jump() {
     	 	int weight = 10;
     	 	System.out.println("心脏在跳动 " + ?);  *// 10*
     		System.out.println("心脏在跳动 " + ?);  *// 20*
      		System.out.println("心脏在跳动 " + ?);  *// 30*
       }
  }
}

3. 局部内部类

局部内部类 ：定义在方法中的类。

可以访问当前代码块内的常量，以及此外围类的所有成员。

定义格式:

class 外部类名 {

  数据类型 变量名;
  修饰符 返回值类型 方法名(*参数列表*) {
   class 内部类 {
     *// 成员变量*
     *// 成员方法*
    }
  }
}

4. 匿名内部类【重点】

匿名内部类 ：是内部类的简化写法。它的本质是一个带具体实现的 父类或者父接口的 匿名的 子类对象。

开发中，最常用到的内部类就是匿名内部类了.

4.1 匿名内部类前提和格式

匿名内部类必须继承一个父类或者实现一个父接口。

匿名内部类格式

new 父类名或者接口名(){
    // 方法重写
    @Override 
    public void method() {
        // 执行语句
    }
};

4.2 使用方式

以接口为例，匿名内部类的使用，代码如下：

创建匿名内部类，并调用：GUI做界面

interface Swim {
    public abstract void swimming();
}

public class Demo07 {
    public static void main(String[] args) {
        // 使用匿名内部类
		new Swim() {
			@Override
			public void swimming() {
				System.out.println("自由泳...");
			}
		}.swimming();

        // 接口 变量 = new 实现类(); // 多态,走子类的重写方法
        Swim s2 = new Swim() {
            @Override
            public void swimming() {
                System.out.println("蛙泳...");
            }
        };
        s2.swimming();
        s2.swimming();
    }
}

输出结果：
自由泳...
蛙泳...
蛙泳...

4.3 匿名内部类的特点

1. 定义一个没有名字的内部类

2. 这个类实现了父类，或者父类接口

3. 匿名内部类会创建这个没有名字的类的对象

4.4 匿名内部类的使用场景

通常在方法的形式参数是接口或者抽象类时，也可以将匿名内部类作为参数传递。代码如下：

interface Swim {
    public abstract void swimming();
}

public class Demo07 {
    public static void main(String[] args) {
        // 普通方式传入对象
        // 创建实现类对象
        Student s = new Student();
        
        goSwimming(s);
        // 匿名内部类使用场景:作为方法参数传递
        Swim s3 = new Swim() {
            @Override
            public void swimming() {
                System.out.println("蝶泳...");
            }
        };
        // 传入匿名内部类
        goSwimming(s3);

        // 完美方案: 一步到位
        goSwimming(new Swim() {
            public void swimming() {
                System.out.println("大学生, 蛙泳...");
            }
        });

        goSwimming(new Swim() {
            public void swimming() {
                System.out.println("小学生, 自由泳...");
            }
        });
    }

    // 定义一个方法,模拟请一些人去游泳
    public static void goSwimming(Swim s) {
        s.swimming();
    }
}