Java基础3（数组、方法入门、方法重载）

最新推荐文章于 2022-07-14 23:35:31 发布

帅气的浩浩

最新推荐文章于 2022-07-14 23:35:31 发布

阅读量275

点赞数

本文链接：https://blog.csdn.net/weixin_43693472/article/details/106626591

版权

Java基础3（数组、方法入门、方法重载）

1 数组

1.1 数组的基本知识

1.1.1 数组的概念

数组：
1.概念： java中的数组就是一个容器,可以存储多个数据,但是这多个数据的类型必须保持一致
2.特点：
(1)可以存储多个数据
(2)多个数据的类型必须保持一致
(3)数组长度一旦创建,永远不可以发生改变

1.1.2 数组变量的定义

数组变量: 专门用来存储数组容器的变量

1.数组变量定义格式一：推荐使用的格式
数据类型[] 数组名称1;

2.数组变量定义格式二：不推荐使用的格式
数据类型数组名称[];

1.定义一个存储int类型数组的变量arrayA
2.定义一个存储double类型数组的变量arrayB
3.定义一个存储char类型数组的变量arrayC

public class Demo02Array {
    public static void main(String[] args) {

        //定义int变量num,未赋值
        int num;
        //System.out.println(num);//错误: 变量中没有数据,不能使用

        //1.定义一个存储int类型数组的变量arrayA
        //int类型数组: 该容器只能存储int类型的数据
        int[] arrayA;

        //错误: 目前只是定义好了一个用来存储数组容器的变量,但是还没有向该变量中存储数组呢
        //System.out.println(arrayA);

        //2.定义一个存储double类型数组的变量arrayB
        //double类型数组: 该容器只能存储double类型的数据
        double arrayB[];

        //3.定义一个存储char类型数组的变量arrayC
        //char类型数组: 该容器只能存储char类型的数据
        char[] arrayC;


    }
}

在这里插入图片描述

1.1.3 数组的初始化方式

数组的第一种初始化方式(动态初始化,指定数组的长度)
1.格式:
数据类型[] 数组名称 = new 数据类型[长度];

2.格式解释:
(1)左侧数据类型: 表示数组容器中可以存储什么类型的数据
(2)左侧[]: 表示数组的意思
(3)数组名称: 就是给数组起个名字,方便找到对应的数组
(4)=: 把右侧的数组容器存储到左侧的数组变量中
=就是赋值,只是给数组变量赋的是数组容器在内存中的地址值
(5)new: 在内存中创建数组容器的过程
(6)右侧数据类型: 和左侧保持一致
(7)长度: 数组中可以存储多少个数据

public class Demo03Array {
    public static void main(String[] args) {
        //(1)创建一个int类型的数组,可以存储3个int数据,给该数组起个名称叫做arrayA
        int[] arrayA = new int[3];

        //(2)创建一个double类型的数组,可以存储7个double数据,给该数组起个名称叫做arrayB
        double[] arrayB = new double[7];

        //(3)创建一个char类型的数组,可以存储5个char数据,给该数组起个名称叫做arrayC
        char[] arrayC = new char[5];


    }
}

数组的第二种初始化方式(标准格式静态初始化: 指定数组元素)
1.格式:
数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,元素3…};
2.注意:
(1){}中的多个元素之间用逗号隔开,最后一个元素后面没有逗号
(2)右侧[]中不用写长度,JVM会根据{}中的元素数量,推导出长度

public class Demo04Array {
    public static void main(String[] args) {
        //(1)创建一个int类型的数组,可以存储多个int数据100,200,300,给该数组起个名称叫做arrayA
        int[] arrayA = new int[]{100,200,300};

        //(2)创建一个double类型的数组,可以存储多个double数据1.1,2.2,3.3,4.4,5.5,6.6,7.7,给该数组起个名称叫做arrayB
        double[] arrayB = new double[]{1.1,2.2,3.3,4.4,5.5,6.6,7.7};

        //(3)创建一个char类型的数组,可以存储多个char数据'真','的','好','想','你',给该数组起个名称叫做arrayC
        char[] arrayC = new char[]{'真','的','好','想','你'};

    }
}

数组的第三种初始化方式(简化格式的静态初始化: 指定元素)
1.格式:
数据类型[] 数组名称 = {元素1,元素2,元素3…};
2.注意:
(1){}中的多个元素之间用逗号隔开,最后一个元素后面没有逗号
(2)不需要指定长度,JVM根据{}中元素的数量推导数组长度
(3)虽然没有写new,但是底层/内部仍然有new的过程
(4)对于动态初始化和标准格式的静态初始化数组,可以分成两步完成
(5)对于简化格式静态初始化方式,不可以分成两步完成

public class Demo05Array {
    public static void main(String[] args) {
        //(1)创建一个int类型的数组,可以存储多个int数据100,200,300,给该数组起个名称叫做arrayA
        int[] arrayA = {100, 200, 300};

        //(2)创建一个double类型的数组,可以存储多个double数据1.1,2.2,3.3,4.4,5.5,6.6,7.7,给该数组起个名称叫做arrayB
        double[] arrayB = {1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7};

        //(3)创建一个char类型的数组,可以存储多个char数据'真','的','好','想','你',给该数组起个名称叫做arrayC
        char[] arrayC = {'真', '的', '好', '想', '你'};

        int a;
        a = 10;
        System.out.println(a);
        a = 20;
        System.out.println(a);

        int[] array;//定义存储一个int类型数组的变量array
        array = new int[3];//把长度为3的int数组,存储到变量array中
        array = new int[]{10,20,30,50};//把存储多个int数据的int数组,重新存储到变量array中

        int[] arr /*= {100,200,300,500}*/;
        //arr = {100,200,300,500};//错误: java中规定,简化格式静态初始化数据进行赋值时,不能分成两步完成
    }
}

