Java内部类知识点总结

定义:
放在一个类的内部的类我们就叫内部类。

作用:
内部类可以很好的实现隐藏:一般的类,是不允许有 private 与protected权限的,但内部类可以。
内部类拥有外部类的所有元素的访问权限。
可以实现多重继承。
可以避免修改接口而实现同一个类中两种同名方法的调用。

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

//接口
interface InterfaceTest
{
 void test();
}
//具体类
class Example {  
    private class InsideClass implements InterfaceTest
    {
         public void test()
         {
             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();
 }
}

从这段代码里面我们只知道Example的getIn()方法能返回一个InterfaceTest 实例但并不知道这个实例是怎么实现的。而且由于InsideClass 是private的,不看代码的话根本看不到这个具体类的名字,所以说它可以很好的实现隐藏。

2:可以无条件地访问外部类的所有元素

public class Outter {
   private String name="aa";
   private class Inner
   {
      public Inner()
      {
          System.out.println(name);
      }
   }
   public void test()
   {
    new InTest();
   }
   public static void main(String args[])
   {
       Outer test=new Outer();
       bb.test();
   }
}

name变量是在Outter里面定义的私有变量。这个变量在内部类中可以无条件地访问。

3:可以实现多重继承
它的存在使得Java的继承机制更加完善。大家都知道Java只能继承一个类,它的多重继承在我们没有学习内部类之前是用接口来实现的。但使用接口有时候有很多不方便的地方。比如我们实现一个接口就必须实现它里面的所有方法。而有了内部类就不一样了。它可以使我们的类继承多个具体类或抽象类。

//类一
class Example1 { 
   public String name()
   {
       return "aa";
   }
}
//类二
class Example2 { 
    public int age()
    {
        return 25;
    }
} 
//类三
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:避免修改接口而实现同一个类中两种同名方法的调用。
如果一个类不仅要继承一个类,还要实现一个接口,可是继承的类和接口里面有两个同名的方法怎么办?怎么区分它们??这就需要内部类了。看下面的代码:

//接口
interface Incrementable
{
 void increment();
}
//类 
class MyIncrement {
    public void increment()
    {
      System.out.println("Other increment()");
    }
    static void f(MyIncrement f)
    {
        f.increment();
    } 
}
public class Test 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:成员内部类:作为外部类的一个成员存在,与外部类的属性、方法并列。

  • 成员内部类中不能定义静态成员。
  • 成员内部类可以访问外部类的所有成员变量和方法,不管是静态的还是非静态的都可以。
  • 在内部类里访问外部类的成员:Outerclass.this.member,如果内部类中没有与外部类同名的变量,则可以直接用变量名访问外部类变量。
  • 在外部类的非静态方法里面创建成员内部类的实例:new Innerclass()。
  • 在外部类的静态方法里面或外部类之外创建内部类的实例:(new Outerclass()).new Innerclass()。
  • 内部类是一个编译时的概念,一旦编译成功,就会成为完全不同的两类。对于一个名为outer的外部类和其内部定义的名为inner的内部类。编译完成后出现outer.class和outer$inner.class两类。

2:局部内部类:作为方法内的一个局部变量存在,不能被public, protected, private和static修饰。

  • 可以访问外部类的所有成员变量和方法,不管是静态的还是非静态的都可以。
  • 只能访问方法内的final变量。
  • 局部内部类在方法中定义,所以只能在方法中使用,即只能在方法当中生成局部内部类的实例并且调用其方法。

3:静态内部类(嵌套类):(注意:前两种内部类与变量类似,所以可以对照参考变量)
如果你不需要内部类对象与其外围类对象之间有联系,那你可以将内部类声明为static。这通常称为嵌套类(nested class)。想要理解static应用于内部类时的含义,你就必须记住,普通的内部类对象隐含地保存了一个引用,指向创建它的外围类对象。然而,当内部类是static的时,就不是这样了。
嵌套类意味着:
- 要创建嵌套类的对象并不需要其外围类的对象。
- 不能从嵌套类的对象中访问非静态的外围类对象。
静态内部类中可以定义静态或者非静态的成员。
生成一个静态内部类不需要外部类成员,这是静态内部类和成员内部类的区别。静态内部类的对象可以直接生成:Outer.Inner in = new Outer.Inner();而不需要通过生成外部类对象来生成。这样实际上使静态内部类成为了一个顶级类(正常情况下,你不能在接口内部放置任何代码,但嵌套类可以作为接口的一部分,因为它是static 的。只是将嵌套类置于接口的命名空间内,这并不违反接口的规则)

4:匿名内部类:匿名内部类就是没有名字的内部类。

什么情况下需要使用匿名内部类?如果满足下面的一些条件,使用匿名内部类是比较合适的:
- 只用到类的一个实例。
- 类在定义后马上用到。
- 类非常小(SUN推荐是在4行代码以下)
- 给类命名并不会导致你的代码更容易被理解。

在使用匿名内部类时,要记住以下几个原则:
- 匿名内部类不能有构造方法。
- 匿名内部类不能定义任何静态成员、方法和类。
- 匿名内部类不能是public,protected,private,static。
- 只能创建匿名内部类的一个实例。
- 一个匿名内部类一定是在new的后面,用其隐含实现一个接口或实现一个类。
- 因匿名内部类为局部内部类,所以局部内部类的所有限制都对其生效。

你可能感兴趣的:(Java)