Java学习笔记——方法

一、方法概述

先不说方法是什么，我们先看代码，分析下程序在哪里缺点，应该如何去改进。

• 不使用方法

        int x = 10;
        int y = 20;
        System.out.println(x+"+"+y+"="+(x+y));
        System.out.println(x+"+"+y+"="+(x-y));

        int x1 = 100;
        int y1 = 200;
        System.out.println(x1+"+"+y1+"="+(x1+y1));
        System.out.println(x1+"+"+y1+"="+(x1-y1));

        int x2 = 1000;
        int y2 = 2000;
        System.out.println(x2+"+"+y2+"="+(x2+y2));
        System.out.println(x2+"+"+y2+"="+(x2-y2));

• 使用方法

public class test01 {
    public static void main(String[] args) {
        //调用求和方法计算10和20的和
        sumInt(10,20);
        //调用求和方法计算666和888的和
        sumInt(666,888);
        //调用求和方法计算888和999的和
        sumInt(888,999);

    }
    public static void sumInt(int a, int b){
        int c = a + b;
        System.out.println(a+"+"+b+"="+c);
    }
}

• 使用方法和不使用方法原理：
  
  通过以上程序和图片可以看出来，方法就是一段普通的代码，并且这段代码可以完成某个特定的功能，而且可以被重复的调用或使用。

二、方法的使用

定义/声明方法的语法格式如图所示：

• [修饰符列表]：统一写成public static

• 返回值类型：Java语言当中任何一种数据类型，包括基本数据类型，也包括了所有的引用数据类型。如果一个方法执行结束之后不准备返回任何数据，则返回值类型必须写void。

• 返回值的类型：byte、short、int、long、float、double、char、String、void等。

• 方法名：方法名首字母小写，后面每个单词首字母大写，遵循驼峰命名方式，见名知意，例如：login、getUsername、getPassword等等

• 形式参数列表：(int a,int b)简称形参，每一个形参都是局部变量。

• 方法体：在形参的后面使用括号起来就是方法体，方法体是完全功能的核心代码，方法体当中的代码只遵循自上而下的顺序依次执行，不能跳到执行。

• 方法调用：调用方法格式是提前是方法的修饰符列表中带有static关键字。

• 关于实参：方法在调用的时候，实际传给这个方法的数据被称为实际参数，简称实参，Java语法中规定，实参和形参必须对应的，例如：实参（10,20）对应的形参（int a,int b）

三、方法的返回值

每个方法都是为了完成某个特定的功能，例如：登录功能、求和功能等，既然是功能，那么当这个功能完成之后，大多数情况下都会有一个结果的，比如，登录成功了或者失败了（true/false），求和之后最后的结果是100 或者200，等等。

四、方法执行过程中

常见的数据结构有哪些呢？例如：栈、队列、链表、数组、树、图、堆、散列表等。目前我们先来学习一下栈（stack）数据结构，这是一种非常简单的数据结构。

栈（stack），它是一种运算受限的线性表。其限制是：仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈（push），它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈、退栈或弹栈（pop），它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。

public class test04 {
    public static void main(String[] args) {
        /*
            方法执行过程的内存分析
                方法的执行过程需要使用到栈数据结构
         */
        /*
            先执行main主方法
            main begin
            m1 begin
            m2 begin
            m2 over
            m1 over
            main over
         */
        System.out.println("main begin");
        m1();
        System.out.println("main over");
    }

    public static void m1(){
        System.out.println("m1 begin");
        m2();
        System.out.println("m1 over");
    }
    public static void m2(){
        System.out.println("m2 begin");
        System.out.println("m2 over");
    }
}

运行结果

• 方法执行内存的结构
  通过执行结果我们了解到，main 方法最先被调用，但是它是最后结束的，其中 m2方法最后被调用，但它是最先结束的。调用的时候分配内存是压栈，结束的时候是释放内存弹栈。

五、方法重载/overload

构造方法是类的一种特殊方法，用来初始化类的一个新的对象，在创建对象（new 运算符）之后自动调用。Java 中的每个类都有一个默认的构造方法，并且可以有一个以上的构造方法。

Java构造方法有以下的特点：

1. 方法名必须与类名相同
2. 可以有0个、1个或者多个参数
3. 没有任何返回值，包括void
4. 默认返回类型就是对象类型本身
5. 只能与new运算符结合使用

    public static void main(String[] args) {
        /*
            方法重载
         */
        int a = 10;
        int b = 10;
        int result =sum(a,b);
        System.out.println(result);

        long a1 = 10L;
        long b1 = 20L;
        long result1 = sum(a1,b1);
        System.out.println(result1);

        double a2 = 10.0;
        double b2 = 20.0;
        double result2 = sum(a1,b2);
        System.out.println(result2);
    }


    /*
        方法名：是不允许重复的
        但是，方法重载除外

        做方法重载的设计，方法的名字必须是相同的
        语法是符合规则的

        构成方法重载需要满足一下3个条件：
        （1）在同一个类当中
        （2）方法名相同
        （3）参数列表不同，个数不同算不同，顺序不同算不同，类型不同也算不同
     */



    public static int sum(int a,int b){
        System.out.println("1--------------------");
        return a+b;
    }
    public static long sum(long a,long b){
        System.out.println("2--------------------");
        return a+b;
    }
    public static double sum(double a,double b){
        System.out.println("3--------------------");
        return a+b;
    }
}

运行结果

六、方法递归

方法递归就是方法自己调用自己。

public class test06 {
    public static void main(String[] args) {
        /*
            方法递归
                方法自己，调用自己
         */
        m();
    }
    public static void m(){
        System.out.println("123");
        m();
    }
}

java.lang.StackOverflowError，这个错误是栈内存溢出错误，错误发生后，JVM 退出了，程序结束了。 实际上以上代码在 m()方法执行过程中又调用了 m()方法，方法自身调用自身，这就是方法递归调用。