Java面向对象之内部类

---

提示：以下是本篇文章正文内容，Java系列学习将会持续更新

(1)基本概念

  当一个类的定义放在另一个类的实体时，则该类叫做内部类，该类所在的类叫做外部类。
  外部类可以包含的内容：成员变量、成员方法、构造方法、构造块、静态语句块、静态变量、方法、内部类。

语法格式：

class 外部类类名{
  class 内部类类名{
    内部类的类体;
  }
}

回到目录…

(2)成员内部类

成员内部类是定义在另一个类或接口中的内部类。

注意事项：
  1.内部类不能和外部类重名

  2.成员内部类可以使用final、访问修饰符来修饰

  3.创建内部类对象时，必须先创建外部类对象

    Outer.Inner inner = new Outer().new Inner();

  4.内部类不能含有静态变量、静态代码块、静态方法(除了静态常量)

  5.内部类可以直接访问外部类的成员(包括私有域)；外部类必须通过成员内部类的对象访问内部类的成员(包括私有域)

  6.成员内部类是一个独立的类，编译成独立的.class文件

作用：
  成员内部类既可以访问外部类信息，又可以访问父类信息，从而使多继承的解决变得完整。

定义成员内部类

package inner_text.member_inner;
/**
 * 定义成员内部类
 */
public class Outer { //外部类

    private String str1 = "Outer类的str1";
    private String str2 = "Outer类的str2";

    //外部类可通过成员内部类的对象调用内部类private修饰的私有成员
    public void show1(){
        Inner i = new Inner();
        System.out.println(i.str1);
    }

    public class Inner { //内部类

        private String str1 = "Inner类的str1";

        public void show2(){
            //内部类可以直接调用外部类的成员
            System.out.println(str2);
            //当内部类和外部类的成员重名时，优先调用内部类中的成员
            System.out.println(str1);
            //重名时，可以通过 "外部类名".this.成员名 的方式调用外部类的成员
            System.out.println(Outer.this.str1);
        }
    }
}

测试成员内部类

package inner_text.member_inner;
/**
 * 测试成员内部类
 */
public class Test_1 {
    public static void main(String[] args) {
        //需要先创建外部类的对象
        Outer outer = new Outer();
        outer.show1();

        //创建内部类对象
        Outer.Inner inner = outer.new Inner();
        inner.show2();
    }
}

回到目录…

(3)局部内部类

局部内部类是定义在方法或代码块里的内部类。

注意事项：
  1.不能含有静态变量、静态代码块、静态方法

  2.只能在定义该类的方法或代码块中使用，必须在使用前定义

  3.访问它所在方法的局部变量的时候，局部变量是被隐式的final修饰，不能改。

  4.是一个独立的类，编译成独立的.class文件

  5.只能使用abstract、final修饰，因为外部不可见，所以没有访问修饰符

  6.定义静态块或方法时候，只能访问外部类的静态成员。

定义局部内部类

package inner_text.local_inner;
/**
 * 定义局部内部类
 */
public class Outer { //外部类

    private String str1 = "Outer类的str1";
    private String str2 = "Outer类的str2";

    //定义一个外部的方法
    public void print(){
        System.out.println("Outer类的print方法");
    }

    static{
        class Di{} //局部内部类
    }

    public void method(){

        class Inner{ //局部内部类
            private String str1 = "Inner类的str1";

            public void visitOuter(){
                System.out.println(str1);
                System.out.println(Outer.this.str1);
                System.out.println(str2);
                print(); //直接调用外部类的方法
            }
        }

        //局部内部类只能在定义它的方法或代码块中使用
        Inner in = new Inner();
        in.visitOuter();
        
    }
}

测试局部内部类

package inner_text.local_inner;
/**
 * 测试局部内部类
 */
public class Test {
    public static void main(String[] args) {

        Outer outer = new Outer();
        outer.method();
    }
}

回到目录…

(4)匿名内部类

匿名内部类是实现接口或继承类(一般是抽象类)时创建没有名字的内部类。99%用于方法传参过程中。

语法格式：
  接口/父类类型 引用名 = new 接口/父类类型(){
    进行方法的重写;
  };

注意事项：
  1.必须且仅能继承一个父类或实现一个接口
  2.没有class关键字，没有类名
  3.是特殊的局部内部类
  4.仅能使用一次
  5.不能定义构造方法
  6.匿名类不能是抽象类

优点以及作用：
  匿名内部类可以使我们的代码更加紧凑，简洁、封装性比较好
  匿名内部类可以灵活的创建
  匿名内部类使用多继承的解决方案比较完整

定义匿名内部类

package inner_text.anonymous_inner;
//接口
public interface InterDemo {
    void print();
}
package inner_text.anonymous_inner;
/**
 * 定义匿名内部类
 */
public class Outer {

    private String str1 = "Outer类的str1";
    private String str2 = "Outer类的str2";

    //匿名内部类
    InterDemo id = new InterDemo() {

        private String str1 = "匿名内部类的str1";

        @Override
        public void print() {
            System.out.println(str1);
            System.out.println(Outer.this.str1);
            System.out.println(str2);
        }
    };

    public void show(){
        id.print();
    }
}

测试匿名内部类

package inner_text.anonymous_inner;
/**
 * 测试匿名内部类
 */
public class Test {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.show();
    }
}

回到目录…

(5)静态嵌套类

静态嵌套类是定义在另一个类、接口，使用static关键字修饰的嵌套类

注意事项：
  1.不需要通过生成外部类对象来生成静态嵌套类对象

  2.只能直接访问外部类的静态成员，不能直接访问外部类的非静态成员(此时需要new Outer)

  3.外部类可通过静态嵌套类的对象调用内部类的成员

  4.可以定义静态成员变量或静态成员方法。

定义静态嵌套类

package inner_text.static_inner;
/**
 * 定义静态嵌套类
 */
public class Outer {
    //定义两个成员变量，一个非静态，一个静态
    private String str1 = "Outer类的str1";
    private static String str2 = "Outer类的静态的str2";
    //静态成员方法
    public static void show1(){
        System.out.println("外部类的show方法");
        //new Inner().show2();
    }

    /** 静态嵌套类 **/
    //只能定义到类的成员位置，不能定义在方法或代码块中
    public static class Inner{
        private String str3 = "静态嵌套类的str1";
        private static String str4 = "静态嵌套类的静态str2";

        public void show2(){
            System.out.println(str3);
            System.out.println(str4); 
            //不能访问外部的非静态成员str1
            //可以直接访问外部的静态成员
            System.out.println(str2);
            show1();
        }
    }
}

测试静态嵌套类

package inner_text.static_inner;
/**
 * 测试静态嵌套类
 */
public class Test {
    public static void main(String[] args) {
        //不需要通过生成外部类对象来生成静态嵌套类对象
        Outer.Inner inner = new Outer.Inner();
        inner.show2();
    }
}

回到目录…

(6)静态内部类和非静态内部类的区别

名称	非静态内部类	静态内部类
定义位置上	成员位置、方法、代码块	只能在外部类的成员位置
组成	实例成员、静态常量、构造方法	实例成员、静态成员、静态代码块、构造方法
对象创建	必须先有外部类对象	不依赖于外部类实例，可以直接实例化
访问外部类	可以直接访问外部类所有成员	只能直接访问外部类的静态成员

回到目录…

---

总结:
提示：这里对文章进行总结：
以上就是今天的学习内容，本文是继续Java面向对象的学习，认识什么是内部类，学习了四种内部类的用法，其中最重要的就是成员内部类和静态内部类。之后的学习内容将持续更新！！！