黑马程序员—java基础—java基础语法：数组，二维数组，方法重载

                                                                      ------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

 

 

一，方法

方法定义：方法是具有特定功能的代码块。

有些时候，我们需要重复执行一些操作。如果我们执行一次操作就写一次代码，这会使得代码量增大，代码显得臃肿。我们可以把这些操作封装成一个方法，需要执行就去调用，这样就会使代码变得简洁。

方法的意义，用以下代码表示：

import java.util.Scanner;

/**
 * 学习java语言中的知识点：方法（具有特定功能的一个代码块）
 *
 * 键盘输入：1、导包：java.util.Scanner，且在class之前
 *			  2、创建对象：Scanner jianpan = new Scanner(System.in);
 *			  3、进行键盘的输入：jianpan.nextInt();
 *
 * 方法的格式：
 *			访问修饰符 返回值的数据类型 方法名[建议用动词] （参数类型 参数1，参数类型 参数2。。。） {
 *				语句体;
 *				return 返回值
 *			}
 *
 * 方法的格式说明：
 *			1、访问修饰符：public static 可以进行访问，就是等会儿给main来访问的
 *			2、返回值的数据类型（int、double、float。。。）还可以是其他的引用类型等等，我们先用基本类型演示
 *			3、方法名字：
 *					如果是一个单词：全小写，如果是多个单词第二个单词开始，之后的每个单词的首字母大写
 *					举例：compute
 *			4、参数类型其实就是数据类型：
 *					形式参数：只是约束当前什么形式的数据可以进行，但没有具体的值。例如：洗手间的标识
 *					实际参数：就是我们要参与的具体的数据
 *			5、语句体：代码块，可以是1行，可以是多行。语句体要根据需求来做
 *			6、return：标示结束一个方法，返回值表示方法结束的时候把这个数据一起带走！
 *
 * 事例演示：
 *			1、不论是java语言的默认的main方法，还是我们自己定义的方法，级别相同。所以写法上来说是并列的
 *			2、方法有两部分组成
 *				2.1 定义方法：和main方法是并列平级的关系
 *				2.2 调用（使用）方法：被另一个方法使用（是由main方法包含另一个方法）
 */
class Function {
	/**
	 * java程序运行入口
	 * jvm自动加载main方法
	 */
	public static void main(String[] args) {
		/*System.out.println(3.0 + 4);
		System.out.println(3.0 - 4);
		System.out.println(3.0 * 4);
		System.out.println(3.0 / 4);
		
		System.out.println(30.0 + 40);
		System.out.println(30.0 - 40);
		System.out.println(30.0 * 40);
		System.out.println(30.0 / 40);
		
		System.out.println(300.0 + 400);
		System.out.println(300.0 - 400);
		System.out.println(300.0 * 400);
		System.out.println(300.0 / 400);*/
		
		// 鉴于以上的代码用常量计算带死板，所以用变量来进行计算
		
		/*double x = jianpan.nextDouble();
		double y = jianpan.nextDouble();
		
		System.out.println(x + y);
		System.out.println(x - y);
		System.out.println(x * y);
		System.out.println(x / y);
		
		double a = jianpan.nextDouble();
		double b = jianpan.nextDouble();
		
		System.out.println(a + b);
		System.out.println(a - b);
		System.out.println(a * b);
		System.out.println(a / b);*/
		
		// 针对重复的操作Java语言中可以将重复的代码块（一行或多行）抽取成一个方法，后续只需要调用就可以了
		// 这样的好处是，代码量减少了，出错率也减少了，使用起来更加灵活
		
		// 定义一个方法，来实现四则运算
		// 如果只是单独的调用没有太大意义
		// sum(5, 6);
		
		// 可以直接输出查看结果，但是不一定要查看结果我还可以进行二次计算
		// System.out.println(sum(5, 6));
		
		// 建议使用一个变量来接收方法返回的结果值
		double result = sum(5, 6);
		System.out.println(result + 7);
	}

	/**
	 * 这是我们自定义的方法，由需求而定
	 * 需求：进行两个数字的四则运算
	 */
	public static double sum(double num1, double num2) {
		double he = num1 + num2;
		return he;
	}
}

方法功能演示：打印乘法表：

import java.util.Scanner;

/**
 * 键盘录入一个数据n(1<=n<=9)，输出对应的nn乘法表
 *
 * 需求分析：看见键盘想到Scanner，录入一个变量（取值范围1-9），功能是做乘法
 *
 */
class FunctionTest1 {
	/**
	 * java程序运行入口
	 * jvm自动加载main方法
	 */
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		
		// 人机交互
		System.out.println("请输入1-9之间的数字：");// 计算机给我的提示
		int num = input.nextInt();// 我给计算机的一个响应
		
		// 24行到27行代码是更加严谨的容错代码，让我的程序变得更加强壮
		if (num < 1 || num >9) {
			System.out.println("非法操作，程序退出");
			return;
		}
		
