花几千上万学习Java，真没必要！（十五）

1、基本数据类型传递：

测试代码1：

package overload.com;
//基本类型（如int、double、char、boolean等）作为参数传递给方法时，是通过值传递的方式进行的。
//方法接收的是参数值的一个副本，而不是参数的原始引用或地址。
//因此，在方法内部对参数值的任何修改都不会影响到方法外部的原始变量。
public class BasicTypeParameterPassing {  
  
    // 一个方法，接收一个int类型的参数  
    public static void modifyInt(int number) {  
        // 尝试修改参数的值  
        number = number + 10;  
        // 这里的修改只影响到了number这个副本，原始的变量不会受到影响  
        System.out.println("Inside method: " + number);  
    }  
  
    // 主方法  
    public static void main(String[] args) {  
        int originalNumber = 5;  
        System.out.println("Before method call: " + originalNumber);  
  
        // 调用方法，传递originalNumber作为参数  
        modifyInt(originalNumber);  
  
        // 检查originalNumber的值是否发生了变化  
        System.out.println("After method call: " + originalNumber);  
        // 输出将显示originalNumber的值没有变化，因为传递的是值而不是引用  
    }  
}

运行结果如下：

测试代码2：

package overload.com;
public class BasicTypesDemo {  
	  
    public static void main(String[] args) {  
        byte byteValue = 1;  
        short shortValue = 2;  
        int intValue = 3;  
        long longValue = 4L;  
        char charValue = 'a';  
        float floatValue = 5.5f;  
        double doubleValue = 6.6;  
        boolean booleanValue = true;  
  
        System.out.println("Before method call:");  
        System.out.println("byteValue: " + byteValue);  
        System.out.println("shortValue: " + shortValue);  
        System.out.println("intValue: " + intValue);  
        System.out.println("longValue: " + longValue);  
        System.out.println("charValue: " + charValue);  
        System.out.println("floatValue: " + floatValue);  
        System.out.println("doubleValue: " + doubleValue);  
        System.out.println("booleanValue: " + booleanValue);  
  
        modifyValues(byteValue, shortValue, intValue, longValue, charValue, floatValue, doubleValue, booleanValue);  
  
        System.out.println("\nAfter method call:");  
        System.out.println("byteValue: " + byteValue);  
        System.out.println("shortValue: " + shortValue);  
        System.out.println("intValue: " + intValue);  
        System.out.println("longValue: " + longValue);  
        System.out.println("charValue: " + charValue);  
        System.out.println("floatValue: " + floatValue);  
        System.out.println("doubleValue: " + doubleValue);  
        System.out.println("booleanValue: " + booleanValue);  
    }  
  
    public static void modifyValues(byte b, short s, int i, long l, char c, float f, double d, boolean bool) {  
        b = 10; // 修改对byteValue无影响  
        s = 20; // 修改对shortValue无影响  
        i = 30; // 修改对intValue无影响  
        l = 40L; // 修改对longValue无影响  
        c = 'z'; // 修改对charValue无影响  
        f = 50.5f; // 修改对floatValue无影响  
        d = 60.6; // 修改对doubleValue无影响  
        bool = false; // 修改对booleanValue无影响  
  
        // 只是修改了方法内部的变量副本，并没有影响到main方法中的原始变量  
        System.out.println("\n方法内部的变量值:"); 
        System.out.println("byteValue: " + b);  
        System.out.println("shortValue: " + s);  
        System.out.println("intValue: " + i);  
        System.out.println("longValue: " + l);  
        System.out.println("charValue: " + c);  
        System.out.println("floatValue: " + f);  
        System.out.println("doubleValue: " + d);  
        System.out.println("booleanValue: " + b);  
    }  
}

运行结果如下：

2、方法重载：

测试代码1：

package overload.com;
public class OverloadDemo {  
	  
    // 方法1：无参数  
    public void display() {  
        System.out.println("无参数方法");  
    }  
  
    // 方法2：有一个int类型参数  
    public void display(int i) {  
        System.out.println("有一个int类型参数的方法: " + i);  
    }  
  
    // 方法3：有两个String类型参数  
    public void display(String s1, String s2) {  
        System.out.println("有两个String类型参数的方法: " + s1 + ", " + s2);  
    }  
  
    // 方法4：有一个String类型参数和一个int类型参数  
    public void display(String s, int i) {  
        System.out.println("有一个String类型参数和一个int类型参数的方法: " + s + ", " + i);  
    }  
  
    public static void main(String[] args) {  
        OverloadDemo obj = new OverloadDemo();  
  
        // 调用无参数方法  
        obj.display();  
  
        // 调用有一个int类型参数的方法  
        obj.display(10);  
  
        // 调用有两个String类型参数的方法  
        obj.display("Hello", "World");  
  
        // 调用有一个String类型参数和一个int类型参数的方法  
        obj.display("Hello", 20);  
    }  
}

运行结果如下：

测试代码2：

package overload.com;
/*
 *方法1：无参数。
  方法2：有一个 int 类型的参数。
  方法3：有一个 String 类型的参数和一个 int 类型的参数。
  方法4：与方法3参数类型相同，但参数顺序不同（int 在前，String 在后），这仍然构成重载。
  方法5：有三个参数，分别是 String、int 和 double 类型的。
 */
public class MethodOverloadingDemo {  
	  
    // 方法1：无参数  
    public void show() {  
        System.out.println("无参数的方法");  
    }  
  
    // 方法2：有一个int类型参数  
    public void show(int num) {  
        System.out.println("有一个int类型参数的方法: " + num);  
    }  
  
    // 方法3：有两个参数，一个是String，一个是int  
    public void show(String text, int num) {  
        System.out.println("有一个String和一个int参数的方法: " + text + ", " + num);  
    }  
  
    // 方法4：与方法3参数类型相同，但顺序不同（重载）  
    public void show(int num, String text) {  
        System.out.println("有一个int和一个String参数的方法: " + num + ", " + text);  
    }  
  
    // 方法5：有三个参数，分别是String, int, 和double  
    public void show(String text, int num, double d) {  
        System.out.println("有一个String, 一个int, 和一个double参数的方法: " + text + ", " + num + ", " + d);  
    }  
  
    public static void main(String[] args) {  
        MethodOverloadingDemo demo = new MethodOverloadingDemo();  
  
        demo.show(); // 调用无参数方法  
        demo.show(10); // 调用有一个int参数的方法  
        demo.show("Hello", 20); // 调用有一个String和一个int参数的方法  
        demo.show(30, "World"); // 调用有一个int和一个String参数的方法（与方法3参数相同但顺序不同）  
        demo.show("Example", 40, 50.5); // 调用有三个参数的方法  
    }  
}

运行结果如下：