第六天 变量的区别，必使用代码中的命令行参数，可变参数

1、变量的分类

2、可变参数

如果我们定义一个方法时，此时某个形参的类型可以确定，但是形参的个数不确定，那么我们可以使用可变参数。

• 格式：
  【修饰符】 返回值类型 方法名(【非可变参数部分的形参列表,】参数类型… 形参名){ }

public static void main（Stirng[]args）{

}
1
2
3

条件：
（1）一个方法最多只能有一个可变参数
（2）如果一个方法包含可变参数，那么可变参数必须是形参列表的最后一个

优点：便于参数不确定时的格式。
方便递归。

案例一：

n个字符串进行拼接，每个字符串之间使用某种字符进行分割，如果没有传入字符串，那么返回控制串

public class Demo01{
	public static void main(String [] args){
		System.out.println(concat("_","Hellow","world","java"));
	}
	public static String concat(char seperator,String ... args){
		String str = "";//局部变量
		
		for(int i = 0;i<args.length;i++){
			if(i==0){
				str = args[i];
			}else{
				str+=seperator+args[i];
			}
		}
		return str;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

案例二：求n个整数的和

public class ChangeArgs {
	public static void main(String[] args) {
		int[] arr = { 1, 4, 62, 431, 2 };
		int sum1 = getSum1(arr);
		System.out.println(sum1);

		int sum2 = getSum2(arr);
		System.out.println(sum2);
		int sum3 = getSum2(1, 4, 62, 431, 2);
		System.out.println(sum3);
	}

	// 完成数组 所有元素的求和
	// 原始写法
	public static int getSum1(int[] arr) {
		int sum = 0;
		for (int i = 0; i < arr.length; i++) {
			sum += arr[i];
		}

		return sum;
	}

	// 可变参数写法
	public static int getSum2(int... arr) {
		int sum = 0;
		for (int i = 0; i < arr.length; i++) {
			sum += arr[i];
		}
		return sum;
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

3、方法重载

用重载实现:
案例一：定义方法求两个整数的最大值定义方法求三个整数的最大值定义方法求两个小数的最大值

public class Demo02{
	/*用重载实现:
定义方法求两个整数的最大值定义方法求三个整数的最大值定义方法求两个小数的最大值
*/
	public static void main(String[]args){
		
		System.out.println(max(4,5));
		System.out.println(max1(4,5,6));
		System.out.println(max3(4.5,3.55));
	}
	
	//两个byte类型的
	//参数列表不一致（数据类型，参数个数都可能不一致）
	public static int max(int a,int b){
		return a >b ? a :b;
	}
	public static int max1(int a,int b,int c){
		return (a>b?a:b)>c?(a>b?a:b):c;
	}
	public static double max3(double a,double b){
		return a >b ? a :b;
	}
	
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

3、命令行参数

public class TestCommandParam{
	//形参：String[] args
	public static void main(String[] args){
		System.out.println(args);
		System.out.println(args.length);
		
		for(int i=0; i<args.length; i++){
			System.out.println("第" + (i+1) + "个参数的值是：" + args[i]);
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11

命令行输入：java TestCommandParam

[Ljava.lang.String;@15db9742
0
1
2

java TestCommandParam 1 2 3

[Ljava.lang.String;@15db9742
3
第1个参数的值是：1
第2个参数的值是：2
第3个参数的值是：3
1
2
3
4
5

java TestCommandParam hello gec

[Ljava.lang.String;@15db9742
2
第1个参数的值是：hello
第2个参数的值是：gec
1
2
3
4

4、包的使用

1、给你两段代码，配置合适的目录，并将其正确运行出来

package com.gec.bean;

public class Student {
	// 成员变量
	private String name;
	private int age;

	// 构造方法
	public Student() {
	}

	public Student(String name, int age) {
		this.name = name;
		this.age = age;
	}

	// 成员方法
	public void setName(String name) {
		this.name = name;
	}

	public String getName() {
		return name;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public int getAge() {
		return age;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

package com.gec.test;

import java.util.Scanner;
import java.util.Date;
import com.gec.bean.Student;

public class Test{
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);
        Student stu = new Student();
        String str = "hello";
        stu.setName("小王");
        Date now = new Date();
		System.out.println("name="+stu.getName());
        java.sql.Date d = new java.sql.Date(346724566);        
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

步骤：看包名，都是com.gec开头，但是都不在同一个包中，即不在同一个目录下面。
我们先创建Student.java源码文件，将Student的代码放进去。
再创建Test.java文件，将Test的代码放进去（这两个文件在同一个目录下）
之后在命令行运行javac -d . Student.java
此时就能看到在当前目录下有com/gec/bean/Student.class。的目录和文件
然后我们在命令行运行javac -d . Test.java 。这个命令会产生 com/gec/test/Test.class的目录和文件。这里注意命令行的语句中的.前后需要空格。到这里我们的编译就完成了。在同一个包名下的目录构建。
我们执行时输入java com.gec.test.Test 就可与正常输出了