JAVA基础

JAVA基础

JAVA运行机制

1、.java文件先被编译器编译成.class文件
2、然后.class文件被虚拟机编译成机器码
3、然后在操作系统上运行

注释

//单行注释
快捷键 ctrl + /

多行注释
/*
多行注释
多行注释
*/
快捷键 ctrl + shift + /

文档注释
/**
 * @author crestashi
 * @version 1.0
 */

Scanner

    public static void main(String[] args) {
//        实例化Scanner对象
        Scanner scanner = new Scanner(System.in);
//        判断是否有输入
        if (scanner.hasNextLine()){
            String str = scanner.nextLine();
            System.out.println(str);
        }
//        关闭Scanner，避免浪费资源
        scanner.close();
    }

增强for

    public static void main(String[] args) {
//        增强for
        String[] strings = new String[]{"张三","李四","王五"};
        for (String str:strings) {
            System.out.println(str);
        }
//        增强for就是foreach
    }

方法重载

1、方法名相同，参数类型不同
2、参数个数不同

可变参数

public class Demo {
//    可变参数
    public static void main(String[] args) {
        Demo demo = new Demo();
        double max = demo.getMax(23, 12, 23, 34, 56);
        System.out.println(max);
    }

    public double getMax(double i,int... x){
        if (x.length == 0){
            return i;
        }
        double result = i;
        for (int j = 0; j 

递归

public class Demo {
//    使用递归方法求阶乘
    public static void main(String[] args) {
        Demo demo = new Demo();
        int f = demo.f(5);
        System.out.println(f);
    }

    public int f(int x){
        if (x==1){
            return 1;
        }else {
            return x*f(x-1);
        }
    }
}

数组

• 数组是相同类型数据的有效集合
• 数组一但被创建，长度就不可改变
• 数组中存放的元素必须相同
• 可以存放基本数据类型，也能存放引用类型
• 操作数组的类java.util.Arrays

冒泡排序

public class Demo {
    //    冒泡排序
    public static void main(String[] args) {
        Demo demo = new Demo();
        int[] sort = demo.sort(new int[]{12, 23, 2, 45, 13, 45});
        for (int num : sort) {
            System.out.println(num);
        }
    }

    public int[] sort(int[] array) {
        for (int i = 0; i < array.length - 1; i++) {
            for (int j = i + 1; j < array.length; j++) {
                if (array[i] > array[j]) {
                    int temp = array[i];
                    array[i] = array[j];
                    array[j] = temp;
                }
            }

        }
        return array;
    }
}

稀疏数组

public class Demo {
    //    稀疏数组
//    0代表空  1代表白棋   2代表黑棋
    public static void main(String[] args) {
//        棋盘
        System.out.println("初始棋盘");
        int[][] array1 = new int[11][12];
        array1[1][2] = 1;
        array1[2][3] = 2;
        for (int[] hang : array1) {
            for (int num : hang) {
                System.out.print(num + "\t");
            }
            System.out.println();
        }
        System.out.println("==========================");
//        将数组压缩为稀疏数组进行存储
//        获取有效数字个数
        int sum = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[0].length; j++) {
                if (array1[i][j] != 0) {
                    sum++;
                }
            }

        }
        System.out.println("有效值的个数是：" + sum);
//        申明稀疏数组
        int[][] array2 = new int[sum+1][3];
        array2[0][0] = array1.length;
        array2[0][1] = array1[0].length;
        array2[0][2] = sum;
//        遍历棋盘有效值放进稀疏数组
        int count = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[0].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[] hang : array2) {
            for (int num : hang) {
                System.out.print(num + "\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];
        }
        System.out.println("======================");
//        遍历还原后的数组
        System.out.println("还原的棋盘");
        for (int[] hang : array3) {
            for (int num : hang) {
                System.out.print(num + "\t");
            }
            System.out.println();
        }
    }
}

static

被static修饰的属性或方法，被称为静态属性和静态方法，静态属性和静态方法可直接通过类名.访问

异常处理机制

• 处理方式1 try catch finally
• 处理方式2 throws throw

try catch finally 是真正的处理异常，然后程序正常执行
throws throw是抛出异常