		print(num);
	}
	
	/**
	 * 建议用动词来给方法命名
	 */
	public static void print(int a) {
		for (int i = 1; i <=a; i++) {
			for (int j = 1; j <= i; j++) {
				System.out.print(i + "*" + j + "=" + i*j + "\t");
			}
			
			System.out.println();
		}
	}
}

二，一维数组

通过前面的练习，我们知道，我们需要在编程过程中操作一些数据。如果操作一个数据就定义一个新变量，不仅会使代码变得臃肿，而且看着也会很乱。为了有一个容器来存储很多个数据，数组应运而生。

数组的定义方法：

 数组的格式：1、int[] array; 2、int array[]，方式1最常用。

因为数组是被当成对象的，所以数组的初始化需要new

动态初始化：

int[] arr  = new int[5],5代表这个数组有5个元素，索引从0到4；

int[0] = 2;

int[1] = 8;

......

 

这种方式定义数组不常用，开发中常用的数组定义方式是

int[] arr = {3,4,4,5,3};

因为数组是引用数据类型，在数组没有开辟空间的时候，打印数组的结果是null，如果一旦在堆内存中给了数组分配空间，这个时候打印出来的数组是一个地址值。

下面通过一个例子和一张图来分析一下：

/**
 * 数组的图解2：
 *		数组之间是引用类型，多个数组之间可能会相互影响数据
 *
 */
class ArrayDemo1 {
	/**
	 * java程序运行入口
	 * jvm自动加载main方法
	 */
	public static void main(String[] args) {
		int[] array1 = new int[4];
		int[] array2 = {2, 8, 9};
		
		/*System.out.println(array1[0]);
		System.out.println(array1[1]);
		System.out.println(array1[2]);
		System.out.println(array1[3]);*/
		
		array1[0] = 55;
		array1[1] = 66;
		array1[2] = 77;
		array1[3] = 88;
		
		/*System.out.println(array1[0]);
		System.out.println(array1[1]);
		System.out.println(array1[2]);
		System.out.println(array1[3]);*/
		
		System.out.println(array1[0]);
		System.out.println(array1[1]);
		System.out.println(array1[2]);
		System.out.println(array1[3]);
		System.out.println("---------------------");
		System.out.println(array2[0]);
		System.out.println(array2[1]);
		System.out.println(array2[2]);
		System.out.println("上面是变化前的");
		
		array1 = array2;
		
		System.out.println(array1[0]);
		System.out.println(array1[1]);
		System.out.println(array1[2]);
		System.out.println("---------------------");
		System.out.println(array2[0]);
		System.out.println(array2[1]);
		System.out.println(array2[2]);
		System.out.println("上面是变化后的");
		
		array1[0] = 99;
		
		System.out.println(array1[0]);
		System.out.println(array1[1]);
		System.out.println(array1[2]);
		System.out.println("---------------------");
		System.out.println(array2[0]);
		System.out.println(array2[1]);
		System.out.println(array2[2]);
		System.out.println("上面是变化后且修改的");
	}
}

 

方法的重载：

方法重载的格式：将功能相似的方法，起名时用相同的动词标识，但是重载的方法中的参数类型不同 ，或者参数个数不同

个人理解方式：所谓的方法重载，就是方法的功能一样，但是方法体的参数类型或者参数个数不一样，系统调用哪个方法，需要匹配传入参数类型。

class OverloadDemo {
	/**
	 * java程序运行入口
	 * jvm自动加载main方法
	 */
	public static void main(String[] args) {
		System.out.println("你好");
		System.out.println(6.0);
		System.out.println(true);
		
		// 分析下它为什么不这样写
		/*System.out.printlnForString("你好");
		System.out.printlnForDouble(6.0);
		System.out.printlnForBoolean(true);*/
	}
}

上面的例子，因为数据类型不同，实现方法重载

三，二维数组

   二维数组格式1
   数据类型[][] 变量名 = new 数据类型[m][n];
   m表示这个二维数组有多少个一维数组
   n表示每一个一维数组的元素个数
   举例:
   int[][] arr = new int[3][2];
   定义了一个二维数组arr
   这个二维数组有3个一维数组，名称是arr[0],arr[1],arr[2]
   每个一维数组有2个元素，可以通过arr[m][n]来获取
            表示获取第m+1个一维数组的第n+1个元素
   注意事项
   A:以下格式也可以表示二维数组
   a:数据类型 数组名[][] = new 数据类型[m][n];
   b:数据类型[] 数组名[] = new 数据类型[m][n];
   这两种格式不推荐使用，下面举例：

class Array2Demo {
	/**
	 * java程序入口
	 * jvm自动加载main方法
	 */
	public static void main(String[] args) {
		//定义一个二维数组
		int[][] arr = new int[3][2];
		//输出二维数组名
		System.out.println(arr);//
        //输出一维数组名
		System.out.println(arr[0]);
		System.out.println(arr[1]);
		System.out.println(arr[2]);
        
		System.out.println(arr[0][0]);
		System.out.println(arr[1][1]);


	}
}

上面代码打印结果分析图：

