Java基础回顾_Java方法详解
- 何谓方法？
- 方法的重载
- 命令行传参（不经常使用）
- 可变参数
- 递归（重点）
- 数组
  - 数组的声明创建
  - 数组的内存分析
  - 数组的四个基本特点
  - 数组边界
  - 数组使用
  - 多维数组
  - Arrays类
  - 八大排序
  - 稀疏数组

Java基础回顾_Java方法详解

何谓方法？

Java方法是解决一类问题的步骤的有序组合
方法包含于类或对象中
方法在程序中被创建，在其它地方被引用

设计方法的原则：方法的本意是功能块，就是实现某个功能的语句块的集合。我们设计方法的时候，最好保持方法的原子性，就是一个方法只能完成一个功能，这样利于我们后期的发展。

个人随笔：

方法命名遵循 小驼峰原则
main方法尽量保持简洁、干净
方法其实就是C语言里的函数，方法遵循原子性，即一个方法只完成一件事
有些方法没有return返回值，于是方法体就不需要写返回值类型，这个时候就要用 void 替代 返回值类型
有参数的方法一定要有return返回值，没有参数的方法即void方法就不需要return返回值
参数类型这里得注意：参数类型分为形式参数 和实参（或称为变量）。
形式参数：形参就是创建方法的时候我个人定义的像 int a, int b 这样的，没有实际值，等着调用的时候再往里传具体值的参数，相当于占位符，先把位置占着，用的时候再给它其他的值；
实参（或称为变量）：方法在被调用的时候直接给参数赋值，像add( 1, 2);这种里面的 1和2 就是实参。

代码格式：

修饰符 + 返回值类型 + 自定义方法名 + （参数类型 + 参数名--->"参数可以定义一个或者多个" ）{

//执行的代码语句，即方法体

return + 返回值；

}

例如：下面的add方法（加法）：

public int add( int a, int b ){

return a+b;

}

个人随笔：

有时候用return 0；去终止方法。
方法的带你用：用对象名去点方法名，例如：对象名.方法名（实参列表）

拓展了解：值传递和引用传递

Java都是值传递！只有值传递！

方法的重载

个人练习：

结合Scanner对象，完成手动输入两个整数打印最小值；以及直接注入三个整数然后得到三个整数中最小的那个。

这两个方法的方法名都是min，但是它们的参数列表不一样，一个是两个变量（实参），一个是3个变量（实参）！！！！妙啊！！！

