【JavaSE语法】类之间方法的调用（静态方法与非静态方法间的互相调用）

原创 已于 2026-02-07 22:21:24 修改 · 2.8k 阅读 · 16 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#java #开发语言
于 2023-10-10 02:35:03 首次发布
博客主要围绕Java类方法调用展开。指出在静态main方法中无法调用同类非静态内部类，可将其改为静态类。详细阐述了静态方法和非静态方法调用其他方法的规则，包括类内部和外部方法的调用方式，还提及了外部静态方法的导入及调用。

目录）

在静态main方法中无法调用同类里的内部类（非静态）

public class Code01_Trie {

    //该前缀树的路用数组实现
    class Trie{//前缀树类
 	}
    public static void main(String[] args) {
     Code01_Trie.Trie trie1 = new Code01_Trie.Trie();//错
     Trie trie1 = new Trie();//错，执行不了
     Code01_Trie trie1 = new Code01_Trie();//对，但调不到内部类
    }
}

解决方法，把内部类改为静态类

Java类之间方法的调用

一、静态方法调用其他方法

注意以下提到的类外的方法和变量，都是默认同包。除非明确提出包外

1.静态方法调用非静态方法

可见，不论是调用类内的非静态方法还是外部类的非静态方法，
在静态方法中调用的只要是非静态的变量或方法时只能用 对象名.方法名 调用。
对象只用一次的话可以用匿名对象
（1）静态方法调用类内的非静态变量/方法

public class Test01 {
    public void test01Method(){
        System.out.println("执行test01的非静态方法");
    }
    public static void main(String[] args) {
        //调用本类方法------------------------
        //错误调用非静态方法
        //test01Method();
        
        //匿名对象调用非静态方法
        new Test01().test01Method();//★
        
        //创建对象调用非静态方法
        Test01 t1 = new Test01();
        t1.test01Method();//★
    }
}

（2）静态方法中调用类外的非静态

public class Test02 {
    public void test02Method(){
        System.out.println("执行test02的非静态方法");
    }
}

public class Test01 {
    public static void main(String[] args) {
		//调用同包不同类方法-------------
        new Test02().test02Method();
        
        Test02 t2 = new Test02();
        t2.test02Method();//★
    }
}

（3）静态方法调用包外的非静态，import导包后同（2）

2.静态方法调用静态方法

类内部的静态方法可以直接调用，类外部的需要类名.静态方法名

  • （1）静态方法调用类内静态
public class Test02 {
    public static void test02StaticMethod(){
        System.out.println("执行test02的静态方法");
    }
    public static void main(String[] args) {
        //调类内部静态方法
        test02StaticMethod();//★
    }
}
  • （2）静态方法调用类外的静态
public class Test01 {
    public static void test01StaticMethod() {
        System.out.println("执行test01静态方法");
    }
}

public class Test02 {
    public static void main(String[] args) {
        //调用同包不同类的静态方法
        Test01.test01StaticMethod();//★
    }
}

二、非静态方法调用其他方法

1.非静态方法调用类内部方法

静态方法和非静态方法都直接调用即可

public class Test03 {
    public static void test03StaticMethod(){
        System.out.println("执行test03静态方法");
    }
    public void test03Method(){
        System.out.println("执行test03非静态方法");
    }
    
    public void method(){//非静态方法调用内部类方法
        test03StaticMethod();
        test03Method();
    }
    
    public static void main(String[] args) {
        new Test03().method();
    }

}

2. 非静态方法调用外部类方法

通过类对象调用该对象方法，通过类名调用静态方法
非静态方法调用外部非静态方法时，必须通过对象.方法名才可以调用。调用静态方法时，可以类.方法名也可以对象名.方法名。
但建议静态方法还是使用类名调用，以免与对象方法混淆，且编译期间也会把调用静态方法的对象名.方法名改为类名.方法名

public class Test03 {
    public static void test03StaticMethod(){
        System.out.println("执行test03静态方法");
    }
    public void test03Method(){
        System.out.println("执行test03非静态方法");
    }
}

