Java-NestedClass(Interface).

内部类（Nested Class）##

内部类:即在一个类中还包含着另外一个类,一般是作为匿名类或者是使用数据隐藏时使用的.例子:

//内部类
class Out{
	private int age = 12;
       class In {
       	 public void print(){
       		System.out.println(age);
   	     }
       }
}
public class Demo{
	public static void main(String[] args){
	Out.In in = new Out().new In();
    in.print();
    //或者如下调用:
    /*
    Out out = new Out();
    out.In = out.new In();
    in.print();
    */
    }
}

在编译后产生两个.class文件,分别是Out.class和Out(In.class,所以)代表了内部类的含义.需要注意亮点:

1. 开头的Out就是为了表示用来生成的内部类是属于哪个外部类的;
2. 要生成内部类的对象就必须先得到外部类的对象,内部类的作用就是来访问外部类的中的成员变量.

内部类中的变量访问方式####

class Out{
	private int age = 12;
    class In{
    	private int age = 13;
    	public void print(){
    		int age = 14;
            System.out.println("局部变量: " + age);
            System.out.println("内部类变量: " + this.age);
            System.out.println("外部类变量: " + Out.this.age);
    	}
    }
}
public class Demo{
	public static void main(String[] args){
	Out.In in = new Out().new In();
    in.print();
    //或者如下调用:
    /*
    Out out = new Out();
    out.In = out.new In();
    in.print();
    */
    }
}

== 运行结果 ==
局部变量 : 14
内部类变量 : 13
外部类变量 : 12

如上可以看出,在内部类中如果没有同名变量,那么可以直接访问外部类中的变量,但是在内部类中如果存在同名变量,则必须使用this指针访问内部类的成员,而用OutClassName.this来访问外部类的成员变量.

静态内部类####

如果使用static来修饰内部类,即内部类为静态类.那么同普通静态类一样,内部类内只能使用static类型的成员变量,同时也只能访问外部类中的静态变量.此时,应将上面例子中的age前加上static.
另: 由于内部类被静态化,因此可以将Out.In当为一个整体看,即不必生成Out类的对象也可以直接访问内部类.

私有内部类####

class Out{
	private int age = 12;
    private class In{
    	public void print(){
        	System.out.printLn(age);
        }
    }
	public void outPrint(){
    	//System.out.println(age);
        new In().print();
    }
}

public class Demo{
	public static void main(String[] args){
    	//下面方法无效
    	/*	Out.In in = new Out().In()
         *	in.print();
        */
        Out out = new Out();
        out.outPrint();
    }
}

当使用private修饰内部类时,类的可访问属性大于下面任意成员函数的属性,所以即使私有内部类的成员函数的访问权限是public,私有内部类也仅仅能被Out类中的成员函数访问,外部不可见.

方法内部类####

在一个函数内部定义,在函数作用域外均不可见.

class Out{
	private int age = 12;
    public void outPrint(funal int x){
    	class In{
        	public void inPrint(){
          	   System.out.println(x);
         	   System.out.println(age);
            }
        }
        new In().inPrint();
    }
}

public class Demo{
	public static void main(String[] args){
    	Out out = new Out();
        out.outPrint();
    }
}
== 运行结果 ==
3
12

内部类的作用域仅仅限于函数内部,因此在定义完函数之后,只能在同一个函数中进行调用.同时从外部传递参数必须使用final修饰.

内部接口（Nested/Inner Interface）

访问权限：

有关访问权限，内部接口遵循以下原则：

• 不管内部接口是定义在类还是在接口中，内部接口都隐式地声明为static。
• 在接口中定义的内部接口隐式地定义为public
• 在类中定义的内部接口可以使用任何访问权限的修饰符修饰
• 只要可见，内部接口就可以被任意类实现

所以在接口中定义接口，得到的一定是public static的。

/* NestedInterfaceDemo.java */
interface A
{
  interface NestedA { void aMethod(); }

  // modifier public and static are placed for 
  // demonstration, in real life avoid placing modifiers that
  // are implicit to declarations
  public static interface NestedAA { void aaMethod(); }
}

public class NestedInterfaceDemo implements A.NestedA, A.NestedAA
{
  public static void main (String args[])
  {
    A.NestedA na = new NestedInterfaceDemo();
    na.aMethod();
    A.NestedAA naa = (A.NestedAA) na;
    naa.aaMethod();
  }

  public void aMethod()
  {
    System.out.println("within from aMethod");
  }

  public void aaMethod()
  {
    System.out.println("within from aaMethod");
  }
}

OUTPUT
======
D:JavaPrograms>javac NestedInterfaceDemo.java
D:JavaPrograms>java NestedInterfaceDemo
within from aMethod
within from aaMethod

而当内部接口定义在类中时，则可以用访问限制符修饰以限制其访问。extends的接口也必须要实现，同内部类，如果不是static的需要在new Outer().new Inner()，这样的方式才能实例化，而静态类则是不需要实例化外部类对象就可以访问内部类的构造函数，
同样的道理，在静态类（函数）中，需要保证静态，所以如果访问实例变量则需要当场实例化外部类才能访问，否则只能访问static变量。

class A
{
  private interface NestedPA { void paMethod(); }
  protected interface NestedA extends NestedPA { void aMethod(); }
  public interface NestedAA { void aaMethod(); }
}

public class NestedInterfaceDemo implements A.NestedA, A.NestedAA
{
  public static void main (String args[])
  {
    A.NestedA na = new NestedInterfaceDemo();
    na.aMethod();
    na.paMethod();

    A.NestedAA naa = (A.NestedAA) na;
    naa.aaMethod();
  }

  public void aMethod()
  {
    System.out.println("within from aMethod");
  }

  public void aaMethod()
  {
    System.out.println("within from aaMethod");
  }

  public void paMethod()
  {
    System.out.println("within from paMethod");
  }
}

OUTPUT
======
D:JavaPrograms>javac NestedInterfaceDemo.java

D:JavaPrograms>java NestedInterfaceDemo
within from aMethod
within from paMethod
within from aaMethod

综合例子：

package com.lyb.Section4;

/**
 * Created by lyb on 15-7-31.
 */
public class InnerInterfaceTest implements A.NestedA, A.NestedAA{
    public static void main(String[] args){
        InnerInterfaceTest a = new InnerInterfaceTest();
        ((A.NestedA)a).pamethod();
        a.aamethod();

        InnerInterfaceTest.Bnonstatic bnonstatic = new InnerInterfaceTest().new Bnonstatic();
        bnonstatic.BnonstaticMethod();

        InnerInterfaceTest.B b = new InnerInterfaceTest.B();
        b.BstaticMethod();
    }

    private int tt = 45;
    private static int ttt = 89;


    static class B{
        void BstaticMethod(){
            System.out.printf("%d,static %d 
",new InnerInterfaceTest().tt,ttt);
        }
    }

    class Bnonstatic{
        void BnonstaticMethod(){
            System.out.printf("%d, static %d in nonstatic
",tt,ttt);
        }
    }


    public void pamethod(){
        System.out.printf("This is the private Amethod. 
");
    }

    @Override
    public void amethod() {
        System.out.printf("This is the protected Amethod. 
");
    }

    @Override
    public void aamethod() {
        System.out.printf("This is the public AAmethod. 
");
    }
}

class A{
    private interface NestedPA{
        void pamethod();
    }

    protected interface NestedA extends NestedPA{
        void amethod();
    }

    public interface NestedAA{
        void aamethod();
    }
}

最终，内部类和内部接口最先的作用就是提高封装性，解决命名空间的问题的。