1.1.4 数组的使用（重点）

1.数组名称: 代表数组在内存中的地址值,是一个16进制的整数数字
2.索引编号: 是一个整数数字
(1)数组中的每个数据,称之为数组元素
(2)数组为内部的每个元素进行了一个数字编号(整数数字),称为索引/角标
索引从0开始到最大值(数组长度减 1)
3.数组元素:
数组名称[索引编号]
比如:
array[2]: 数组array中索引编号为2的元素

4.数组长度的获取:
每个数组内部都有一个length属性,保存数组用元素的个数
数组名称.length: 是一个int数字,代表数组的长度
注意: length后面是没有()的

public class Demo01UseArray {
    public static void main(String[] args) {
        //int num = 10;
        //System.out.println(num);//10

        //创建int类型数组array,并初始化
        int[] array = new int[]{100,200,300};//100的索引编号是0,200的索引编号是1,300的索引编号是2
        //数组名称: 代表数组在内存中的地址值,是一个16进制的整数数字
        System.out.println(array);//[I@1540e19d

        //打印100
        System.out.println(array[0]);//打印数组array中索引编号为0的元素的值: 100

        //打印200
        System.out.println(array[1]);//打印数组array中索引编号为1的元素的值: 200

        //打印300
        System.out.println(array[2]);//打印数组array中索引编号为2的元素的值: 300
        System.out.println("---------------");

        //把100修改为1000
        array[0] = 1000;//把数字1000存储到array中索引编号为0的元素中

        //把200修改为2000
        array[1] = 2000;//把数字2000存储到array中索引编号为1的元素中

        //把300修改为3000
        array[2] = 3000;//把数字3000存储到array中索引编号为1的元素中

        //打印1000
        System.out.println(array[0]);//打印数组array中索引编号为0的元素的值: 1000

        //打印2000
        System.out.println(array[1]);//打印数组array中索引编号为1的元素的值: 2000

        //打印3000
        System.out.println(array[2]);//打印数组array中索引编号为2的元素的值: 3000
        System.out.println("---------------");

        //获取数组array的长度,是一个int数字,保存到int变量count中
        int count = array.length;
        System.out.println("数组长度: "+count);
        System.out.println("数组长度: "+array.length);
        System.out.println("---------------");
        /*
            array.length的值: 3

            打印数组元素,数组元素的所有格式: 数组名[索引编号]
            array[array.length-1]: 先计算array.length-1 ==> 3 - 1 ==> 2
            上面的式子等价于array[2]: 3000
         */
        System.out.println(array[array.length-1]);//3000

    }
}

1.2 数组原理内存图

1.2.1 java中的内存分配

1.方法区: 存储可以运行的class文件。
2.方法栈: 方法运行时使用的内存，比如main方法运行，进入方法栈中执行。
3.堆内存存储对象或者数组，new来创建的，都存储在堆内存。
4.寄存器给CPU使用，和我们开发无关不关心
5.本地方法栈 JVM在使用操作系统功能的时候使用，和我们开发无关。不关心
今天主要使用:
1.栈内存: 运行方法的,存储方法中定义的变量的
2.堆内存: 存储的是所有new出来的内容
在这里插入图片描述

1.2.2 一个数组内存图

一个数组的内存图解
1.数组名称: 数组在堆内存空间的地址值,16进制的整数数字
2.数组元素有默认值
(1)整数数组 0
(2)小数数组 0.0
(3)字符数组空白字符
(4)布尔数组 false
(5)引用类型: null
3.注意:
(1)数组变量保存数组在堆内存中的地址值,通过地址值找到对应的数组

(2)数组元素都有索引编号,通过索引编号找到对应的元素

public class Demo01OneArray {
    public static void main(String[] args) {
        //创建int类型数组one,长度为2
        int[] one = new int[2];
        System.out.println(one);//数组名称: 数组在堆内存空间的地址值,16进制的整数数字: [I@1540e19d
        System.out.println(one[0]);//打印数组one中索引编号0对应的元素的值,默认值:0
        System.out.println(one[1]);//打印数组one中索引编号1对应的元素的值,默认值:0

        //把索引编号0对应的元素修改成100
        one[0] = 100;//把数字100存储到数组one中索引编号为0的元素中

        //把索引编号1对应的元素修改成200
        one[1] = 200;//把数字200存储到数组one中索引编号为1的元素中

        System.out.println(one);//数组名称: 数组在堆内存空间的地址值,16进制的整数数字: [I@1540e19d
        System.out.println(one[0]);//打印数组one中索引编号0对应的元素的值:100
        System.out.println(one[1]);//打印数组one中索引编号1对应的元素的值:200
    }
}

在这里插入图片描述

1.2.3两个变量指向一个数组

