Java的基本概念（5）方法

一：方法

①：什么是方法？

	方法（method）是程序中最小的单元

②：实际开发中，什么时候用到方法？

	重复的代码、具有独立功能的代码可以抽取到方法中

③：实际开发中，方法有什么好处？

	可以提高代码的复用性跟可维护性

public class MethodDemo01 {
    public static void main(String[] args) {
        /*
        用输出语句来描述一局游戏
         */
        System.out.println("选人物");
        System.out.println("开局");
        System.out.println("对线");
        System.out.println("崩盘");
        System.out.println("骂队友");
        System.out.println("送人头");
        System.out.println("游戏结束");
    }
}

实际开发中的场景
如果有相同的场景，那我们可以，对某相同的场景打包，其他场景需要的时候直接调用
可以提高代码的复用性，跟可维护性

二：简单方法的定义和调用

①：把一些代码打包在一起，过程就是方法的定义
②：方法定义后并不是直接运行的需要手动调用才能执行，这个过程就成为方法的调用
方法的定义格式：

public  static   返回值类型   方法名(参数){
			方法体；
		  return  	返回值；
}

注意：方法必须先定义在使用，不然会报错

public class MethodDemo01 {
    public static void main(String[] args) {
        //使用方法调用，进行多局游戏
       playGames();
       playGames();
    }
    //定义一个简单的方法
    public static void playGames(){
        System.out.println("选人物");
        System.out.println("开局");
        System.out.println("对线");
        System.out.println("崩盘");
        System.out.println("骂队友");
        System.out.println("送人头");
        System.out.println("游戏结束");
    }
}

//Practice01

public class MethodDemo02 {
    public static void main(String[] args) {
        //定义一个方法，调用女朋友的信息
        printGFInfo();
    }
    public  static void printGFInfo(){
        System.out.println("嘿嘿嘿");
        System.out.println("18岁");
        System.out.println("活泼开朗");
    }
}

//Practice02
public class MethodDemo03 {
    public static void main(String[] args) {
        //需求：在方法里面定义两个变量求和并打印
        getSum();
    }

    public static void getSum(){
        int number1 = 10;
        int number2 = 20;
        int number3 = number1 + number2;
        System.out.println(number3);
    }
}

三：带参数的方法定义和调用

注意：方法调用时，参数的数量与类型必须与方法定义中小括号里面的变量一一对应，否则程序会报错

public class MethodDemo04 {
    public static void main(String[] args) {
        //带参数的方法，求任意两个数的和
        getSum(10,20);
    }
    public static void getSum(int num1,int num2){
        int result = num1 + num2;
        System.out.println(result);
    }
}

①：形参跟实参

形参：全称形式参数，是指方法定义的参数
实参：全称实际参数，方法调用中的参数

public class MethodDemo05 {
    public static void main(String[] args) {
        getLength(1.25,3.5);
    }

    /**
     * 求长方形的周长
     * @param len 高
     * @param with 宽
     */
    public static void getLength(double len ,double with){
        getArea(5.6);
        double result = (len + with) * 2;
        System.out.println(result);
    }

    /**
     * 求圆的面积
     * @param radius 半径
     */
    public static void getArea(double radius){
        double result1 = radius * radius * 3.14;
        System.out.println(result1);
    }
}

三：带返回值的方法定义和调用

方法的返回值就是方法运行结果

	如果在调用处要根据方法的结果，去编写另外一段代码逻辑
	为了在调用处拿到方法产生的结果，就需要定义带有返回值的方法

public class MethodDemo06 {
    public static void main(String[] args) {
      /*  //直接调用，用在没有返回值地方
        getSum(10,20,30);
        //赋值调用
        int sum = getSum(10,20,30);
        System.out.println(sum);
        //输出调用
        System.out.println(getSum(10,20,30));*/
        //先计算一个季度的营业额
        int sum1 = getSum(10,20,30);
        //先计算二个季度的营业额
        int sum2 = getSum(20,30,40);
        //先计算三个季度的营业额
        int sum3 = getSum(20,30,40);
        //先计算四个季度的营业额
        int sum4 = getSum(20,30,40);
        //计算季度总和
        int sum = sum1 + sum2 + sum3 +sum4;
        System.out.println("季度总和为：" +sum);

    }
    public static int getSum(int num1,int num2,int num3){
        int result = num1 + num2 + num3;
        return  result;
    }
}

注意：

	①：什么时候用到有返回值的方法？
					在调用处要根据方法的结果，去编写另外一段代码
	②：有返回值的定义格式
	       public static  返回值类型   方法名(参数){
				方法体;
				return f返回值；
			}
	③：有返回值方法的调用格式	
			直接调用       赋值调用      输出嗲用

