一文读懂java内部类

分手后的思念是犯贱 2022-12-31 06:21 152阅读 0赞

### 内部类概述： ###

简单来说，内部类就是定义在另一个类中的类。而，需要内部类的主要原因有以下三点：

*  内部类方法可以访问该类定义在所在的作用域中的数据，包括私有数据
 *  内部类可以对同一个包中的其他类隐藏起来
 *  当想要定义一个回调函数且不想编写大量代码时，使用匿名内部类比较便捷

### 内部类基础： ###

**广泛意义上的内部类一般包括四种：**

*  成员内部类
 *  局部内部类
 *  匿名内部类
 *  静态内部类

### 成员内部类： ###

成员内部类时最普通的内部类，它的定义位于另一个类的内部，形如下面的形式：

class Circle {
        double radius = 0;
        public Circle(double radius){
            this.radius = radius;
        }
    
        // 内部类
        class Draw {
            public void drawShape(){
                System.out.println("drawshape");
            }
        }
    }

这样看来，类Draw像是类Circle的一个成员，Circle称为外部类。成员内部类可以无条件访问外部类的所有成员属性和成员方法（包括private成员和静态成员）。

class Circle {
        double radius = 0;
        private static int count = -1;
        public Circle(double radius){
            this.radius = radius;
        }
    
        // 内部类
        class Draw {
            public void drawShape(){
                // 外部类的私有成员
                System.out.println(radius);
                // 外部类的静态成员
                System.out.println(count);
            }
        }
    }

不过要注意的是，当成员内部类拥有和外部类同名的成员变量或者方法时，会发生隐藏现象，即默认情况下访问的时成员内部类的成员。如果要访问外部类的同名成员，需要以下面的形式进行访问：

外部类.this.成员变量
    外部类.this.成员方法

虽然成员内部类可以无条件地访问外部类的成员，而外部类想访问成员却不是这么随心所欲了。在外部类中如果要访问成员内部类的成员，必须先创建一个成员内部类的对象，再通过这个对象的引用来访问：

class Circle {
        double radius = 0;
    
        public Circle(double radius){
            this.radius = radius;
            // 必须先创建成员内部类的对象，在进行访问
            getDrawInstance().drawShaped();
        }
    
        private Draw getDrawInstance(){
            return new Draw();
        }
    
        // 内部类
        class Draw {
            public void drawShape(){
                // 外部类的私有成员
                System.out.println(radius);
            }
        }
    }

成员内部类依附外部类而存在，也就是说，如果要创建成员内部类的对象，前提是必须存在一个外部类对象。创建成员内部类对象的一般方式如下：

public class Test {
        public static void main(String[] args){
            //第一种方式：
            Outter outter = new Outter();
            //必须通过Outter对象来创建
            Outter.Inner inner = outter.new Inner();
    
            //第二种方式：
            Outter.Inner inner1 = outter.getInnerInstance();
        }
    }
    
    class Outter {
        private Inner inner = null;
        public Outter() {}
        public Inner getInnerInstance() {
            if (inner == null)
                inner =  new Inner();
            return inner;
        }
    
        class Inner{
            public Inner() {}
        }
    }

### 局部内部类： ###

局部内部类是定义在一个方法或者一个作用域里面的类，它和成员内部类的区别在于局部内部类的访问仅限于方法内或者该作用域内。

class People{
        public People(){}
    }
    
    class Man{
        public Man(){}
        public People getWoman(){
            //局部内部类
            class Woman extends People{
                int age = 0;
            }
            return new Woman();
        }
    }

局部内部类就像是方法里面的一个局部变量一样，是不能有public、protected、private以及static修饰的。

### 匿名内部类： ###

将局部内部类的使用在深入一步。假如只创建这个类的一个对象，就不用命名了，这种类被称为匿名内部类。

匿名内部类应该是平时我们编写代码时用的最多的，在编写事件监听的代码时使用匿名内部类不但方便，而且使用代码更加容易。

scan_bt.setOnClickListener(new OnClickListener() {
        @Override
        public void onClick(View v) {
            // TODO Auto-generated method stub
             
        }
    });
     
    history_bt.setOnClickListener(new OnClickListener() {
         
        @Override
        public void onClick(View v) {
            // TODO Auto-generated method stub
             
        }
    });

**这段代码中的：**

new OnClickListener() {
        @Override
        public void onClick(View v) {
            // TODO Auto-generated method stub
             
        }
    }

就是匿名内部类的使用。代码中需要给按钮设置监听器对象，使用匿名内部类能够在实现父类或者接口中的方法情况下同时产生一个相应的对象，但是前提是这个父类或者接口必须先存在才能这样使用。当然还可以使用下面这种写法，和上面使用匿名内部类效果相同：