一个数组两个引用(名称)的内存图解
1.数组名称: 数组在堆内存空间的地址值,16进制的整数数字
2.在使用数组名称进行赋值时,传递的都是数组在内存空间的地址值
3.注意:
(1)数组变量保存数组在堆内存中的地址值,通过地址值找到对应的数组
(2)数组元素都有索引编号,通过索引编号找到对应的元素

数组变量名one中保存的是数组在堆内存空间的地址值,把one的值赋值给新的数组变量two,
导致数组变量名one和two保存相同的地址值,操作的是堆内存空间的同一个数组

注意:
1.数组变量保存数组在堆内存空间的地址值
2.使用数组变量进行赋值时,传递的是地址值

3.one保存数组在堆内存空间的地址值
把one赋值给新的数组变量two之后,
导致one和two保存相同的地址值,操作的
是同一个数组,不管通过one还是two修改
数组,之后再通过one和two看到的一定是
修改后的

public class Demo03SameArray {
    public static void main(String[] args) {
        //创建int类型数组one,长度为2
        int[] one = new int[2];//你在北京延庆购买了一套两居室的房子,one就是打开这套房子的钥匙

        one[0] = 100;

        /*
            数组变量名one中保存的是数组在堆内存空间的地址值,把one的值赋值给新的数组变量two,
            导致数组变量名one和two保存相同的地址值,操作的是堆内存空间的同一个数组

         */
        int[] two = one;


        two[0] = 1000;


        System.out.println(one[0]);//1000
        System.out.println(two[0]);//1000
        System.out.println(one);//[I@1540e19d
        System.out.println(two);//[I@1540e19d

    }
}

在这里插入图片描述

1.3 数组操作的常见问题

1.3.1 数组越界异常

数组操作的常见问题一:
数组索引越界(超出了范围)异常
1.问题描述: java中使用java.lang.ArrayIndexOutOfBoundsException类来描述索引越界异常

2.产生原因:
使用int数字作为索引编号时,该索引编号在数组中是不存在的
索引编号范围: 从0开始到最大值 ( 数组长度减 1 one.length - 1 )

3.解决方案:
找到索引越界的数字,进行修改,不让该数字超出数组元素的索引范围

public class Demo01ArrayProblem {
    public static void main(String[] args) {
        //创建int数组one,并初始化
        int[] one = new int[]{100, 200};//100编号是0,200的编号是1
        System.out.println(one);//地址值: [I@1540e19d
        System.out.println(one[0]);//100
        System.out.println(one[1]);//200
        //System.out.println(one[2]);//索引2不存在: 程序出现问题,停止了 报出数组索引越界异常

        System.out.println("main...end...");
    }
}

1.3.2 数组空指针异常

数组操作的常见问题二:
空指针异常
1.问题描述: java中使用java.lang.NullPointerException类来描述空指针异常

2.产生原因:
null是引用类型的空常量,可以赋值给任意引用类型的变量,一旦把null赋值给引用类型变量后,
说明该变量不再指向堆内存中的任何空间,也就不能操作堆内存空间的内容

null是引用类型的空常量,一旦把null赋值给数组变量后,
说明该数组变量不再指向堆内存空间中的任何数组,
也就不能再访问数组元素了,只要访问就会报出空指针异常

3.解决方案:
(1)找到引用变量是null的地方,进行修改,不让它是null,让它指向堆内存中的一个具体的数组
(2)不使用值为null的引用变量访问堆内存空间的内容

public class Demo02ArrayProblem {
    public static void main(String[] args) {
        //创建int数组one,并初始化
        int[] one = new int[]{100, 200};//100编号是0,200的编号是1
        System.out.println(one);//地址值: [I@1540e19d
        System.out.println(one[0]);//100
        System.out.println(one[1]);//200
        
        one = null;

        System.out.println(one);//null

        //System.out.println(one[0]);//one的值是null,不能访问数组元素: 报出空指针异常

        System.out.println("main...end...");
    }
}

1.4 数组练习

1.4.1 数组遍历

数组遍历：
	就是将数组中的每个元素分别获取出来，就是遍历。遍历也是数组操作中的基石。
	
public class Demo01ArrayEach {
    public static void main(String[] args) {
        //创建int数组array,并初始化
        int[] array = {100, 200, 300};
        System.out.println(array);//地址值
        System.out.println(array[0]);//100
        System.out.println(array[1]);//200
        System.out.println(array[2]);//300
        System.out.println("----------------");

        //以上三行代码重复,只有作为索引编号的数字0,1,2是不同的,可以使用for循环获取作为索引编号的数字0,1,2
        for (int i = 0; i < 3; i++) {
            //System.out.println("索引编号: "+i+" 对应数组的元素值: "+array[i]);
            System.out.println(array[i]);
        }
        System.out.println("----------------");

        //以上for循环,数字3写死了,其实数字3可以使用数组长度(数组名称.length)代替
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }

        System.out.println("----------------");
        for (int i = 0; i <= array.length - 1; i++) {
            System.out.println(array[i]);
        }

    }
}

1.4.2数组获取最大值元素

需求:
求三个int数字的最大值

实现步骤:
1.定义三个int变量a,b,c,并分别初始化
2.假设变量a的值是最大的,保存到int变量max中
3.判断如果b的值大于 max,说明max中已经不是最大的
3.1 把b的值赋值给max
4.判断如果c的值大于 max,说明max中已经不是最大的
4.1 把c的值赋值给max
5.打印max的值

