java自学笔记（day02），归纳总结自：B站狂神说java

基础2

转义字符

/t：代表横向跳到下一制表符位置

打印九九乘法表

public class ForDemo3 {
    //打印九九乘法表
    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");
                if (i == j){
                    System.out.println();
                }
            }
        }
    }
}

break和continue的区别

break在任何循环语句的主体部分，均可用break控制循环的流程。break用于强行退出循环，不执行循环中剩余的语句。(break语句也在switch语句中使用)

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

打印三角形

public class TestDemo {
    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++) {
            for (int j = 5; 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 class TestDemo2 {
    public static void main(String[] args) {
        //打印倒三角
        for (int i = 1; i <= 5; i++) {
            for (int j = 1; j < i; j++){
                System.out.print(" ");
            }
            for (int j = 5; j >= i; j--){
                System.out.print("*");
            }
            for (int j = 5; j > i; j--){
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

方法

System.out.println();

可理解为：System是一个类，out是该类的对象，println()是其中的方法。
return 具有终止方法的作用

值传递(Java都是) 和 引用传递，

Java都是使用栈机制的

方法的重载

重载就是在一个类中，有相同的函数名称，但形象不同的函数。

方法的重载的规则：

1. 方法名称必须相同
2. 参数列表必须不同(个数不同，或类型不同，参数排列顺序不同等)
3. 方法的返回类型可以相同也可以不相同
4. 仅仅返回类型不足以为方法的重载

实现理论

​ 方法名称相同时，编译器会根据调用方法的参数个数、参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，则编译器报错。

命令行传参

有时候你希望运行一个程序时候再传递给它消息。这是要靠传递命令行参数给main()函数实现。

D:\IDEA\JavaSE\基础语法\src\com\scy\method>javac Demo.java

D:\IDEA\JavaSE\基础语法\src\com\scy\method>java Demo this is yang ge
错误: 找不到或无法加载主类 Demo

D:\IDEA\JavaSE\基础语法\src\com\scy\method>cd ../

D:\IDEA\JavaSE\基础语法\src\com\scy>cd ../

D:\IDEA\JavaSE\基础语法\src\com>cd ../

D:\IDEA\JavaSE\基础语法\src>java com.scy.method.Demo

D:\IDEA\JavaSE\基础语法\src>java com.scy.method.Demo this is yangge
args[0]this
args[1]is
args[2]yangge

可变参数

JDK1.5开始，Java支持传递同类型的可变参数的一个方法。

在方法声明中，在指定参数类型后加一个省略号，三个点(…)。

一个方法中只能指定一个可变参数，它必须是方法的最后一个参数，任何普通的参数必须在它之前声明。

public class Demo2 {
    public static void main(String[] args) {
        Demo2 demo2 = new Demo2();
        demo2.test(5,6,7,8,9,5,2,3,1,12,9,16);
    }
    public  void  test(int... i){
        System.out.println(i[0]);
        System.out.println(i[1]);
        System.out.println(i[2]);
        System.out.println(i[3]);
        System.out.println(i[4]);
        System.out.println(i[5]);
    }
}

递归

A方法调用B方法，我们容易理解！

递归就是：A方法调用A方法！就是自己调用自己

利用递归可以用简单的程序来解决一些复杂的问题，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需要少量的程序就可以描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量，递归的能力在于有限的语句来定义对象的无限集合。

递归结构包括两个 部分：

​ 递归头：什么时候不调用自身方法，如果没有头，将陷入死循环。

​ 递归体：什么时候需要调用自身方法。

数组

public class ArrayDemo {
    public static void main(String[] args) {
        int[] nums;     //1.声明一个数组
        nums = new int[10];     //2.创建一个数组
    }
}

数组的四个基本特点：

1. 其长度是确定。数组一旦被创建，它的大小就是不可以改变的。
2. 其元素必须是相同类型，不允许出现混合类型。
3. 数组中的元素可以是任何数据类型，包括基本类型和引用类型。
4. 数组变量属于引用类型，数组也可以 看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是 在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。

冒泡排序

1. 比较数组中两个相邻的元素，如果第一个比第二个数大，则交换它们的位置
2. 每一次比较，都会产生一个最大，或者最小的数字
3. 下一轮则可以少一次排序
4. 依次循环，直到结束

public class Demo1 {
    public static void main(String[] args) {
        //冒泡排序
       int[] a = {156,5641,3,123,56,3,2,1,9,8463,651,55};
       int temp = 0;
       for (int i = 0; i < a.length; i++){
           for (int j = 0; j < a.length-1; j++ ){
               if (a[j] > a[j+1]){
                   temp = a[j+1];
                   a[j+1] = a[j];
                   a[j] = temp;
               }
           }
       }
        System.out.println(Arrays.toString(a));
    }
}

备注：在内层for里的判断条件要写为a.length-1，否则会数组下标溢出

Exception in thread “main” java.lang.ArrayIndexOutOfBoundsException: 3

稀疏数组

public class Demo2 {
    public static void main(String[] args) {
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;

        System.out.println("输出原始数组为：");
        for (int i = 0; i < array1.length; i++){
            for (int j = 0; j < array1[i].length; j++){
                System.out.print(array1[i][j]+"\t");
            }
            System.out.println();
        }

        System.out.println("=================================");

        //转化为稀疏数组保存
        int sum = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (array1[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 < 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("=============================");
        //还原稀疏数组
        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("打印原始数组：");
        for (int i = 0; i < array3.length; i++){
            for (int j = 0; j < array3[i].length; j++){
                System.out.print(array3[i][j]+"\t");
            }
            System.out.println();
        }
    }
}