J2EE | 基础篇 | D04 方法调用、重载、数组详解、相关内存解释图、加强for循环以及课后作业（含参考答案）

最新推荐文章于 2020-09-01 21:19:02 发布

沧海随云

最新推荐文章于 2020-09-01 21:19:02 发布

阅读量355

点赞数

分类专栏： Java基础知识笔记篇

本文链接：https://blog.csdn.net/qq_39674985/article/details/90518722

版权

Java基础知识笔记篇专栏收录该内容

11 篇文章 0 订阅

订阅专栏

文章目录

调用方法的三种方式：
return关键字
break,continue和return的区别
方法重载（overload）
- 方法重载发生的条件
数组
java中的内存划分：
只有一个数组的内存图：
有两个独立数组的内存图：
两个引用指向同一个数组的内存图：
数组的长度运行期间不可改变：
加强for循环 foreach
课后作业

调用方法的三种方式：

第一种：通过对象名.方法名进行调用，这是最普通的也是最常见的一种调用方式。
第二种：通过new关键字调用构造方法，这种是在实例化对象时使用的方式。
第三种：通过类名.方法名调用，当需要调用的那个方法为静态（有static的）方法时使用。
练习：定义一个方法，用于判断两个数字是否相同。

三要素：
返回值：boolean
方法名：isSame()
参数：int x, int y

public static boolean isSame(int x, int y){
    return x == y;
}

return关键字

程序执行到方法里面的return语句时，方法就会返回，return下面的语句不会被执行。
例：

public class MethodTest{

    public static void main(String[] args){
        //不接收返回值也行，符合语法规则，编译可以通过。
        sumInt(10,20);

        //对于有返回值的方法，通常都会定义变量用来接收方法的返回值
        int result = sumInt(10,20);

        System.out.println("计算结果是："+result);
    }


    public static int sumInt(int a,int b){

        int c = a + b;

        return c; //程序执行到此处sumInt方法执行结束。并将int类型的值c返回

    }

    public static int test1(){
        return 1; //这行代码只要执行，整个方法就结束了。
        //System.out.println("hello"); //这里的代码是无法执行的，编译报错。
    }

    public static void test2(){
        return; //可以,return后面没有返回任何数据
    }

    /*
    public static int test3(){
        return; //错误
    }
    */
}

如果方法有返回值，那么要在其方法里面设置返回值。
例：

public class MethodTest{


    /*
     * 编译阶段不会运行代码，编译器并不知道flag的值，它只知道flag要么是true，要么是false。
     * 对于test1方法，编译器会考虑到当flag为false的时候，该方法就没有返回值了，所以在编译阶段会报错
     * 
     */

    /*public static int test1() {
        boolean flag = true;
        if (flag) {
            return 1;
        }
    }*/

    //以下程序还是编译报错，因为编译器就认为以下的这个if语句的大括号当中的代码可能执行，也可能不执行。
    /*
    public static int test2(){
        if(true){
            return 1;
        }
    }
    */



    //if结合else使用，这样要么执行if中的语句，要么执行else中的语句。
    //此时编译器可以判定这个程序return 语句一定会执行的
    public static int test3(boolean flag) {

        /*
         * 下面这种写法会报错，需要在else里面设置返回值 
         */
        /*if (flag) {
            return 0;
        } else {
            System.out.println("1");
        }*/

        if (flag) {
            return 0;
        } else {
            return 1;
        }

    }

    //下面程序会报错吗？
    //不会报错，因为这样编写可以保证一定会有一个return语句执行
    public static int test4(){
        boolean flag = false;
        if(flag){
            return 1;
        }
        return 0;
    }
}

break,continue和return的区别

break; 和 continue; 这两个语句主要是用来控制循环的，跟方法没有关系。
return; 和以上的两个语句不是一个级别的，return;是用来终止当前方法的。

public class Test {


    public static void main(String[] args){

        test();
        System.out.println("hello world!");

    }

    public static void test() {

        for( int i = 0 ; i < 10 ; i ++ ){
            if( i == 5 ){
                //break;
                //continue;
                return; //终止当前方法的执行。（不是终止JVM的执行）
            }
            System.out.println("i = " + i);
        }
    }
}

