一,方法(浅浅理解)
方法:用于执行特定的操作和任务(相当于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
→ 内存分配方式(属于类还是对象)
1.2方法参数注意事项
void invalidMethod(int a, String... names, double b)
(可变参数不在最后)
String... names
是可变参数(可以接受 0 个或多个String
参数)。- 但后面又跟了一个固定参数
double b
,这违反了 Java 的语法规则。
Java 规定:如果方法有可变参数,它必须是参数列表中的最后一个参数。
因为可变参数本质上是一个数组,编译器需要明确知道参数列表在哪里结束。如果可变参数后面还有其他参数,编译器无法区分传入的值属于可变参数还是后面的固定参数。
正确写法:void invalidMethod(int a, double b,String... names)