public class Demo01 { public static void main(String[] args) {  Scanner scanner = new Scanner(System.in);  System.out.println("请依次输入要比较的两个整数：");  int a = scanner.nextInt();  int b = scanner.nextInt();  int min = min(a, b);  System.out.println("输入的两个整数中较小的那个整数是："+min);  int min1 = min(6, 8, 3);  System.out.println("三个整数中最小的整数是："+min1); } public static int min(int a,int b){  int minNumber;  if (a<b){   minNumber = a;  }else {   minNumber = b;  }  return minNumber; } //重载的取最小值的方法，但是参数列表不一样，多了一个参数 public static int min(int a,int b,int c){  int minNumber;  if (a<b){   minNumber = a;  }else {   minNumber = b;  }  if(minNumber<c){   return minNumber;  }else {   minNumber=c;  }  return minNumber; }}

方法重载的规则：

方法名称必须一模一样
参数列表必须不同，即参数的个数不同、或参数的类型不同、或参数的排列顺序不同等
方法的返回值类型可以相同，也可以不相同，但是仅仅只有返回值类型不同也不行

个人随笔：

当编写了重载的方法的时候，再去调用这些方法名相同的方法的时候，编译器它自己会根据参数列表的差异去一个方法一个方法的找，知道找到对应的方法，如果找不到，它就会报错！

命令行传参（不经常使用）

有时候你希望运行一个程序的时候，再传递给它消息。这个时候就要靠传递命令行参数给main()函数去实现。

可变参数

什么是可变参数？

有时候根据实际需求，可能需要用方法重载去编写几十个甚至上百个方法名相同，参数链表不同的方法，这样也太离谱了，这时候就诞生了可变参数 这种东西，它解决了上述问题！妙啊！！！！！！

用法：在参数列表中的参数声明的参数类型后面加上一个省略号，例如：

利用可变参数，自定义任意的数据传入方法，取得最大值！

public class Demo01 { public static void main(String[] args) {  printMax(1,5,3,4,6,8,2,3,9,6,4);  printMax(new double[]{1,2,3}); } public static void printMax(double... numbers){  if (numbers.length == 0){   System.out.println("No argument passed");   return;  }  double result = numbers[0];  //排序！  for (int i = 1; i < numbers.length; i++) {   if (numbers[i] > result){    result = numbers[i];   }  }  System.out.println("The max Value is " + result); }}

递归（重点）

递归就是：A方法调用A方法，即自己调用自己！递归是一种思想！

递归结构包括两个部分：

递归头：就是有一串可以停止调用方法（函数）的代码，让程序不会无限循环运行！
递归体：

友情提示：能不用递归就不用递归，因为如果调用方法次数过多，会非常占用资源，影响性能！

个人练习：

写一个计算器，要求实现加减乘除功能，并且能循环接收新的数据，通过用户交互实现（即Scanner对象）

用到了 while循环 switch语句，实现了数据的循环输入并计算！！！！妙啊！！！！

import java.util.Scanner;public class Calculator{ public static void main(String[] args) {  //创建对象用来调用对象里的方法  Calculator calculator = new Calculator();  //调用computer方法  calculator.computer(); } //第一步：加减乘除四个方法（因为要循环计算，每次传入一个数字，所以参数列表应该只有一个参数） //加法 public static double add(double a){  System.out.println("请输入一个数：");  Scanner scanner3 = new Scanner(System.in);  double b = scanner3.nextDouble();  return a+b; } //减法 public static double subtract(double a){  System.out.println("请输入一个数：");  Scanner scanner3 = new Scanner(System.in);  double b = scanner3.nextDouble();  return a-b; } //乘法 public static double multiply(double a){  System.out.println("请输入一个数：");  Scanner scanner3 = new Scanner(System.in);  double b = scanner3.nextDouble();  return a*b; } //除法 public static double divide(double a){  System.out.println("请输入一个数：");  Scanner scanner3 = new Scanner(System.in);  double b = scanner3.nextDouble();  return a/b; } //第二步：完成循环输入数据的功能（while（true）+switch）,必须创建一个方法完成这一步 public void computer(){  System.out.println("请输入一个数：");  Scanner scanner1 = new Scanner(System.in);  double a = scanner1.nextDouble();  while(true){   Scanner scanner2 = new Scanner(System.in);   System.out.println("你可以输入的操作有：加(+)减(-)乘(*)除(/)清零(小写的c)结束(小写的end)--->");   String str = scanner2.nextLine();   switch (str){    case "+":     a = add(a);     System.out.println("="+a);     break;    case "-":     a = subtract(a);     System.out.println("="+a);     break;    case "*":     a = multiply(a);     System.out.println("="+a);     break;    case "/":     if (a == 0){      System.out.println("除法分子不能为零，请重新输入：");      break;     }     a = divide(a);     System.out.println("="+a);     break;    case "c":     computer();     break;    case "end":     System.exit(-1);     break;    default:     System.out.println("输入的字符有误！");   }  } }}

数组

什么是数组 ?

数组是相同类型 数据的有序组合。

数组的声明创建

首先必须声明数组变量，才能在程序中使用数组。

一共两种声明数组变量的格式如下：

int[] nums;//建议选择这种声明数组变量的格式；int nums2[];//不建议使用这种格式；这是c和c++里的格式，早些年为了程序员能快速掌握Java所以也有这种声明数组变量的格式

创建一个数组

int[] nums;//建议选择这种声明数组变量的格式；int nums2[];//不建议使用这种格式；nums = new int[10];//这里可以存放10个int类型的元素//创建数组，一步到位double[] nums3 = new double[10];System.out.println(nums3.length);//输出nums3的数组长度

数组的内存分析

略...

数组的三种初始化：

静态初始化----------------------------->在声明数组的时候就直接给数组赋值------>int[] a = {1,2,3,4,5};
动态初始化----------------------------->在声明数组之后，再给数组赋值------>int[] a = new int[5]; a[0]=1; a[1]=2; a[2]=3; a[3]=4; a[4]=5;
数组的默认初始化-------------------->在声明数组之后，数组里的元素默认为0------>int[] a = new int[5]；//a= {0,0,0,0,0}

数组的四个基本特点

数组被创建之后，长度就不能改变了；
数组中所有的元素必须是同一数据类型；可以是任意数据类型，包括基本类型和引用类型；
数组中的变量属于引用类型，我们用的时候就去点它，数组也可以看成是对象，其中的没个元素都相当于是该对象的成员变量；
数组本身就是对象，Java中的对象都在堆中，所以数组对象本身是在堆中的。

数组边界

数组下标从0开始到数组长度减一，如果下标超了，就会报错：ArrayIndexOutofBounds--------->数组下标越界异常

数组使用

For-Each 循环
数组当作参数传入方法中
数组当作返回值返回

多维数组

int[][] a = {{1,2},{3,4},{8,9}};//这是一个二维数组

个人理解：多维数组就是不停的套娃！妙啊！！！！！！！！！！！

Arrays类

Arrays.toString(数组名称)；//可以打印出数组所有数组元素；
Arrays.sort(数组名称)；//可以对数组排序：升序（从小到大）
Arrays.fill(数组名称,想要填充的值)；//可以对数组进行填充：所有元素都会被想要填充的值给替换
Arrays.fill(数组名称,3,8,想要填充的值)；//只有数组下标为3到8的元素被替换

八大排序

个人理解：

冒泡排序：比较数组中两个相邻的元素，如果右边的元素比左边的小，则它们交换位置，达到左边的元素永远比右边的元素小的效果；从右往左比较，这样每个数都能被比较到，由于每次都将较小的移到了左边，所以每比较完一轮，下一轮又从最右边往最左边比较的时候，就可以少比较一次（比如有5个元素，每次比较两个元素的话，一轮就需要比较4次，第二轮就只需要比较3次，第三轮就只需要比较2次，第四轮就需要比较1次，然后就排好顺序了）；--------------->时间复杂度为O(n的2次方)。

public class Demo01 { public static void main(String[] args) {  int[] array2 ={1,4,8,3,5,9,2};  System.out.println(Arrays.toString(fun1(array2 ))); } //编写一个给数组冒牌排序的方法，参数为数组 public static int[] fun1(int[] array1){  //声明一个用来给两个相邻元素交换位置的变量  int t = 0;  for (int i = 0; i < array1.length-1; i++) {   for (int j = 0; j < array1.length-1-i; j++) {    if (array1[j+1]<array1[j]){     t = array1[j];     array1[j] = array1[j+1];     array1[j+1] = t;    }   }  }  return array1; }}

。。。

稀疏数组

创建一个数组，打印出它的稀疏数组，并通过稀疏数组打印出原数组！！！！！！

public class Demo01 { public static void main(String[] args) {  //二维数组  int[][] array = new int[11][11];  array[1][2] = 1;  array[2][3] = 2;  for (int[] ints : array) {   for (int anInt : ints) {    System.out.print(anInt + "\t");   }   System.out.print("\n");  }  //将上面的二维数组转换为稀疏数组保存起来  //获取有效值的个数  int count = 0;  for (int i = 0; i < array.length; i++) {   for (int j = 0; j < array.length; j++) {    if(array[i][j] != 0){     count ++;    }   }  }  System.out.println("该二维数组中有效值的个数为："+ count);  //稀疏数组  //第一步：创建一个二维数组，称之为稀疏数组  int[][] array1 = new int[count+1][3];//有效值+1就是稀疏数组的行数，列固定为3列  //第二步，给这个稀疏数组加入第一行应该展示的数据；  array1[0][0] = array.length;//原数组的行数  array1[0][1] = array.length;//原数组的列数  array1[0][2] = count;//原数组中有效值 的个数  //第三步：给稀疏数组赋值  int count1 = 0;  for (int i = 0; i < array.length; i++) {   for (int j = 0; j < array[i].length; j++) {    if(array[i][j] != 0){     count1++;     array1[count1][0] = i;     array1[count1][1] = j;     array1[count1][2] = array[i][j];    }   }  }  //第四步：打印输出数组  System.out.println("原数组array的稀疏数组array1如下所示：");  //遍历输出稀疏数组array1  for (int[] ints : array1) {   for (int anInt : ints) {    System.out.print(anInt + "\t");   }   System.out.print("\n");  }//  for (int i = 0; i < array1.length; i++) {//   System.out.println(array1[i][0]+"\t"+array1[i][1]+"\t"+array1[i][2]);//  }  System.out.println("将稀疏数组还原成原数组:");  //将稀疏数组还原成原数组  //第一步：用稀疏数组中第一行的值去创建一个二维数组，用来显示原数组  int array2[][] = new int[array1[0][0]][array1[0][1]];//确定数组为几行几列  //确认数组的大小后，就要通过稀疏数组中描述的原数组的有效值传入array2中  for (int i = 1; i < array1.length; i++) {   array2[array1[i][0]][array1[i][1]] = array1[i][2];  }  //第二步：打印array2数组  for (int[] ints : array2) {   for (int anInt : ints) {    System.out.print(anInt+"\t");   }   System.out.print("\n");  } }}

将上面的代码写为两个方法：数组转稀疏数组的方法，和，稀疏数组转原数组的方法：

public class Demo01 { public static void main(String[] args) {  //二维数组  int[][] array = new int[11][11];  array[1][2] = 1;  array[2][3] = 2;  System.out.println("数组array的稀疏数组为：" );  sparseArray(array);  int[][] array1 = new int[3][3];  array1[0][0] = 11;array1[0][1] = 11;array1[0][2] = 2;  array1[1][0] = 1;array1[1][1] = 2;array1[1][2] = 1;  array1[2][0] = 2;array1[2][1] = 3;array1[2][2] = 2;  System.out.println("稀疏数组array1的原数组为：" );  sparseArrayToArray(array1); } /**  * 数组 转为 稀疏数组  * @param array  */ public static void sparseArray(int[][] array){  //将上面的二维数组转换为稀疏数组保存起来  //获取有效值的个数  int count = 0;  for (int i = 0; i < array.length; i++) {   for (int j = 0; j < array.length; j++) {    if(array[i][j] != 0){     count ++;    }   }  }  //稀疏数组  //第一步：创建一个二维数组，称之为稀疏数组  int[][] array1 = new int[count+1][3];//有效值+1就是稀疏数组的行数，列固定为3列  //第二步，给这个稀疏数组加入第一行应该展示的数据；  array1[0][0] = array.length;//原数组的行数  array1[0][1] = array.length;//原数组的列数  array1[0][2] = count;//原数组中有效值 的个数  //第三步：给稀疏数组赋值  int count1 = 0;  for (int i = 0; i < array.length; i++) {   for (int j = 0; j < array[i].length; j++) {    if(array[i][j] != 0){     count1++;     array1[count1][0] = i;     array1[count1][1] = j;     array1[count1][2] = array[i][j];    }   }  }  //第四步：打印输出数组  //遍历输出稀疏数组array1  for (int[] ints : array1) {   for (int anInt : ints) {    System.out.print(anInt + "\t");   }   System.out.print("\n");  } } /**  * 稀疏数组 转为 数组  * @param sparseArray  */ public static void sparseArrayToArray(int[][] sparseArray){  //将稀疏数组还原成原数组  //第一步：用稀疏数组中第一行的值去创建一个二维数组，用来显示原数组  int array2[][] = new int[sparseArray[0][0]][sparseArray[0][1]];//确定数组为几行几列  //确认数组的大小后，就要通过稀疏数组中描述的原数组的有效值传入array2中  for (int i = 1; i < sparseArray.length; i++) {   array2[sparseArray[i][0]][sparseArray[i][1]] = sparseArray[i][2];  }  //第二步：打印array2数组  for (int[] ints : array2) {   for (int anInt : ints) {    System.out.print(anInt+"\t");   }   System.out.print("\n");  } }}

原文转载：http://www.shaoqun.com/a/666720.html

跨境电商：https://www.ikjzd.com/

acca：https://www.ikjzd.com/w/1370

心怡科技：https://www.ikjzd.com/w/1327

目录Java基础回顾_Java方法详解何谓方法？方法的重载命令行传参（不经常使用）可变参数递归（重点）数组数组的声明创建数组的内存分析数组的四个基本特点数组边界数组使用多维数组Arrays类八大排序稀疏数组Java基础回顾_Java方法详解何谓方法？Java方法是解决一类问题的步骤的有序组合方法包含于类或对象中方法在程序中被创建，在其它地方被引用设计方法的原则：方法的本意是功能块，就是实现某个功能
抢注商标：https://www.ikjzd.com/w/1053
捷汇：https://www.ikjzd.com/w/419
mile：https://www.ikjzd.com/w/1746
Shopify SEO：增加自然搜索流量的 10 个简单技巧-megalithant：https://www.ikjzd.com/home/135276
又一家电商大卖上市，遨森电商成功挂牌新三板！：https://www.ikjzd.com/home/10331
公司大叔爱上我口述我和大叔第一次敞开心扉的经历：http://www.30bags.com/a/250235.html

Fashion World

2021-04-06