简述内部类及其作用

参考链接  https://www.zhihu.com/question/26954130

 

定义：把类定义在另一个类的内部，该类就被称为内部类。

class Outer {
      class Inner {
      }
  }

访问规则

​ A:可以直接访问外部类的成员，包括私有

​ B:外部类要想访问内部类成员，必须创建对象

内部类的分类

​ A：成员内部类

​ B：局部内部类

​ C：静态内部类

​ D：匿名内部类

(1) 成员内部类

成员内部类——就是位于外部类成员位置的类
特点：可以使用外部类中所有的成员变量和成员方法（包括private的）

1 格式

import java.util.*;

class Outer {
    private int age = 20;

    private void pr() {
        System.out.println("123");
    }

    // 成员位置
    class Inner {
        public void show() {
            System.out.println(age);
            pr();
        }
    }
}

public class Main {
    public static void main(String[] ages) {
        // 成员内部类是非静态的演示
        Outer.Inner oi = new Outer().new Inner();

        oi.show();  //20 123

    }
}

2 创建对象

 //成员内部类不是静态的：
  外部类名.内部类名 对象名 = new 外部类名.new 内部类名();
  ​
  //成员内部类是静态的：
  外部类名.内部类名 对象名 = new 外部类名.内部类名();    





3 成员内部类的修饰符

private

如果我们的内部类不想轻易被任何人访问，可以选择使用private修饰内部类，这样我们就无法通过创建对象的方法来访问，想要访问只需要在外部类中定义一个public修饰的方法，间接调用。

这样做的好处就是，我们可以在这个public方法中增加一些判断语句，起到数据安全的作用。

 

import java.util.*;

class Outer {
    public int x = 5;

    public void sh() {
        System.out.println(x);
    }

    private class Inner {
        public void show() {
            System.out.println("成功进入内部类");
        }
    }

    // 使用getXxx()获取成员内部类，可以增加校验语句（文中省略）
    public Inner getInner() {
        if (x > 10)
            return new Inner();
        else {
            System.out.println("fail");
            return null;
        }
    }

    public static void main(String[] args) {
        Outer outer = new Outer();
        // outer.x = 15;
        // outer.sh();
        // Outer.Inner inner = outer.getInner();
        // inner.show();  // 15 成功进入内部类
        outer.x = 5;
        outer.sh();
        Outer.Inner inner = outer.getInner();
        inner.show(); // 5 fail
    }

}

(2) 局部内部类

  class Outer {
      public void method(){
          class Inner {
          }
      }
  }

定义 ： 定义在一个方法或者一个作用域里面的类

特点：主要是作用域发生了变化，只能在自身所在方法和属性中被使用

 

 

1 格式

 

import java.util.*;

//在局部位置，可以创建内部类对象，通过对象调用和内部类方法
class Outer {
    private int age = 20;

    public void method() {
        final int age2 = 30;
        class Inner {
            public void show() {
                System.out.println(age);
                // 从内部类中访问方法内变量age2，需要将变量声明为最终类型。
                System.out.println(age2);
            }
        }
        Inner i = new Inner();
        i.show();

    }

    public static void main(String[] args) {
        Outer out = new Outer();
        out.method();// 20 30
    }
}

为什么局部内部类访问局部变量必须加final修饰呢？

因为局部变量是随着方法的调用而调用，使用完毕就消失，而堆内存的数据并不会立即消失。

所以，堆内存还是用该变量，而该变量已经没有了。为了让该值还存在，就加final修饰。

原因是，当我们使用final修饰变量后，堆内存直接存储的是值，而不是变量名。

（即上例 age2 的位置存储着常量30 而不是 age2 这个变量名）

(3) 静态内部类 （类似类的静态成员变量）

我们所知道static是不能用来修饰类的,但是成员内部类可以看做外部类中的一个成员,所以可以用static修饰,这种用static修饰的内部类我们称作静态内部类,也称作嵌套内部类.
特点：不能使用外部类的非static成员变量和成员方法

 没有定义为静态类，那么在这个内部类中如果要利用static关键字来修饰某个成员方法或者成员变量是不允许的

