Java内部类初探

之前对内部类的概念不太清晰，在此对内部类与外部类之间的关系以及它们之间的调用方式进行一个总结。

Java内部类一般可以分为以下三种：

• 成员内部类
• 静态内部类
• 匿名内部类

一、成员内部类

• 内部类的创建：成员内部类的创建需要依赖于外部类对象，没有创建外部类实例之前无法创建成员内部类对象

  若在main函数中直接创建成员内部类则会报错：

  MemberInner memberInner = new MemberInner();
  

• 私有属性访问：成员内部类可直接访问外部类非静态私有属性，外部类访问内部类私有属性则需要通过内部类的对象来访问

  在memberInnerTest()方法中，可以直接访问外部类中的私有test字段，若内部类中有与外部类同名字段，调用外部类需要使用如下方法：

  OuterTest.this.test
  

• 创建内部类：

  • 在外部类内部创建内部类对象：使用new关键字创建内部类对象

    private void createMemberInner(){
        MemberInner memberInner = new MemberInner();
        memberInner.memberInnerTest();
    }
    

  • 在外部类外部创建内部类对象：需要先创建外部类对象，再通过外部类创建内部类

    OuterTest outerTest = new OuterTest();
    MemberInner memberInner = outerTest.new MemberInner();
    

    若不需要使用外部类，可以使用如下方式创建内部类

    MemberInner memberInner = new OuterTest().new MemberInner();
    

    使用该方法创建内部类需要注意：若外部类中有多个内部类，这种方法会new出多个外部类对象，各个类对象都是独立的，因此外部类的成员变量并不会在内部类中共享。

    如下代码中，由于new出了两个OuterVar类，所以InnerOne与InnerTwo类输出的成员变量var均为0。若想InnerOne与InnerTwo类共享成员变量var，则需用如下方式创建：

      OuterVar outerVar = new OuterVar();
      InnerOne innerOne = outerVar.new InnerOne();
      InnerTwo innerTwo = outerVar.new InnerTwo();
    

    public class OuterVar {
    private int var = 0;
    
    class InnerOne{
      private void innerOnePrint(){
          System.out.println("innerOnePrint:"+var);
          var+=1;
      }
    }
    
    class InnerTwo{
      private void innerTwoPrint(){
          System.out.println("innerTwoPrint:"+var);
      }
    }
    
    public static void main(String[] args) {
      InnerOne innerOne = new OuterVar().new InnerOne();
      InnerTwo innerTwo = new OuterVar().new InnerTwo();
    
      innerOne.innerOnePrint();
      innerTwo.innerTwoPrint();
    }
    }
    /* 结果
    innerOnePrint:0
    innerTwoPrint:0
    */
    

/*1、成员内部类
  2、静态内部类
  3、匿名内部类
*/
public class OuterTest {
    /*
    1、成员内部类
     */
    private String test = "OuterTest";

    private void createMemberInner(){
        MemberInner memberInner = new MemberInner();
        memberInner.memberInnerTest();
    }

    class MemberInner{
        private String test = "MemberInnerTest";

        public void memberInnerTest(){
            System.out.println("MemberInner");
            System.out.println(test);
            System.out.println(OuterTest.this.test);

        }
    }

    public static void main(String[] args) {
        // 成员内部类
        OuterTest outerTest = new OuterTest();
        MemberInner memberInner = outerTest.new MemberInner();
//        MemberInner memberInner = new OuterTest().new MemberInner();
        
        memberInner.memberInnerTest();
    }
}


/* 结果
   MemberInner
   MemberInnerTest
   OuterTest */

二、静态内部类

静态内部类定义在外部类的内部，使用static关键字修饰，静态内部类不需要外部类对象产生就能使用，不能访问外部类的成员域，但能访问静态域。

• 私有属性访问：静态内部类不可直接访问外部类的非静态属性

• 创建内部类：

  • 在外部类内部创建内部类对象：使用new关键字创建内部类对象

    private void createStaticInner(){
        StaticInner staticInner = new StaticInner();
        staticInner.staticInnerTest();
    }
    

  • 在外部类外部创建内部类对象：可以不创建外部类对象，直接创建内部类对象

    StaticInner staticInner = new StaticInner();
    

public class OuterTest {
    /*
      2、静态内部类
     */
    private String test = "OuterTest";

    private void createStaticInner(){
        StaticInner staticInner = new StaticInner();
        staticInner.staticInnerTest();
    }


    static class StaticInner{
        private String test = "StaticInnerTest";

        public void staticInnerTest(){
            System.out.println("StaticInner");
            System.out.println(test);
        }
    }

    public static void main(String[] args) {
        // 静态内部类
        StaticInner staticInner = new StaticInner();
        staticInner.staticInnerTest();
    }
}

/* 结果
   StaticInner
   StaticInnerTest */

三、匿名内部类

使用匿名内部类的前提条件：必须继承一个父类或实现一个接口。 有以下一些特点:

• 由于匿名内部类是没有类名，所以匿名内部类不能有构造方法
• 匿名内部类不能定义任何静态成员、方法和类

//匿名内部类
interface Father{
    public abstract void talk();

    public abstract void eat();
}
public class Test {
    public static void main(String[] args) {
        //匿名内部类
        Father father = new Father() {
            @Override
            public void talk() {
                System.out.println("I'm Father");
            }

            @Override
            public void eat() {
                System.out.println("I'm eating");
            }
        };
        father.talk();
        father.eat();
    }
}

/* 结果
   I'm Father
   I'm eating */