java基础笔记 --5.方法入门

一、方法:就是将一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能。

当我们需要这个功能的时候，就可以去调用。这样即实现了代码的复用性，也解决了代码冗余的现象。

定义格式:

修饰符 返回值类型 方法名 （参数列表）{

            代码......

            return ;

}

 

public static void 方法名称() {

          方法体

}

定义格式解释：

*  修饰符：目前固定写法 public static 

* 返回值类型：目前固定写法 void,其他返回值类型在后面的课程讲解.

* 方法名：为我们定义的方法起名，满足标识符的规范，用来调用方法.

* 参数列表：目前无参数，带有参数的方法在后面的课程讲解。

* return : 方法结束。因为返回值类型是void，方法大括号内的return 可以不写.

public static void main(String[] args) {
        System.out.println("这是一个方法");
    }

方法名称的命名规则和变量一样，使用小驼峰。

方法体：也就是大括号当中可以包含任意条语句。

 

注意事项：

1. 方法定义的先后顺序无所谓。

2.方法定义好了之后，不会执行的。如果要想执行，一定要进行方法的【调用】

 如何调用方法，格式:

public class Demo11Method {
	
	public static void main(String[] args) {
		farmer(); // 调用农民的方法
		seller(); // 调用小商贩的方法
		cook(); // 调用厨子的方法
		me(); // 调用我自己的方法
	}
	
	// 厨子
	public static void cook() {
		System.out.println("洗菜");
		System.out.println("切菜");
		System.out.println("炒菜");
		System.out.println("装盘");
	}
	
	// 我
	public static void me() {
		System.out.println("吃");
	}
	
	// 小商贩
	public static void seller() {
		System.out.println("运输到农贸市场");
		System.out.println("抬高价格");
		System.out.println("吆喝");
		System.out.println("卖给厨子");
	}
	
	// 农民伯伯
	public static void farmer() {
		System.out.println("播种");
		System.out.println("浇水");
		System.out.println("施肥");
		System.out.println("除虫");
		System.out.println("收割");
		System.out.println("卖给小商贩");
	}
}

3.方法定义注意事项：

* 方法必须定义在一类中，方法外

* 方法不能定义在另一个方法的里面

public class Demo {
    public static void main(String[] args){
    }
    //正确写法，类中，main方法外面可以定义方法
    public static void method(){}
}

public class Demo {
    public static void main(String[] args){
        // 错误写法，一个方法不能定义在另一方法内部
        public static void method(){}
    }
}

二、扩展知识点

2.1 += 符号的扩展

下面的程序有问题吗？

public static void main(String[] args) {
        short s = 1;
        s += 1;
        System.out.println(s);
    }

分析： s += 1 逻辑上看作是 s = s + 1 计算结果被提升为int类型，再向short类型赋值时发生错误，因为不能将取值范围
大的类型赋值到取值范围小的类型。但是， s=s+1 进行两次运算 ， += 是一个运算符，只运算一次，并带有强制转换的特点，
也就是说 s += 1 就是 s = (short)(s + 1) ，因此程序没有问题编译通过，运行结果是2。

2.2 常量和变量的运算

下面的程序有问题吗？

public static void main(String[] args) {
    byte b1 = 1;
    byte b2 = 2;
    byte b3 = 1 + 2;
    byte b4 = b1 + b2;
    System.out.println(b3);
    System.out.println(b4);
    
}

分析： b3 = 1 + 2 ， 1 和 2 是常量，为固定不变的数据，在编译的时候（编译器javac），已经确定了 1+2 的结果并没
有超过byte类型的取值范围，可以赋值给变量 b3 ，因此 b3=1 + 2 是正确的。
反之， b4 = b2 + b3 ， b2 和 b3 是变量，变量的值是可能变化的，在编译的时候，编译器javac不确定b2+b3的结果是什
么，因此会将结果以int类型进行处理，所以int类型不能赋值给byte类型，因此编译失败。

三、有参数的方法的定义和调用

格式：

修饰符 返回值类型 方法名（参数列表) {

      // 代码省略...

      return 结果;

}

* 修饰符： public static 固定写法
* 返回值类型： 表示方法运行的结果的数据类型，方法执行后将结果返回到调用者
* 参数列表：方法在运算过程中的未知数据，调用者调用方法时传递
* return ：将方法执行后的结果带给调用者，方法执行到 return ，整体方法运行结束

public static void main(String[] args) {
        // 调用方法getSum，传递两个整数，这里传递的实际数据又称为实际参数
        // 并接收方法计算后的结果，返回值
        int sum = getSum(5,6);
        System.out.println(sum);
    }

    /*
   定义计算两瞧瞧整数和的方法
   返回值类型，计算结果是int
   参数：不确定数据求和，定义int参数又称为形式参数
     */
    public static int getSum(int a,int b) {
        return a + b;
    }
}

程序执行，主方法 main 调用 getSum 方法，传递了实际数据 5 和6 ，两个变量 a 和b 接收到的就是实际参数，并
将计算后的结果返回，主方法 main 中的变量 sum 接收的就是方法的返回值。

四、方法重载

方法重载：指在同一个类中，允许存在一个以上的同名方法，只要它们的参数列表不同即可，与修饰符和返回值类型无关。

参数列表：个数不同，数据类型不同，顺序不同。

重载方法调用：jvm通过方法的参数列表，调用不同的方法。

/*
对于功能类似的方法来说，因为参数列表不一样，却需要记住那么多不同的方法名称，太麻烦。

方法的重载（Overload）：多个方法的名称一样，但是参数列表不一样。
好处：只需要记住唯一一个方法名称，就可以实现类似的多个功能。

方法重载与下列因素相关：
1. 参数个数不同
2. 参数类型不同
3. 参数的多类型顺序不同

方法重载与下列因素无关：
1. 与参数的名称无关
2. 与方法的返回值类型无关
 */
public class Demo01MethodOverload {

    public static void main(String[] args) {
        /*System.out.println(sumTwo(10, 20)); // 30
        System.out.println(sumThree(10, 20, 30)); // 60
        System.out.println(sumFour(10, 20, 30, 40)); // 100*/

        System.out.println(sum(10, 20)); // 两个参数的方法
        System.out.println(sum(10, 20, 30)); // 三个参数的方法
        System.out.println(sum(10, 20, 30, 40)); // 四个参数的方法
//        System.out.println(sum(10, 20, 30, 40, 50)); // 找不到任何方法来匹配，所以错误！

        sum(10, 20);
    }

    public static int sum(int a, double b) {
        return (int) (a + b);
    }

    public static int sum(double a, int b) {
        return (int) (a + b);
    }

    public static int sum(int a, int b) {
        System.out.println("有2个参数的方法执行！");
        return a + b;
    }

    // 错误写法！与方法的返回值类型无关
//    public static double sum(int a, int b) {
//        return a + b + 0.0;
//    }

    // 错误写法！与参数的名称无关
//    public static int sum(int x, int y) {
//        return x + y;
//    }

    public static int sum(double a, double b) {
        return (int) (a + b);
    }

    public static int sum(int a, int b, int c) {
        System.out.println("有3个参数的方法执行！");
        return a + b + c;
    }

    public static int sum(int a, int b, int c, int d) {
        System.out.println("有4个参数的方法执行！");
        return a + b + c + d;
    }

}