JavaSE笔记——03

标签：03 int System 笔记 static println JavaSE public out

Java方法

仅仅个人学习历程记录，不涉及任何商用

方法

1. 方法的定义：

一段用来完成特定功能的代码片段，类似于其他语言的函数。

2. 方法的作用：

用于定义该类或该类的实例的行为特征和功能实现

3. 区别：

面向过程中，函数是最基本的单位，整个程序都是由一个个程序组成的

面向对象中，整个程序的最基本的单位是类，方法是从属于类和对象的。

4. 方法的申明格式：

【修饰符1 修饰符2 ……】返回值类型方法名（形参列表）{

Java语句；

}

5. 方法的调用方法：

普通方法：	对象名.方法名（实参列表）
静态方法：	类名.方法名（实参列表）

6.

package Method;
/**
 * @author Yu
 * @version 1.8
 * @since 1.0
 * 功能：判断并输出最大值
 */

public class Demo01 {
    // main方法
    public static void main(String[] args) {
        int add = Demo01.max(20,30); // 通过类名直接调用静态方法
        System.out.println(add);
    }

    // 其他方法
    // static静态方法，可直接调用，否则就要new实例化来调用
    public static int max(int number1, int number2) {
        int result = 0;
        if(number1==number2){
            System.out.println("number1==number2");
            return 0;               // 返回值同时终止方法
        }else if (number1<number2){
            result=number2;
        }else {
            result=number1;
        }
        return result;
    }

}

return语句的作用：
```
	返回值；结束方法。
```

7. 扩展：值传递和引用传递（Java都是值传递）

package Method;
/**
* @author Yu
* @version 1.8
* @since 1.0
* 功能：实现值传递的测试类
*/
public class TestDemo02 {
    public static void main(String[] args) {
       int a = 1;
       System.out.println(a);      // 1
     
       TestDemo02.change(a);
       System.out.println(a);      // 1
     
       double b=11.1;
       b=TestDemo02.change(b);
       System.out.println(b);      // 10.1
	}
    public static void change(int a){
       a=10;
	}
    public static double change(double a){
        a=10.1;
        return a;
    }
}

package Method;
/**
 * @author Yu
 * @version 1.8
 * @since 1.0
 * 功能：实现引用传递的测试类
 *      引用传递：对象，其实本质还是值传递
 */
public class TestDemo03 {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name);        // null

        TestDemo03.change(person);
        System.out.println(person.name);        // 小李
    }
    
    public static void change(Person person){
        // person是一个对象：指向的 ---> Person person = new Person;
        person.name="小李";
    }

}

// 1.定义一个Person类，有一个属性：name
class Person{
    String name;   // null
}

8. 方法的重载

重载是在一类中，有相同的方法名，参数列表不同的方法
构成方法重载的条件：
1. 不同的含义：形参类型、形参个数、形参顺序不同
2. 方法名称必须相同
3. 只有返回值类型不同不构成方法的重载
```
eg：int a(String str){} 和 void a(String str){}
```
4. 只有形参的名称不同，也不构成方法的重载
```
eg: int a(String str){} 和 int a(String s){}
```
实现理论

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

命令行传参

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

package Method;
/**
 * @author Yu
 * @version 1.8
 * @since 1.0
 * 功能：靠传递命令行参数给 main()函数里的数组赋值并输出
 */
public class Demo04 {
    public static void main(String[] args) {
        for (int i = 0; i < args.length; i++) {
            System.out.println("args["+i+"]:"+args[i]);
        }
    }
}

可变参数

Jdk1.5开始，Java支持传递同类型的可变参数给一个方法。
在方法声明中，在指定参数类型后加一个省略号 (…)。
一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。
本质：数组

package Method;

import java.util.Scanner;

/**
 * @author Yu
 * @version 1.8
 * @since 1.0
 * 功能：打印输入参数的最大值
 */
public class Demo05 {
    public static void main(String[] args) {
        Demo05.printMax(1,2,3,4);
        Demo05.printMax();
    }

    public static void printMax(int... num) {
        if(num.length==0){
            System.out.println("No arrays");
            return;
        }
        int max = num[0];
        for (int i = 0; i < num.length; i++) {
            if (num[i]>max){
                max = num[i];
            }
        }
        System.out.println("max:"+max);
    }
}

递归（自己调自己）

递归结构包括两个部分

定义递归头：解决什么时候不调用自身的方法
定义递归体：解决什么时候需要调用自身

package Method;

import java.util.Scanner;

/**
 * @author Yu
 * @version 1.8
 * @since 1.0
 * 功能：计算n！
 */
public class TestFactorial {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("输入要计算多少的阶乘，即n:");
        if(scanner.hasNextInt()){
            int num = scanner.nextInt();
            System.out.println(factorial(num));
        }
    }

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

递归耗时

package Method;

import java.util.Scanner;

/**
 * @author Yu
 * @version 1.8
 * @since 1.0
 * 功能：(1)计算n！
 *      (2)打印递归耗时
 */
public class TestFactorial {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("输入要计算多少的阶乘，即n:");
        if(scanner.hasNextInt()){
            int num = scanner.nextInt();
            long startTime = System.currentTimeMillis();
            System.out.println(factorial(num));
            long endTime = System.currentTimeMillis();
            System.out.println("耗时:"+(endTime-startTime));
        }
    }

标签：03,int,System,笔记,static,println,JavaSE,public,out
From： https://www.cnblogs.com/manqingxiao/p/17351182.html