public class Demo03ArrayMax {
    public static void main(String[] args) {
        //1.创建int数组array,并初始化
        int[] array = {5, 15, 2000, 10000, 100, 4000};

        //2.假设索引为0的元素是最大的,保存到int变量max中
        int max = array[0];

        //3.使用for循环依次获取后面的(从索引1开始)每个元素
        for (int i = 1; i < array.length; i++) {
            //3.1如果当前元素值 大于 max 说明max中已经不是最大的了
            if(array[i] > max) {
                //3.2把当前元素赋值给max
                max = array[i];
            }
        }
        //4.for循环结束,打印max
        System.out.println("数组元素最大值: "+max);
    }
}

2 方法

2.1 方法入门（无返回值无参数方法）

2.1.1方法的概念和格式

1.方法的概念:
就是将具有独立功能的代码块组织成为一个整体，使其具有特殊功能的代码集。
将具有特殊功能的一段代码,使用{}括起来,添加一些必要的修饰符等,起个名字,方便使用

2.方法的格式:
修饰符返回值类型方法名称(参数列表…) {
方法功能代码;
return ; 或者 return 结果数据/返回值数据;
}

3.格式解释:
(1)修饰符: public static 目前固定写法,先记住
(2)返回值类型: 方法的功能代码执行完毕后,产生的返还给方法调用者的结果数据的类型
目前定义的方法内部没有结果数据返回给调用者,返回值类型固定写为void
目前定义的方法是没有返回值的,返回值类型固定写为void
(3)方法名称: 给方法起个名字(标识符: 符合命名规范(小驼峰规则)),方便后期调用
(4)参数列表:目前定义的方法没有参数,不需要写参数列表,但是必须保留()
(5)方法功能代码: 一行/多行语句
(6)return ; 结束方法,返回到方法的调用处,建议省略

2.1.2无返回值无参数方法的定义和调用

无返回值无参数方法的定义和调用
1.无返回值:
方法内部没有结果数据返回给调用者,返回值类型固定写为void
方法是没有返回值的,返回值类型固定写为void

2.无参数:
方法没有参数,不需要写参数列表,但是必须保留()

3.练习:
定义方法method,方法内部输出一句话"我是一个方法"

4.注意:
(1)方法定义完毕后,不调用不执行
(2)方法的调用格式:
方法名称(…);
(3)方法定义完毕后,可以调用任意多次

ublic class Demo01Method {

    public static void main(String[] args) {

        System.out.println("main...start...");

        //调用method方法

        method();


        System.out.println("main...end...");

    }

    //定义方法method,方法内部输出一句话"我是一个方法"
    public static void method() {

        System.out.println("我是一个方法");

        return ;//结束方法返回到方法的调用处

    }
}

在这里插入图片描述

2.2方法详解

2.2.1方法的格式详解

2.方法的格式:
修饰符返回值类型方法名称(数据类型1 变量名称1,数据类型2 变量名称2 …) {
方法功能代码;
return 结果数据/返回值数据;
}

3.格式解释:
(1)修饰符: public static 目前固定写法,先记住
(2)返回值类型: 你调用我的方法后,我方法内部会返还你一个什么样子的数据
方法的功能代码执行完毕后,产生的返还给方法调用者的结果数据的类型
举例:
方法内部如果返回数字100: 返回值类型 int
方法内部如果返回数字6.6: 返回值类型 double
方法内部如果返回true/false: 返回值类型 boolean

(3)方法名称: 给方法起个名字(标识符: 符合命名规范(小驼峰规则)),方便后期调用
(4)参数列表: 你调用我的这个方法时,需要传递给我几个什么样子的数据
	参数列表...的本质: 就是在定义一个/多个变量,可以接收调用者调用方法时,传递的数据
	举例:
		定义方法时(): 调用方法时,必须什么都不传递
		定义方法时(int a): 调用方法时,必须传递一个int类型的数据
		定义方法时(int a,int b): 调用方法时,必须传递两个int类型的数据
		定义方法时(int a,int b,double c): 调用方法时,必须传递两个int类型的数据和一个double类型的数据 而且顺序不能错误

(5)方法功能代码: 一行/多行语句
(6)return 结果数据/返回值数据;
a.结束方法
b.把return后面的结果数据/返回值数据返还给方法的调用者

4.方法的理解: 可以理解为工厂/机器
生产汽车的工厂:
原材料: 发动机,变速箱,车架 …
产出物: BMW750Li,S600,ZT700 …
榨汁机:
原材料: 水果,水…
产出物: 果汁
原材料是进入工厂/机器的东西,相当于调用方法是,传递给方法的参数进入方法的东西参数列表
产出物是从工厂/机器里面出来的东西,相当于调用方法后返回的数据从方法中出来的东西返回值–返回值类型

5.定义方法的三要素:
(1)方法名称:
(2)参数列表:
(3)返回值类型:

2.2.2无返回值有参数的方法练习-打印最大值

需求:
定义一个方法用于打印两个int数中的较大数，数据来自于方法参数

