与人讨论匿名内部类的构造方法问题，自己写代码看看原理到底是什么样子的。因为类是匿名的，所以就无从创建一个同名的构造方法了。但是可以直接调用父类的构造方法。测试代码如下：
Java代码

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

package testtest;  

   

public class Main {  

   

    public static void main(String[] args) {  

        InnerTest inner = new InnerTest();  

        Test t = inner.get(3);  

        System.out.println(t.getI());  

    }  

}  

   

class Test {  

   

    private int i;  

   

    public Test(int i) {  

        this.i = i;  

    }  

   

    public int getI() {  

        return i;  

    }  

}  

   

class InnerTest {  

   

    public Test get(int x) {  

        return new Test(x) {  

   

            @Override 

            public int getI() {  

                return super.getI() * 10;  

            }  

        };  

    }  

}

编译之后得到４个class文件：Test.class，InnerTest.class，InnerTest$1.class以及Main.class。容易看出来，Main.class是测试类的class文件，Test.class是超类Test的class文件，InnerTest.class是InnerTest 的class文件，最值得关注的就是匿名内部类的class文件InnerTest$1.class。

首先javap -c InnerTest$1

Java代码

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

Compiled from "Main.java" 

class testtest.InnerTest$1 extends testtest.Test{  

final testtest.InnerTest this$0;  

   

testtest.InnerTest$1(testtest.InnerTest, int);  

  Code:  

   0:   aload_0  

   1:   aload_1  

   2:   putfield    #1; //Field this$0:Ltesttest/InnerTest;  

   5:   aload_0  

   6:   iload_2  

