成员内部类、局部内部类、匿名内部类、静态内部类、内部类的继承、接口

（一）成员内部类
1.成员内部类简介
在一个类中使用内部类，可以在内部类中直接存取其所在类的私有成员变量。
内部类的实例一定要绑定在外部类的实例上，如果从外部类中初始化一个内部类对象，那么内部类对象就会绑定在外部类对象上。

内部类对象的实例化必须在外部类或外部类的非静态方法中实现
因为非静态方法才可以调用静态或非静态的成员方法与变量，而静态的方法只能调用静态的成员变量，与静态的成员方法。

public class OuterClass {

	innerClass in=new innerClass();//在外部类中实例化内部类对象引用
	public void ouf() {//在外部类方法中调用内部类方法
		in.inf();
	}
	class innerClass{ //定义一个内部类
		innerClass(){//内部类构造方法
		}
		public void inf() {
			//内部类成员方法
		}
		int y;//定义内部类成员变量
	}

	public innerClass doit() {
		//y=4; //这行代码会报错，外部类不可以直接访问内部类成员变量，因为相当于它私有的。只能用内部类的对象才能访问，内部类的成员。
		in.y=4;
		return new innerClass();
	}
	public static void main(String[] args) {
		OuterClass out=new OuterClass();
		//内部类的对象实例化必须在外部类或外部的非静态方法中实现。
		OuterClass.innerClass in=out.doit();//在外部类的非静态方法中实现实例化
		OuterClass.innerClass in2=out.new innerClass();//内部类的实例一定要绑定在外部类的实例上，如果从外部类中初始化一个内部类对象，那么内部类对象就会绑定在外部类对象上。
	}
}

内部类对象会依赖外部类对象，除非已经存在一个外部类对象，否则类中不会出现内部类对象。

2.内部类向上转型为接口。
如果将一个权限修饰符是private的内部类向上转型为其父类对象，或者直接向上转型为一个接口，在程序中就可以完全隐藏内部类的具体实现过程。
可以在外部提供一个借口，在接口中声明一个方法，如果在实现该接口的内部类中实现该接口的方法，就可以定义多个内部类以不同的方式实现接口中的同一个方法，而在一般的类中不能多次实现接口中的同一个方法。

非内部类不能被声明为private或protected访问类型
一 对于非静态内部类，不能有静态成员，例如变量，方法等。静态内部类的非静态成员可以访问外部类的静态变量，而不可访问外部类的非静态变量。非静态内部类的非静态成员可以访问外部类的非静态变量。

成员内部类可以随意使用外部类的成员方法及成员变量，尽管这些类成员被修饰为private.内部类的实例一定要绑定在外部类对象上。

一个内部类可以定义在一个类中，一个方法中甚至一个表达式中。

分类：
内部类分为四种：

静态内部类(static inner classes)

成员内部类(member inner classes)

局部内部类(local inner classes)

匿名内部类(anonymous inner classes)

1、静态内部类(static inner classes)
静态内部类的特征：
只能访问外部类的静态成员变量与静态方法。静态内部类的非静态成员方法可以访问外部类的静态变量，而不可访问外部类的非静态变量。

生成静态内部类对象的方法：
OuterClass.InnerClass inner = new OuterClass.InnerClass();

相关使用例子：
静态内部类：

class StaticInner{

    private static int a = 1;//私有的静态的外部类成员变量

 

    /**

　　 * 静态内部类

 　　* 生成的类名：StaticInner$InnerClass

 　　*/

    public static class InnerClass{

        //静态内部类可以声明静态的成员变量，其他的非静态成员内部类不可以

        private static int b = 1;

        public void execute(){

            //静态内部类只能访问静态的外部类成员变量和方法

            System.out.println(a +b);//这里直接访问外部类的静态成员变量a

        }

    }

public static void main(String[] args) {
    //创建静态内部类对象

     StaticInner.InnerClass  innerClass = new  StaticInner.InnerClass();

     innerClass.execute();//用内部类对象调用内部类方法

 }
}

2、成员内部类(member inner classes)
成员内部类的特征：
成员内部类可以访问外部类的静态与非静态的方法和成员变量。

尽管这些类成员被修饰为private.内部类的实例一定要绑定在外部类对象上。

对于非静态内部类，不能有静态成员，例如变量，方法等。

生成成员内部类对象的方法：

OuterClass.InnerClass inner = new OuterClass().new InnerClass();

或者用外部类的实例来来创建对象
例如：

OuterClass  out  =  new OuterClass();
OuterClass.InnerClass  in = out.new InnerClass();

在内部类的方法中访问外部类的成员变量的方法：
OuterClass.this.a;

相关使用例子：

class MemberInner{

    private int a = 1;//定义一个私有的外部类

 

    public void execute(){

        //在外部类中创建成员内部类的实例化对象

        InnerClass innerClass =this.new InnerClass();
        //this 表示当前外部类的实例。用外部类的实例来生成内部类的对象

    }

 

    /**

 * 成员内部类

 */

    public class InnerClass{

 

        //内部类可以创建与外部类同名的成员变量

        private int a = 2;

 

        public void execute(){

            //当前this引用的是内部类

           System.out.println(this.a);

            //在内部类的方法中使用外部类的成员变量的方法

           System.out.println(MemberInner.this.a);

        }

    }

}

public static void main(String[] args) {
    //创建成员内部类对象
     MemberInner.InnerClass innerClass = new MemberInner().new InnerClass();
     innerClass.execute();
}

3、局部内部类(local inner classes)
局部内部类的特征：
类似于局部变量，不能定义为public，protected，private或者static类型。

定义方法中，只能方法中声明为final类型的变量。

相关使用例子：

class OuterClass{

    public void execute(){

        final int a = 1;

        /**

 * 创建局部内部类

 */

        class InnerClass{//局部内部类在外部类的方法里面

            public void execute(){

               System.out.println("LocalInner Class");

                //局部内部类只能访问final类型的变量

                System.out.println(a);

            }

        }

        //只能在所在方法的区域创建对象

        new InnerClass().execute();

    }

public static void main(String[] args) {
     //外部不能直接创建局部内部类对象,
    LocalInner localInner = new LocalInner();
    //只能用外部类的对象调用局部内部类所在的方法才能实例化对象。
    //所以局部内部类所在的方法的最后一局代码是创建局部内部类的对象。
    localInner.execute();
}
}

4、接口：
接口不能有构造方法，接口不能创建对象，因为接口是抽象的内容。
接口的作用就是给类来实现的，类通过implements关键字来实现接口。本质上就是一个继承的关系。

public interface InterfaceDemo1{
 public String name="数据";//在接口当中，final关键字可以省略。
 public final String sex="男";
public abstract void test1();
public void test2();//在接口当中abstract关键字可以省略不写
}

可以通过子类向上转型为接口。
一个接口可以同时继承多个接口

5、匿名内部类(anonymous inner classes)
匿名内部类的特征：
匿名内部类没有类名，没有class关键字也没有extends和implements等关键字修饰。

匿名内部类会隐式地继承一个父类或实现一个接口。