黑马程序员—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]);
c164
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]
;

   m表示这个二维数组有多少个一维数组

   n表示每一个一维数组的元素个数

   举例:

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

   定义了一个二维数组arr

   这个二维数组有3个一维数组，名称是arr[0],arr[1],arr[2]

   每个一维数组有2个元素，可以通过arr[m]
来获取

            表示获取第m+1个一维数组的第n+1个元素

   注意事项

   A:以下格式也可以表示二维数组

   a:数据类型 数组名[][] = new 数据类型[m]
;

   b:数据类型[] 数组名[] = new 数据类型[m]
;

   这两种格式不推荐使用，下面举例：

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<nums.length; i++) {
System.out.print(nums[i] + "\t");
}
System.out.println();
}
}

逆序是从后往前遍历

元素查找：

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);
}
}