package innerclass;
public class OuterClass {private void outerMethod() {System.out.println("It's Method of OuterClass");}public static void main(String[] args) {OuterClass t = new OuterClass();OuterClass.Innerclass in = t.new Innerclass();in.innerMethod();}class Innerclass {public void innerMethod() {OuterClass.this.outerMethod();// 内部类成员方法与外部类成员方法同名时，使用this调用外部类的方法outerMethod();// 内部类没有同名方法时执行外部类的方法}private void outerMethod() {System.out.println("It's Method of Innerclass");}}
}

It's Method of OuterClass
It's Method of Innerclass

public class OuterClass {int num1 = 0;// 成员变量private void outerMethod() {int num2 = 0;// 方法内的局部变量class Innerclass_1 {public void innerMethod() {System.out.println(num1);// 方法中内部类的方法，可以正常访问外部类的成员变量System.out.println(num2);// JDK1.8以前，方法中内部类的方法，不能直接访问外部类的方法的局部变量，必须声明为final}}}
}

    private void outerMethod() {System.out.println("It's Method of OuterClass");Innerclass in = new Innerclass();//在外部类的outerMethod方法中实例化内部类是可以啊}

但在static方法中，就要注意啦！！！！不能在static方法中直接new内部类，否则出现错误：

public class OuterClass {private void outerMethod() {System.out.println("It's Method of OuterClass");}public static void main(String[] args) {Innerclass in = new Innerclass();in.innerMethod();}static class Innerclass {//把内部类声明为staticpublic void innerMethod() {System.out.println("It's Method of innerMethod");}}}

当然，一般不使用static的方式，而是推荐这种方法：x.new A() ，其中 x是外部类OuterClass的实例，A是内部类Innerclass

package innerclass;
public class OuterClass {private void outerMethod() {System.out.println("It's Method of OuterClass");}public static void main(String[] args) {OuterClass.Innerclass in = new OuterClass().new Innerclass();//使用x.new A()的方式in.innerMethod();}class Innerclass {public void innerMethod() {System.out.println("It's Method of innerMethod");}}
}

x.new A() ，其中 x是外部类OuterClass的实例，A是类部类Innerclass，当然可以拆分如下，这样就显然很明白啦：

    public static void main(String[] args) {OuterClass out = new OuterClass();//外部实例OuterClass.Innerclass in = out.new Innerclass();//外部实例.new 外部类in.innerMethod();}

package javatest2;
public class JavaTest2 {public static void main(String[] args) {class Boy implements Person {public void say() {// 匿名内部类自定义的方法saySystem.out.println("say方法调用");}@Overridepublic void speak() {// 实现接口的的方法speakSystem.out.println("speak方法调用");}}Person per = new Boy();per.speak();// 可调用per.say();// 不能调用}
}
interface Person {public void speak();
}

       per.speak()可调用，而per.say()不能调用，这时因为per是Person对象，要想调用子类的方法，可以强制向下转型为：((Boy) per).say();或者直接改为Boy per = new Boy();。从中可发现，要想调用内部类的自定义的方法，必须通过内部类的对象来调用。那么，匿名内部类连名字都没有，怎么调用内部类自定义的方法？

abstract class Father(){
....
}
public class Test{Father f1 = new Father(){ .... }  //这里就是有个匿名内部类
}

一般来说，new 一个对象时小括号后应该是分号，也就是new出对象该语句就结束了。但是出现匿名内部类就不一样，小括号后跟的是大括号，大括号中是该new 出对象的具体的实现方法。因为我们知道，一个抽象类是不能直接new 的，必须先有实现类了我们才能new出它的实现类。上面的伪代码就是表示new 的是Father的实现类，这个实现类是个匿名内部类。
    其实拆分上面的匿名内部类可为：

class SonOne extends Father{...       //这里的代码和上面匿名内部类，大括号中的代码是一样的
}
public class Test{Father f1 = new SonOne() ;
}

public class JavaTest2 {public static void main(String[] args) {Person per = new Person() {public void say() {// 匿名内部类自定义的方法saySystem.out.println("say方法调用");}@Overridepublic void speak() {// 实现接口的的方法speakSystem.out.println("speak方法调用");}};per.speak();// 可调用per.say();// 出错，不能调用}
}interface Person {public void speak();
}

这里per.speak()是可以正常调用的，但per.say()不能调用，为什么呢？注意Person per = new Person()创建的是Person的对象，而非匿名内部类的对象。其实匿名内部类连名字都没有，你咋实例对象去调用它的方法呢？但继承父类的方法和实现的方法是可以正常调用的，本例子中，匿名内部类实现了接口Person的speak方法，因此可以借助Person的对象去调用。

public class JavaTest2 {public static void main(String[] args) {new Person() {public void say() {// 匿名内部类自定义的方法saySystem.out.println("say方法调用");}@Overridepublic void speak() {// 实现接口的的方法speakSystem.out.println("speak方法调用");}}.say();// 直接调用匿名内部类的方法}
}
interface Person {public void speak();
}