一、成员内部类

​ 内部类可以用来实现多继承。成员内部类可以访问外部类的所有成员变量,包括private修饰的。

​ 内部类跟外部类有一个很重要区别:内部类可以用private修饰,而外部类是不能使用private修饰的。如果内部类仅仅在类内部使用时,使用private修饰后,就可以更好的隐藏内部信息。

​ 当需要使用到内部类的时候,还是推荐使用getInnerInstance的方式来获取,特别是当内部类只有无参构造器的时候

  1. public class Outer {
  2. private int num;
  3. private Inner inner;
  4. Outer(){
  5. num = 1;
  6. inner = new Inner();
  7. }
  8. public void print(){
  9. System.out.println("Outer.print()");
  10. System.out.println(inner.num);
  11. System.out.println(num);
  12. }
  13. //获取内部类对象
  14. public Inner getInnerInstance() {
  15. return new Inner();
  16. }
  17. class Inner{
  18. private int num;
  19. Inner(){
  20. num = 2;
  21. }
  22. public void print(){
  23. System.out.println("Inner.print()");
  24. System.out.println(this.num);
  25. System.out.println(Outer.this.num);
  26. }
  27. }
  28. }
  1. public class Test {
  2. public static void main(String[] args) {
  3. Outer outer = new Outer();
  4. Outer.Inner inner = outer.new Inner();
  5. outer.print();
  6. inner.print();
  7. }
  8. }

​ 外部类访问内部类是先生成内部类实例,然后就能访问所有方法和属性,内部类访问外部类方法和属性则直接使用Outer.属性/方法名 即可。

二、局部内部类

局部内部类就是定义在代码块、方法体内、作用域(使用花括号“{}”括起来的一段代码)内的类。局部内部类有以下特性:

  1. 局部内部类只能在代码代码块、方法体内和作用域中使用。
  2. 局部内部类同样可以无限制调用外部类的方法和属性。
  3. 可以使用abstract修饰,声明为抽象类。
  1. public class Outer {
  2. public static final int TOTAL_NUMBER = 5;
  3. public int id = 123;
  4. public void func() {
  5. final int age = 15;
  6. String str = "http://www.weixueyuan.net";
  7. class Inner {
  8. public void innerTest() {
  9. System.out.println(TOTAL_NUMBER);
  10. System.out.println(id);
  11. // System.out.println(str);不合法,只能访问本地方法的final变量
  12. System.out.println(age);
  13. }
  14. }
  15. new Inner().innerTest();
  16. }
  17. public static void main(String[] args) {
  18. Outer outer = new Outer();
  19. outer.func();
  20. }
  21. }

三、匿名内部类

  1. new 父类(参数列表)|实现接口() {
  2. //匿名内部类的内部定义
  3. }
  1. public class AnonymousTest {
  2. public static void main(String[] args) {
  3. new Thread(new Runnable() {
  4. public void run() {
  5. for (int i = 0; i < 10; i++) {
  6. try {
  7. sleep(1000);
  8. } catch (InterruptedException e) {
  9. e.printStackTrace();
  10. }
  11. System.out.println(i);
  12. }
  13. }
  14. }).start();
  15. }
  16. }

这里创建了一个继承于Thread的匿名内部类,覆盖了其中的 run方法,并创建了一个实例返回给了t,然后再调用run方法,可以看到,匿名内部类只能存在一个实例对象,因为new过一次就无法再创建了。匿名内部类不仅可以继承于类,也可以实现于接口:

  1. public class AnonymousTest {
  2. public static void main(String[] args) {
  3. new Thread(new Runnable() {
  4. public void run() { …… }).start();
  5. }
  6. }

当我们创建的类只需要一个实例的时候可以使用匿名内部类,比如说在多线程中,要使用多线程,一般先继承Thread类或者实现Runnable接口,然后再去调用它的方法,而每个任务一般都不一样,每次都新建一个类显然会很难管理,因为每个类只用一次就丢掉了,这个时候使用匿名内部类就很方便了,不仅不需要管理一堆一次性类,而且创建起来简单粗暴。

  1. 使用匿名内部类还是有很多限制的:
  2. 1、匿名内部类必须是继承一个类或者实现一个接口,但是两者不可兼得,同时也
  3. 只能继承一个类或者实现一个接口。
  4. 2、匿名内部类不能定义构造函数。
  5. 3、匿名内部类中不能存在任何的静态成员变量和静态方法。
  6. 4、匿名内部类是特殊的局部内部类,所以局部内部类的所有限制同样对匿名内部类生效。
  7. 5、匿名内部类不能是抽象的,它必须要实现继承的类或者实现的接口的所有抽象方法。
  1. //通过初始化块来实现匿名内部类的初始化
  2. //匿名内部类只能定义在方法等内部
  3. public class AnonymousTest{
  4. public static void main(String[] args){
  5. Human human = new Human(){
  6. private String name;
  7. {
  8. name="human";
  9. }
  10. @Override
  11. public void walk(){……}
  12. };
  13. human.walk();
  14. }
  15. }

注意,如果匿名内部类需要使用外部的参数或者变量,那么必须使用final修饰,因为内部类使用的其实是参数的拷贝,并不是参数本身,为了更明显的表明参数不可变,编译器会要求使用final关键字来修饰需要使用的变量。

  1. public class AnonymousTest {
  2. public static void main(String[] args) {
  3. Human human = new AnonymousTest().getHumanInstance("Frank");
  4. human.walk();
  5. }
  6. public Human getHumanInstance(final String name){
  7. return new Human() {
  8. private String nameA;
  9. {
  10. nameA = name;
  11. }
  12. @Override
  13. public void walk() {
  14. System.out.println(nameA + " walk.");
  15. }
  16. };
  17. }
  18. }

四、静态内部类

它的创建不依赖外部类,创建内部类的实例不需要像普通内部类一样先创建外部类实例才能创建。它不能无限制访问外部类的方法和成员变量,只能访问静态成员变量和静态方法

  1. public class Caculate {
  2. //定义一个pair类来将两个数捆绑
  3. static class Pair{
  4. private int first;
  5. private int second;
  6. public Pair(int first, int second) {
  7. this.first = first;
  8. this.second = second;
  9. }
  10. public int getFirst() {
  11. return first;
  12. }
  13. public int getSecond() {
  14. return second;
  15. }
  16. }
  17. //获取一个int数组中的最大和最小值
  18. public static Pair getMaxMin(int[] values){
  19. int max = Integer.MIN_VALUE;
  20. int min = Integer.MAX_VALUE;
  21. for (int i:values){
  22. if (min > i) min = i;
  23. if (max < i) max = i;
  24. }
  25. return new Pair(min,max);
  26. }
  27. public static void main(String[] args){
  28. int[] list = {1,3,5,2,77,23,25};
  29. Caculate.Pair pair = Caculate.getMaxMin(list);
  30. System.out.println(pair.getFirst());
  31. System.out.println(pair.getSecond());
  32. System.out.println(pair.first);
  33. System.out.println(pair.second);
  34. }
  35. }


学习笔记      JAVA随笔

本博客所有文章除特别声明外,均采用 CC BY-SA 3.0协议 。转载请注明出处!