标签：java int void args day06 static 方法 public

Java流程控制

循环结构

增强for循环
- Java5引入了一种主要用于数组或集合的增强型for循环
- 增强型for循环格式如下：
  - for(声明语句 : 表达式){ //代码 }
  - 声明语句：声明局部变量，此变量类型必须要与数组元素类型匹配
  - 表达式：要访问的数组名或者返回数组的方法
- 主要用来遍历数组和集合

break

break在任何循环语句的主体部分都可以控制流程，用于强制退出循环，不执行循环中brake下面的语句，也在switch中使用因为穿透效应的存在

public class BreakDemo1 {
    public static void main(String[] args) {
        int i = 0;
        while(true){
            i = i +1;
            System.out.println(i);
            if(i==50){
                break;//跳出循环
            }
        }
        //break跳出循环后，循环外的语言正常执行 对于switch也是如此
        System.out.println("谢谢了break兄弟，要不然什么时候才能执行到我");
    }
}

continue

continue语句用在循环语句中，用于终止某次循环缓存，即跳过循环体中还未执行的语句，去进行下一次是否执行循环的判定

public class ContinueDemo1 {
    public static void main(String[] args) {
        int i = 0;
        while (i<100){
            i = i+1;
            if (i%10==0){
                System.out.println();
                continue;     //遇到continue 程序回到while（i<100）地方继续执行

            }
            System.out.print(i+" ");
        }
    }
}

如果有两层循环continue在内循环中猜猜会怎么样

练习题

打印正方形和三角形

public class PracticeDemo1 {

    public static void main(String[] args) {

        //打印6*6正方形
        for (int i = 1; i <= 6; i++) {
            System.out.print("\t\t");
            for (int j = 1; j <= 6; j++) {
                System.out.print("*"+"  ");
            }
            System.out.println();
        }

        System.out.println("\n"+"++++++++++++++++++++++++++++++++++++++++"+"\n");

        //打印三角形6行
        for (int i = 1; i <= 5; i++) {
            System.out.print("\t");  //加了制表符让整个位置靠右一些
            for (int j = 5; j >= i; j--) {
                System.out.print("  ");  //左下倒三角
            }
            for (int k = 1;k <= i; k++){
                System.out.print(" *");  //左正三角
            }
            for (int l = 1;l < i; l++){
                System.out.print(" *");  //右正三角
            }
            System.out.println();

        }
    }
}

Java方法

什么是方法

Java方法是语句的集合，它们在一起执行一个功能
- 方法是解决一类问题的步骤的有序组合
- 方法包含于类或对象中
- 方法在程序中被创建，在其他地方被引用

设计方法的原则：方法的本意是功能块，就是实现某个功能的语句块的集合。设计方法的时候最好保持方法的原子性，即一个方法只完成一个功能，这样有利于后期的拓展

public class Demo1 {

    //main方法
    public static void main(String[] args) {
        int sum = add(1,2); //直接调用add方法 无须新建Demo1类型 Demo1 d = new Demo1() 然后d.add()调用
        System.out.println(sum);
    }

    //加法
    //增加关键字static可以在类中直接调用本方法
    public static int add(int a,int b){
        return a+b;
    }
}

方法的定义

Java的方法类似其他语言的函数，是一段用来完成特定功能的代码片段。一个方法的语法如下：
- 方法包含一个方法头和一个方法体
  - 修饰符：这是可选的，定义此方法的访问类型
  - 返回值类型：有些方法需要返回值，返回值类型规定了方法返回值的数据类型不需要返回值关键字就为void
  - 方法名：方法的实际名称。方法名和参数表共同构成方法签名。记得驼峰原则如runMan()
  - 参数类型：参数像占位符，声明了传入方法变量的类型和数量声明是形参实际传入的变量是实参
  - 方法体：包含具体的语句，定义该方法的功能

方法的调用

调用方法：对象名.方法名(实参列表)
Java支持两种调用方法的方式，根据方法是否包含返回值来选择
当方法返回一个值时，方法调用通常被当作一个值：int a = max(10,20);
返回值为void，当作一条语句处理：System.out.print(max());
Java的值传递以及Java不具有的引用传递
- 值传递：是指在调用函数时，将实参复制一份到函数中，这样函数对参数如何更改都不会应该实际参数
- 引用传递：在调用函数时，将实参的地址传递到函数中，这样的话函数对参数修改，实参也会被影响

  public class Demo2 {
    public static void main(String[] args) {
        double d = new Demo2().max(34.9,67);     
   		System.out.println(d);
}

//比大小
public double max(double a,double b){
    double res = 0.0;
    //        if (a>b){
//            res = a;
//        }else if(a<b){
//            res = b;
//        }else {
//            System.out.println("数字相等");
//        }
        if (a==b){
            System.out.println("两个数相等");
            return 0;
        }
        if (a>b){
            res = a;
        }else {
            res = b;
        }
        return res;

    }

}

方法的重载

重载就是在一个类中，有相同的函数名称，但是形参不同包括类型不同或者数量不同的函数
方法重载的规则
- 方法名必须相同
- 参数列表必须不同（个数不同、类型不同或者排列顺序不同）
- 方法的返回值可同可不同
- 仅仅返回类型不同不能叫作重载
实现理论：
- 方法名称相同时，编译器会根据调用方法的参数个数、参数类型等去逐个匹配，以选择对应的方法，若匹配失败则编译器报错

public class Demo3 {
    public static void main(String[] args) {
        add(3,5);       //根据实参类型选择方法
        add(3.5,4.5);
    }
    
    public static int add(int a,int b){
        
        return a+b;
    }
    
    public static double add(double a,double b){
        
        return a+b; 
    } 
}

命令行传参

有时候需要运行一个程序在传递消息，就需要传递给main()方法实现

public class Demo4 {
    public static void main(String[] args) {
        //
        for (int i = 0; i < args.length; i++) {
            System.out.println("args["+i+"]:"+args[i]);
        }
    }
}

要注意在命令行执行且需要注意执行时路径问题

可变参数

在方法声明中，在指定参数类型后加一个省略好(...)
一个方法只能指定一个可变参数，必须时方法的最后一个参数，任何普通的参数必须在啊它之前声明

public class Demo5 {
    public static void main(String[] args) {
        Demo5 demo5 = new Demo5();
//        demo5.test(1,45,213);
        printMax(34.4,56.8,23432);
    }

    public void test(int...i){
        System.out.println(i[0]);
    }

    public static void printMax(double... numbers){

        if(numbers.length==0){
            System.out.println("没有数字可以比较");
            return; 
        }
        double res = numbers[0];
        for (int i = 1; i < numbers.length ; i++) {
            if(res < numbers[i]){
                res = numbers[i];
            }
        }
        System.out.println("最大数是：" + res);
    }
}

可以发现可变参数实质上就是一个数组

递归

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

递归结果包括两个部分

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

public class Demo6 {
    public static void main(String[] args) {
        System.out.println(fn(5));

    }

    public static int fn(int n){
        if (n == 1){
            return 1;
        }else {
           return n*fn(n-1);
        }
    }
}

标签：java,int,void,args,day06,static,方法,public
From： https://www.cnblogs.com/onlyxue/p/16754133.html

java_day06