/*
无返回值有参数的方法练习-打印最大值
1.无返回值:
分享经验: 当在需求中明确看到打印/输出二字,说明该方法内部不需要返回结果,返回值类型固定写为void

2.有参数:
分享经验: 当在需求中有不明确/不确定的内容时,需要定义参数

3.练习:
定义一个方法用于打印两个int数中的较大数，数据来自于方法参数

4.注意:
(1)方法定义完毕后,不调用不执行
(2)方法的调用格式:
方法名称(…);
(3)方法定义完毕后,可以调用任意多次

5.定义方法的三要素:
(1)方法名称: printMax
(2)参数列表: int a,int b
(3)返回值类型: void

public class Demo01PrintMax {

    public static void main(String[] args) {

        System.out.println("main...start...");

        //调用方法printMax: 传递常量
        printMax( 10 , 20 );

        System.out.println("main...end...");

    }

    //定义一个方法用于打印两个int数中的较大数，数据来自于方法参数
    public static void printMax(int a , int b ) {

        int max = (a>b) ? a : b;

        System.out.println("最大值: "+max);

        return ;//结束方法,返回到方法的调用处

    }

}

2.2.3有返回值有参数的方法练习-获取最大值

需求:
设计一个方法可以获取两个int数的较大值，数据来自于参数
/*
有返回值有参数的方法练习-获取最大值
1.有返回值:
分享经验: 当在需求中明确看到获取/判断/返回二字,说明该方法内部需要返回结果,必须定义返回值类型

2.有参数:
分享经验: 当在需求中有不明确/不确定的内容时,需要定义参数

3.练习:
设计一个方法可以获取两个int数的较大值，数据来自于参数

4.注意:
(1)方法定义完毕后,不调用不执行
(2)方法的调用格式:
方法名称(…);
(3)方法定义完毕后,可以调用任意多次

5.定义方法的三要素:
(1)方法名称: getMax
(2)参数列表: int a,int b
(3)返回值类型: int

public class Demo01GetMax {

    public static void main(String[] args) {

        System.out.println("main...start...");

        //调用getMax方法,传递10和20,把方法返回的结果赋值给int变量result
        int result = getMax(10 ,20 );

        System.out.println("最大值: "+result);

        System.out.println("main...end...");

    }

    //设计一个方法可以获取两个int数的较大值，数据来自于参数
    /*
        你调用我的方法printMax时,必须给我传递2个int数据,
        我方法内部代码执行完毕后,返回给你一个int数据
        你: 方法的调用者
        我: 方法本身

        有进有出
     */
    public static int getMax(int a , int b ) {

        int max = (a > b) ? a : b;

        return max;//结束方法,把max中的数据返还给方法的调用处/者
    }

}

2.3 方法注意事项

2.3.1方法的注意事项一

1.方法不能嵌套定义(在定义方法的内部又定义了其它方法),可以调用其它方法
2.方法可以嵌套调用
3.定义方法时参数列表根据需求确定(可以有0个/1个/2个/3个…)
4.定义方法时返回值类型根据需求确定
如果没有返回值,返回值类型固定写为void
5.如果方法需要参数列表,参数列表中定义的变量的类型根据需求确定
可以是基本类型/引用类型
6.如果分析后发现方法需要返回值类型,那么返回值类型也可以是基本类型/引用类型

public class Demo01MethodNotice {
    public static void main(String[] args) {
        method();

        //调用方法获取一个int数字保存到int变量a中
        int a = getNum();

        //调用方法打印一个int数字
        printNum(a);

        System.out.println("-----------");
        printNum( getNum() );
    }

    //定义打印一个int数字的方法
    public static void printNum(int num) {
        System.out.println(num);
    }

    //定义方法获取一个int数字
    public static int getNum() {
        return 100;
    }

    //定义无参数无返回值方法
    public static void method() {
        System.out.println("method...");
        //错误: 定义方法时,该方法内部不能在定义其它方法
        /*public static void fun() {
            System.out.println("fun...");
        }*/
        //正确的: 定义方法时,该方法内部可以调用其它方法
        show();
    }

    //定义无参数无返回值方法
    public static void show() {
        System.out.println("show....");
    }

}

2.3.2方法的注意事项二

1.返回值类型，必须要和 return 语句返回的数据的类型要匹配，否则编译失败。
2.不能在 return 后面写代码， return 意味着方法结束，所有后面的代码永远不会执行，属于无效代码。
3.void表示无返回值，可以省略return，也可以单独的书写return，后面不加数据 return ;
4.如果定义的方法需要返回值,那么只能返回一个数据,不能返回2个及以上的数据
而且可以返回基本类型也可以返回引用类型(根据需求确定)
如果非得返回多个数据,可以把多个数据放在数组中,返回一个数组

public class Demo02MethodNotice {
    public static void main(String[] args) {
        byte b = 100;
        //float a = 6.6;
        double d = 'a';
    }

    public static int getNum2() {
        //return 100,200;//return 后面只能写一个数据
        return 100;
    }

    public static int[] getArray() {
        return new int[]{100,200,300};
    }

    //1.返回值类型，必须要和 return 语句返回的数据的类型要匹配，否则编译失败 。
    public static boolean getNum() {
        //return 100;//100是int类型,返回值类型写为int
        //return 6.6;//6.6是double类型,返回值类型写为double
        //return 'a';//'a'是char类型,返回值类型写为char
        return true;//true是boolean类型,返回值类型写为boolean
    }

