Java内部类

将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类。    

内部类分为：成员内部类、局部内部类、匿名内部类

1.成员内部类：

  在描述事物时，若一个事物内部还包含其他事物，就可以使用内部类这种结构。比如，汽车类 Car 中包含发动机 ，发动机类就是汽车类的内部类。
类 Engine ，这时， Engine 就可以使用内部类来描述，定义在成员位置。

###成员内部类格式

class 外部类 {
    class 内部类{ 
    }
}

成员内部类访问特点

• 内部类可以直接访问外部类的成员，包括私有成员。

• 外部类要访问内部类的成员，必须要建立内部类的对象。

//创建内部类方式：外部类名.内部类名 对象名 = new 外部类型().new 内部类型();

//++例子++
//dingy类
public class Person {
    private  boolean live = true;
    class Heart {
        public void jump() {
            // 直接访问外部类成员
            if (live) {
                System.out.println("心脏在跳动");            
            }else {
                System.out.println("心脏不跳了");            
            }
        }
    }

    public boolean isLive() {
        return live;
    }

    public void setLive(boolean live) {
        this.live = live;
    }

}
//测试类
public class InnerDemo {
    public static void main(String[] args) {       
        // 创建外部类对象 
        Person p  = new Person();
        // 创建内部类对象
        Heart heart = p.new Heart();

        // 调用内部类方法
        heart.jump();
        // 调用外部类方法
        p.setLive(false);
        // 调用内部类方法
        heart.jump();
    }
}

内部类仍然是一个独立的类，在编译之后会内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号。比如，Person$Heart.class

2.局部内部类

将一个类定义在一个方法中，该类就称之为是局部内部类

例子：

public class Test {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.show();
    }
}


public class Outer {
    public void show(){
        // 局部内部类
        class Inner{
            public void method(){
                System.out.println("Inner 局部内部类的method方法执行了....");
            }
        }

        // 在外部类的方法内使用局部内部类
        Inner inner = new Inner();
        inner.method();

    }
}

3.匿名内部类

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

开发中，最常用到的内部类就是匿名内部类了。以接口举例，当你使用一个接口时，似乎得做如下几步操作

         1. 定义子类 
         2. 重写接口中的方法 
         3. 创建子类对象 
         4. 调用重写后的方法

注意：使用内部类前提：匿名内部类必须==继承一个父类==或者==实现一个父接口==。

匿名内部类的写法格式：

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

匿名内部类的使用：

以借口方式为例：

//定义接口
public interface Fly{
    public abstract void fly();
}


//创建匿名内部类，并调用

public class InnerDemo {
    public static void main(String[] args) {
        
        Fly  f = new Fly(){
/*
{}括号内的为类，括号前为类的声明
*/
            public void fly() {
                System.out.println("我飞了~~~");
            }
        };

        //调用 fly方法,执行重写后的方法
        f.fly();
    }
}

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

例子如下：

public class Inner {


    public static void showFly(FlyAble f) {
        f.fly();
    }


    public static void main(String[] args) {                 
        /*
        创建匿名内部类,直接传递给showFly(FlyAble f)
原本的调用方式是直接用showFly（f），直接简化可以写成如下方式在需要调用的方法的参数中使用匿名内部类。如下
        */
        showFly( new Fly(){
            public void fly() {
                System.out.println("我飞了~~~");
            }
        });
    }

    
}