   7:   invokespecial   #2; //Method testtest/Test."

很明显，虽然我们看来是匿名内部类，但编译的时候给这个类指定了名字

InnerTest$1,而且看出来是继承自Test:

Java代码

1

class testtest.InnerTest$1 extends testtest.Test

而且在这个类有构造方法：　

Java代码

1

testtest.InnerTest$1(testtest.InnerTest, int);

这里也很容易理解，两个参数，一个是匿名内部类的外部类引用直接传了进来，这也是我们能在内部类中直接访问外部类成员的实现原理。另外一个就是int类型的参数了。也就是说其实编译器自动的给我们添加了带参数的构造方法。继续往下看：　
7: invokespecial #2; //Method testtest/Test."

因为匿名内部类没有类名(至少是明面上没有)，不然为何叫匿名？ 构造器是要有类名的。 不过有种方式可以起到构造器的作用，但有局限性，那就是“构造代码块”

通过反射，我们可以获得一个类运行时的信息（属性，构造方法和普通方法），但是当我们是使用反射区获取一个类的内部类的构造方法时，会发现内部类默认的无参构造中会出现父类类型的参数

测试代码：

public class OuterClass { class InnerClass{ }}

注意：Class.forName()中的类名不能使用eclipse中的Copy qualified Name 来获取，应为内部类编译后会产生两个文件，具体做法是：到工程的根目录下，找到bin文件夹，java文件编译后的calss文件都放在这个目录下，找到编译后的内部类的class文件，复制类名，然后在前面加上包名即可

import java.lang.reflect.Constructor;public class Test {  public static void main(String[] args) {  try {   Class clazz=Class.forName("reflect.OuterClass$InnerClass");   Constructor[] constructors = clazz.getDeclaredConstructors();   for(Constructor c:constructors){    System.out.println(c);   }  } catch (ClassNotFoundException e) {   // TODO Auto-generated catch block   e.printStackTrace();  } }}

结果：

使用反射获取内部类的构造方法时，获取的并不时它的无参构造，而是带有父类类型的参数，具体原因如下

编译后的文件：

编译后产生了三个文件，外部类中的内部类编译后会产生一个  外部类类名$内部类类名.calss的文件

使用javap反编译命令对这两个文件进行反编译

OuterClass.class

OuterClass$InnerClass.class

可以看到，外部类中有一个public reflect.OuterClass的无参构造

在看内部类，是一个final reflect.OuterClass this$0 和 reflect.OuterClass$InnerClass(reflect.OuterClasss)的构造函数

 

对于这个貌似无法从JDK中查看原因，就来阐述一下我的理解，又不对的地方还望指教

对于final reflect.OuterClass this$0 我个人认为，内部类在编译后会与外部类分离，这个final类的的reflect.OuterClass类型的变量this$0 应该是一个与外部类建立联系的表示，而reflect.OuterClass$InnerClass(reflect.OuterClasss)可以从创建外部类的创建入手如果想要在外部类的外部获得内部类的对象，需要进行如下声明：OuterClass.InnerClass innerClass=new OuterClass().new InnerClass() ，可以看出，想要获得内部类对象需要先new OuterClass(),然后再new InnerClass(),在可以获得一个内部类的对象，这也就就是了为甚麽获得一个内部类需要先new出一个外部类，因为内部类中的默认构造中有一个外部类类型的参数

验证：

static关键字可以用于修饰变量和方法，代码块等，不能修饰再类上，但是并不是绝对的，static关键字是可以修饰内部类，且用static关键字修饰的内部类和不同内部类也有很大的不同

static关键字修饰内部类

代码：

public class OuterClass { static class InnerClass{ }}

静态内部类（InnerClass）意味着创建一个static内部类的对象，不需要一个外部类对象，不能从一个static内部类的一个对象访问一个外部类对象

测试代码：

public class Main { public static void main(String[] args) {  InnerClass in1 = new InnerClass();//或  OuterClass.InnerClass in2 = new OuterClass.InnerClass(); }}

使用以上两种方式都可以获得内部类的实例，但什么可以这样写？

对其进行反编译：

OuterClass$InnerClass.class

反编译之后，外部类并没有什么太大变化，但是内部类和之前有明显的差别

final reflect.OuterClass this$0 已经没有了，而且reflect.OuterClass$InnerClass(reflect.OuterClasss)也变成了reflect.OuterClass$InnerClass()，reflect.OuterClasss类型的参数已经没有了，

而此时可以用InnerClass in1 = new InnerClass();对其进行实例化，比没有依赖于外部类

OuterClass.InnerClass in2 = new OuterClass.InnerClass();也并没有先new OuterClass()这一操作

这也就验证了上面我的猜想

对于final reflect.OuterClass this$0 ，内部类在编译后会与外部类分离，这个final类的的reflect.OuterClass类型的变量this$0 应该是一个与外部类建立联系的表示，而reflect.OuterClass$InnerClass(reflect.OuterClasss)可以从创建外部类的创建入手，如果想要在外部类的外部获得内部类的对象，需要进行如下声明：OuterClass.InnerClass innerClass=new OuterClass().new InnerClass() ，可以看出，想要获得内部类对象需要先new OuterClass(),然后再new InnerClass(),在可以获得一个内部类的对象，这也就就是了为甚麽获得一个内部类需要先new出一个外部类，因为内部类中的默认构造中有一个外部类类型的参数

构造方法 Constructor

    1.构造方法与类名相同，没有返回值，连void都没有

    2.具有可见性

3 .不写时，编译器默认生成一个无参构造方法

    4.将所有实例属性初始化为0

5.如果程序编写了一个构造方法，而不再自动生成构造方法

 

6.无参构造方法

      1>无参构造方法可以方便地创建对象

            无论是人工创建还是通过反射创建都很方便

      2>无参构造方法创建的对象，属性值要么是0，要么是n

通常在使用之前还需要再次给属性赋一个有用的值

 

   在java中有一个概念---bean

     bean类要求有一个无参构造方法

     可以使用工具自动创建对象

 

1.构造器必须与类同名（如果一个源文件中有多个类，那么构造器必须与公共类同名）

2.每个类可以有一个以上的构造器

3.构造器可以有0个、1个或1个以上的参数

4.构造器没有返回值

5.构造器总是伴随着new操作一起调用

 

Getter/Setter访问器方法

目的是不让属性直接暴露出来，而是通过方法（getter/setter）间接地访问属性

 好处是：

    可以控制只读、只写

    还可以在赋值时进行转换、验证等操作

    可以在获取值时进行转换或修改

 

继承

   没有指定父类，默认都从Object类继承

   使用extends关键字可以指定父类

 

  如果要覆盖或重写父类的方法，最好标记@Override注解（Annotation）

注解是可以附加到类元数据上的对象

   反射是获取类元数据信息的编程接口

 

抽象类

用abstract标记

不需要实例化，只为继承而存在

 

抽象方法

    不为调用，只为继承

     用abstract标记，没有方法体！

抽象类中既可以有抽象方法也可以有非抽象方法！

 

在继承体系中子类可以通过super关键字访问父类

    调用父类构造方法

         Super()

    调用本类构造方法

         This()

访问父类的属性

       Super.属性名

 调用父类的方法

       Super.方法名()

 

 

 

如果父类有无参构造方法，子类可以不显式调用super()，如果没有无参构造方法，必须手动显式调用super(xxx)，否则报编译错误。

当父类同时存在无参和有参构造方法时，默认调用无参构造方法。

当未写任何构造方法时，编译期自动帮你添加一个无参构造方法，其他同上。

编译器是会自动在子类的构造行数中, 在首行添加"super();", 这么一个语句,用来初始化父类的数据;

如果没有的话, 编译的时候,无法找到父类的无参构造函数,就无法绑定运行时候调用哪个父类的构造函数,编译的时候就会报错啦;

所以记得在以前学习的时候, 很多书籍都是让重载构造函数的时候, 记得添加一个无参的构造函数