private void setListener()
    {
        scan_bt.setOnClickListener(new Listener1());       
        history_bt.setOnClickListener(new Listener2());
    }
     
    class Listener1 implements View.OnClickListener{
        @Override
        public void onClick(View v) {
        // TODO Auto-generated method stub
                 
        }
    }
     
    class Listener2 implements View.OnClickListener{
        @Override
        public void onClick(View v) {
        // TODO Auto-generated method stub
                 
        }
    }

匿名内部类也是不能有访问修饰符和static修饰符的。它是唯一一种没有构造器的类。正因为没有构造器，所以匿名内部类的使用范围非常有限，大部分匿名内部类用于接口回调。匿名内部类在编译的时候由系统自动起名为Outter$1.class。一般来说，匿名内部类用于继承其他类或是实现接口，并不需要增加额外的方法，只是对继承方法的实现或是重写。

### 静态内部类： ###

有时候，使用静态内部类只是为了把一个类隐藏在另外一个类内部，并不需要内部类引用外围类对象。为此，可以将内部类声明为static，以便取消产生的引用。

静态内部类不需要依赖于外部类，并且它不能使用外部类的非static成员变量或者方法，这点很好理解，因为在没有外部类的对象的情况下，可以创建静态内部类对象，如果允许访问呢外部类的非static成员就会产生矛盾，因为外部类的非static成员必须依附于具体的对象。

public class Test {
        public static void main(String[] args)  {
            Outter.Inner inner = new Outter.Inner();
        }
    }
     
    class Outter {
        public Outter() {
             
        }
         
        static class Inner {
            public Inner() {
                 
            }
        }
    }

### 内部类的使用场景： ###

*  每个内部类都能独立的继承一个接口的实现，所以无论外部类是否已经继承了某个（接口）的实现，对于内部类都没有影响。内部类使得多继承的解决方案变得完整
 *  方便将存在一定逻辑关系的类组织在一起，又可以对外界隐藏
 *  方便编写事件驱动程序
 *  方便编写线程代码

### 常见的与内部类相关的笔试面试题： ###

**1、根据注释填写(1)(2)(3)处的代码**

public class Test{
        public static void main(String[] args){
               // 初始化Bean1
               (1)
               bean1.I++;
               // 初始化Bean2
               (2)
               bean2.J++;
               //初始化Bean3
               (3)
               bean3.k++;
        }
        class Bean1{
               public int I = 0;
        }
     
        static class Bean2{
               public int J = 0;
        }
    }
     
    class Bean{
        class Bean3{
               public int k = 0;
        }
    }

从前面可知，队员成员内部类，必须先产生外部类的实例化对象，才能产生内部类的实例化对象。而静态内部类不用产生外部类的实例化对象即可产生内部类的实例化对象。

创建静态内部类对象的一般形式为：**外部类类名.内部类类名 xxx = new 外部类类名.内部类类名()**

创建成员内部类对象的一般形式为：**外部类类名.内部类类名 xxx = 外部类对象名.new 内部类类名()**

因此，（1）（2）（3）处的代码分别为：

Test test = new Test();    
    Test.Bean1 bean1 = test.new Bean1();

Test.Bean2 b2 = new Test.Bean2();

Bean bean = new Bean();     
    Bean.Bean3 bean3 =  bean.new Bean3();

**2、下面这段代码的输出结果是什么？**

public class Test {
        public static void main(String[] args)  {
            Outter outter = new Outter();
            outter.new Inner().print();
        }
    }
     
     
    class Outter
    {
        private int a = 1;
        class Inner {
            private int a = 2;
            public void print() {
                int a = 3;
                System.out.println("局部变量：" + a);
                System.out.println("内部类变量：" + this.a);
                System.out.println("外部类变量：" + Outter.this.a);
            }
        }
    }

3
    2
    1

最后补充一点知识：关于成员内部类的继承问题。一般来说，内部类是很少用来作为继承用的。但是当用来继承的话，要主要两点：

*  成员内部类的引用方式必须为Outter.Inner
 *  构造器中必须有指向外部类对象的引用，并通过这个引用调用super()。

class WithInner {
        class Inner{
             
        }
    }
    class InheritInner extends WithInner.Inner {
          
        // InheritInner() 是不能通过编译的，一定要加上形参
        InheritInner(WithInner wi) {
            wi.super(); //必须有这句调用
        }
      
        public static void main(String[] args) {
            WithInner wi = new WithInner();
            InheritInner obj = new InheritInner(wi);
        }
    }