方法重载（overload）

public class MethodTest{

    public static void main(String[] args){

        System.out.println(sum(10,20));

        System.out.println(sum(1.0,2.0));

        System.out.println(sum(10L,20L));

        System.out.println(sum(1.0F,2.0F));

    }

    public static int sum(int a,int b){

        return a + b;

    }

    public static double sum(double a,double b){

        return a + b;

    }

    public static long sum(long a,long b){

        return a + b;

    }

    public static float sum(float a,float b){

        return a + b;

    }

}

上面将之前的代码里面的4个方法名全部改成一样的了，这种情况叫做方法重载（overload）。

方法重载发生的条件

发生在同一个类中.
方法名相同
参数列表不同(类型，个数，顺序)

注意：
方法重载和返回值类型无关
方法重载和方法的修饰符列表无关。

//参数的类型不同，构成重载
public static void m1(int a){}
public static void m1(double a){}

//参数的个数不同，构成重载
public static void m2(int a,int b){}
public static void m2(int a){}

//参数的顺序不同，构成重载，不过开发中不这样使用    
public static void m3(int a,double b){}
public static void m3(double a,int b){}

//以下两个m4方法并没有构成重载.
//两个方法完全一样，错误
//public static void m4(int a){}
//public static void m4(int b){}


/*
方法的重载和方法的返回值类型无关，不构成重载
public static void m5(){}
public static int m5(){
    return 100;
}
*/


/*
方法的重载和方法的修饰符列表无关,不构成重载
static void m6(){}
public static void m6(){}
*/

数组

什么是数组？

数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。
数组里面既可以存储基本数据类型，也可以存储引用数据类型，但是只能存储同一种数据类型。
数组是一种简单的数据结构，线性的结构
数组一旦创建其长度是不可变的
数组是引用数据类型

数组的分类

一维数组
二维数组
三维数组
多维数组

如何定义数组？

//动态初始化
int[] array = new int[4];
array[0] = 5;
array[1] = 15;
array[2] = 25;
array[3] = 35;

//静态初始化
int[] array = new int[] {5, 15, 25, 35};

//打印长度
System.out.println(array.length);

课堂笔记

/*
 *   变量： 存储一个数值
 *   数组：存储多个数值

数组的特点：
1. 数组是一种引用数据类型
2. 数组当中的多个数据，类型必须统一
3. 数组的长度在程序运行期间不可改变

数组的初始化：在内存当中创建一个数组，并且向其中赋予一些默认值。

两种常见的初始化方式：
1. 动态初始化（指定长度）
2. 静态初始化（指定内容）

动态初始化数组的格式：
数据类型[] 数组名称 = new 数据类型[数组长度];
     int[] arrayA  = new int[300];
解析含义：
左侧数据类型：也就是数组当中保存的数据，全都是统一的什么类型
左侧的中括号：代表我是一个数组
左侧数组名称：给数组取一个名字
右侧的new：代表创建数组的动作
右侧数据类型：必须和左边的数据类型保持一致
右侧中括号的长度：也就是数组当中，到底可以保存多少个数据，是一个int数字
 */
 动态初始化（指定长度）：在创建数组的时候，直接指定数组当中的数据元素个数。
静态初始化（指定内容）：在创建数组的时候，不直接指定数据个数多少，而是直接将具体的数据内容进行指定。

静态初始化基本格式：
数据类型[] 数组名称 = new 数据类型[] { 元素1, 元素2, ... };

注意事项：
虽然静态初始化没有直接告诉长度，但是根据大括号里面的元素具体内容，也可以自动推算出来长度。

//动态初始化拆分为步骤
		int[] arrayC;
		arrayC = new int[5];

		//
//        int[] arrayD;
//        arrayD = { 10, 20, 30 }; 错误！静态初始化省略格式不能拆分为两个步骤

