2021-10-13

方法

修饰符 返回类型 方法名（参数列表） {
    // 方法体
}

1. 修饰符：public、private、default（不写）、protec、final、static等 修饰符的顺序是任意的
2. 返回类型：基本类型（8个）、引用类型.void
3. 方法名首字母小写、尽量用动词
4. 参数列表是可选的，参数就相当于是在方法中声明的变量。

可变参数

static int f(int... nums) { // ...被称为可变参数（参数可以是0个或多个）
        // 可变参数可以被理解为一个数组，或者说当作一个数组去使用
        int sum = 0;
        for (int num : nums)
            sum += num;
        return sum;
    }

//    static void h(String... a, int... n) { } // 一个方法中最多只能有一个可变参数
    static void j(String[] a, int[] b) {

    }
    static void h(String str, char c, int i, int... nums) {

    }
//    static void h(int... nums, String str) {} // 如果一个方法中有可变参数，可变参数必须出现在结尾的位置上
    static public void main(String... a) {
        h(" ", 'a', 31);
        h(" ", 'a', 31, 22, 123);
        // 几乎所有的数组都可以换成可变参数的形式
        System.out.println(f());
        System.out.println(f(new int[]{1, 2, 3}));
        System.out.println(f(1, 2, 3));
        System.out.println(f(1, 2));
        
        g(new int[]{1, 2, 3});
        // g();
        System.out.printf("%d%d", 1, 2);
    }

方法中传递引用类型和基本类型参数的问题

1.传递基本类型

public class Test { 
    static void f(int i) { 
        i = i + 1; 
        System.out.println("方法中的i加1后得到的结果是："+i); 
}

static public void main(String... a) { 
    int i = 100; 
    System.out.println("调用方法f之前的i是：" + i);
    f(i); //当传递的参数是基本类型的时候，不管在方法里做了什么，方法结束后，这个变量依然维持原始内容  
    System.out.println("调用方法f之后的i是：" + i); } }

2.传递引用类型-除了基本类型之外都是引用类型，比如数组

2.1 当修改了引用类型本身的时候，和基本类型的效果一样。

public class Test { 
    static void f(int[] nums) { 
        nums = new int[]{4, 5, 6}; //修改了引用类型本身 
        System.out.println("方法中数组的值是：" + Arrays.toString(nums)); 
}

    static public void main(String... a) { 
        int[] nums = {1, 2, 3}; 
        System.out.println("调用方法f之前的i是：" + Arrays.toString(nums)); 
        f(nums); 
        System.out.println("调用方法f之后的i是：" + Arrays.toString(nums)); 
    } 
}

2.2 当修改了引用类型里面包含的值的时候，那么方法内和方法外就都真正被修改了。

import java.util.Arrays;

public class Test { 
    static void f(int[] nums) { 
        nums[0] = 4; //修改了引用类型里面包含的值 
        nums[1] = 5;  
        nums[2] = 6; 
        System.out.println("方法中数组的值是：" + Arrays.toString(nums)); }

    static public void main(String... a) {
        int[] nums = {1, 2, 3};
        System.out.println("调用方法f之前的i是：" + Arrays.toString(nums));
        f(nums); //调用f之后，此时的123已经没了，完全变成了456
        System.out.println("调用方法f之后的i是：" + Arrays.toString(nums));
    }

}

方法重载: 方法名字相同，参数列表不同。 Java中规定方法的名字本来就不能相同，相同就被认为出错。 但是重载是其中的一个例外而已。

1. 重载与否和方法返回类型无关
2. 参数列表只看类型，不看名字。 void f(int i){} void f(int j){} 不叫重载，而是错误。
3. 参数列表不同指：参数类型不同，参数个数不同，参数顺序不同 void g(double d){} void g(int i){} void g(int i, double d){} void g(double d, int i){} 以上4个g都是正确的重载

杂项

1. String的常见方法

public class Test {

    static public void main(String... a) { 
        String s = "je llo, wor ld"; //字符串和byte[]互相转换 
        byte[] bytes = s.getBytes(); //String转为byte[] 
        s = new String(bytes); //字节数组转为String

        System.out.println(s.indexOf("l")); //求参数中的字符在字符串s中首次出现的下标
        System.out.println(s.contains("od"));
        System.out.println(s.contains("lo")); //判读参数中的内容是否被包含在字符串s中
​
        String[] strs = s.split(" "); //将字符串s用空格分割，得到一个String数组
        Arrays.stream(strs).forEach(e->System.out.printf("%-10s", e));
​
         System.out.println("\n" + s.compareTo("je lk"));//比较两个字符串，从第一个不相同的字母开始，求这两个字符的数值差

    }
}

2.局部变量的作用域

作用域：一个变量起作用的范围。

一般来说，一个变量的作用范围都是从声明处开始起作用，直到包含它的右大括号为止。

public class Test { 
    static public void main(String... a) { 
        int i = 0; 
        for (; i < 10; i++) { 
            System.out.println(i); 
        } 
        System.out.println(i);

    {
        int j = i;
    }
    //System.out.println(j); //j只能用在复合语句中

    }
 }

3. 大数值：用于任意精度和位数的计算

public class Test { 
    static public void main(String... a) { 
        BigInteger num1 = new                                     

        BigInteger("9999999999999999999999999999999");
        BigInteger num2 = BigInteger.ONE; //new BigInteger(1);             
        System.out.println(num1.add(num2));

         BigDecimal ten = new BigDecimal("10");
         BigDecimal three =  new BigDecimal("3");
         System.out.println(ten.add(three));
         System.out.println(ten.divide(three, 1001, RoundingMode.DOWN));
         // 1000指保留小数点后1000位

    }
 }

4. 强制类型转换

除了boolean类型之外其余的基本类型之间都可以强制类型转换。

强转的时候，小的值给大的值一般没问题，不需要强制类型转换

short s = 30000;

int i = s; 

但是要注意，int给float和long给float、double都会有些精度损失。

static public void main(String... a) { 
    int i = 1234567890;
    float f = i; 
    double d = i; 
    System.out.println(f); //int给float会有精度上的损失 
    System.out.println(d); //int给double不会有任何精度损失

    long l = 1234567891234567891L;
    double d = l;
    System.out.println(d); //long给float和double都会有精度损失

}

4.2 大的值给小的值一定需要强制类型转换，结果采用截断处理

long l = 1L;

int i = (int)l;

此时的l在计算机中占8个字节

00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001

此时的i在计算中占4个字节

00000000 00000000 00000000 00000001（此时将long的高32位直接砍掉）

long l = 4294967295L;

int i = (int)l;

System.out.println(i); //-1

此时的l在计算机中占8个字节

00000000 00000000 00000000 00000000 11111111 11111111 11111111 11111111

此时的i在计算中占4个字节

11111111 11111111 11111111 11111111（此时将long的高32位直接砍掉）