java 可变参数 数组_Java基础学习191221（可变参数，数组，Array类,稀疏数组，继承重写多态，抽象类，接口）...

Java基础学习

可变参数

在方法声明中，在指定参数类型后加一个省略号(...)。

一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通参数都必须在它之前声明。

public class printMax {

public static void main(String[] args) {

printMax(1,5,8,78,415,15);

}

public static void printMax( double... numbers){

if (numbers.length == 0){

System.out.println("No argument passed");

return;

}

double result = numbers[0];

for (int i = 0; i

if (numbers[i]>result){

result = numbers[i];

}

}

System.out.println("The max value is"+ result);

}

}

数组声明创建

dataType[] arrayRefVar = new dataType[arraySize]

Array 类

数组的工具类java.util .Arrays

由于数组对象本身并没有什么方法可以供我们调用，但是API中提供了一个工具类Arrays供我们使用，从而可以对数据对象进行一些基本的操作。

查看JDK帮助文档。

Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而"不用"使用对象来调用(注意：是“不用”而不是“不能”)

常用功能：

1. 给数组赋值：通过fill方法。

2. 对数组排序：通过sort方法。

3. 比较数组：通过equals方法比较数组中元素值是否相等。

4. 查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作。

稀疏数组

当一个数组中大部分元素为0，或者为同一值得数组时，可以使用稀疏数组来保存该数组。

稀疏数组的处理方式：

记录数组一共有几行几列，有多少个不同的值。

把具有不同值得元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模

eg:第一个是原始数组，第二个是稀疏数组。

package study;

public class arraysDemo {

public static void main(String[] args) {

//1.创建一个二维数组6*7 array1

int[][] array1 = new int[6][7];

array1[0][3] = 22;

array1[0][6] = 15;

array1[1][1] = 11;

array1[1][5] = 17;

array1[2][3] = -6;

array1[3][5] = 39;

array1[4][0] = 91;

array1[5][2] = 28;

//输出原始数组

System.out.println("输出原始数组");

for(int[] ints:array1){

for(int anInt: ints){

System.out.print(anInt+"\t");

}

System.out.println();

}

System.out.println("====================");

//转换为稀疏数组保存

//获取有效值的个数

int sum = 0;

for (int i = 0; i <6 ; i++) {

for (int j = 0; j <7 ; j++) {

if (array1[i][j]!=0){

sum++;

}

}

}

System.out.println("有效值的个数"+sum);

//2.创建一个稀疏数组的数组

int[][] array2 =new int[sum+1][3];

array2[0][0] = 6;

array2[0][1] = 7;

array2[0][2] = sum;

//遍历二维数组，将非零的值，存放到稀疏数组中

int count = 0;

for (int i = 0; i

for (int j = 0; j

if (array1[i][j]!=0){

count++;

array2[count][0] = i;

array2[count][1] = j;

array2[count][2] =array1[i][j];

}

}

}

//输出稀疏数组

System.out.println("稀疏数组");

for (int i = 0; i

System.out.println(array2[i][0]+"\t"+array2[i][1]+"\t"+array2[i][2]+"\t");

}

System.out.println("======================");

System.out.println("稀疏数组的还原");

//1.读取稀疏数组

int[][] array3 =new int[array2[0][0]][array2[0][1]];

//2.给其中的元素还原它的值

for (int i = 1; i

array3[array2[i][0]][array2[i][1]] = array2[i][2];

}

//3.打印

System.out.println("输出还原的数组");

for(int[] ints:array3){

for(int anInt: ints){

System.out.print(anInt+"\t");

}

System.out.println();

}

}

}

继承

super注意点:

1. super调用父类的构造方法，必须在构造方法的第一个

2. super必须只能出现在子类的方法或者构造方法中

3. super和this不能同时调用构造方法

this:

代表的对象不同：

this: 本身调用这个对象

super:代表对父类对象的引用

前提

this:没有继承也可以使用

super:只能在继承条件才可以使用

构造方法

this():本类的构造

super():父类的构造

重写

重写：需要有继承关系，子类重写父类的方法！

参数列表必须相同

修饰符：范围可以扩大但不能缩小

抛出的异常：范围可以变小，但不能变大

重写即子类的方法和父类一致但方法体不同

为什么需要重写？

父类的功能，子类不一定需要，或者不一定满足。

ALT+Insert: override

多态

对象能执行哪些方法，主要看对象左边的类型，和右边关系不大。

Student s1 = new Student();

Person s2 = new Student();

Object s3 = new Student();

//其中Student继承父类person，当子类Student 有自己的方法时 ,s2与s3对象无法调用其方法

多态注意事项：

多态是方法的多态，属性没有多态

父类和子类，有联系

存在条件：继承关系，方法需要重写，父类引用指向子类对象！ Father f1 =new Son();

不能使用多态：

static 方法，属于类，也不属于实例

final 常量

private方法

抽象类

public abstract class Student{

public abstract void f();

}

不能new这个抽象类，只能靠子类去实现它，其是一种约束

抽象类中可以写普通的方法

抽象方法必须在抽象类中

接口

interface

作用：

1. 约束

2. **定义**一些方法，让不同的人实现

3. 方法 public abstract

4. 属性 public static final

5. 接口不能被实例化，接口中没有构造方法

6. implements可以实现多个接口

7. 必须要重写接口中的方法

package study.oop;

public interface UserService {

void add(String name);

void delete(String name);

void update(String name);

void query(String name);

}

package study.oop;

public class UserServiceimpl implements UserService {

@Override

public void delete(String name) {

}

@Override

public void update(String name) {

}

@Override

public void query(String name) {

}

@Override

public void add(String name) {

}

}