/*
直接打印数组名称，得到的是数组对应的：内存地址哈希值。
二进制：01
十进制：0123456789
16进制：0123456789abcdef

访问数组元素的格式：数组名称[索引值]
索引值：就是一个int数字，代表数组当中元素的编号。
【注意】索引值从0开始，一直到“数组的长度-1”为止。
 */
 
 /*
使用动态初始化数组的时候，其中的元素将会自动拥有一个默认值。规则如下：
如果是整数类型，那么默认为0；
如果是浮点类型，那么默认为0.0；
如果是字符类型，那么默认为'\u0000'；
如果是布尔类型，那么默认为false；
如果是引用类型，那么默认为null。

注意事项：
静态初始化其实也有默认值的过程，只不过系统自动马上将默认值替换成为了大括号当中的具体数值。
 */

java中的内存划分：

只有一个数组的内存图：

有两个独立数组的内存图：

两个引用指向同一个数组的内存图：

数组的长度运行期间不可改变：

加强for循环 foreach

（1） foreach
用法：主要是用来遍历数组和集合的；
缺点：没有索引，凡是涉及有索引相关操作还是用普通for循环，
（2）语法结构

for(元素类型 e ：数组 ){
System.out.println(e);
}

遍历一个数组也可以使用我们之前学的for循环

这两种方式的打印结果一样。

课后作业

编写重载方法，分别实现输出字符串，字符串数组，整型数据和整形数组。
编写重载方法分别计算一个整数，一个浮点数的各位数字之和。
B哥去参加青年歌手大奖赛,有10个评委打分,(去掉一个最高一个最低)求平均分?
定义一个数组,数组成员10个,找出数组中最大数连同下标一起输出
定义一个数组来存储12个学生的成绩{72,89,65,58,87,91,53,82,71,93,76,68}，统计各成绩等级（90分以上为‘A’，80_{89分为‘B’，70}79分为‘C’，60~69分为‘D’，60分以下为E）学生人数，并将其放入到数组count中，其中：count[0]存E级的人数，count[1]存D级的人数，……，count[4]存A级的人数。
先定义一个数组，再尝试把数组元素反转。
如：（{5,8,3,4,1} -》 {1，4，3，8，5}）
思考题：想一想为什么说数组的长度不可改变？
（提示：int[] a = new int[3]; a = new int[5]，你觉得这样做是把长度为3的数组改变成长度为5的数组吗？）

编写重载方法，分别实现输出字符串，字符串数组，整型数据和整形数组。

package com.zcl.homework;

public class D04_1 {
	public static void main(String[] args) {
		String[] s = new String[] { "这", "是", "数组" };
		int[] i = new int[] { 89, 92, 94, 88, 94, 93, 98, 96, 91, 97 };
		String a = "这是字符串";
		Output(a);
		Output(s);
		Output(5);
		Output(i);
	}

	public static void Output(String s) {
		System.out.println(s);
	}

	public static void Output(String[] s) {
		for (int i = 0; i < s.length; i++) {
			System.out.print(s[i]);
		}
	}

	public static void Output(int s) {
		System.out.println(s);
	}

	public static void Output(int[] s) {
		for (int i = 0; i < s.length; i++) {
			System.out.print(s[i]+" ");
		}
	}

}

编写重载方法分别计算一个整数，一个浮点数的各位数字之和。

package com.zcl.homework;

public class D04_2 {

	public static void main(String[] args) {

		add(468);
		add(468.56);

	}
		
		
		public static void add(int num) {
			int count = 0;
			while (num != 0) {
				count += num % 10;
				num = num / 10;
			}
			System.out.println("整数各位数之和："+count);
		}
		
		public static void add(double num) {
			int count = 0;
			//写一个循环，每次乘10，直到成为整数
			while (num != (int)num) {
				num *= 10;
			}
			while (num != 0) {
				count += num % 10;
				num = num / 10;
			}
			System.out.println("浮点数各位数之和："+count);
		}
}

B哥去参加青年歌手大奖赛,有10个评委打分,(去掉一个最高一个最低)求平均分?

package com.zcl.homework;

public class D04_3 {

