Java 内部类种类及使用解析

Java中的内部类共分为四种：

　　静态内部类static inner class (also called nested class)

　　成员内部类member inner class

　　局部内部类local inner class

　　匿名内部类anonymous inner class
作用
1.内部类可以很好的实现隐藏
一般的非内部类，是不允许有 private 与protected权限的，但内部类可以
2．内部类拥有外围类的所有元素的访问权限
3.可是实现多重继承
4.可以避免修改接口而实现同一个类中两种同名方法的调用。
下面看些例子
  静态内部类Static Inner Class
　　类定义时加上static关键字。

　　不能和外部类有相同的名字。

　　被编译成一个完全独立的.class文件，名称为OuterClass$InnerClass.class的形式。

　　只可以访问外部类的静态成员和静态方法，包括了私有的静态成员和方法。

　　生成静态内部类对象的方式为：

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

public class TestExample {
	private String name;
	private static String constant ="test";
	public static void main(String args[]) {
		TestExample.Inner a = new TestExample.Inner();
	}
	
	static class Inner{
		public Inner(){
			//System.out.println(name);//only reference static variable or method of outer class.
			System.out.println(constant);
		}
	}
}

成员内部类Member Inner Class
成员内部类就像一个实例变量。

　　它可以访问它的外部类的所有成员变量和方法，不管是静态的还是非静态的都可以。

　　在外部类里面创建成员内部类的实例：

　　this.new Innerclass();

　　在外部类之外创建内部类的实例：

　　(new Outerclass()).new Innerclass();

　　在内部类里访问外部类的成员：

　　Outerclass.this.member

public class TestExample {
	private String name;
	private static String constant ="test";
	public static void main(String args[]) {
		TestExample.Inner a = new TestExample().new Inner();
	}
	
	class Inner{
		public Inner(){
			System.out.println(name);//can reference all kinds of outer class variable or method.
			System.out.println(constant);
		}
	}
}

局部内部类Local Inner Class

局部内部类定义在方法中，比方法的范围还小。是内部类中最少用到的一种类型。

　　像局部变量一样，不能被public, protected, private和static修饰。

　　只能访问方法中定义的final类型的局部变量。

　　局部内部类在方法中定义，所以只能在方法中使用，即只能在方法当中生成局部内部类的实例并且调用其方法。

public class TestExample {
	private String name;
	private static String constant ="test";
	public static void main(String args[]) {
		TestExample a = new TestExample();
		a.say();
	}
	
	public void say() {
		
		String methodname = "say";
		final String methodname2 = "say";
		class LocalInner{
			public LocalInner(){
				System.out.println(name);//can reference all kinds of variable or method of outer class .
				System.out.println(constant);
				//System.out.println(methodname);//error
				System.out.println(methodname2);//only reference final variable in local.
			}
		}
		new LocalInner();
	}
}

匿名内部类Anonymous Inner Class
匿名内部类就是没有名字的局部内部类，不使用关键字class, extends, implements, 没有构造方法。

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

　　匿名内部类使用得比较多，通常是作为一个方法参数。

public class TestExample {
	private String name;
	private static String constant = "test";

	public static void main(String args[]) {
		TestExample a = new TestExample();
		a.getDate(new Date(){
			@Override
            @Deprecated
            public String toLocaleString()
            {
                return "Hello: " + super.toLocaleString();
            }
		});
	}

	 public String getDate(Date date) {
		return date.toLocaleString();
	}

}

实现隐藏

package insidecategory;
 
public interface Incrementable
{
 void increment();
}
具体类
package insidecategory;
 
public class Example {
  
    private class InsideClass implements Incrementable
    {
         public void increment()
         {
             System.out.println("这是一个测试");
         }
    }
    public InterfaceTest getIn()
    {
        return new InsideClass ();
    }
}
public class TestExample {
 
 public static void main(String args[])
 {
    Example a=new Example();
    InterfaceTest a1=a.getIn();
    a1.test();
 }
}

实现多重继承

类一
 package insidecategory;
 
public class Example1 {
 
   public String name()
   {
       return "liutao";
   }
}
类二
package insidecategory;
 
public class Example2 {
 
    public int age()
    {
        return 25;
    }
}
 
类三
 package insidecategory;
 
public class MainExample
{
   private class test1 extends Example1
    {
        public String name()
        {
          return super.name();
        }
    }
    private class test2 extends Example2
    {
       public int age()
       {
         return super.age();
       }
    }
   public String name()
    {
    return new test1().name();
   }
   public int age()
   {
       return new test2().age();
   }
   public static void main(String args[])
   {
       MainExample mi=new MainExample();
       System.out.println("姓名:"+mi.name());
       System.out.println("年龄:"+mi.age());
   }
}

避免修改接口而实现同一个类中两种同名方法的调用

大家假想一下如果，你的类要继承一个类，还要实现一个接口，可是你发觉你继承的类和接口里面有两个同名的方法怎么办？你怎么区分它们？？这就需要我们的内部类了。看下面的代码
接口
package insidecategory;

public interface Incrementable
{
void increment();
}

类 MyIncrement
   package insidecategory;

public class MyIncrement {

    public void increment()
    {
      System.out.println("Other increment()");
    }
    static void f(MyIncrement f)
    {
        f.increment();
    }

}
大家看上面加黑的部分，两个方法都是一样的。在看下面这个类要继承这两个类
如果不用内部类
package insidecategory;

public class Callee2 extends MyIncrement implements Incrementable
{
public void increment()
      {
        //代码
       }
}
想问一下大家increment()这个方法是属于覆盖MyIncrement这里的方法呢？还是Incrementable这里的方法。我怎么能调到MyIncrement这里的方法？显然这是不好区分的。而我们如果用内部类就很好解决这一问题了。看下面代码
package insidecategory;

public class Callee2 extends MyIncrement
{
private int i=0;
private void incr()
{
       i++;
       System.out.println(i);
}
private class Closure implements Incrementable
{
      public void increment()
      {
        incr();
      }
}
Incrementable getCallbackReference()
{
      return new Closure();
}
}
我们可以用内部类来实现接口，这样就不会与外围类的方法冲突了