内部类如何调用外部类的方法

直接上代码

public class test{
	public static void main(String[] args) {
		Outer.Inner  p=new Outer().new Inner(); 
	    p.show();
	
 }
}
 class Outer{
	 int sum;
	 class Inner{
		 public void show(){
			 System.out.println("这是内部类的方法");
			 Outer.this.test();      //在内部类的方法中，直接外部类的名字+this+外部类方法名
		 }
	 }
	 public void test(){      
		System.out.println("这是一个外部类方法");
	 }
 }

新手，多多理解，多多交流。

内部类调用外部类的方法 

public class test{
	public static void main(String[] args) {
		Outer.Inner  p=new Outer().new Inner(); 
	    p.show();
	
 }
}
class Outer{
    int sum;
    //在Outer类中声明一个内部类Inner
    class Inner{
        public void show(){
            System.out.println("这是内部类的方法");
            //在内部类的方法中调用外部类的方法：直接外部类的名字+this+外部类方法名
            Outer.this.test();
        }
    }
    public void test(){      
        System.out.println("这是一个外部类方法");
    }
}

外部调用内部类的方法

1. 使用static可以声明一个内部类， 可以直接在外部调用

// 定义外部类
public class Outer{
    // 定义外部类的私有属性 info
    private static String info = "hello world";
    // 定义外部类的方法
    public void fun(){
        // 通过内部类的实例化对象调用内部类的方法
        new Inner().print();
    }
    // 使用static定义内部类
    static class Inner{
        // 定义内部类的方法
        public void print(){
            // 直接访问外部类的私有属性
            System.out.println(info);
        }
    };
};
public class test{
    public static void main(String args[]){
        new Outer.Inner().print();  // 调用外部类的fun()方法
    }
};

2. 不使用statc声明一个内部类 ，使外部调用

//定义外部类
class Outer{
    // 定义外部类的私有属性
    private String info = "hello world";
    // 定义外部类的方法
	public void fun(){
        // 通过内部类的实例化对象调用方法
		new Inner().print();
	}
    // 定义内部类
    class Inner{
        // 定义内部类的方法
        public void print(){
            // 直接访问外部类的私有属性
            System.out.println(info);
        }
    };
};
public class test{
	public static void main(String args[]){
        // 外部类实例化对象
		Outer out = new Outer();
        // 内部类实例化对象
		Outer.Inner in = out.new Inner();
        // 调用内部类的方法
		in.print();
	}
};

3. 在方法中定义内部类 ，使外部调用

// 定义外部类
class Outer{
    // 定义外部类的私有属性
	private String info = "hello world";
    // 定义外部类的方法
	public void fun(final int temp){
        // 在方法中定义的内部类
		class Inner{
            // 定义内部类的方法
			public void print(){
                // 直接访问外部类的私有属性
				System.out.println("外部类的属性：" + info);
				System.out.println("外部类的方法中的参数：" + temp) ;
			}
		};
        // 通过内部类的实例化对象调用方法
		new Inner().print();
	}
};
public class InnerClassDemo05{
	public static void main(String args[]){
        // 调用外部类的方法
		new Outer().fun(30);
	}
};

一、 Java内部类分类：

1.非静态成员内部类：

内部类没有使用static关键字修饰，并且和外部类的成员变量和方法属于同一级别，这样的是非静态成员内部类（可以使用权限修饰符修饰，和final、abstract关键字修饰）。

public class Atest {
   private String name = "张三";
   //类没有用static修饰
   class Btest{
       public void say(){
           System.out.println("我是非静态成员内部类");
       }
   }
}

2.静态成员内部类：

内部类使用static关键字修饰，并且和外部类的成员变量和方法属于同一级别，这样的是静态成员内部类（可以使用权限修饰符修饰，和final、abstract关键字修饰）。

public class Atest {

  public static String name = "张三";
  public String age = "23";
  
  static class Btest{
      public void say(){
          System.out.println("外部成员变量，name = " + name);
          System.out.println("我是静态成员内部类");
//            不可以调用非静态
//            System.out.println("外部成员变量，age = " + age);
      }
  }
}

3.局部内部类：

定义在一个类的成员方法、代码块、构造器内部的类，这样的类成为局部内部类（不能使用权限修饰符修饰局部内部类）。

public class Atest {
 
 public void execute(){
     class Dtest{

     }
 }
}

4.匿名内部类：

匿名内部类是没有类名的类，是特殊的局部内部类。
（匿名内部类需要实现接口或是继承一个抽象类，此外匿名内部类不能定义构造器,因为是匿名）
局部内部类实现接口：

public class Atest {

  public static String name = "张三";
  public String age = "23";
  

  public void execute(){
      class MyInterface implements TestInterface{

          @Override
          public void play() {
              System.out.println(name + "在打篮球");
          }
      }
  }

}
interface TestInterface{
  void play();
}

可以简化成匿名内部类：

public class Atest {

    public static String name = "张三";
    public String age = "23";


    public void execute(){
        TestInterface myInterface = new TestInterface(){

            @Override
            public void play() {
                System.out.println("这是匿名内部类");
            }
        };
        myInterface.play();
    }

}
interface TestInterface{
    void play();
}

二、 内部类如何实例化：

1.实例化非静态成员内部类：

public class Atest {

    public static String name = "张三";
    public String age = "23";


    class Btest{

        public void say(){
            System.out.println("测试非静态成员内部类实例化");
        }
    }

}

public class MainTest {

    public static void main(String[] args) {
        //非静态成员内部类实例化
        //1.实例化外部类
        Atest atest = new Atest();
        //2.实例化内部类
        Atest.Btest btest = atest.new Btest();
        btest.say();
    }
}

2.实例化静态成员内部类：

public class Atest {

  public static String name = "张三";
  public String age = "23";


  static class Ctest{

      public void say(){
          System.out.println("测试静态成员内部类实例化");
      }
  }

}

public class MainTest {

    public static void main(String[] args) {
        //静态成员内部类实例化
        Atest.Ctest ctest = new Atest.Ctest();
        ctest.say();
    }
}

三、 内部类如何调用外部类属性与方法：

public class Atest {

    public static String name = "张三";
    public String age = "23";


    class Btest{
        public String age = "22";

        public void say(String age){
            System.out.println("我是输出的形参参数，age = " + age);
            System.out.println("我是输出的Btest类成员变量，age = " + this.age);
            System.out.println("我是输出的Atest类成员变量，age = " + Atest.this.age);
        }
    }

}

执行主方法：

public class MainTest {

    public static void main(String[] args) {
        //静态成员内部类实例化
        Atest atest = new Atest();
        Atest.Btest btest = atest.new Btest();
        btest.say("18");
    }
}

输出结果：

我是输出的形参参数，age = 18
我是输出的Btest类成员变量，age = 22
我是输出的Atest类成员变量，age = 23