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 <numbers.length ; 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 <array1.length ; i++) {
for (int j = 0; j <array1[i].length; 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 <array2.length ; 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 <array2.length ; 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) {
}
}