public class Test04 {
    public void method(){//非静态方法调用外部类方法
        new Test03().test03Method();
        Test03.test03StaticMethod();
    }
    public static void main(String[] args) {
        new Test04().method();
    }
}

❤调用包外的情况

  1. 第一种导包，只导入到外包类的类名
    普通导包格式：import 包路径.类名称;方便new类对象，调用类对象的方法
    结构 如下，导包 import static_invoke.OutPack;
    这种导包情况下，使用时和调用同包外类的调用方法一样。
    在这里插入图片描述
package static_invoke;

/**
 * Created with IntelliJ IDEA 2024.1.4.
 * jdk 17.0.12
 *
 * @Authur: xuexuezi
 * @Date: 2026/01/27/下午9:40
 * @Description:
 */
public class OutPack {
    public int opNum = 5;
    public static int sOpNum = 6;
}


package static_invoke.non_static;

public class StaticInvoke {
    int exNum1 = 3;
    static int sExNUm2 = 4;


}

package static_invoke.non_static;
import static_invoke.OutPack;//包外
/*回忆：静态和非静态的互相调用写法
 * 1. 静态方法内的调用
 * 1) 要调非静态的，一律->new对象后调用该对象的非静态方法
 * 2-1)调静态的，内部的->直接调（即直接使用变量或方法）2-2) 同包不同类外部的->类名.静态 调用
 *
 * 2. 非静态方法内的调用
 * 1）类内部都是->直接调,不论静态或非静态
 * 2-1）调同包不同类的外部方法，非静态就 new 对象
 * 2-2）静态就类名.名*/


public class Main {

    /*设置了三组，静态和非静态变量。s开头都是非静态*/
    int num = 1;
    static int sNum = 2;

    public static void main(String[] args) {
        /*静态方法调用主要区分调用的是非静态还是静态*/
        System.out.println("静态方法main调用本类非静态" + new Main().num);
        //，多一个import导入外包的类OutPack
        StaticInvoke staticInvoke = new StaticInvoke();
        System.out.println("静态调用同包外类非静态" + staticInvoke.exNum1);
        ////必须import导入
        System.out.println("静态方法调用外包的非静态" + new OutPack().opNum);;

        //
        System.out.println("静态调用静态//内部类的" + sNum);
        //
        System.out.println("静态调用外类的" + StaticInvoke.sExNUm2);
        //外包的//前提有导包
        System.out.println("import导包后，静态调用外包的" + OutPack.sOpNum);

        System.out.println("-------------------非静态方法的调用------------------");
        new Main().testOutPack();
    }
    /*★*/
    void testOutPack(){
        /*非静态调用主要区分是内部还是外部*/
        //调内部,统一直接调
        System.out.println("类内非静态" + num);
        System.out.println("类内静态" + sNum);

        //调外部类
        System.out.println("调类外非静态" + new StaticInvoke().exNum1);
        System.out.println("调类外静态" + StaticInvoke.sExNUm2);

        //调用外包的，普通导包后一切调用规则都跟外部类的一样
        System.out.println("调外包的非静态"+ new OutPack().opNum);
        System.out.println("调用外包的静态" + OutPack.sOpNum);
    }
    

}

❤ 扩展，静态导入

  1. import static static_invoke.OutPack.*;
    解释：用.*时，表示导入类中的所有静态属性和方法。使用时，就像使用类内部的静态成员一样没有区别

  2. import static staitc_invoke.OutPack.sOpNum;
    用静态名称时，表示只导入该静态属性或方法。
    import static导入外部类的静态方法，在本类的静态方法中就可以直接调用，不用类名.方法名

注意！如图，只静态导入的话

  • 是无法使用外包类中的非静态成员的，只能使用OutPack的静态成员。
  • 并且无法使用类名，因为只是导入了该类的静态成员，并不是该类
    在这里插入图片描述
    静态导入的正确调用
