内部类

什么是内部类

将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类。
在描述事物时，若一个事物内部还包含其他事物，就可以使用内部类这种结构。
例如：Body类中包含着Heart类,这个Heart类就可以使用内部类来描述。（来一幅很形象的图吧）

代码举例

class Body{       //外部类

		class Hreat{    //内部类
		}
}

访问特点

• 内部类可以直接访问外部类的成员，包括私有成员。
• 外部类要访问内部类的成员，必须要建立内部类的对象

创建内部类对象格式：

• 外部类名.内部类名 对象名 = new 外部类型().new 内部类型()；

一：成员内部类

代码演示（这里是间接调用）

package innerClass.demo01;

public class Outter {   // 外部类

    public class Inner{   //成员内部类

        public void methodIn(){     // 内部类方法
            System.out.println("内部类方法 ");

            System.out.println("我叫"+name);
        }

    }

    public void methodOut(){      //外部类方法
        System.out.println("外部类方法");

        Inner inner = new Inner();   //new 一个内部类的兑象
        inner.methodIn();           //调用内部类方法
    }

    private String name;
	public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

package innerClass.demo01;

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

        //new 一个外部类的对象
        Outter outter = new Outter();
        //通过外部类对象调用外部类方法实现调用内部类方法
        outter.methodOut();
    }
}

结果

代码演示（这里是直接调用）

package innerClass.demo02;

public class Outter {   // 外部类

    public class Inner{   //成员内部类

        public void methodIn(){     // 内部类方法
            System.out.println("内部类方法 ");

            System.out.println("我叫"+name);
        }

    }

    public void methodOut(){      //外部类方法
        System.out.println("外部类方法");

//        Inner inner = new Inner();   //new 一个内部类的兑象
//        inner.methodIn();           //调用内部类方法
    }

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

package innerClass.demo02;

public class InnerClassTest {
    public static void main(String[] args) {
		// 通过   ----- 外部名称 . 内部类名称 对象名  =  new 外部类名称.（）new 内部类名称（）；
        Outter.Inner object = new Outter().new Inner();
        object.methodIn();
    }
}

结果

内部类变量重名问题

package innerClass.demo03;

public class Outer {

    int num = 10;                                   //num 

    public class Inner{

        int num = 20;                               //num
        public void InnerMethod(){
            int num = 30;                           //num

            System.out.println(num);  //获取内部类方法中的num
            System.out.println(this.num);  //获取内部类中的num
            System.out.println(Outer.this.num); //获取外部类的num
        }
    }
}

package innerClass.demo03;

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

        Outer.Inner obj = new Outer().new Inner();
        obj.InnerMethod();
    }
}

结果

二：局部内部类

一个类定义在方法中，这个类就称为局部内部类。
“局部”：当前所属的方法才能使用它，除了方法就不可以访问。

package innerClass.demo04;

public class Outer {

    public void MethodOuter(){

          class Inner{       // 局部内部类
              int num = 10;
              public void MethodInner(){
                  System.out.println(num);
              }

         }
         Inner inner = new Inner();
          inner.MethodInner();
    }
}

package innerClass.demo04;

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

        Outer outer = new Outer();
        outer.MethodOuter();
    }
}

结果

三：匿名内部类

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

格式解析

new   接口名称  ( )   {**** } ;

1. new 代表创建对象
2. 接口名称就是内部类需要实现的接口名称
3. ｛****｝ 是匿名内部类的主要内容

应用场景

此类指向用一次，用完之后再也不用
匿名内部类就是只能**创建对象时候使用一次，也就是只能new一个对象，**只可用唯一一次
如果想要多次使用，就只能写实现类了。

代码实现

package innerClass.demo05;

public interface noNameInnerClass {

     public abstract void method();

}

package innerClass.demo05;

public class Test {

    public static void main(String[] args) {

        /*
        .等号右边:是匿名内部类，定义并创建该接口的子类对象
         等号左边:是多态赋值,接口类型引用指向子类对象
         */

        noNameInnerClass obj = new noNameInnerClass() {
            @Override
            public void method() {
                System.out.println("匿名内部类方法");

            }
        };                                      //到这里是匿名内部类

        obj.method();

    }

}

结果

（转载标明出处，谢谢）