如何调用内部类中的静态方法

Posted 2023-04-23

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了如何调用内部类中的静态方法相关的知识，希望对你有一定的参考价值。

参考技术A 一般来说，外部类调用内部类的方法分为以下几种情况：
1.使用static可以声明一个内部类，可以直接在外部调用

// 定义外部类
class Outer

// 定义外部类的私有属性
private static String info = "hello world";
// 使用static定义内部类为外部类
static class Inner

// 定义内部类的方法
public void print()

// 直接访问外部类的私有属性
System.out.println(info);

;

// 定义外部类的方法
public void fun()

// 通过内部类的实例化对象调用方法
new Inner().print();

;

public class InnerClassDemo03

public static void main(String args[])

// 调用外部类的fun()方法
new Outer.Inner().print() ;

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

//定义外部类
class Outer

//定义外部类的私有属性
private String info = "hello world";
//定义内部类
class Inner

//定义内部类的方法
public void print()

//直接访问外部类的私有属性
System.out.println(info);

;
//定义外部类的方法
public void fun()

//通过内部类的实例化对象调用方法
new Inner().print();

;

内部类和外部类之间的相互调用

内部类：

①静态内部类中可以有非静态的方法

②当内部类中有静态方法或者静态成员变量时，一定是静态内部类

一般内部类在外部类的成员变量位置，像这样：

1 public class Outer {
2     class Inner{
3         
4     }
5 }

1、外部类访问内部类：

　　　内部类被static修饰：可以直接new

　　　　Inner in = new Inner();

　　　内部类没有被static修饰:得先new出来外部类的实例，再new内部类的

　　　　Inner in = new Outer().new Inner();

2、内部类访问外部类：（外部类.this.变量）

 1 public class Outer {
 2     int x = 9;
 3     class Inner{
 4         int x = 8;
 5         public void test(){
 6             int x = 7;
 7             System.out.println(x);
 8             System.out.println(this.x);
 9             System.out.println(Outer.this.x);
10             test1();
11         }
12     }
13     
14     private void test1(){
15         System.out.println("test");
16     }
17     public static void main(String[] args) {
18         Inner in = new Outer().new Inner();
19         in.test();
20     }
21 }

输出为：7，8，9，test

分析：第七行第八行相信大家都没有什么问题，第九行输出的是9，说明访问到了外部类的变量，而输出的test说明内部类访问到了外部类的test1方法

总结：

　　输出是9的原因：因为内部类持有一个外部类的引用，格式：外部类名.this

　　可以调用private方法原因是：因为他们在一个类Outer中所以可以调用

3、外部类和内部类中的方法相互访问：

①外部类的静态方法test和非静态内部类的非静态方法voice的相互访问：

! test----->voice 先new外类再new内类，再调方法

 1 public class Outerclass {
 2     class Inner{
 3         public void voice(){
 4             System.out.println("voice()");
 5         }
 6     }
 7     public static void test(){
 8         new Outerclass().new Inner().voice();
 9     }
10     public static void main(String[] args) {
　　　　　　//主函数调用test方法
11        test();13     }
14 }

输出：voice();

!! voice----->test 外类.this.方法（持有的外部类的引用）

 1 public class Outerclass {
 2     class Inner{
 3         public void voice(){
 4             Outerclass.this.test();
 5         }
 6     }
 7     public static void test(){
 8         System.out.println("test()");
 9     }
10     public static void main(String[] args) {
　　　　//主函数调用voice()
11         Inner in = new Outerclass().new Inner();
12         in.voice();
13     }
14 }

输出：test();

②外部类的非静态方法test和静态内部类中的非静态方法voice之间的相互调用

　! voice------>test

 1 public class Outerclass {
 2     static class Inner{
 3         public void voice(){
 4             new Outerclass().test();
 5         }
 6     }
 7     public void test(){
 8         System.out.println("test()");
 9     }
10     public static void main(String[] args) {
　　　　//主函数调用voice()方法
11         new Outerclass.Inner().voice();
12     }
13 }

输出：test();

!! test----->voice

 1 public class Outerclass {
 2     static class Inner{
 3         public void voice(){
 4             System.out.println("voice()");
 5         }
 6     }
 7     public void test(){
　　　　　　//1、其他类访问外部类中的静态内部类的非静态方法
 8        // new Outerclass.Inner().voice();
　　　　　　//2、此处的Outerclass中的test方法访问静态内部类中的非静态方法
　　　　　　 new Inner().voice();
 9     }
10     public static void main(String[] args) {
　　　　　　//主函数调用test方法
11         new Outerclass().test();
12     }
13 }