package static_invoke.non_static;
//import static static_invoke.OutPack.sOpNum;
import static static_invoke.OutPack.*;

/**
 * Created with IntelliJ IDEA 2024.1.4.
 * jdk 17.0.12
 *
 * @Authur: xuexuezi
 * @Date: 2026/02/07/下午9:32
 * @Description:
 */
public class ImportMain {
    /*设置了三组，静态和非静态变量。s开头都是非静态*/
    int num = 1;
    static int sNum = 2;

    public static void main(String[] args) {
        /*静态方法调用主要区分调用的是非静态还是静态*/

        ////必须import导入
        //System.out.println("静态方法调用外包的非静态" + new OutPack().opNum);;

        //外包的//前提有导包
        System.out.println("import导包后，静态调用外包的" + sOpNum);/*★*/

        System.out.println("-------------------非静态方法的调用------------------");
        new Main().testOutPack();
    }
    
    void testOutPack(){
        /*非静态调用主要区分是内部还是外部*/

        //调用外包的，普通导包后一切调用规则都跟外部类的一样
        //❌️System.out.println("调外包的非静态"+ new OutPack().opNum);
        //❌️System.out.println("调用外包的静态" + OutPack.sOpNum);
        System.out.println("调用外包的静态" + sOpNum);/*★*/
    }

}
  • 例2
    静态导入同包外类的成员
    结果：该类的静态成员使用时不用再加类名
public class Test01 {
    public static void test01StaticMethod() {
        System.out.println("执行test01静态方法");
    }
}

//这两句导包写法都可以
//import static review.demo02.Test01.test01StaticMethod;
import static review.demo02.Test01.*;
public class Test02 {
    public static void test02StaticMethod(){
        System.out.println("执行test02的静态方法");
    }
    public void test02Method(){
        System.out.println("执行test02的非静态方法");
    }

    public static void main(String[] args) {
        //调类内部静态方法
        test02StaticMethod();
        
        //调用同包不同类的静态方法
        //若没有导入，写法应该是Test01.test01StaticMethod()
        test01StaticMethod();/*★*/

    }
}

例如：此处Test01和Test02类不在同一个包，所以普通导入和静态导入都可以做普通导包如果.*导入包内所有成员的话，功能是覆盖静态导入的。
若在同一个包，new类对象.普通方法不用导包，类名.静态方法名也不用导包。只是需要加类名
但想要直接调用静态方法不写类名，还是需要导包
在这里插入图片描述

总结

  • 非静态方法调用内部类方法：一律直接调

    • 非静态方法调用外部类方法：静态方法用类名.方法名。
    • 非静态方法用对象名.方法名。

  • 静态方法调用非静态方法：一律用对象.方法名。

    • 静态方法调用静态方法：内部类的方法直接调，
    • 外部类的方法用类名.方法名。
  • 关于导包
    • 如果是导包全部，即import 包路径.类名.*; 则这个包外部的类所有成员都相当于类内部的成员
    • 如果是静态导入 import static 包路径.类名.*;则是这个类所有静态成员都相当于类内部的静态成员，再配合上文的规律调用