解释：非静态内部类编译后会默认的保存一个指向外部类的引用，而静态类却没有。

1)首先，用内部类是因为内部类与所在外部类有一定的关系，往往只有该外部类调用此内部类。所以没有必要专门用一个Java文件存放这个类。

2)静态都是用来修饰类的内部成员的。比如静态方法，静态成员变量，静态常量。它唯一的作用就是随着类的加载(而不是随着对象的产生)而产生，以致可以用类名+静态成员名直接获得。

这样静态内部类就可以理解了，因为这个类没有必要单独存放一个文件，它一般来说只被所在外部类使用。 并且它可以直接被用外部类名+内部类名获得。 非静态内部类中不能有静态成员变量。

1 格式

import java.util.*;

class Outter {
    int age = 10;

    static int age2 = 20;

    public Outter() {
    }

    static class Inner {
        public void method() {
            // System.out.println(age);//错误
            System.out.println(age2);// 正确 20
        }
    }

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

(4) 匿名内部类

匿名内部类：声明一个类之后就只能创建一个对象了,因为他并没有类名字。开发中，最常用到的内部类就是匿名内部类了。

 只能使用一次，没有类名，只能访问外部类的final变量。

1 格式

匿名内部类的定义格式：
接口或抽象类名称 对象名 = new 接口或抽象类名称() {undefined
//覆盖重写所有抽象方法（匿名内部类的内容）
};
意思是创造一个实现（继承）了接口或抽象类的类的对象。

使用匿名内部类的目的：
1、因为接口和抽象类都不能实例化对象

2、通常访问一个接口时要：（1）定义子类、（2） 重写接口中的方法、（3） 创建子类对象、（4） 调用重写后的方法
如果接口的实现类（或者是父类的子类）只需要使用唯一的一次，那么这种情况下我们就可以省略掉该类的定义，而改为使用匿名内部类

import java.util.*;

interface Hello {
    public abstract void Run();

    public abstract void Read();
}

class Outter {

    public static void main(String[] args) {
        Hello hello = new Hello() {// 匿名内部类
            public void Run() {
                System.out.println("跑步");// 重写所有抽象方法
            }

            public void Read() {
                System.out.println("读书");// 重写所有抽象方法
            }
        };
        hello.Run();// 输出结果 跑步
        hello.Read();// 输出结果 读书
    }
}

// final 多种权限 静态内部类

内部类的特点：
1、内部类提供了更好的封装。只能让外部类直接访问，不允许同一个包中的其他类直接访问。
2、内部类可以直接访问外部类的私有属性，内部类被当成其外部类的成员。但外部类不能访问内部类的内部属性。
3、内部类可以实现java的单继承局限。 多继承

我们之前的学习知道，java是不可以实现多继承的，一次只能继承一个类，我们学习接口的时候，有提到可以用接口来实现多继承的效果，

即一个接口有多个实现，但是这里也是有一点弊端的，那就是，一旦实现一个接口就必须实现里面的所有方法，有时候就会出现一些累赘，但是使用内部类可以很好的解决这些问题

间接的实现了多继承

import java.util.*;

class Demo1 {
    public String name() {
        return "BWH_Steven";
    }
}

class Demo2 {
    public String email() {
        return "xxx.@163.com";
    }
}

public class Main {
    private class test1 extends Demo1 {
        public String name() {
            return super.name();
        }
    }

    private class test2 extends Demo2 {
        public String email() {
            return super.email();
        }
    }

    public String name() {
        return new test1().name();
    }

    public String email() {
        return new test2().email();
    }

    public static void main(String args[]) {
        Main md = new Main();
        System.out.println("我的姓名:" + md.name());
        System.out.println("我的邮箱:" + md.email());
    }
}

我的姓名:BWH_Steven
我的邮箱:xxx.@163.com