java基础学习-内部类

内部类

1.内部类可以很好的实现隐藏

一般的非内部类，是不允许有 private 与protected权限的，但内部类可以
平时我们对类的访问权限，都是通过类前面的访问修饰符来限制的，一般的非内部类，是不允许有 private 与protected权限的，但内部类可以，所以我们能通过内部类来隐藏我们的信息。可以看下面的例子

接口
package insidecategory;
public interface Incrementable{
 void increment();
}
具体类
package insidecategory;
public class Example {
  
   <strong> private class InsideClass implements InterfaceTest{
         public void test(){
             System.out.println("这是一个测试");
         }
    }</strong>
    public InterfaceTest getIn(){
        return new InsideClass();
    }
}

上面加粗的部分是内部类，访问修饰符是private
客户端程序

package insidecategory;
public class TestExample {
 public static void main(String args[]){
    Example a=new Example();
    <strong>InterfaceTest a1=a.getIn();</strong>
    a1.test();
 }
}

加粗的那部分就是客户端调用的代码，从这段代码里面我只知道Example的
getIn()方法能返回一个InterfaceTest 实例但我并不知道这个实例是这么实现的。而且由于InsideClass 是private的，所以我们如果不看代码的话根本看不到这个具体类的名字，所以说它可以很好的实现隐藏。

2.内部类拥有外围类的所有元素的访问权限

3.可是实现多重继承

这个特点非常重要，个人认为它是内部类存在的最大理由之一。正是由于他的存在使得Java的继承机制更加完善。大家都知道Java只能继承一个类，它的多重继承在我们没有学习内部类之前是用接口来实现的。但使用接口有时候有很多不方便的地方。比如我们实现一个接口就必须实现它里面的所有方法。而有了内部类就不一样了。它可以使我们的类继承多个具体类或抽象类。大家看下面的例子。

类一
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());
   }
}

大家注意看类三，里面分别实现了两个内部类 test1,和test2 ，test1类又继承了Example1，test2继承了Example2，这样我们的类三MainExample就拥有了Example1和Example2的方法和属性，也就间接地实现了多继承。

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

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

接口
package insidecategory;
public interface Incrementable{
 void <strong>increment</strong>();
}
 
类 MyIncrement
package insidecategory;
public class MyIncrement {
    public void <strong>increment</strong>(){
      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();
 }
}

我们可以用内部类来实现接口，这样就不会与外围类的方法冲突了。

内部类分类

1.成员内部类

成员内部类（member inner class）：可以访问外部类的静态与非静态的方法与成员变量。生成成员内部类对象的方式为： 
OuterClass.InnerClass inner = new OuterClass().new InnerClass();

class MemberInner{
	private int a = 4;	
	public class Inner2{
		private int a = 5;		
		public void doSomething(){
			System.out.println(MemberInner.this.a);
		}
	}
	
	public void method(){
		Inner2 inner = this.new Inner2();
	}
}

public class MemberInnerClassTest{
	public static void main(String[] args){
		MemberInner.Inner2 inner = (new MemberInner()).new Inner2();		
		inner.doSomething();		
	}
}

2.静态内部类

 静态内部类（static inner class）：只能访问外部类的静态成员变量与静态方法，生成静态内部类对象的方式为： 

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

class StaticInner{ 
	private static int a = 4;
	public static class Inner	{
		public void test(){
			System.out.println(a);
		}
	}
}

public class StaticInnerClassTest{
	public static void main(String[] args){
		StaticInner.Inner inner = new StaticInner.Inner();		
		inner.test();
	}
}

3.局部内部类

局部内部类（Local Inner Class）：定义在方法当中，只能访问方法中声明的final类型的变量,无法在外部直接使用。

public class Parcel4 { 
    public Destination destination(String s) { 
        class PDestination implements Destination { 
            private String label; 
 
            private PDestination(String whereTo) { 
                label = whereTo; 
            } 
 
            public String readLabel() { 
                return label; 
            } 
        } 
        return new PDestination(s); 
    } 
 
    public static void main(String[] args) { 
        Parcel4 p = new Parcel4(); 
        Destination d = p.destination("Tasmania"); 
    } 
}

4.匿名内部类

匿名内部类（Anonymous Inner Class）：匿名内部类会隐式地继承一个父类或实现一个接口。

public static void main(String[] args){
		AnonymousInnerClassTest test = new AnonymousInnerClassTest();
		//String str = test.get(new Date());;
		//System.out.println(str);
		String str = test.get(new Date(){ 
			public String toLocaleString(){
				return "hello world";
			}
		});
		System.out.println(str);
}