告别重复劳动！用xdotool在Linux上实现自动化办公（附鼠标键盘模拟脚本）
最新发布
weixin_30892037的博客
03-31 1465
本文介绍了如何使用xdotool在Linux上实现自动化办公，通过模拟鼠标键盘操作来告别重复劳动。文章详细讲解了xdotool的安装、基础操作、实战案例以及高级技巧，帮助用户高效完成日常办公任务，提升工作效率。
JavaSE学习日志4（类与对象、类型转换、静态方法）
m0_73419206的博客
03-27 1049
法一：类型名 [] 数组名 = new 类型名[数量]例：String [ ] a = new String [3];//创建能存放3个String类型的数组法二：类型名 [] 数组名 = new 类型名[]{元素一、元素二、...}例：String [ ] a = new String []{"str","ddd","abc"};//创建能存放3个指定元素的String类型的数组法三：类型名 [ ] 数组名 ={元素一、元素二...}
静态方法中调用非静态方法
热门推荐
qq_45793102的博客
06-15 1万+
1、常见现象 静态static方法中不能直接调用非静态non-static方法，但可以通过将一个对象的引用传入静态方法内，进而再调用该对象的非静态（non-static）方法。其实，在主函数(static方法)中，我们经常需要创建某个类的实例，再利用引用调用其非静态方法。 2、代码说明 package com.ypj.java; import java.util.Stack; public class StackQueue { Stack<Integer> stack1
为什么静态成员不能访问非静态成员
augfun的博客
02-15 1306
首先static的成员是在类加载的时候初始化的，JVM的CLASSLOADER的加载，首次主动使用加载，而非static的成员是在创建对象的时候，即new 操作的时候才初始化的； 先后顺序是先加载，才能初始化，那么加载的时候初始化static的成员，此时非static的成员还没有被加载必然不能使用，而非static的成员是在类加载之后，通过new操作符创建对象的时候初始化，此时static 已经分配内存空间，所以可以访问！ 简单点说：静态成员属于类,不需要生成对象就存在了.而...
静态方法调用非静态方法
zealfory
12-27 1万+
静态方法不能（直接）调用非静态变量，非静态方法可以引用静态变量。 静态方法不属于对象，是属于类的，不需要实例化； 而非静态变量是属于对象的，需要先实例化。 在一个类的静态成员中去访问其非静态成员，因为类的静态成员先于类的非静态成员存在，访问一个内存中不存在的东西会出错。相反，非静态方法可以引用静态变量。 因为静态变量是存储在静态内存单元内，可以直接用类进行调用，也可以用实例化的对象对其引用。
java静态方法和非静态方法的互相调用
weixin_43615192的博客
04-21 562
静态方法属于类，而不属于类的实例。这意味着你可以在不创建类的实例的情况下调用静态方法。 另一方面，非静态方法属于类的实例，你需要创建类的实例才能调用它们。 以上代码中被注释掉的部分是错误的，未被注释掉的是可以使用的。
【JavaSE】之基础语法
小新要变强的博客
10-05 7492
Java基础语法介绍，注释，标识符和关键字，数据类型，类型转换，变量与常量，基本运算等~
JavaSE - 包、本类中如何调用其他类中的方法
Fighting！！！
08-15 4025
包、本类中如何调用其他类中的方法
JavaSE基础之静态方法
m0_57443189的博客
06-26 649
方法(method)：就是完成特定功能的代码块 isEvenNumber(int number)方法实现的功能是判断number是不是偶数，并且返回一个boolean类型的数据表示是不是偶数；main(String[] args)方法实现的功能是提供主方法入口，调用了isEvenNumber方法判断实参number是否为偶数，并在控制台打印判断结果；静态方法的调用方式有两种： 在同一包下的静态方法可以直接通过方法名调用，或者类名.方法名的形式调用，在不同包下的静态方法需要import导包 还有方法重载相关
【从入门到起飞】JavaSE—方法引用
小吉妙妙屋
09-22 2833
方法引用
static(静态方法中)如何调用非静态方法？
John_D_B_Lee的博客
03-14 1万+
静态方法也叫类方法，就是没有this的方法，方法属于类而不属于对象； 在静态方法的内部不能调用非静态方法，反过来倒是可以，可以在没有创建任何对象的前提下，仅仅通过类本身来调用静态方法。这正是static方法的主要用途。他很像全局方法，java中禁止使用全局方法，但你在类中置入static方法就可以访问其他static方法和static域， 使用static方法时，由于不存在this，所以不是通过”向对象发送消息“的方式来完成的。的确，要是在代码中出现了大量的static方法，就该重新考虑自己的设计了。 简单
静态/非静态方法调用本类/非本类的静态/非静态量的调用规则
maomaomao321的博客
02-20 1276
package project7; //静态和非静态方法调用本类与非本类的静态和非静态的规则 public class Static { //定义本类静态变量 public static int value=10; //定义本类非静态变量 public int var=20; //定义静态方法 public static void StaticFun3() { //这是待调用的静态方法 ...
非静态方法和静态方法相互调用的方式
weixin_34232744的博客
03-26 1051
2019独角兽企业重金招聘Python工程师标准>>> ...
Java 静态方法static调用非静态方法non-static
zhsihui429的博客
03-13 2196
非静态方法可直接调用静态方法 而静态方法(static) 无法直接调用非静态方法(non-static)，想要调用的话有以下两个做法： 把非静态方法改成静态方法 使用&lt;类名.方法名&gt;调用非静态方法 public class Static_test { public static void main(String[] args) { //Method1();//错误...
静态方法和非静态方法的调用
weixin_43582743的博客
04-22 1943
静态方法是属于类的，所以可以直接通过类名调用同一类中的其他静态方法，因此直接写`myStaticMethod2();`this`是当前对象的引用，可以省略不写，但使用`this`可以更加清晰地表达出当前方法是在操作当前对象的属性或方法。当你在同一个类的动态方法中调用静态方法时，Java虚拟机会首先在当前类中查找这个静态方法，然后进行调用。1.mian属于静态方法，所以我们先来研究静态方法如何使用静态方法（指同一类中的静态方法）4.怎么在动态方法中使用动态方法（指同一类中的动态方法）
[JavaSE]静态字段与静态方法
weixin_44431550的博客
06-14 244
静态字段与静态方法 提到静态，就跟关键字static密不可分。 静态字段 理解 首先，你可以在变量前加上关键字static。静态字段它只属于类，而不属于任何单个的对象，而对于非静态的实例字段，每个对象都有自己的一个副本。 例如： class Student{ private static String uniformColor = "black"; //校服颜色 private int score; //成绩 ... } 上例中，校服的颜色这个实例字段对于同一个学校的学生来说都是一样的。也就是
02-JavaSE基础语法
weixin_57982550的博客
01-15 1686
方法就是 一个带名字的能够解决特定问题的代码块 ，可以方便我们多次使用。方法是指人们在实践过程中为达到一定目的和效果所采取的办法、手段和解决方案。所谓方法，就是解决一类问题的代码的有序组合，是一个功能模块。编程语言中的方法是组合在一起来执行操作语句的集合。例如 System.out.println() 方法，该系统实际上是为了在控制台上输出的消息执行多条语句。定义递归头：什么时候不调用自身方法。如果没有头，将陷入死循环。递归体：什么时候需要调用自身方法以及自身需要做什么操作。
【JavaSE】接口的语法知识和使用方法总结
m0_73648729的博客
08-10 839
在现实生活中，接口的例子比比皆是，比如：笔记本上的USB口，电源插座等。电脑的USB口上，可以插：U盘、鼠标、键盘...所有符合USB协议的设备电源插座插孔上，可以插：电脑、电视机、电饭煲...所有符合规范的设备通过上述例子可以看出：接口就是公共的行为规范标准，大家在实现时，只要符合规范标准，就可以通用。 在Java中，接口可以看成是：多个类的公共规范，是一种引用数据类型。接口的定义格式与定义类的格式基本相同，将class关键字换成 interface 关键字，就定义了一个接口。 提示:1. 接口类型是一种
调用同一个类中的其他方法_【Java学习 | Javase】方法
weixin_39738755的博客
12-03 2765
整理自：动力节点Javase基础讲义、《Java核心技术》方法前言 方法的出现是为了实现代码的复用，对于功能性代码，我们希望不要重复写，而是独立出来，可以被重复的调用所以，方法是一段可以完成某个特定功能并且可以被重复利用的代码片段方法定义 语法格式：[修饰符列表] 返回值类型 方法名(形参列表)[throws 异常列表]{方法体;}若方法有返回值，则Java语法要求方法必须能够“百分百...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值