2020-12-06面向对象基础

可变参数

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

格式：

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

（1）一个方法只能有一个可变参数
（2）可变参数必须是形参列表的最后一个
（3）其实这个书写“等价于”

修饰符 返回值类型 方法名(【非可变参数部分的形参列表,】参数类型[] 形参名){ }
1
只是后面这种定义，在调用时必须传递数组，而前者更灵活，既可以传递数组，又可以直接传递数组的元素，其实编译成的class文件，将这些元素先封装到一个数组中，在进行传递。这些动作都在编译.class文件时，自动完成了。

好处：

同样是代表数组，但是在调用这个带有可变参数的方法时，不用创建数组(这就是简单之处)，直接将数组中的元素作为实际参数进行传递，其实编译成的class文件，将这些元素先封装到一个数组中，在进行传递。这些动作都在编译.class文件时，自动完成了。

代码演示：

public class ChangeArgs {
public static void main(String[] args) {
// 创建对象
Count c = new Count();

	int[] arr = { 1, 4, 62, 431, 2 };
	int sum1 = c.getSum1(arr);
	System.out.println(sum1);

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

}

class Count {

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

	return sum;
}

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

}
练习一：找最大值
定义求1-n个整数中的最大值

public class ChangeArgs_Exer1 {
public static void main(String[] args) {
Count c = new Count();
System.out.println(c.max(1));
System.out.println(c.max(5,3,2,6));
}
}
class Count{
public int max(int num, int… others){
int max = num;
for (int i = 0; i < others.length; i++) {
if(max < others[i]){
max = num;
}
}
return max;
}
}

练习二：字符串拼接
定义将n个字符串进行拼接，如果没有传入字符串，那么返回空字符串

public class ChangeArgs_Exer2 {
public static void main(String[] args) {
StringUtil su = new StringUtil();
System.out.println(su.concat());
System.out.println(su.concat(“hello”,“world”));
}
}
class StringUtil{
public String concat(String… args){
String str = “”;
for (int i = 0; i < args.length; i++) {
str += args[i];
}
return str;
}
}

方法的参数传递机制

形参：在定义方法时方法名后面括号中的变量名称称为形式参数（简称形参），即形参出现在方法定义中。
实参：调用者方法中调用另一个方法时，方法名后面括号中的参数称为实际参数（简称实参），即实参出现在调用者方法中。
方法的参数传递机制：实参给形参赋值
方法的形参是基本数据类型时，形参值的改变不会影响实参；
方法的形参是引用数据类型时，形参地址值的改变不会影响实参，但是形参地址值里面的数据的改变会影响实参，例如，修改数组元素的值，或修改对象的属性值。
注意：String、Integer等特殊类型除外

示例代码1：

class Test{
public static void swap(int a, int b){
int temp = a;
a = b;
b = temp;
}

public static void main（String[] args){
    int x = 1;
    int y = 2;
    swap(x,y);//调用完之后，x与y的值不变
}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
示例代码2：

class Test{
public static void change(MyData my){
my.num *= 2;
}

public static void main(String[] args){
    MyData m = new MyData();
    m.num = 1;
    
    change(m);//调用完之后，m对象的num属性值就变为2
}

}

class MyData{
int num;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
示例代码3：

public class Test {
public static void main(String[] args) {
int[] arr = {2,4,1,5,3};

	ArrayUtil util = new ArrayUtil();
	util.sort(arr);
	
	for (int i = 0; i < arr.length; i++) {
		System.out.println(arr[i]);
	}
}

}
class ArrayUtil{
public void sort(int[] arr){
for (int i = 1; i < arr.length; i++) {
for (int j = 0; j < arr.length - i; j++) {
if(arr[j] > arr[j+1]){
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
}
}
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
陷阱1：

/*
陷阱1：在方法中，形参 = 新new对象，那么就和实参无关了
*/
class Test{
public static void change(MyData my){
my = new MyData();//形参指向了新对象
my.num *= 2;
}

public static void main(String[] args){
    MyData m = new MyData();
    m.num = 1;
    
    change(m);//调用完之后，m对象的num属性值仍然为1
}

}

class MyData{
int num;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
陷阱2：见字符串和包装类部分

public class Test {
public static void main(String[] args) {
StringUtil util = new StringUtil();
String str = “尚硅谷”;
util.change(str);
System.out.println(str);
}
}
class StringUtil{
public void change(String str){
str += “你好”;//String对象不可变，一旦修改就会产生新对象
}
}

包

static

静态方法只能访问静态成员
在静态方法中，不能出现：this，也不能直接使用本类的非静态的成员。相反，非静态的实例成员方法可以直接访问静态的类变量或静态方法。
class Son{
private int a;
public static void fun(){
// method();//错误的
// System.out.println(a);//错误
// System.out.println(this.a);//错误

	System.out.println("Son:fun()");
}
public void method(){
	System.out.println("Son:method()");
}

}
静态方法无需创建对象便可以使用

数组工具类Arrays

java.util.Arrays数组工具类，提供了很多静态方法来对数组进行操作，而且如下每一个方法都有各种重载形式，以下只列出int[]类型的，其他类型的数组类推：

static int binarySearch(int[] a, int key) ：要求数组有序，在数组中查找key是否存在，如果存在返回第一次找到的下标，不存在返回负数

static int[] copyOf(int[] original, int newLength) ：根据original原数组复制一个长度为newLength的新数组，并返回新数组

static int[] copyOfRange(int[] original, int from, int to) ：复制original原数组的[from,to)构成新数组，并返回新数组

static boolean equals(int[] a, int[] a2) ：比较两个数组的长度、元素是否完全相同

static void fill(int[] a, int val) ：用val填充整个a数组

static void fill(int[] a, int fromIndex, int toIndex, int val)：将a数组[fromIndex,toIndex)部分填充为val

static void sort(int[] a) ：将a数组按照从小到大进行排序

static void sort(int[] a, int fromIndex, int toIndex) ：将a数组的[fromIndex, toIndex)部分按照升序排列

static String toString(int[] a) ：把a数组的元素，拼接为一个字符串，形式为：[元素1，元素2，元素3。。。]

示例代码：

import java.util.Arrays;
import java.util.Random;

public class Test{
public static void main(String[] args){
int[] arr = new int[5];
// 打印数组,输出地址值
System.out.println(arr); // [I@2ac1fdc4
// 数组内容转为字符串
System.out.println(“arr数组初始状态：”+ Arrays.toString(arr));

	Arrays.fill(arr, 3);
	System.out.println("arr数组现在状态："+ Arrays.toString(arr));
	
	Random rand = new Random();
	for (int i = 0; i < arr.length; i++) {
		arr[i] = rand.nextInt(100);//赋值为100以内的随机整数
	}
	System.out.println("arr数组现在状态："+ Arrays.toString(arr));
	
	int[] arr2 = Arrays.copyOf(arr, 10);
	System.out.println("新数组：" + Arrays.toString(arr2));
	
	System.out.println("两个数组的比较结果：" + Arrays.equals(arr, arr2));
	
	Arrays.sort(arr);
	System.out.println("arr数组现在状态："+ Arrays.toString(arr));
}

}