Java学习过程40.内部类

内部类

• 内部类就是在一个类的内部定义一个类，比如：A 类中定义一个 B 类，那么 B 类相对 A 类来说就称为内部类，而 A 类相对 B 类来说就是外部类。
  1. 成员内部类
  2. 静态内部类
  3. 局部内部类
  4. 匿名内部类
• 一个 java 类中可以有多个 class 类，但是只能有一个 public class 的类

public class Outer {
    class A{}
}

• 内部类可以获得外部类的私有属性、私有方法

• 通过外部类来实例化内部类，即可访问内部类。

• Outer outer = new Outer();
  //通过外部类来实例化内部类
  Outer.Inner inner = outer.new Inner();
  

成员内部类

public class Outer {
    private int id;
    public void out(){
        System.out.println("这是外部类的方法");
    }
    public class Inner{ //成员内部类
        public void in(){
            System.out.println("这是内部类的方法");
        }
        public void print(){ // 获取外部类的私有属性
            System.out.println(id);
        }
    }
}

静态内部类

public class Outer {
    public void out(){
        System.out.println("这是外部类的方法");
    }
    public static class Inner{ //静态内部类
        public void in(){
            System.out.println("这是内部类的方法");
        }
    }
}

局部内部类

在方法里定义的类

public class Outer {
    public void method(){
        //局部内部类
        class Inner{
        }
    }
}

匿名内部类

这种类没有类名，不能显示的 new 的方法创建对象。如果还要再构造器中初始化属性，那么就要用代码块来进行初始化的工作。

public class Outer {
    public static void main(String[] args){
            public void hello(){
                //匿名内部类：没有名字初始化类，不用将实例保存到变量中
                new Apple().eat();
                //实现了接口的类，但这个类没有名字
                UserService userservice = new UserService(){
            }
        }
    }
}
class Apple{
    public void eat(){
        System.out.println("eat");
    }
}
interface UserService{
    void hello();
}

内部类的特性

内部类作为类的成员：

• 可以声明为 final
• 和外部类不同，内部类可以声明为 private 或者 protected
• 内部类可以声明为 static，但此时就不能使用外层类的非静态成员变量

内部类作为类;

• 可以声明为 abstract 类（抽象类），因此可以被其他的内部类继承

注意：非 static（非静态）的内部类中的成员不能声明为 static，只有在外部类或 static 的内部类中才可声明 static 成员

内部类的作用

• 主要解决了 Java 不能多重继承的问题，使用内部类来变相的实现类的多重继承，可以同时继承多个类。

public class Test {
    //使用内部类来实现多重继承
    public static void main(String[] args) {
        A a = new A();
        a.getTestB();
        a.getTestC();
    }
}

class A {
    // 因为InnerB私有化，所以写个方法来调用内部类InnerB的方法
    public void getTestB(){
        new InnerB().testB();
    }

    public void getTestC(){
        new InnerC().testC();
    }
	//内部类InnerB继承类B，并重写其中的testB方法
    private class InnerB extends B {
        @Override
        public void testB() {
            System.out.println("重写后的testB");
        }
    }

    private class InnerC extends C {
        @Override
        public void testC() {
            System.out.println("重写后的testC");
        }
    }
}

class B {
    public void testB(){}
}

class C {
    public void testC(){}
}