标签：appdata   重写   约束   count   为什么   images   获取   可变   length   

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:

1. 代表的对象不同：

   this: 本身调用这个对象

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

2. 前提

   this:没有继承也可以使用

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

3. 构造方法

   this():本类的构造

   super():父类的构造

重写

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

1. 参数列表必须相同
2. 修饰符：范围可以扩大但不能缩小
3. 抛出的异常：范围可以变小，但不能变大
4. 重写即子类的方法和父类一致但方法体不同

为什么需要重写？

• 父类的功能，子类不一定需要，或者不一定满足。
• ALT+Insert: override

多态

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

Student s1 = new Student();
Person s2 = new Student();
Object s3 = new Student();
//其中Student继承父类person，当子类Student 有自己的方法时 ,s2与s3对象无法调用其方法

多态注意事项：

1. 多态是方法的多态，属性没有多态
2. 父类和子类，有联系
3. 存在条件：继承关系，方法需要重写，父类引用指向子类对象！ Father f1 =new Son();

不能使用多态：

• static 方法，属于类，也不属于实例
• final 常量
• private方法

抽象类

public abstract class Student{
    public abstract void f();
}

1. 不能new这个抽象类，只能靠子类去实现它，其是一种约束
2. 抽象类中可以写普通的方法
3. 抽象方法必须在抽象类中

接口

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) {

    }
}

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

标签：appdata   重写   约束   count   为什么   images   获取   可变   length   

原文地址：https://www.cnblogs.com/litingblog/p/12078756.html