Java-方法

一,方法(浅浅理解)

方法:用于执行特定的操作和任务(相当于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,(没有写 publicprivate 或 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)

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值