public class MethodDemo07 {
    public static void main(String[] args) {
        //比较那个长方形大
        double air1 = getArea(1.65,5.30);
        double air2 = getArea(2.31,1.26);
        if (air1 > air2){
            System.out.println("第一个长方形大");
        }else {
            System.out.println("第二个长方形大");
        }
    }
    public static double getArea(double len, double with){
        double result = len * with;
        return  result;
    }
}

方法的注意事项

方法不调用就不执行
方法与方法之间是平级的关系，不能相互嵌套
方法的编写顺序和执行顺序无关
方法的返回值类型为void，表示该方法没有返回值，没有返回值的方法可以省略return语句，如果要编写return，后面不能跟具体的数据
return语句的下面，不能编写代码，因为永远执行不到，属于无效代码

方法的注意事项

方法没有返回值：可以省略不写，如果书写，表示结束方法
方法有返回值：必须要写，表示结束方法和返回结果

四：方法的重载

方法的重载practice

在用一个类中，定义了多个同名的方法，这些同名的方法具有同种的功能
每个方法具有不同的参数类型或参数个数，这些同名的方法，构成了重载的关系

简记：同一类中，方法名相同，参数不同的方法，与返回值无关
参数不同：个数不同，顺序不同
类型的顺序不同，也是可以构成重载的，但是不建议

public class MethodDemo08 {
    public static void main(String[] args) {
        /*
        需求：定义两个整数，设计比较两个整数是否相同
        要求：兼容(byte、short、int、long)
         */
        compare(10,20); // int方法   //false
    }

    public static void compare(byte b1, byte b2){
        System.out.println("byte");
        System.out.println(b1 == b2);
    }
    public static void compare(short s1, short s2){
        System.out.println("short");
        System.out.println(s1 == s2);
    }
    public static void compare(int i1, int i2){
        System.out.println("int");
        System.out.println(i1 == i2);
    }
    public static void compare(long l1, long l2){
        System.out.println("long");
        System.out.println(l1 == l2);
    }
}

五：练习

数组的遍历

public class Practice01 {
    public static void main(String[] args) {
        /*
        需求：设计一个方法用于遍历数组，要求遍历的数组是在一行上的
        例如：[11,22,33,44,55]
         */
        int[] array = {11,22,33,44,55};
        arr(array);
    }

    public static void arr(int[] array){
        System.out.print("[");
        for (int i = 0; i < array.length; i++) {
            if (i == array.length-1){
                System.out.print(array[i]);
            }else{
                System.out.print(array[i] + ",");
            }
        }
        System.out.print("]");
    }
}

求最大数值

public class Practice02 {
    public static void main(String[] args) {
        //定义一个数组
        int[] array = {1,5,7,9,3,10};

        //调用方法求最大值
        int max = getMax(array);
        System.out.println(max);
    }
    public static int getMax(int[] array){
        int max = array[0];
        for (int i = 1; i < array.length; i++) {
            if (max < array[i]){
                max = array[i];
            }
        }
        return max;
    }
}

判断数组中的数据是否存在

public class Practice03 {
    public static void main(String[] args) {
        //定义数组
        int[] array = {12,5,3,58,6,13,31};
        //判断一个数字是否在数组中存在
        boolean contains = contains(array, 31); //查存在的数，看返回值
        System.out.println(contains);
    }
    public static boolean  contains(int[] array,int number){
        for (int i = 0; i < array.length; i++) {
            if (array[i] == number){
                return true;
            }
        }
        return false;
    }

}

数组返回的内容设置

public class Practice04 {
    public static void main(String[] args) {
        /*
        需求：定义一个方法copyOfRange(int[] array, int from, int to)
        功能：将数组array中从索引from开始
        到索引to结束(不包含to)的元素复制到新的数组中
        将数组返回
         */
        //原始数组
        int[] arr = {1,2,3,4,5,6,7,8,9};
        int[] ints = copyOfRange(arr, 3, 7);

        for (int i = 0; i < ints.length; i++) {
            System.out.print(ints[i] + " "); // 4 5 6 7
        }
    }

    public  static int[] copyOfRange(int[] array,int from, int to){
        //定义数组
        int[] newArray = new int[to - from];
        int index = 0;
        for (int i = from; i < to; i++) {
            newArray[index] = array[i];
            index++;
        }
        return newArray;
    }
}

六：什么是基本数据类型和引用数据类型

基本数据类型：数值是存储在自己的空间中，特点：赋值给其他变量，也是赋的真实的值

• 整数类型
• 浮点类型
• 布尔类型
• 字符类型
  引用数据类型
  除了基本数据类型的所有类型
  数据值是存储在其他空间中
  自己空间中存储的是地址值
  特点：赋值给其他的值，赋的地址值
  方法的值传递
  传递基本数据类型时，传递的是真实的数据，形参的改变，不影响实际参数的值