    //2.不能在 return 后面写代码， return 意味着方法结束，所有后面的代码永远不会执行，属于无效代码。
    public static int getMax(int a, int b) {
        if(a>b) {
            return a;
            //System.out.println(".....");//无效代码
        } else {
            return b;
            //System.out.println(".....");//无效代码
        }
        //System.out.println(".....");//无效代码
    }
}

2.4 返回值的方法调用方式

2.4.1 有返回值的方法调用方式

有返回值的方法调用方式可以赋值/打印/单独调用
1.赋值调用: 把调用有返回值的方法返回的结果数据保存到左侧的变量中 —推荐使用—
数据类型变量名称 = 方法名称(参数列表…);

2.打印/输出调用: 把调用有返回值的方法返回的结果数据直接交给输出语句进行输出
System.out.println(方法名称(参数列表…));

3.单独调用: 把调用有返回值的方法返回的结果数据既没有赋值给变量也没有交给输出语句 —不推荐使用—
此时把结果数据丢了,这种调用方式意义不大,但是代码没错哈
方法名称(参数列表…)

public class Demo01InvokeMethod {
    public static void main(String[] args) {
        System.out.println("main...start...");

        //1.赋值调用: 把调用有返回值的方法返回的结果数据保存到左侧的变量中
        int result = getSum(10,20);

        System.out.println("和: "+result);
        System.out.println("和: "+(result*10));

        //2.打印/输出调用: 把调用有返回值的方法返回的结果数据直接交给输出语句进行输出
        System.out.println(getSum(100,200));

        //3.单独调用: 把调用有返回值的方法返回的结果数据 既没有赋值给变量也没有交给输出语句
        getSum(1000,2000);

        System.out.println("main...end...");
    }

    //定义方法,获取2个int数据之和
    public static int getSum(int a , int b ) {

        int sum = a + b;

        return sum;

    }
}

2.4.2 无返回值的方法调用方式

有返回值的方法调用方式只能采用单独调用,不能使用赋值和打印调用

1.单独调用: —只能使用—
方法名称(参数列表…)

2.赋值调用: 错误

3.打印/输出调用: 错误

public class Demo02InvokeMethod {
    public static void main(String[] args) {
        System.out.println("main...start...");

        //1.单独调用: ---只能使用---
        printSum(10,20);

        //2.赋值调用: 错误
        //int result = printSum(100,200);//错误: int变量只能保存int数据,但是该方法没有返回int数据

        //void v = printSum(100,200);//错误: void根本不是数据类型

        //3.打印/输出调用:  错误

        //System.out.println(printSum(1000,2000));//错误: 因为printSum方法没有任何数据返回

        System.out.println("main...end...");
    }

    //定义方法,打印2个int数据之和
    public static void printSum(int a , int b ) {

        int sum = a + b;

        System.out.println("和: "+sum);

        return ;

    }
}

2.5 形式参数和实际参数的区别

形式参数和实际参数的区别?
形式参数:
1.概念: 定义方法时,小括号()中定义的参数(变量),给它起个名字,叫做形式参数
2.特点:
(1)在定义时,指定的
(2)是没有值的,定义时是不能赋值的
(3)当调用方法时,使用调用时传递的参数进行赋值

实际参数:
1.概念: 在调用方法时,小括号()中给出的数据常量/变量,给它起个名字,叫做实际参数
2.特点:
(1)在调用方法时,指定的
(2)实际参数,是在调用方法时使用的,必须要有值,没有值报错

注意:
实参和形参名字是可以相同的,互不影响

public class Demo03MethodParam {
    public static void main(String[] args) {
        System.out.println("main...start...");
        
        //调用printSum方法: 传递常量
        printSum(100,200);//100和200 叫做实际参数

        //调用printSum方法: 传递变量
        int m = 100,n = 200;
        printSum( m , n );//m和n 叫做实际参数

        //调用printSum方法: 传递变量
        int a = 1000, b = 2000;
        printSum( a , b );//调用方法时,传递的a和b: 叫做实际参数


        System.out.println("main...end...");
    }

    //定义方法,打印2个int数据之和
   
    public static void printSum(int a , int b ) {//a和b 叫做形式参数

        int sum = a + b;

        System.out.println("和: "+sum);

        return ;

    }
}

在这里插入图片描述

3 方法重载

3.1方法重载的引入

需求:
1.定义一个获取两个int数字之和的方法
2.定义一个获取三个int数字之和的方法
3.定义一个获取两个double数字之和的方法
4.定义一个获取三个double数字之和的方法

定义一个获取两个int数字之和的方法
三要素:
1.方法名称:
2.参数列表:
3.返回值类型:
发现问题:
以下四个方法,都是完成求和功能,只是参数列表不同,
然而我们却给每个方法起了一个相当之复杂的名字,
导致程序员使用和学习方法的成本增加(太复杂,记不住)

解决方案:
使用方法重载

public class Demo01Method {
    public static void main(String[] args) {
        System.out.println(getTwoIntNumSum(10,20));
        System.out.println(getThreeIntNumSum(10,20,30));
        System.out.println(getTwoDoubleNumSum(10.0,20.0));
        System.out.println(getThreeDoubleNumSum(10.0,20.0,30.0));
    }

    //1.定义一个获取两个int数字之和的方法
    public static int getTwoIntNumSum(int a, int b) {
        System.out.println("两个int数字之和的方法被调用了.....");
        return a + b;
    }