	public static void main(String[] args) {
		int[] i = new int[] { 8, 9, 9, 8, 7, 9, 8, 6, 5, 7 };

		average(i);
	}
	public static void average(int[] array) {
		int min = array[0];
		int max = array[0];
		for (int i = 0;i < array.length;i++) {
			min = array[i] > min ? min : array[i];
		}
		for (int i = 0; i < array.length;i++) {
			max = array[i] < max ? max : array[i];
		}
		int sum = 0;
		for (int i = 0;i <= 9;i++) {
			sum += array[i];
		}
		double ave = (double)(sum-min-max)/(array.length-2);
		System.out.println(max);
		System.out.println(min);
		System.out.println(ave);
	}
}

定义一个数组,数组成员10个,找出数组中最大数连同下标一起输出

package com.zcl.homework;

public class D04_4 {

	public static void main(String[] args) {
		int[] i = new int[] { 89, 92, 94, 88, 94, 93, 98, 96, 91, 97 };
		Max(i);
	}

	public static void Max(int[] array) {
		int max = array[0];
		int index = 0;
		for (int i = 0; i < array.length; i++) {
			if (max < array[i]) {
				max = array[i];
				index = i;
			}
			//max = array[i] < max ? max : array[i];
		}
		System.out.println("最大数为：" + max + "下标为：" + index);
	}
}

定义一个数组来存储12个学生的成绩{72,89,65,58,87,91,53,82,71,93,76,68}，统计各成绩等级（90分以上为‘A’，80_{89分为‘B’，70}79分为‘C’，60~69分为‘D’，60分以下为E）学生人数，并将其放入到数组count中，其中：count[0]存E级的人数，count[1]存D级的人数，……，count[4]存A级的人数。

package com.zcl.homework;

public class D04_5 {

	public static void main(String[] args) {

		int[] array = new int[] { 72, 89, 65, 58, 87, 91, 53, 82, 71, 93, 76, 68 };
		Count(array);
	}

	public static void Count(int[] array) {
		int[] arr = new int[5];
		for (int i = 0; i < array.length; i++) {
			if (array[i] >= 90) {
				arr[4]++;
			} else if (array[i] < 90 && array[i] >= 80) {
				arr[3]++;
			} else if (array[i] < 80 && array[i] >= 70) {
				arr[2]++;
			} else if (array[i] < 70 && array[i] >= 60) {
				arr[1]++;
			} else {
				arr[0]++;
			}

		}
		
		System.out.println("数组count为[" + arr[0] + "," + arr[1] + "," + arr[2] + "," + arr[3] + "," + arr[4] + "]");
	}
}

先定义一个数组，再尝试把数组元素反转。
如：（{5,8,3,4,1} -》 {1，4，3，8，5}）

package com.zcl.homework;

public class D04_6 {

	public static void main(String[] args) {
		int[] a = new int[] { 5, 8, 3, 4, 1 };

		reversal(a);
	}

	public static void reversal(int[] arr) {
		int min = 0;
		int max = arr.length-1;
		while (min < max) {
			int temp = arr[min];
			arr[min] = arr[max];
			arr[max] = temp;
			min++;
			max--;
		}
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i]+" ");
		}
	}
}

思考题：想一想为什么说数组的长度不可改变？
（提示：int[] a = new int[3]; a = new int[5]，你觉得这样做是把长度为3的数组改变成长度为5的数组吗？）

不可改变，每次初始化一个数组都是在堆里申请一个独立的空间，无法更改数组的长度，同一个数组被再次初始化后也会重新申请一个独立的空间，原来的不会改变，也不会再用

沧海随云

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
J2EE | 基础篇 | D04 方法调用、重载、数组详解、相关内存解释图、加强for循环以及课后作业（含参考答案）

文章目录调用方法的三种方式：return关键字break,continue和return的区别方法重载（overload）方法重载发生的条件数组什么是数组？数组的分类如何定义数组？课堂笔记java中的内存划分：只有一个数组的内存图：有两个独立数组的内存图：两个引用指向同一个数组的内存图：数组的长度运行期间不可改变：加强for循环 foreach课后作业调用方法的三种方式：第一种：通过对象名...
复制链接

扫一扫