二维数组格式2
  数据类型[][] 变量名 = new 数据类型[m][];
   m表示这个二维数组有多少个一维数组
   这一次没有直接给出一维数组的元素个数，可以动态的给出。
  举例：
   int[][] arr = new int[3][];

   arr[0] = new int[2];
   arr[1] = new int[3];
   arr[2] = new int[1];

不做代码举例。

二维数组格式3
   数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}...};
   简化版:
   数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};
   这个格式属于静态初始化:由我们指定具体的元素值,由系统给分配长度
   举例:
    int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
    int[][] arr = {{1,2,3},{5,6},{7}};

    这种二维数组的格式比较常用！

class Array2Demo3 {
	public static void main(String[] args) {
		//二维数组静态初始化
		int[][] arr = {{3,4,6},{1},{8,5,7,4}};
		
		System.out.println(arr[0]);//地址值
		System.out.println(arr[1]);//地址值
		System.out.println(arr[2]);//地址值

		System.out.println(arr[0][0]);//3
		System.out.println(arr[1][0]);//1
		System.out.println(arr[2][3]);//4


	}
}

四，数组的常见功能

数组的常见功能有：      

        遍历
        逆序
        反转
        求最值
        元素查找

 

       由于这些方法，在后面学习到的工具类里面都有介绍，现在就以一维数组举例分别演示一下这些方法

数组的遍历：

class ArrayTest1 {
	/**
	 * java程序运行入口
	 * jvm自动加载main方法
	 */
	public static void main(String[] args) {
		System.out.println("******欢迎使用传智播客包子点餐系统******");
		
		Scanner input = new Scanner(System.in);
		
		String[] foods = new String[5];
		// 请录入食物数据
		System.out.println("请录入食物数据");
		/*foods[0] = input.nextLine();
		foods[1] = input.nextLine();
		foods[2] = input.nextLine();
		foods[3] = input.nextLine();
		foods[4] = input.nextLine();
		
		System.out.println("您录入了5条数据，最后一条数据是：" + foods[4]);*/
		
		for (int i = 0; i < foods.length; i++) {
			foods[i] = input.nextLine();
		}
		
		for (int i = 0; i < foods.length; i++) {
			System.out.println(foods[i]);
		}
		
		
	}
}

反转：

class ArrayTest2 {
	/**
	 * java程序运行入口
	 * jvm自动加载main方法
	 */
	public static void main(String[] args) {
		System.out.println("{1、2、3、4、5、6、7、8、9}逆序输出");
		
		int[] nums = {1, 2, 3, 4, 5, 6, 7, 8, 9};
		printArray(nums);
		
		reverse(nums);
		
		printArray(nums);
	}
	
	/**
	 * 数组的反向输出
	 */
	public static void reverse(int[] num) {//int[] nums =  
		int temp;
		for (int i = 0; i < num.length/2; i++) {
			temp = num[i];
			num[i] = num[num.length - i - 1];
			num[nums.length - i - 1] = temp;
		}
	}
	
	/**
	 * 打印数组
	 */
	public static void printArray(int[] nums) {
		for (int i =0; i

逆序是从后往前遍历

元素查找：

import java.util.Scanner;

/**
 * 数组元素查找(查找指定元素第一次在数组 
 * 中出现的索引)
 *
 */
class ArrayTest6 {
	/**
	 * java程序运行入口
	 * jvm自动加载main方法
	 */
	public static void main(String[] args) {
		int[] scores = {89, 91, 64, 99, 78, 79, 100, 85};
		Scanner input = new Scanner(System.in);
		
		System.out.println("请问您要查找的分数：");
		int score = input.nextInt();
		if (score > 100 || score < 0) {
			System.out.println("您的成绩不合法，程序退出！");
			return;
		}
		int index = search(scores, score);// 方法调用
		
		System.out.println("此分数所在数组下标的索引值是：" + index);
	}
	
	/**
	 * 根据当前数据查找其在数组中的索引位置
	 */
	public static int search(int[] scores, int score) {
		/*for (int i =0; i < scores.length; i++) {
			if (scores[i] == score) {
				return i;
			}
		// return 0，在返回数组下标的题目中不能用，数组的第一个元素下标是0建议用-1
		}return -1;*/
		
		// 默认没有在当前数组scores中查找到score
		int result = -1;
		for (int i = 0; i < scores.length; i++) {
			if (scores[i] == score) {
				result = i;
				
			}
		}
		return result;
	}
}

元素求最值：

/**
 * 学习数组的最值
 *
 * 最值两个最大和最小：max和min
 *
 */
class ArrayTest3 {
	Sys
		// 我们不操作具体的单一元素，用数组统一管理
		// int a = 99;
		// int b = 28...
		//            0    1   2   3   4
		int[] nums = {36, 99, 28, 66, 88};
		
		int max = nums[0];
		int min = nums[0];
		for (int i = 1; i < nums.length; i++) {
			if (nums[i] > max) {
				max = nums[i];
			}
		}
		for (int i = 1; i < nums.length; i++) {
			if (nums[i] < min) {
				min = nums[i];
			}
		}
		
		System.out.println("最大值：" + max + "，最小值：" + min);
	}
}