    //2.定义一个获取三个int数字之和的方法
    public static int getThreeIntNumSum(int a, int b, int c) {
        System.out.println("三个int数字之和的方法被调用了.....");
        return a + b + c;
    }

    //3.定义一个获取两个double数字之和的方法
    public static double getTwoDoubleNumSum(double a, double b) {
        System.out.println("两个double数字之和的方法被调用了.....");
        return a + b;
    }

    //4.定义一个获取三个double数字之和的方法
    public static double getThreeDoubleNumSum(double a, double b,double c) {
        System.out.println("三个double数字之和的方法被调用了.....");
        return a + b + c;
    }
}

3.2方法重载的概念

方法重载
1.概念:
在同一个类中,多个功能相同,但是参数列表不同的方法,可以使用相同的名字,这种多个同名不同参的方法,
可以存在于同一个类中的现象,叫做方法重载
简单来讲:
比如某个类中已经有了一个名字叫method的方法,我们可以再写多个名称叫method的方法,但是要求,
每个名称为method的方法,之间的参数列表必须要有区别

2.作用/目的:
(1)减少程序员的学习和使用的成本(原来必须要记4个方法名,现在只需要记一个方法名)
(2)减少了方法名称的数量

3.调用
(1)根据名称
(2)参数数量
(3)参数类型(优先做完全类型匹配,否则做自动类型提升的匹配)

3.3方法重载的注意事项

参数列表不同有哪些情况可以构成方法重载?
1.参数的数量不同
2.参数的类型不同
3.多个类型,顺序不同

总结:
方法重载的本质区别: 一定是看方法参数的数量和类型上的区别

public class Demo02OverLoadNotice {
    public static void main(String[] args) {

    }

    //1.没有参数
    public static void method() {

    }

    //2.有一个int参数
    //方法1没有参数,方法2有1个int参数,参数的数量不同可以构成重载
    public static void method(int a) {

    }



    //3.有2个int参数
    //方法3和方法2,参数数量不同,方法3和方法1参数数量也不同,参数的数量不同可以构成重载
    public static void method(int a,int b) {

    }

    //4.有1个double参数
    //方法4和方法1,都是1个参数,但是类型不同,参数的类型不同可以构成重载
    public static void method(double a) {

    }

    //5.有两个double参数
    //方法5有2个double参数,方法3有2个int参数,参数的类型不同可以构成重载
    public static void method(double a,double b) {

    }
    //6.有一个int参数和一个double参数
    public static void method(int a,double b) {

    }

    //7.有一个double参数和一个int参数
    //方法6的参数先int后double,方法7的参数是先double后int,多个类型,顺序不同
    public static void method(double a, int b) {

    }
}

方法重载与哪些因素无关?
1.与参数的名称无关
2.与返回值类型无关
3.与修饰符无关

public class Demo03OverLoadNotice {
    public static void main(String[] args) {

    }

    //1.有2个int参数
    public static int method(int a, int b) {
        return 200;
    }

    //2.有2个int参数
    //报错: 不是方法重载,因为方法1和方法2,只有参数的名称不同,然而方法重载与参数名称无关
    /*public static int method(int c, int d) {
        return 100;
    }*/

    //3.有2个int参数
    //报错: 不是方法重载,因为方法1和方法3,只有返回值类型不同,然而方法重载与返回值类型无关
    /*public static double method(int a, int b) {
        return 200.0;
    }*/

    //4.有2个int参数
    //报错: 不是方法重载,因为方法1和方法4,只有修饰符不同,然后方法重载与修饰符无关
    /*public int method(int a, int b) {
        return 200;
    }*/
    //5.有2个int参数
    //报错: 不是方法重载,因为方法1和方法5,只有修饰符不同,然后方法重载与修饰符无关
    /*private int method(int a, int b) {
        return 200;
    }*/

}

4 方法的参数传递

4.1 方法参数传递

数传递:
可以理解当我们要调用一个方法时，我们会把指定的数值，传递给方法中的参数(定义方法时()中定义的变量)，
这样方法中的参数就拥有了这个指定的值，可以使用该值，在方法中运算了。这种传递方式，我们称为参数传递。

形式参数: 定义方法时,()中定义的参数(1个/多个变量),叫做形式参数定义时是没有值的
实际参数: 调用方法时,()中指定的数据(常量/变量),叫做实际参数使用时必须是有值的

注意:
1.基本类型变量a的值赋值给基本类型变量b,其实是把a的值复制一份,赋值给b,之后不管如何修改变量b的值,都不会影响变量a中的值

2.局部变量:
(1)概念: 在定义方法方法()中定义的变量或者在方法内部定义的变量,都叫做局部变量
(2)特点: 只在方法内部有效,出了所在的方法,就无法使用了

ublic class Demo01Var {
    public static void main(String[] args) {
        //定义int变量a,并赋值
        int a = 10;

        //定义int变量b,未赋值
        int b;

        b = a;//把变量a的值赋(复制)值给变量b

        System.out.println("a="+a);//10
        System.out.println("b="+b);//10

        b = b*10;

        System.out.println("a="+a);//10
        System.out.println("b="+b);//100

        //c是在method方法中定义的,出了method方法,就不能使用了
        //System.out.println(c);

        method(a,b);//a和b既叫做实际参数,有叫做局部变量

    }
    public static void method(int m,int n) {//m和n既叫做形式参数,有叫做局部变量
        //a和b是在main方法中定义的,出了main方法,就不能使用了
        //System.out.println(a);
        //System.out.println(b);
        int c = 2000;
        System.out.println(c);
    }
}

