JavaSE开发基础--包机制&JavaDoc&Scanner&循环结构&方法&数组

包机制

如果文件在包中需要 在文件首行添加 package 地址

package pkg1.pkg2.pkg3

import package1

JavaDoc

    /**
     * @author作者名
     * @version版本号
     * @since指明需要最早使用的jdk版本
     * @param参数名
     * @return返回值情况
     * @throws异常抛出情况
     */

cmd生成doc文档：

javadoc -protected -splitindex -use -author -version -encoding UTF-8 -charset UTF-8 -d G:\Desktop\JavaSE\JavaDoc @C:\Users\Administrator\AppData\Local\Temp\javadoc_args

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tMV1f5Ds-1659764530952)(assets/image-20220611095847-nt0f6i4.png)]

Scanner

public class Demo01 {
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);

        // nextLine  以回车键为结束字符
        String str = scanner.nextLine();
        System.out.println("输出的内容为："+str);

        //next  以空格为结束字符
        String str2 = scanner.next();
        System.out.println("输出的内容为："+str2);

        //凡是属于IO流的类如果不关闭会一直占用资源，要养成良好的习惯用完就关掉。
        scanner.close();
    }
}

循环结构

IF

public class Demo03 {
    public static void main(String[] args){
        Scanner scanner =  new Scanner(System.in);

        int s = scanner.nextInt();
        if (s==100){
            System.out.println(s);
        }else if (s<100&&s>=80){
            System.out.println(s+"1");
        }else if (s>=0){
            System.out.println("aaaa");
        }else {
            System.out.println("结束");
        }
        scanner.close();
    }
}

switch case

如果case里面没有写break进行跳出，则会发生case穿透。

一下结果为：及格、不及格、级别未知。因为没有在case后加入break

public class Demo04 {
    public static void main(String[] args){
        char result = 'c';
        switch (result){
            case 'a':
                System.out.println("优秀");
            case 'b':
                System.out.println("良好");
            case 'c':
                System.out.println("及格");
            case 'd':
                System.out.println("不及格");
            default:
                System.out.println("级别未知");
        }

    }
}

while

只要条件符合就一直执行

while(条件){
	执行语句
}

do while

与while的区别在先执行后判断。

For

是运行最高效的循环结构

public class Demo01 {
    public static void main(String[] args) {
        for (int i = 1; i <= 9; i++) {
            for (int j = 1;j<=i;j++){
                System.out.print("i"+"*"+"j"+i*j+"\t");
            }
            System.out.println();
        }
    }
}

增强for循环

主要在遍历数组和集合的时候用，jdk5以后才有。

public class ForDemo02 {
    public static void main(String[] args){
        int[]  numbers = {10,20,30,40,50};
        for(int x:numbers){
            System.out.println(x);
        }
    }
}

break continue

break在任何循环语句的主体，均可用break控制循环流程，其作用是强行退出循环，不执行循环中剩余的语句。

continue 语句在循环语句中使用，用于终止某次循环过程，即跳过循环体中未执行的语句，接着进行下一次是否执行循环的判断。

goto

打印三角形

public class SanJiao {
    public static void main(String[] args){
        int num =10;
        for(int i =1;i<=num;i++){
            for (int j=0;j<=50;j++){
                System.out.print(" ");
            }
            for (int j=num;j>i;j--){
                System.out.print(" ");
            }
            for(int j=1;j<=i;j++){
                System.out.print("*");
            }
            for(int j=1;j<i;j++){
                System.out.print("*");
            }
            System.out.println();

        }
    }
}

方法（一般面向对象叫方法，面向过程叫函数）

public static void main

其中 void 是指该方法不返回值，在自定义的方法中可以是任何数据类型 static 是修饰类的表示静态

public class Demo1 {
    public static void main(String[] args){
        System.out.println(add(3, 5));
    }
    public static int add(int a,int b){
        return a+b;
    }
}

return不仅可以用来返回值，也可以用来终止方法运行。

方法重载

就是相同的方法名，参数不同

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gm4Zu3ZL-1659764530953)(assets/image-20220617154437-yt3qzd9.png)]

命令行传参

可以在命令的时候直接传递参数，在接受参数的时候和scanner的text一样遇到空格后即变为下一个参数

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7nip11AG-1659764530954)(assets/image-20220617155551-tpyv0ri.png)]

可变参数（不定向参数）

方法声明中，在指定参数类型后加一个省略号（…）

