对day4做的一个复习
文章目录
- 1. 声明的格式
-
- 1.1 有返回值的方法
- 1.2 无返回值的方法 (void)
- 1.3 带有参数的方法
- 1.4 没有参数的方法
- 2. 调用格式
-
- 2.1 静态方法调用
- 2.2 实例方法调用
- 3. 方法的重载
-
- 3.1 参数个数不同的重载
- 3.2 参数类型不同的重载
- 3.3 参数顺序不同的重载
1. 声明的格式
1.1 有返回值的方法
这些方法会返回一个值，返回类型是某种数据类型（如 int、String、double 等）。
例子1：返回整数的加法方法
public class MethodExample {
// 返回整数的加法方法
public static int add(int a, int b) {
return a + b;
}
public static void main(String[] args) {
int result = add(5, 10);
System.out.println("Sum: " + result); // 输出 Sum: 15
}
}
例子2：返回字符串的拼接方法
public class MethodExample {
// 返回拼接后的字符串
public static String concatenate(String str1, String str2) {
return str1 + " " + str2;
}
public static void main(String[] args) {
String result = concatenate("Hello", "World");
System.out.println(result); // 输出 Hello World
}
}
例子3：返回浮点数的平方根
public class MethodExample {
// 返回浮点数的平方根
public static double sqrt(double num) {
return Math.sqrt(num);
}
public static void main(String[] args) {
double result = sqrt(16.0);
System.out.println("Square root: " + result); // 输出 Square root: 4.0
}
}
1.2 无返回值的方法 (void)
这些方法没有返回值，通常用于执行某些操作或打印信息。
例子1：打印问候语的方法
public class MethodExample {
// 无返回值的方法，打印问候语
public static void greet() {
System.out.println("Hello, Java!");
}
public static void main(String[] args) {
greet(); // 输出 Hello, Java!
}
}
例子2：打印数字的方法
public class MethodExample {
// 无返回值的方法，打印给定数字
public static void printNumber(int num) {
System.out.println("The number is: " + num);
}
public static void main(String[] args) {
printNumber(100); // 输出 The number is: 100
}
}
例子3：结束程序的方法
public class MethodExample {
// 无返回值的方法，结束程序
public static void terminate() {
System.out.println("Terminating program...");
System.exit(0);
}
public static void main(String[] args) {
terminate(); // 输出 Terminating program... 并结束程序
}
}
1.3 带有参数的方法
这些方法带有一个或多个参数，执行时会根据传入的参数进行不同的处理。
例子1：计算两个数的和的方法
public class MethodExample {
// 带有参数的方法，计算两个数的和
public static int add(int a, int b) {
return a + b;
}
public static void main(String[] args) {
int result = add(10, 20); // 传入参数 10 和 20
System.out.println("Sum: " + result); // 输出 Sum: 30
}
}
例子2：打印个人信息的方法
public class MethodExample {
// 带有参数的方法，打印个人信息
public static void printInfo(String name, int age) {
System.out.println("Name: " + name + ", Age: " + age);
}
public static void main(String[] args) {
printInfo("Alice", 25); // 传入参数 "Alice" 和 25
}
}
例子3：判断一个数是否为负数
public class MethodExample {
// 带有参数的方法，判断一个数是否为负数
public static boolean isNegative(int num) {
return num < 0;
}
public static void main(String[] args) {
boolean result = isNegative(-5); // 传入参数 -5
System.out.println("Is negative? " + result); // 输出 Is negative? true
}
}
1.4 没有参数的方法
这些方法不接受任何参数，通常用于执行固定任务或输出信息。
例子1：打印固定消息的方法
public class MethodExample {
// 没有参数的方法，打印固定消息
public static void printMessage() {
System.out.println("This is a message!");
}
public static void main(String[] args) {
printMessage(); // 输出 This is a message!
}
}
例子2：展示当前时间的方法
import java.time.LocalTime;
public class MethodExample {
// 没有参数的方法，打印当前时间
public static void showTime() {
LocalTime time = LocalTime.now();
System.out.println("Current time: " + time);
}
public static void main(String[] args) {
showTime(); // 输出当前时间
}
}
例子3：无操作的方法
public class MethodExample {
// 没有参数的方法，不执行任何操作
public static void doNothing() {
// 什么也不做
}
public static void main(String[] args) {
doNothing(); // 什么也不会输出
}
}
2. 调用格式
2.1 静态方法调用
静态方法属于类本身，因此可以通过类名直接调用，而不需要实例化对象。
例子1：静态方法计算两个数的和
public class MathUtils {
// 静态方法：计算两个数的和
public static int add(int a, int b) {
return a + b;
}
public static void main(String[] args) {
// 通过类名直接调用静态方法
int result = MathUtils.add(5, 10);
System.out.println("Sum: " + result); // 输出 Sum: 15
}
}
例子2：静态方法计算圆的面积
public class Geometry {
// 静态方法：计算圆的面积
public static double calculateArea(double radius) {
return Math.PI * radius * radius;
}
public static void main(String[] args) {
// 通过类名调用静态方法
double area = Geometry.calculateArea(5);
System.out.println("Area: " + area); // 输出 Area: 78.53981633974483
}
}
例子3：静态方法打印欢迎信息
public class Welcome {
// 静态方法：打印欢迎信息
public static void printWelcomeMessage() {
System.out.println("Welcome to Java Programming!");
}
public static void main(String[] args) {
// 通过类名直接调用静态方法
Welcome.printWelcomeMessage(); // 输出 Welcome to Java Programming!
}
}
2.2 实例方法调用
实例方法属于类的对象，调用时需要先创建对象，再通过该对象调用实例方法。
例子1：实例方法计算两数之和
public class Calculator {
// 实例方法：计算两数之和
public int add(int a, int b) {
return a + b;
}
public static void main(String[] args) {
// 创建对象
Calculator calculator = new Calculator();
// 通过对象调用实例方法
int result = calculator.add(5, 10);
System.out.println("Sum: " + result); // 输出 Sum: 15
}
}
例子2：实例方法打印学生信息
public class Student {
// 实例方法：打印学生信息
public void printStudentInfo(String name, int age) {
System.out.println("Student Name: " + name + ", Age: " + age);
}
public static void main(String[] args) {
// 创建对象
Student student = new Student();
// 通过对象调用实例方法
student.printStudentInfo("Alice", 22); // 输出 Student Name: Alice, Age: 22
}
}
例子3：实例方法判断数字是否为负数
public class NumberUtils {
// 实例方法：判断数字是否为负数
public boolean isNegative(int num) {
return num < 0;
}
public static void main(String[] args) {
// 创建对象
NumberUtils utils = new NumberUtils();
// 通过对象调用实例方法
boolean result = utils.isNegative(-5);
System.out.println("Is negative? " + result); // 输出 Is negative? true
}
}
3. 方法的重载
3.1 参数个数不同的重载
当方法的参数个数不同时，Java 会将它们视为不同的方法。即使方法名相同，只要参数的数量不同，Java 也会识别为不同的方法。
例子1：加法方法，接受不同数量的参数
public class Calculator {
// 加法方法，接受两个整数
public int add(int a, int b) {
return a + b;
}
// 加法方法，接受三个整数
public int add(int a, int b, int c) {
return a + b + c;
}
public static void main(String[] args) {
Calculator calc = new Calculator();
System.out.println("Sum of 2 numbers: " + calc.add(5, 10)); // 输出 15
System.out.println("Sum of 3 numbers: " + calc.add(5, 10, 15)); // 输出 30
}
}
例子2：打印字符串，接受不同数量的参数
public class Printer {
// 打印单个字符串
public void print(String text) {
System.out.println(text);
}
// 打印两个字符串
public void print(String text1, String text2) {
System.out.println(text1 + " " + text2);
}
public static void main(String[] args) {
Printer printer = new Printer();
printer.print("Hello");
printer.print("Hello", "World");
}
}
例子3：计算圆的面积，接受不同数量的参数
public class Circle {
// 计算圆的面积，接受一个半径参数
public double calculateArea(double radius) {
return Math.PI * radius * radius;
}
// 计算圆的面积，接受半径和直径两个参数
public double calculateArea(double radius, double diameter) {
return Math.PI * (diameter / 2) * (diameter / 2);
}
public static void main(String[] args) {
Circle circle = new Circle();
System.out.println("Area with radius: " + circle.calculateArea(5)); // 输出 78.53981633974483
System.out.println("Area with diameter: " + circle.calculateArea(5, 10)); // 输出 78.53981633974483
}
}
3.2 参数类型不同的重载
当方法的参数类型不同（即使数量相同）时，Java 也会将它们视为不同的方法。
例子1：加法方法，接受不同类型的参数
public class Calculator {
// 加法方法，接受两个整数
public int add(int a, int b) {
return a + b;
}
// 加法方法，接受两个浮点数
public double add(double a, double b) {
return a + b;
}
public static void main(String[] args) {
Calculator calc = new Calculator();
System.out.println("Sum of 2 integers: " + calc.add(5, 10)); // 输出 15
System.out.println("Sum of 2 doubles: " + calc.add(5.5, 10.5)); // 输出 16.0
}
}
例子2：打印不同类型的数据
public class Printer {
// 打印整数
public void print(int num) {
System.out.println("Integer: " + num);
}
// 打印浮点数
public void print(double num) {
System.out.println("Double: " + num);
}
public static void main(String[] args) {
Printer printer = new Printer();
printer.print(10); // 输出 Integer: 10
printer.print(10.5); // 输出 Double: 10.5
}
}
例子3：检查一个对象的类型
public class Checker {
// 检查整数
public void checkType(int num) {
System.out.println("This is an integer: " + num);
}
// 检查字符串
public void checkType(String str) {
System.out.println("This is a string: " + str);
}
public static void main(String[] args) {
Checker checker = new Checker();
checker.checkType(100); // 输出 This is an integer: 100
checker.checkType("Hello World"); // 输出 This is a string: Hello World
}
}
3.3 参数顺序不同的重载
即使方法的参数类型和数量相同，参数的顺序不同，也可以认为是重载的方法。Java 会根据调用时传入的参数顺序来决定调用哪个版本的方法。
例子1：加法方法，参数顺序不同
public class Calculator {
// 加法方法，先接受两个整数，再接受一个浮点数
public double add(int a, int b, double c) {
return a + b + c;
}
// 加法方法，先接受一个浮点数，再接受两个整数
public double add(double a, int b, int c) {
return a + b + c;
}
public static void main(String[] args) {
Calculator calc = new Calculator();
System.out.println("Sum with different order: " + calc.add(5, 10, 2.5)); // 输出 17.5
System.out.println("Sum with different order: " + calc.add(2.5, 5, 10)); // 输出 17.5
}
}
例子2：打印姓名，顺序不同
public class Printer {
// 打印姓名，先接受姓名和年龄
public void print(String name, int age) {
System.out.println("Name: " + name + ", Age: " + age);
}
// 打印姓名，先接受年龄和姓名
public void print(int age, String name) {
System.out.println("Age: " + age + ", Name: " + name);
}
public static void main(String[] args) {
Printer printer = new Printer();
printer.print("Alice", 22); // 输出 Name: Alice, Age: 22
printer.print(22, "Alice"); // 输出 Age: 22, Name: Alice
}
}
例子3：打印坐标，顺序不同
public class Coordinate {
// 打印坐标，先接受 x 和 y
public void printCoordinates(int x, int y) {
System.out.println("X: " + x + ", Y: " + y);
}
// 打印坐标，先接受 y 和 x
public void printCoordinates(int y, int x) {
System.out.println("Y: " + y + ", X: " + x);
}
public static void main(String[] args) {
Coordinate coordinate = new Coordinate();
coordinate.printCoordinates(10, 20); // 输出 X: 10, Y: 20
coordinate.printCoordinates(20, 10); // 输出 Y: 20, X: 10
}
}