JAVA学习

2022.1.8

---

打印9*9乘法表

package Struct;

public class ForDemo4 {
    public static void main(String[] args) {
        //打印9*9乘法表
        for (int i = 1; i < 10; i++) {
            for (int j = 1; j <=i; j++) {
                System.out.print(i+"*"+j+"="+i*j);
                System.out.print("\t");
            }
            System.out.println();

        }
    }
}

1.增强性for循环

{
    public static void main(String[] args) {
        int[] numbers={10,20,30,40,50};//定义一个数组

        //遍历数组的元素
        for (int x:numbers){
            System.out.println(x);
        }
        
    }
}

2.break 、continue

break用于强行退出循环

package Struct;

public class BreakDemo {
    public static void main(String[] args) {
        int i=0;
        while (i<100){
            i++;
            System.out.println(i);
            if (i==30)
                break;;
        }
    }
}

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

package Struct;

public class ContinueDemo {
    public static void main(String[] args) {
        int i=0;
        while (i<100){
            i++;
            if (i%10==0){
                System.out.println();
                continue;
            }
            System.out.print(i+"\t");
        }
    }
}

输出：

1    2    3    4    5    6    7    8    9    
11    12    13    14    15    16    17    18    19    
21    22    23    24    25    26    27    28    29    
31    32    33    34    35    36    37    38    39    
41    42    43    44    45    46    47    48    49    
51    52    53    54    55    56    57    58    59    
61    62    63    64    65    66    67    68    69    
71    72    73    74    75    76    77    78    79    
81    82    83    84    85    86    87    88    89    
91    92    93    94    95    96    97    98    99    

---

3.方法

System.out.println();   类.对象.方法

方法是语句的集合，它们在一起执行一个功能

方法命名规则：首字母小写，后面遵循驼峰原则。

设计方法的原则：一个方法只完成一个功能。

Java的方法类似于C语言的函数，是一段用来完成特定功能的代码片段。

修饰符 返回值类型 方法名（参数类型 参数名）{

....

方法体

...

return 返回值；

}

修饰符：这是可选的，

返回值类型：没有返回值的情况下关键字是void

方法名：首字母小写，后面遵循驼峰原则。

参数类型：是一个占位符，参数是可选的，方法可以不包含任何参数。

（1）实际参数：实际调用传给他的参数。

（2）形式参数：用来定义作用的。

方法体：方法体包含具体的语句，定义该方法的功能。

4.方法调用

调用方法：对象名.方法名（实参列表）

当方法返回一个值的时候，方法调用通常被当作一个值，int larger=max(30,40);

如果返回值是void，方法调用一定是一条语句   System.out.println("111");

package Method;

public class Demo2 {
    public static void main(String[] args) {
        int max = max(10, 20);
        System.out.println(max);
    }
    //比大小
    public static int max(int num1,int num2){
        int result=-1;
        if (num1==num2){
            System.out.println("num1==num2");
            return 0;//终止方法
        }
        if (num1>num2){
            result=num1;
        }else {
            result=num2;
        }
        return result;
    }

}

5.方法的重载

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

（1）方法名称必须相同

（2）参数列表必须不同（个数不同、类型不同、参数排列顺序不同等等）

package Method;

public class Demo2 {
    public static void main(String[] args) {
        double max = max(30.0, 20.0);
        System.out.println(max);
    }
    //比大小
    public static double max(double num1,double num2){
        double result=-1;
        if (num1==num2){
            System.out.println("num1==num2");
            return 0;//终止方法
        }
        if (num1>num2){
            result=num1;
            //return num1;
        }else {
            result=num2;
        }
        return result;
      }
    public static int max(int num1,int num2){
        int result=-1;
        if (num1==num2){
            System.out.println("num1==num2");
            return 0;//终止方法
        }
        if (num1>num2){
            result=num1;
            //return num1;
        }else {
            result=num2;
        }
        return result;
    }

}

6.可变参数

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

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

package Method;

public class Demo4 {
    public static void main(String[] args) {
        Demo4 demo4 = new Demo4();
        demo4.test(1,2,3,4,5,6);
    }
    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]);
    }
    /* public void method(){}
    public void method(int i){}
    public void method(int i,int i2){}
    public void method(int i,double i2){ }
    */
}

7.递归！

A方法自己调用自己

递归包括两个部分：

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

 

package Method;

public class Demo6 {
    public static void main(String[] args) {
        System.out.println(f(5));
    }
    public static int f(int n){
        if (n==1){
            return 1;
        }else {
            return n*f(n-1);
        }
    }
}

能不用递归尽量把不用递归，基数小的情况下可以使用。