输入与输出+方法

一、输出

1、System.out.println("需要换行");
2、System.out.print("不用换行");
3、System.out.printf("%s","需要格式化输出");

二、输入 

基本格式：
Scanner scanner=new Scanner(System.in);
int age= scanner.nextInt();//输入一个整数

注意：

1、

​​ Scanner scanner=new Scanner(System.in);
        int age= scanner.nextInt();
        System.out.println("年龄： "+age);
        Scanner scanner1=new Scanner(System.in);
        String name= scanner.nextLine();  
        System.out.println("姓名： "+age);
  

nextLine不能用在第二个输出，因为它表示输出一行，会把第一次输出的回车读掉；所以可以先输出姓名，在输出年龄

2、

 Scanner scanner=new Scanner(System.in);
        String name= scanner.next();
        System.out.println("姓名： "+name);
        Scanner scanner1=new Scanner(System.in);
        int age= scanner.nextInt();
        System.out.println("年龄： "+age);
    

 next读到空格就会自动结束，所以会出现编译错误

 当输入数据时，优先处理字符串输入

 3、多次循环输入整数

ublic static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        while (scanner.hasNextInt()) {      //hasNextInt是输入整数的
            int age = scanner.nextInt();
            System.out.println("年龄： " + age);
        }
    }
}

  IDEA上用Ctrl+D结束字符串的输入

三、方法(用小驼峰表示）

方法定义：

public  static  返回值类型  方法名（形式参数列表）{

方法体；

}

（1）方法的调用：

函数无返回值类型：

public static void add(int x,int y){
        System.out.println(x+y);        //无返回值类型直接输出
    }
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        int a= scanner.nextInt();
        int b= scanner.nextInt();
        add(a,b);
    }

函数有返回值类型： 

public static int  add(int x,int y){
        return x+y;                      //有返回值类型必须return
}
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        int a= scanner.nextInt();
        int b= scanner.nextInt();
        int ret=add(a,b);
        System.out.println(ret);
    }

分析：局部变量作用域为什么会在函数里面？

只要调用方法，就会在虚拟栈上开辟一块栈帧，这个栈帧也会分配内存给里面的局部变量，当遇到函数遇到return表示函数结束，这个栈会被回收，而栈里面的局部变量也会被销毁。

（2）实参与形参的关系

1、 形参是实参的临时拷贝，对形参的改变不会改变到实参

2、局部变量在栈中存储，而Java是在堆中，不能获取栈上的地址，要想在Java中交换a和b两个变量，必须把他们放在堆上。数组是在栈上存放的

 四、方法的重载

定义：

1、方法名称必须一致

2、方法参数（数据类型   个数    顺序）不一样

3、返回值没有过多要求

优点：不需要记住太多方法名，降低成本

 

五、递归 

方法在执行过程中调用自身，起始条件也是终止条件。

1、求 N 的阶乘

法一：递归

public static int fac(int n){
        if(n==1){
            return 1;
        }
        return n*fac(n-1);
    }
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        int n= scanner.nextInt();
        int ret=fac(n);
        System.out.println(ret);
    }

 法二：方法

public static int fac1(int y){
        int ret=1;
        for (int i = 1; i <=y ; i++) {
            ret*=i;
        }
        return ret;
    }
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        int n= scanner.nextInt();
        int a=fac1(n);
        System.out.println(a);
    }

2、按顺序打印一个数字的每一位(例如 1234 打印出 1 2 3 4)

public static void print(int x) {
        if (x < 10) {
            System.out.println(x);
        } else {
            print(x / 10);
            System.out.println(x % 10);
        }
    }
    public static void main(String[] args){
        int a = 1234;
        print(a);
    }

3、求打印的每一位之和

public static int sum(int x) {
        if (x < 10) {
            return x;   //返回1与后面相加
        }
            int tmp = x % 10 + sum(x / 10);
            return tmp;
        }
        public static void main (String[]args){
            int d=1234;
            int ret = sum(d);
            System.out.println(ret);
        }

4、递归求 1 + 2 + 3 + ... + 10

public static int sum4(int x){
        if (x==1){
            return 1;
        }
        return x+sum4(x-1);
        }
    public static void main(String[] args) {
        int g=sum4(4);
        System.out.println(g);
    }

5、求斐波那契数列的第 N 项

例如：1   1  2    3   5  8  13  21

法1：循环，程序的执行效率大大提高

public static int fib(int n) {
        int a = 1;
        int b = 1;
        int c = 0;
        for (int i = 3; i <=n; i++) {
            c=a+b;
            a=b;
            b=c;
        }
        return c;
    }
    public static void main(String[] args) {
       int ret= fib(6);
        System.out.println(ret);
    }

 法2：递归  （效率不高，多次重复运算）

public static int fib1(int n) {
        if (n==1||n==2){
            return 1;
        }
        return fib1(n-1)+fib1(n-2);
    }
    public static void main(String[] args) {
        int ret= fib1(2);
        System.out.println(ret);
    }