Java内部类

前言

最近看《Java编程思想》，看了内部类的讲解，发现自己好多都没听过或者没注意到。

指向外部类的指针

每个内部类都有一个隐藏的外部类的this指针，可以通过Outer.this获得

public class Main {
    private String message = "hello";
    
    public String getMessage() {
        return message;
    }
  
    class Inner {
        public Inner() {
            System.out.println(Main.this.getMessage());
            System.out.println(getMessage());
        }
    }
  
    public static void main(String[] args) {
        Main main = new Main();
        Main.Inner inner = main.new Inner();
    }
}

这个例子看其实意义不大，因为函数getMessage()没有歧义。
如果Inner中也有个getMessage()，那么调用的就是Inner中的，这里this指针就派上用场了。

题外话，在《Java并发编程实战》33页页提到了这个隐藏指针，如果把对象逸出，那么可能出现为构造未完全就调用了方法。比如下面（抱歉写的有点臃肿）。。。

interface Escape{
    void doSome(Some some);
}
class Some {
    protected Demo demo;
  
    public void printI() {
        demo.printI();
    }
}
class Demo {
    private int i = 0;
    public Demo(Escape escape) {
        escape.doSome(new Some() {
            {
                this.demo = Demo.this;
            }
        });
  
        i = 1;
    }
  
    public void printI() {
        System.out.println(i);
    }
  
}
public class Main {
    public static void main(String[] args) {
        Escape escape = new Escape() {
            @Override
            public void doSome(Some some) {
                some.printI();
            }
        };
        Demo demo = new Demo(escape);
    }
}

Demo构造完应该i = 1
但是这里调用过之后却是输出了0
这就是内部类是对象隐藏指针逸出导致得到了未构造完全的对象。

返回private内部类

正常类的来说，只能是public或者缺省的，不可以是private的。
但是内部类可以是public，priavte， protected或者缺省的。

class Demo {
    private class Innter {}
    public Innter getInnerInstence() {
        return new Innter();
    }
}
public class Main {
    public static void main(String[] args) {
        Demo demo = new Demo();
        //下面是不可以的，因为Inner是private的
        //Demo.Inner inner = demo.getInnerInstence();
    }
}

作为一种折中的方法，我们可以申明一个接口来解决这个问题

interface ForTest{}
class Demo {
    private class Innter implements ForTest {}
    public Innter getInnerInstence() {
        return new Innter();
    }
}
public class Main {
    public static void main(String[] args) {
        Demo demo = new Demo();
        ForTest inner = demo.getInnerInstence();
    }
}

普通内部类不能有static方法和实例变量

public class Main {
  
    class Inner {
    	//Inner classes cannot have static declarations
        //public static String message = "hello";
    }
}

静态内部类

如果你想要内部类可以用static，那么可以使用静态内部类。
但是静态内部类没有对外部类的引用了。就像是完全的独立的一个类。
创建静态内部类的时候也不需要先创建外部类了。

public class Main {
  
    private String name = "hello";
      
    static class Inner {
        public static String message = "hello";
        public Inner() {
        	//Non-static field 'name' cannot be referenced from a static context
            //System.out.println(name);
        }
    }
}

匿名类的构造

匿名类因为没有类名，所以构造函数没法重新定义，不过可以用{}包裹起来作为构造函数。

public class Main {
  
    private String name = "hello";
  
    public Main(String name) {
        this.name = name;
    }
  
    public Main getMain(String name) {
        return new Main(name){
            //报错
            //public Main(){}
            {
                System.out.println("name is" + name);
            }
        };
    }
}

内部类的构造参数

如果想要在内部类中使用其他的对象，必须是final的或者effectively final的，也就是说不允许内部类修改外界的对象。
什么是effectively final呢，就是如果你在内部类内部没有修改这个参数，那么jvm就默认这个是final的，不需要显式的加final关键词了。
是在Java8中引入的，有点像语法糖。

public class Main {
  
    private String name = "hello";
  
    public Main(String name) {
        this.name = name;
    }
  
    public Main getMain(String name) {
        return new Main(name){
            {
            	//variable 'name' is accessed from within inner class, need to be final or effectively final
                name = "lll";
            }
        };
    } 
}

显然我们想知道为什么呢？
stackoverflow的答案

接口中的内部类

接口中定义的方法默认是public的，
接口中定义的类默认是static的。

静态内部类作为测试

一般我们会为每个类做一个main方法进行一些简单的测试。
但是这样编译过之后，class文件中还是有main方法的，占用了空间。
我们可以使用静态内部类作为测试，因为编译过后静态内部类会生成一个单独的class文件，
生产环境中可以不把它包含进去。

我觉得没啥用，因为不止静态内部类，普通内部类和匿名类也会单独生成一个class文件。
生产环境中一个一个删除不是傻逼吗。。。

为什么要引入内部类

作为不能多继承的补充
好有道理

继承内部类

因为内部类拥有外部类的引用，所以继承的时候要有点技巧。

class Demo {
    class Inner{}
}
  
public class Main extends Demo.Inner{
  
	//构造函数只能这么写。。。
    public Main(Demo demo) {
        demo.super();
    }
  
    public static void main(String[] args) {
          
    }
}

内部类重写

内部类可以向方法一样重写吗并进行多态吗
不行