java方法
-
调用系统类里面的标准输出对象out中的方法println()。
-
方法是语句的集合，它们在一起执行一个功能；一个方法只完成一个功能，利于后期扩展（原子性）。命名规则：首字母小写，驼峰命名规则。
-
方法包含于类或对象中，在程序中被创建，在其它地方被引用。‘
-
代码加法如下：
package com.zhz.base.method;
public class Demo01 {
//main方法
public static void main(String[] args) { //void类型为没有返回值
int sum = add(1, 2); //直接调用add方法，把1和2赋值给a和b,在方法中运算后，赋值给sum，（1，2）是实际参数。
System.out.println(sum);
test(); //假设为某方法，可以如此引用 public static void test(){}
}
//加法
public static int add(int a,int b){ //public static为修饰符，int为返回值类型，add为方法名，随意取，括号内int a,int b为形式变量，形参（定义作用的参数）
return a+b;
}
}
方法的定义
修饰符：public static告诉编译器如何让调用该方法，定义方法的访问类型。
返回值类型：int void 方法可能会产生返回值，也可能只有操作，无返回值。
方法名：首字母小写，驼峰原则。
参数类型：像是一个占位符，方法被调用时，实参传递值给形参，参数是可选的，方法可以不含参数；形参是在方法被调用时用于接收外界输入数据，实参是调用方法时实际传给方法的数据。
方法体：包含具体语句，定义方法功能。
修饰符 返回值类型 方法名（参数类型 参数名）{
方法体
return 返回值；
}
-
方法调用：对象名.方法名（实参列表）
-
当方法有返回值时，方法调用通常都会被当成一个值。int max = max(10, 20);
-
当方法返回值是void时，方法调用一定是一条语句。System.out.println("hello");
-
代码如下：一个main方法，被JVM虚拟机调用，一个max方法，
package com.zhz.base.method;
public class Demo02 {
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 = 0;
if(num1==num2){
System.out.println("num1==num2");
return 0; //return的作用是终止方法，结束方法或者返回值。
}
if (num1>num2) {
result = num1;
}else{
result = num2;
}
return result; //return
}
}
-
值传递（java都是值传递，有一个拷贝的概念）和引用传递，后期更。
方法的重载
-
重载就是在一个类中，有相同的函数名称，但形参不同的函数。
-
方法可以有无限多重名，但要确保参数类型不同，就是方法的重载，JVM编译器会根据方法的样子，参数类型判断用哪个方法；找不到方法，编译器会报错。
-
重载的规则：方法名称必须相同；参数列表必须不同（个数不同或类型不同，参数排列顺序不同等）;返回值可以相同，可以不同
-
代码如下：
package com.zhz.base.method;
public class Demo02 {
public static void main(String[] args) {
double max = max(10, 20);
System.out.println(max);
}
//方法一
public static int max(double num1,double num2){
double result = 0;
if(num1==num2){
System.out.println("num1==num2");
return 0; //return的作用是终止方法，结束方法或者返回值。
}
if (num1>num2) {
result = (int)num1;
}else{
result = (int)num2;
}
return result; //return
}
//比大小
public static int max(int num1,int num2){
int result = 0;
if(num1==num2){
System.out.println("num1==num2");
return 0; //return的作用是终止方法，结束方法或者返回值。
}
if (num1>num2) {
result = num1;
}else{
result = num2;
}
return result; //return
}
}
-
命令行传参
package com.zhz.base.method;
public class Demo03 {
public static void main(String[] args) {
//args.length 数组长度
for (int i = 0; i < args.length; i++) {
System.out.println("args["+i+"]:"+args[i]);
}
}
}
在命令行中传参数运行：
想要直接运行一个class文件，需要找到所含包的路径com.zhz.base.method，一层层返回到包含这些文件夹外面的文件夹，然后进行加载，否则不能执行，无法加载主类。（open in explorer在文件夹中打开）。
可变参数
一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通参数必须它之前声明；在指定参数类型后加一个省略号...
代码一：输出结果是一个对象：[I@4554617c
package com.zhz.base.method;
public class Demo04 {
public static void main(String[] args){
Demo04 demo04 = new Demo04(); //new一个类Demo04,它会返回一个当前，demo04就是一个对象，对象名可以随便取。
demo04.test(); //对象.方法 上一行创建出这个类public class Demo04里的Demo04这个类，这个类里面存在方法test,所以用demo04来调用这个方法。
}
public void test(int...i){
System.out.println(i);
}
}
代码二：给i赋值1，2，3，输出1，3
package com.zhz.base.method;
public class Demo04 {
public static void main(String[] args){
Demo04 demo04 = new Demo04(); //new一个类Demo04,它会返回一个当前，demo04就是一个对象
demo04.test(1,2,3); //对象.方法 上一行创建出这个类public class Demo04里的Demo04这个类，这个类里面存在方法test,所以用demo04来调用这个方法。
}
public void test(int...i){
System.out.println(i[0]);
System.out.println(i[2]);
}
}
代码三：排序方法和调用
max(2,3,4,6,7);
public static void max(double...numbers){
double result = numbers[0];
for (int i = 0; i < numbers.length; i++) {
if (numbers[i]>result) {
result = numbers[i];
}
}
System.out.println("The max value is" + result);
}
递归
A方法调用A方法，就是自己调用自己。（可能导致栈溢出异常），一种思想。
递归结构：递归头：什么时候不调用自身方法。如果没有头，将陷入死循环；
递归体：什么时候需要调用自身方法。
阶乘代码如下：
package com.zhz.base.method;
public class Demo06 {
public static void main(String[] args) {
System.out.println(f(3));
}
//2 2*f(1) 2的阶乘
//3 3*f(2) 3的阶乘
public static int f(int n){
if(n==1){
return 1;
}else{
return n*f(n-1); //一层一层调用，f(5)调用f(4),f(4)调用f(3),...f(2)调用f(1),f(1)有结果，
} //f(1)会向上，一层层返回结果。
} //想办法让递归能走到一个尽头f(1)，并且能跑的出来，比如到运算f(1)之后，程序执行到底 了，不会在往下走了。所有东西f(2),f(3),f(4),f(5)瞬间就会全部都有值，然后一步一步返回。
//边界条件：到最后一个数的时候，程序会执行到底，就是有一个边界。
//前阶段：到边界之前；返回阶段：到边界之后。
//java都是使用栈机制的，就比如一个罐子，main在最底层，每调用一个方法，就会在上面压一层，方法结束后就会消失，main方法执行完了，栈里面就空了，它就不跑程序了。假设无限往栈里面压东西，栈里面空间就不行了。对于一些嵌套层数比较深的算法，递归就会显得力不从心，物理内存上造成内存崩溃，就崩了。因为代码虽然写起来简单，但代码调用函数比较多。递归深度越大，时控性就不好了，会占用大量空间内存。能不用就不用。基数较小可以用。
}