4.2 基本类型作为方法参数传递

基本类型作为方法参数传递的特点
1.基本类型变量,保存的是具体的数据值
2.基本类型变量作为方法参数传递时,传递的也是具体的数据值
3.基本类型变量作为方法参数传递特点:
形式参数的改变,不会影响实际参数

形式参数: 定义方法时,()中定义的变量
实际参数: 调用方法时,()中给出的数据/变量

change方法内部修改形式参数a和b的值,不会影响main方法中实际参数a和b的值

基本类型作为方法的形式参数时,形式参数的改变,不会影响实际参数

注意:
1.每个方法的执行都有自己独立的内存空间(在栈中)
2.方法内部定义的变量,也有自己独立的内存空间

总结:
1.不同的方法内部可以定义相同名称的变量
2.每个方法有自己独立的空间,方法中的变量也有自己独立的空间,它们之间是互不影响,互不干扰的

public class Demo02BaseVar {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println("ms...a="+a);//10
        System.out.println("ms...b="+b);//20

        change(a,b);

        System.out.println("me...a="+a);//10
        System.out.println("me...b="+b);//20

    }
    public static void change(int a,int b) {
        System.out.println("cs...a="+a);//10
        System.out.println("cs...b="+b);//20
        a = a * 10;
        b = b * 10;
        System.out.println("ce...a="+a);//100
        System.out.println("ce...b="+b);//200
    }
}

在这里插入图片描述

4.3 引用类型作为方法参数传递

引用类型作为方法参数传递的特点
1.引用类型变量,保存的是堆内存中的地址值
2.引用类型变量作为方法参数传递时,传递的也是具体的堆内存中的地址值
3.引用类型变量作为方法参数传递特点:
引用类型变量作为方法的形式参数时,通过形式参数找到对应的堆内存空间的内容进行修改,
再通过实际参数看到的就是修改之后的内容

引用类型作为方法的形式参数时,形式参数的改变,会影响实际参数

数组作为方法参数传递的特点
1.数组变量名称保存的是数组在堆内存空间的地址值
2.数组作为方法参数传递时,传递的是地址值
3.数组作为方法形式参数时,通过形式参数找到堆内存中的数组,修改其内容后,实际参数看到的是修改之后的

数组作为方法的形式参数时,形式参数的改变,会影响实际参数

public class Demo03RefVar {
    public static void main(String[] args) {
        int[] arr = {10,20};
        System.out.println("ms...arr[0]="+arr[0]);//10
        System.out.println("ms...arr[1]="+arr[1]);//20

        change( arr );//实际参数

        System.out.println("me...arr[0]="+arr[0]);//100
        System.out.println("me...arr[1]="+arr[1]);//200

    }
    public static void change(int[] arr) {//arr: 形式参数
        System.out.println("cs...arr[0]="+arr[0]);//10
        System.out.println("cs...arr[1]="+arr[1]);//20
        arr[0] = arr[0] * 10;
        arr[1] = arr[1] * 10;
        System.out.println("ce...arr[0]="+arr[0]);//100
        System.out.println("ce...arr[1]="+arr[1]);//200

        return ;

    }
}

e…a="+a);//100
System.out.println(“ce…b=”+b);//200
}
}


[外链图片转存中...(img-yxqaHyoA-1591614209765)]

[外链图片转存中...(img-nQTmf8YX-1591614209766)]

### 4.3 引用类型作为方法参数传递

引用类型作为方法参数传递的特点
	1.引用类型变量,保存的是堆内存中的地址值
	2.引用类型变量作为方法参数传递时,传递的也是具体的堆内存中的地址值
	3.引用类型变量作为方法参数传递特点:
		引用类型变量作为方法的形式参数时,通过形式参数找到对应的堆内存空间的内容进行修改,
		再通过实际参数看到的就是修改之后的内容

	引用类型作为方法的形式参数时,形式参数的改变,会影响实际参数


数组作为方法参数传递的特点
	1.数组变量名称保存的是数组在堆内存空间的地址值
    2.数组作为方法参数传递时,传递的是地址值
    3.数组作为方法形式参数时,通过形式参数找到堆内存中的数组,修改其内容后,实际参数看到的是修改之后的

数组作为方法的形式参数时,形式参数的改变,会影响实际参数

```Java
public class Demo03RefVar {
    public static void main(String[] args) {
        int[] arr = {10,20};
        System.out.println("ms...arr[0]="+arr[0]);//10
        System.out.println("ms...arr[1]="+arr[1]);//20

        change( arr );//实际参数

        System.out.println("me...arr[0]="+arr[0]);//100
        System.out.println("me...arr[1]="+arr[1]);//200

    }
    public static void change(int[] arr) {//arr: 形式参数
        System.out.println("cs...arr[0]="+arr[0]);//10
        System.out.println("cs...arr[1]="+arr[1]);//20
        arr[0] = arr[0] * 10;
        arr[1] = arr[1] * 10;
        System.out.println("ce...arr[0]="+arr[0]);//100
        System.out.println("ce...arr[1]="+arr[1]);//200

        return ;

    }
}

在这里插入图片描述