public class Demo03 {
    public static void main(String[] args){
        Demo03 demo03 = new Demo03();
        demo03.test(1,2,3);
    }
    public void test(int... i){
        for (int j =0; j<i.length;j++){
            System.out.println(i[j]);
        }
    }
}

递归

通俗点讲就是自己调用自己。但是程序必须有结束的点，不能是死循环。但是Java是栈结构，所以递归层次过多的话效率会低，并且可能内存溢出。

数组

数组按照存入的先后次序进行排列，数组中所有元素类型必须相同。不赋值就是默认值。数组创建必须分配大小，并且一旦创建不可更改

public class ArraryDemo01 {
    public static void main(String[] args){
        int[] nums;  //声明一个数组
        nums = new int[10];  //创建一个数组，规定大小为10.
	//也可以这么表示int[] nums = new int[10];
        nums[0] = 1;//为第一个元素赋值为1,默认为0，不赋值就是0.
        for (int i = 0; i <nums.length ; i++) {
            System.out.println(nums[i]);
        }
    }
}

数组初始化

public class ArraryDemo01 {
    public static void main(String[] args){
        int[] nums1 = {1,2,3,4,5,6};//静态初始化
        int[] nums2 = new int[10];//动态初始化
        }
}

数组的基本特点

• 长度确定，一旦创建大小不可改变。
• 元素类型必须相同，不允许出现混合类型。
• 数组中元素可以是任何数据类型，包括基本类型和引用类型。
• 数组的变量属于引用类型，数组也可以看成是一个对象。

案例（数组反转）

public class ArrayDemo02 {
    public static void main(String[] args){
        int[] ar = {1,2,3,4,5};
        pringArray(reversalArray(ar));

    }

    public static int[] reversalArray(int[] array){
        int[] result = new int[array.length];
        for (int i = 0,j=array.length-1; i < array.length ; i++,j--) {
            result[i] = array[j];
        }
        return result;
    }

    public static void pringArray(int[] array){
        for (int x:array){
            System.out.print(x+"\t");
        }
    }
}

二维数组

打印

public class ArrayDemo03 {
    public static void main(String[] args){
        int[][] arr = new int[10][4];
        for (int i = 0; i <arr.length ; i++) {
            for (int j = 0; j <arr[i].length ; j++) {
                System.out.print(arr[i][j]+"\t");
            }

        }
    }
}

Arrays类

public class ArrayGj {
    public static void main(String[] args){
        int[] array = {1,2,3,4,5,345,6756,456,234,2311};
        System.out.println(Arrays.toString(array));
        Arrays.sort(array);
        System.out.println(Arrays.toString(array));

    }
}

稀疏数组

public class Demo04 {
    public static void main(String[] args){
        //创建一个二维数组
        int[][] array1 = new int[5][5];
        array1[0][2] = 1;
        array1[1][3] = 2;
        //打印原始数组
        blArray(array1);
        System.out.println("===================");
        System.out.println("打印稀疏数组");
        int[][] array2 = sparseArray(array1);
        blArray(array2);
        System.out.println("===================");
        System.out.println("还原稀疏数组");
        blArray(restoreAyyay(array2));

    }

    //打印二维数组
    public static void blArray(int[][] array){
        for (int[] ints : array) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
    }

    //稀疏数组转换
    public static int[][] sparseArray(int[][] array){
        int num = 0;
        for (int i = 0; i < array.length ; i++) {
            for (int j = 0; j <array[i].length ; j++) {
                if (array[i][j] != 0){
                    num++;
                }
            }
        }
        //创建稀疏数组
        int[][] array_s = new int[num+1][3];
        //定义稀疏数组的第一行
        array_s[0][0] = array.length;
        array_s[0][1] = array[0].length;
        array_s[0][2] = num;

        //为稀疏数组填充内容
        int line = 1;
        for (int i = 0; i < array.length ; i++) {
            for (int j = 0; j <array[i].length ; j++) {
                if (array[i][j] != 0){
                    array_s[line][0] = i;
                    array_s[line][1] = j;
                    array_s[line][2] = array[i][j];
                    line++;
                }
            }
        }


        return array_s;
    }

    public static int[][] restoreAyyay(int[][] array){
        int[][] array_r = new int[array[0][0]][array[0][1]];
        for (int i = 1; i < array.length ; i++) {
            for (int j = 0; j <array[i].length ; j++) {
                array_r[array[i][0]][array[i][1]] = array[i][2];
            }
        }
        return array_r;
    }

}