java调动操作系统的命令

1. 什么是方法
2. 方法的定义和调用
3. 方法重载
4. 命令行传参
5. 可变参数
6. 递归

什么是方法

• System.out.println()是根据什么得来的？

调用System类中的out方法中的println功能

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

• 方法是解决一类问题的步骤的有序集合
• 方法包含于类或者对象中
• 方法在程序中被创建，在其他地方被引用

• 设计方法的原则: 方法的本意是功能块，就是实现某个功能的语句块的集合
• 设计方法的宗旨:就是一个方法只完成一个功能，这样有利于我们后期拓展

/*
 * 通过方法实现加减程序的功能
 */
public class demo01 {
    public static void main(String[] args) {
        int sum = add(1, 2);
        int minus =minu(3,2);
        int multi = multiplication(6, 3);
        int division = division(6,3);
        System.out.println("Sum: "+sum+", Miunus: "+minus+
                "multi: "+multi+" ,division: "+division);
    }
    public static int add(int a,int b){
        return a+b;
    }
    public static  int minu(int a,int b){
        return a-b;
    }
    public static int multiplication(int a, int b){
        return a*b;
    }
    public static int division(int a, int b){
        return a/b;
    }
}

方法的定义和调用

方法的就是一段完成特定功能的代码片段，一般情况下，定义一个方法包含以下语法:

方法头部 和 方法体 ：

• 修饰符：修饰符，可选，告诉编译器如何使用该方法，定义访问的类型
• 返回值类型：方法可能会返回值，returnValueType，如果没有返回值，关键字就是void
• 方法名: 是方法实际的名称，方法名和参数表共同构成方法的签名
• 参数类型 参数名：参数就像是一个占位符，方法被调用的时候传递值给参数，这个值被称之为实参或者变量。参数列表是指方法的参数类型、顺序、参数的个数.

• 形式参数：在方法被调用的时用于接受外界输入参数
• 实参: 调用方法时实际传给方法的数据

• 方法体：定义方法实现功能的语句

修饰符 返回值类型 方法名(参数类型 参数名){
	//方法体
	return 返回值;
}
/*
 * 比较大小的方法
 */
 
 
public class demo02 {
    public static void main(String[] args) {
        max(5,2);
    }
    public static int max(int num1, int num2) {
     		num1==num2?return 0:"";
     		int result = num1>num2?num1:num2;
        System.out.println(result);
        return  result;
    }
}

方法调用

• 调用方法:对象名称.方法名

Java支持两种调用方法的方式,根据方法是否有返回值来选择

int larger = max(30,40);

如果方法返回值是void，方法调用一定是一条语句

System.out.println("Hello World")

方法重载

• 重载就是在一个类中，有着相同的函数名称，但是形参不同的函数
• 方法重载的规则:

• 方法的名称必须相同
• 参数列表必须不同(个数、类型、排列顺序)
• 方法的返回类型可以相同也可以不同
• 仅仅返回类型不同不能重载

• 实现理论:

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

命令行传参

• 有时候希望一个程序执行以后在传递参数，这个传递参数主要通过main()方法来实现

public class CommandLine{
	public static void main(String [] args){
		for(int i=0; i<args.length;i++){
			System.out.println("args["+i+"]: "+args[i])
		}
	}
}
执行：java com.Methods.demo03 this is wallen
结果:
args[0] this
args[1] is
args[2] wallen

可变参数

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

public class demo04 {
    public static void main(String[] args) {
        printMax(10.0,20.0,50.0,25.55,78.839);
        System.out.println("===========");
        printMax();
    }
    public static void printMax(double...numbers){
        if(numbers.length==0){
            System.out.println("No argument passed");
            return;
        }
        double result = numbers[0];
        for (int i = 0; i < numbers.length; i++) {
            if(result<numbers[i]){
                result = numbers[i];
            }
        }
        System.out.println("The value is  :"+result);

    }
}

递归

递归就是方法本身调用自己

利用递归可以实现简单的程序来解决一些复杂的问题，它同上把一个大型复杂的问题层层转化为一个与袁文提相似规模较小的问题来求解，递归的能力在于用有限的语句来定义对象的无线集合

递归结构包含两个部分:

1. 递归头:什么时候不调用自身方法，如果没有头，将陷入死循环
2. 递归体: 什么时候需要调用自身的方法

public class demo05 {
   public static void main(String[] args) {
       /*
        * 通过递归实现斐波那契序列
        */
       demo05 demo05 = new demo05();
       double result = demo05.Fibonacci(3);
       System.out.println(result);
   }

   public static double Fibonacci(int number) {
       if (number == 1) {
           return 1;
       } else {
           return number * Fibonacci(number - 1);
       }
   }
}
/ *
   * result: 6 
   */

实现一个简单的计算器:

public class Calculator {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入你要进行的运算(+、-、*、/):  ");
        String s = scanner.nextLine();
        System.out.println("请输入要运算的第一个参数:  ");
        double s1 = scanner.nextDouble();
        System.out.println("请输入你要运算的第二个参数:  ");
        double s2 = scanner.nextDouble();

        Calculator calculator = new Calculator();
        switch (s){
            case "+":
               double result =calculator.add(s1,s2);
                System.out.println("result: "+result);
                break;
            case "-":
                double result1 =calculator.minus(s1,s2);
                System.out.println("result: "+result1);
                break;
            case "*":
                double result2 =calculator.multiplication(s1,s2);
                System.out.println("result: "+result2);
                break;
            case "/":
                double result3 =calculator.division(s1,s2);
                System.out.println("result: "+result3);
        }
    }
    public static double add(double a, double b){
        return a+b;
    }
    public static double minus(double a,double b){
        return a-b;
    }
    public static double multiplication(double a, double b){
        return a*b;
    }
    public static double division(double a, double b){
        return a/b;
    }
}