Java基础复习-----04篇

Java基础------04篇

For each

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

    }
    //反转数组
    public static int[] arrayReserve(int[] array){
        int[] result=new int[array.length];
        for (int i=array.length-1,j=0;i>=0;i--,j++) {
            result[j] = array[i];
            System.out.println(result[j]);
        }
        return result;
    }

}

多维数组

public class ArrayDemo01 {
    public static void main(String[] args) {
        int[][] array = {{1,2},{2,3},{3,4},{4,5}};
        printArray(array);
    }
    public static void printArray(int[][] arrays){
        for (int i = 0; i < arrays.length ; i++) {
           for(int j = 0; j < arrays[i].length; j++){
               System.out.print(arrays[i][j]+" ");
           }
        }
    }
}

Arrays工具类

冒泡排序

public static int[] bubbleSort(int[] arrays){
    int temp = 0;
    for(int i = 0; i<arrays.length-1; i++ ){
        boolean flag = false;
        for(int j = 0; j<arrays.length-1-i; j++){
            if(arrays[j+1]<arrays[j]){
                temp = arrays[j];
                arrays[j] = arrays[j+1];
                arrays[j+1] = temp;
                flag = true;
            }
        }
        if(flag != true){
            break;
        }
    }
    return arrays;
}

稀疏数组

public class ArrayDemo02 {
    public static void main(String[] args) {
        int[][] array = new int[11][11];
        array[2][1] = 1;
        array[3][2] = 2;
        for (int[] a:array) {
            for (int b:a) {
                System.out.print(b+"\t");
            }
            System.out.println();
        }
        System.out.println("==============");
        //获取有效值的个数
        int sum = 0;
        for(int i = 0; i<array.length-1 ; i++){
            for(int j = 0; j<array.length-1; j++){
                if(array[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println("有效值个数："+sum);

        int[][] array2 = new int[sum+1][3];
        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;

        int count = 0;
        //遍历稀疏数组
        for (int i = 0; i <array.length ; i++) {
            for (int j = 0; j<array[i].length; j++){
                if(array[i][j]!=0){
                    count++;
                    array2[count][0] = i;
                    array2[count][1] = j;
                    array2[count][2] = array[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("==============");
        //反转稀疏数组
        int[][] array3 = new int[array2[0][0]][array2[0][1]];
        //还原有值的坐标
        for (int i = 1; i <array2.length ; i++) {
            array3[array2[i][0]][array2[i][1]] = array2[i][2];
        }
        //遍历还原
        for (int[] a:array) {
            for (int b:a) {
                System.out.print(b+"\t");
            }
            System.out.println();
        }
    }
}

面向过程&面向对象oop

oop本质：以类的方式组织代码，以对象的组织（封装）数据

抽象

三大特性：

1. 封装–“高内聚，低耦合”，信息隐藏

2. 继承–java只有单继承，没有多继承

   私有的无法被继承

   • super

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

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

     3.super和this不能同时调用构造方法（都要在第一行）

   • super 与 this

     1. 代表的对象不同：

        this：本身调用者这个对象

        super：代表父类对象的应用

     2. 前提：

        this：没有继承也能使用

        super：只能在继承条件才能使用

     3. 构造方法：

        this():本类的构造

        super():父类的构造

3. 多态–

静态/非静态方法

1. 静态方法在类加载时就被调用

2. 非静态方法在类实例化之后才存在

值传递/引用传递

构造器

1. 和类名相同的方法

2. 没有返回值

   作用

3. new本质在调用构造方法

4. 初始化对象的值

   注意点

   定义有参构造之后，如果想使用无参构造，显示地定义一个无参地构造

创建对象内存分析

栈。堆。方法区

重写—子类重写父类方法

方法名相同，方法体不同

1. 方法名必须相同

2. 参数列表相同

3. 修饰符：可以扩大不能缩小？

   public>protected>default>private

4. 抛出的异常：范围可以被缩小但不能扩大

多态

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

1. 多态是方法的多态，属性没有多态
2. 父类和子类 类型转换异常
3. 存在条件：继承关系，方法需要重写，父类引用指向子类对象。
4. static，final，private无法重写

抽象类

1. 抽象类只能由子类实现

2. 抽象类可以写普通方法

3. 抽象方法必须在抽象类中

接口

异常机制