内部类基础篇

将一个类定义在一个类或者一个方法里，这样的类就称之为内部类。

Q：大多数业务需求，不使用内部类也可以实现，为什么Java还要设计内部类？

1、内部类可以很好地实现隐藏，非内部类是不可以被private、protected修饰的，但是内部类可以，从而达到了隐藏的作用。同时可以将一定逻辑关系的类组织在一起，增强可读性。

​2、间接实现多继承。每个内部类都可以独立地继承类，实现接口，外部类继承类跟实现接口的情况与内部类无关。

成员内部类

当某个类除了它的外部类外，不会被其他类使用时，使用成员内部类。

• 成员内部类是最普通的一种内部类，可以调用外部内的所有方法和属性，外部类要调用内部类的方法则必须先实例化内部类。

• 成员内部类不能包含静态属性和方法。

• 成员内部类的成员变量与方法允许与外部类重名，但这么做的话需要使用『外部类名.this』进行访问

public class Outer_01 {
    // 成员变量
    private String claim = "我是外部类";
    // 成员方法
    public void display(){
        System.out.println("我是外部类的方法");
    }
    // 成员内部类
    public class Inner {
        // 成员变量
        private String claim;
        // 内部类构造方法
        public Inner() {
            this.claim = "我是成员内部类";
        }
        // 成员方法
        public void display(){
            // 访问内部类的成员变量
            System.out.println("访问内部类的成员变量：" + claim);
            // 访问外部类的成员变量
            System.out.println("访问外部类的成员变量：" + Outer_01.this.claim);
            // 访问外部类的方法
            Outer_01.this.display();
        }
    }
}

// 一个java文件中定义两个类时只能有一个类被public修饰，且该类名必须与文件名一致
class Test01{
    public static void main(String[] args) {
        // 实例化外部类对象
        Outer_01 outer = new Outer_01();
        //调用外部类方法
        outer.display();	//我是外部类的方法
        //实例化外部类对象
        Outer_01.Inner inner = outer.new Inner();
        //调用内部类方法
        inner.display();	//访问内部类的成员变量：①我是成员内部类  ②访问外部类的成员变量：我是外部类  ③我是外部类的方法
    }
}

局部内部类

• 定义在代码块里的类，比如定义在一个方法中。

• 起作用的范围仅限于它所在的代码块中。

• 局部内部类不能被pubic、protected、private、static修饰，但是可以被final修饰。

public class Outer_02 {
    // 成员变量
    private String claim = "我是外部类";
    // 成员方法
    public void display(){
        class Inner {
            private String claim;

            public Inner(){
                this.claim = "我是局部内部类";
            }

            public void display(){
                System.out.println("我是局部内部类");
            }
        }
        // 局部内部类定义在外部内的方法体或者代码块中，在方法体重可以实例化局部内部类，调用局部内部类中的方法。
        Inner inner = new Inner();
        inner.display();
    }
}

class Test02{
    public static void main(String[] args) {
        // 实例化外部类
        Outer_02 outer = new Outer_02();
        // 调用外部类方法
        outer.display();	//我是局部内部类
    }
}

静态内部类

与成员内部类相比多了static关键字的修饰，静态内部类只能访问外部内的静态变量和静态方法。

public class Outer_03 {
    // 成员变量
    public static String claim = "我是外部类";
    // 成员方法
    public static void display(){
        System.out.println("我是外部类的方法");
    }
    // 静态内部类
    public static class Inner{
        // 成员变量
        private String claim;
        // 内部类构造方法
        public Inner() {
            this.claim = "我是成员内部类";
        }
        // 成员方法
        public void display(){
            // 访问内部类的成员变量
            System.out.println("访问内部类的成员变量：" + claim);
            // 访问外部类的静态成员变量
            System.out.println("访问外部类的成员变量：" + Outer_03.claim);
            // 访问外部类的静态方法
            Outer_03.display();
        }
    }
}

class Test03{
    public static void main(String[] args) {
        // 访问外部内成员变量
        System.out.println(Outer_03.claim);		//我是外部类
        //访问外部类方法
        Outer_03.display(); 		//我是外部类的方法
        // 不再需要实例化外部内便可实例化内部类
        Outer_03.Inner inner = new Outer_03.Inner();
        inner.display(); //访问内部类的成员变量：①我是成员内部类  ②访问外部类的成员变量：我是外部类  ③我是外部类的方法
    }
}

匿名内部类

• 匿名内部类是没有名称的内部类。

• 当一个类需要继承一个类或者实现一个接口时（必要条件），并且只使用一次的时候，可以考虑这种方式。

• 调用的时候直接使用父类的无参构造，并重写父类方法，从而达到优化代码的目的。

// 创建一个接口
public interface MyInterface {
    public void display();
}

//实现一个内部类
public class Outer_04 {
    public static void main(String[] args) {
        // 匿名内部类
        MyInterface myInterface = new MyInterface() {
            @Override
            public void display() {
                System.out.println("匿名内部类");
            }
        };
        myInterface.display();  //匿名内部类
    }
}

内部类模拟实现多继承

• 多继承是指一个类可以从多于一个父类那里继承行为和特征。

• 为了保证数据安全，Java只允许单继承。

• 由于外部类可以访问成员内部类全部属性和方法，因此通过定义成员内部类可以模拟实现继承多个类。

// 父类
public class Father {
    public int strong(){
        return 9;
    }
}

// 母类
public class Mother {
    public int kind(){
        return 8;
    }
}

//子类（外部类）
public class Son {

    // 内部类继承父亲
    class  Father_1 extends Father{
        // 重写父亲类方法
        @Override
        public int strong() {
            // 比父亲更加强壮了
            return super.strong() + 1;
        }
    }
    //内部类继承母亲
    class Mother_1 extends Mother{
        // 重写母亲类方法
        @Override
        public int kind() {
            // 没有母亲那么温柔
            return super.kind() - 1;
        }
    }

    public static void main(String[] args) {
        Son son  = new Son();
        // 继承了父亲的强壮，并且比父亲更加强壮了
        System.out.println(son.new Father_1().strong());    // 10
        // 继承了母亲的温柔，但不及母亲温柔
        System.out.println(son.new Mother_1().kind());      // 7
    }
}