回复
添加资源
添加资源将有机会获得更多曝光，你也可以直接关联已上传资源
去关联
Java基础回顾_Java方法详解
deanyuancn
发布于 2021-5-13 10:44
浏览
0收藏
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;
}个人随笔：
1、有时候用return 0；去终止方法。
2、方法的带你用：用对象名去点方法名，例如：对象名.方法名（实参列表）
拓展了解：值传递和引用传递
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;
}
}
方法重载的规则：
1、方法名称必须一模一样
2、参数列表必须不同，即参数的个数不同、或参数的类型不同、或参数的排列顺序不同等
3、方法的返回值类型可以相同，也可以不相同，但是仅仅只有返回值类型不同也不行
个人随笔：
当编写了重载的方法的时候，再去调用这些方法名相同的方法的时候，编译器它自己会根据参数列表的差异去一个方法一个方法的找，知道找到对应的方法，如果找不到，它就会报错！
命令行传参（不经常使用）
有时候你希望运行一个程序的时候，再传递给它消息。这个时候就要靠传递命令行参数给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");
}
}
}
果断就会白给，犹豫就会败北，坚持才是胜利！！！
分类
已于2021-5-13 10:44:09修改
赞
1
收藏
回复
举报
相关推荐
