Java-方法_java 的方法-优快云博客

本文链接：https://blog.youkuaiyun.com/ws262/article/details/147528469

一，方法(浅浅理解）

方法：用于执行特定的操作和任务（相当于c语言中的函数）

定义：[ 修饰符 ] 返回值类型⽅法名称 ([ 参数类型形参 ...])

{ ⽅法体代码 ;

[return 返回值 ];

}

注：

1.[ ]内的可以没有

2.在Java当中，⽅法必须写在类当中

public class Text//类 {
// 定义一个计算三个数的和的方法
    public static int add(int x,int y,int z){
        return x+y+z;
    }
    public static void main(String[] args){
//调用方法
       int result= add(1,2,3);
        System.out.println(result);
    }

1.1方法的调用

在Method类中，有一个add方法

public class Method {
    // 方法的定义
    public static int add(int x, int y) {
        return x + y;
    }

    public static void main(String[] args) {
        // 方法的调用
        int result = add(3, 5); // 调用add方法，传入3和5
        System.out.println("结果是：" + result); // 会输出"结果是：8"
    }
}

注意：

1.方法名要完全匹配

2.参数要匹配（包括类型和个数）

3.静态方法的调用：

因为add方法是static的，所以可以直接用类名调用（在同一个类中可以省略类名）

int result = Method.add(3, 5); // 也可以这样调用

4.接收返回值

5.调用位置（放在其他方法内部（如main方法），不能直接写在类里）

6.打印结果

`1）public` 是 Java 中的一个访问修饰符（Access Modifier），它决定了谁可以调用这个方法

当一个方法被声明为 `public`，意味着：让任何类都能调用这个方法（不管是不是同一个包）。但前提是类的访问权限也允许。例如，如果类本身是`public`的，其他包才能访问它内部的`public`方法；如果类是默认修饰符（非`public`），即使方法是`public`的，其他包也无法访问。

package com.utils;
class HiddenUtils { // 默认修饰符（包私有）
    public static void foo() {} // 即使方法是public，其他包也无法访问
}

不同类调用：

如：public class Calculator {
    // public 方法：任何类都能调用
    public static int add(int a, int b) {
        return a + b;
    }
}

public class Main {
    public static void main(String[] args) {
        int result = Calculator.add(3, 5); //  可以调用，因为 add 是 public
        System.out.println("结果是：" + result);
    }
}

不同包调用，需要正确导入类（使用 `import` 语句）

src/
├── com/example/
│   └── PackageA/
│       └── MyClassA.java
└── com/another/
    └── PackageB/
        └── MyClassB.java



在 MyClassA.java 中定义一个 public 方法
package com.example.PackageA;

public class MyClassA {
    public void publicMethod() {
        System.out.println("This is a public method.");
    }
}


在 MyClassB.java（不同包）中调用 publicMethod()
package com.another.PackageB;

import com.example.PackageA.MyClassA;  // 导入 MyClassA

public class MyClassB {
    public static void main(String[] args) {
        MyClassA obj = new MyClassA();
        obj.publicMethod();  // 可以调用，因为方法是 public 的
    }
}

静态导入

在 MyClassB.java（不同包）中调用 publicMethod()
package com.another.PackageB;

import static com.example.PackageA.MyClassA.publicMethod;  // 静态导入 MyClassA

public class MyClassB {
    public static void main(String[] args) {
      
        publicMethod();  // 可以调用，因为方法是 public 的
    }
}

方法没有写 `public`，默认是 `包级私有`（`package-private`），即：只有同一个包（package）（文件夹）里的类才能调用它。其他包的类（class）不能调用。

class Calculator {
    // 默认（没有 public）：只有同一个包的类能调用
    static int add(int a, int b) {
        return a + b;
    }
}


如果另一个包的类尝试调用：
import somepackage.Calculator;

public class Main {
    public static void main(String[] args) {
        int result = Calculator.add(3, 5); // ❌ 编译错误！不能访问！
    }
}

2）修饰符

Java 提供了四种访问权限修饰符，体现了不同层次的封装控制：

修饰符	同类	同包	子类（不同包）	其他包（全局）
`private`	✅	❌	❌	❌
默认（无修饰符）	✅	✅	❌	❌
`protected`	✅	✅	✅	❌
`public`	✅	✅	✅	✅

3）`static` 的作用

方法中有static

让方法变成“类方法”，而不是“对象方法”。即：static 方法属于类本身，而不是对象
不需要创建对象，直接用 类名.方法名() 调用，如果是在同一个包同一类中，可以直接方法名（）调用
比如 Math.random() 是 static 方法，所以我们可以直接 Math.random()，而不用 new Math()

public class Calculator {
    public static int add(int a, int b) {
        return a + b;
    }

    public static void main(String[] args) {
        int result = add(3, 5);  // 省略 Calculator.，直接写 add()
        System.out.println(result);
    }
}

方法只有static，（没有写 `public`、`private` 或 `protected`），那么它的访问权限是默认的（包级私有，`package-private`）（只有同一个包（package）里的类能调用它，其他包的类不能调用），但它的调用方式仍然是静态方法的方式（不需要创建对象，直接用 `类名.方法名()` 调用，但只能在同一个包的类里调用）

package com.example;

class MathUtils {
    // 只有 static，没有 public → 包级私有
    static int add(int a, int b) {
        return a + b;
    }
}

package com.example;  // 同一个包

public class Main {
    public static void main(String[] args) {
        int result = MathUtils.add(3, 5); // ✅ 可以调用（同一个包）
        System.out.println(result); // 输出 8
    }
}

方法中没有static

必须创建对象才能调用方法。
如果方法没有 static，就不能直接 类名.方法名() 调用，需要创建对象

public class Calculator {
    // 没有 static → 必须用对象调用
    public int add(int a, int b) {
        return a + b;
    }
}
调用时：
public class Main {
    public static void main(String[] args) {
        int result = Calculator.add(3, 5); // ❌ 错误！不能直接调用！
        
        // 正确做法：先 new 一个对象
        Calculator calc = new Calculator();
        int result = calc.add(3, 5); // ✅ 这样才行！
    }
}

public class Calculator {
    public int add(int a, int b) {  // 非 static 方法
        return a + b;
    }

    public static void main(String[] args) {
        Calculator calc = new Calculator(); // 必须先创建对象
        int result = calc.add(3, 5);       // 用对象调用方法
        System.out.println(result);        // 输出 8
    }
}

4）`public static` 组合起来的效果

✅ 任何包（任何类）都可以直接调用，不需要创建对象。

public class Calculator {
    // public + static：任何类都能直接调用，不用 new Calculator()
    public static int add(int a, int b) {
        return a + b;
    }
}



其他类可以这样调用：
public class Main {
    public static void main(String[] args) {
        int result = Calculator.add(3, 5); // ✅ 直接调用！
        System.out.println("结果是：" + result);
    }
}

3）. 4）总结

static （非访问修饰符）用于定义成员的存储方式（类级 vs 实例级）作用：表示成员属于类本身（而非类的实例），或用于静态代码块/静态导入。效果：静态成员（变量/方法）可直接通过类名访问，无需创建对象。
public → 访问控制（谁可以访问）
static → 内存分配方式（属于类还是对象）