什么是方法
-
Java方法是语句的集合，它们在一起执行一个功能
-
方法是解决一类问题的步骤的有序组合
-
方法包含于类和对象中
-
方法在程序中被创建，在其他地方被引用
-
-
设计方法的原则：方法的本意是功能块，就是实现某个的语句块的集合，我们设计方法的时候，最好保持方法的原子性，就是一个方法只完成一个功能。
-
public class Demo01{
public static void main(String[] args){
int sum = add(1,2);//调用add方法进行加法
System.out.print(sum);
}
//加法的方法
public static int add(int a, int b){
return a+b;
}
}-
以上就是创建一个加法的方法，在main中调用add()方法，完成加法的功能。
方法的定义和调用
方法的定义
-
java的方法类似于其他语言的函数，是一段用来完成特定功能的代码片段，一般情况下，定义一个方法包含以下的已于：
-
方法包含一个方法头和一个方法体。下面是一个方法的所有部份：
-
修饰符：修饰符，这是可选的，告诉编译器如果调用该方法，定义了该方法的访问类型。
-
返回值类型：方法可能会返回值，returnValueType是方法返回值的数据类型。有些方法所需的操作，但没有返回值，在这种情况下，returnValueType是关键之void。
-
方法名：是方法的实际名称，方法名和参数表共同构成方法名。
-
参数类型：参数是一个占位符。当方法被调用时，传递值给参数，这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含参数。
-
形参：在方法被调用是用于接收外界输入的数据
-
实参：调用方法时实际传给方法的数据。
-
-
方法体包含具体的居于，定义该方法的功能。
修饰符 返回值类型 方法名（参数类型 参数名）{ ... 方法体 ... return 返回值; } //加法的方法 public static int add(int a, int b){ return a+b; } //其中a是形参，用来定义作用的。在调用add是传入的数值为实参。
-
方法调用
-
调用方法：对象名.方法名(实参列表)
-
java支持两种调用方法的方式，根据方法是否返回值来选择。
-
当方法返回一个值的时候，方法调用通常被当作一个值。例如
int larger = max(30,40);
-
如果方法是void，则方法调用一定是一条语句。
方法的重载
命令行传参
-
有时候希望运行要给程序时候再传递给它消息。这是要靠传递命令行参数给main()函数实现；
-
需要打开cmd中，在里面运行java文件，给args赋值；
public class CommandLine{
public static void main(String args[]){
for(int i=0;i<args.length;i++){
System.out.println("args["+i+"]"+args[i]);
}
}
}可变参数
-
在方法声明中，在指定参数类型后加一个省略号(...)
-
一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。
-
意思就是指定参数类型，在参数类型之后加(...)，之后的参数名，就可以在不指定多个的情况下，调用方法时可以传入多个参数
public class Demo01{ public static void main(String[] args){ Main main = new Main(); main.add(1,2,3);//可以写入多个实参，并且不需要在方法上定义多个形参。 } //加法的方法 public void add(int... a){ System.out.println(a[0]); System.out.println(a[1]); System.out.println(a[2]); } } ![image-20210615153408854]()
-
递归
-
递归就是自身调用自身的方法。
-
递归结构包含两个部份：
-
递归头：什么时候不调用自身方法。如果没有头，将陷入死循环
-
递归体：什么时候需要调用自身方法。
-
-
递归可以用来解决一些复杂的问题，将一个大型复杂的问题逐层转化分解和一个个小问题来解决，递归策略只需要少量的程序就可以描述出解题过程需要的多次计算，大大减少代码量。递归的能力在于用有限的语句来定义对象的无限集合。
public class Demo01{
public static void main(String[] args){
//这里是调用方法传入数值5，
System.out.println(f(5));//输出120
//调用方法过程中发生：5*4*3*2*1=120
}
//创建递归方法，如果不满足条件会继续调用自身
public static int f(int a){
if(a == 1){
return 1;
}else {
return a*f(a-1);
}
}
}数组
-
数组的定义
-
数组是相同类型数据的有序集合
-
数组描述的是相同类型的若干个数据，按照一定的先后次序排序组合而成
-
其中，每一个数据称作一个数组元素，每个数组按照下标来访问它。
-
-
数组的声明创建
-
首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法。
-
public class Demo01{ public static void main(String[] args){ int[] nums;//1.定义数组 int nums[];//也可以 但是推荐用上面 //java语言使用new操作符来创建数组，语法如下： nums = new int[10];//10为数量，数量为几即存放几个数据。 //给数组元素赋值 for(int i=0;i<10;i++){ nums[i]=i+1; } //注意：数组下标是从0开始，即nums[0]=1； //获取数组的长度： nums.length //输出数组 for(int i=0;i<nums.length;i++){ System.out.println(nums[i]); } } }
-
-
三种初始化及内存分析
-
java内存分析：
-
堆：
-
存放new的对象和数组
-
可以被所有的线程共享，不会存放别的对象引用
-
-
栈：
-
存放基本变量类型(会包含这个基本类型的具体数值)
-
引用对象的变量(会存放这个引用在堆里面的具体地址)
-
-
方法区：
-
可以被所有线程共享
-
包含了所有的class和static变量
-
-
//静态初始化 int[] i ={1,2,3,4,5}; System.out.println(i[0]);//输出为1 //动态初始化, int[] a = new int[10]; a[0] = 1; a[1] = 2; System.out.println(a[0]);//输出为1 //栈就箱单与目录，而堆可以相比于内容。 -
数组的使用
-
For-Each循环
-
public class Demo01{ public static void main(String[] args){ int[] number = {1,2,3,4,5}; //打印全部的数组元素 for (int i = 0; i < number.length; i++) { System.out.print(number[i]+"\t"); } System.out.println(); //计算所有元素总和 int sum=0; for (int i = 0; i < number.length; i++) { sum += number[i]; } System.out.println(sum); } //还可以查找最大元素等。 //以下是进阶for循环 // array无下标，可以用于遍历数组，取出每一个数值 int[] arrays = {1,2,3,4,5}; for (int array :arrays ){ System.out.print(array+"\t"); } }
-
-
数组做方法入参
-
public class Demo01{ public static void main(String[] args) { int[] arrays = {1, 2, 3, 4, 5}; //调用打印数组元素的方法 printArray(arrays); //反转数组 System.out.println(Arrays.toString(reverse(arrays)));//输出[5,4,3,2,1] } //打印数组元素 public static void printArray(int[] arrays){ for (int i = 0; i < arrays.length; i++) { System.out.println(arrays[i]); } } //反转数组，让数组按照相反的顺序输出 public static int[] reverse(int[] arrays){ int[] reverse = new int[arrays.length]; for (int i = 0, j = arrays.length-1 ; i < arrays.length; i++,j--) { reverse[j]=arrays[i]; } return reverse; } }![image-20210615200717423]()
-
-
数组做返回值
二维数组
-
相当于在数组之上在创建一个数组(无限套娃哈哈哈)
int[][] = {{1,2},{3,4},{5,6}}
//就比如上方 可以分为3个一维数组，放在一起组成了一个新的数组。
//那么第一个的下标范围就是0-2，第二个下标范围就是0-1
System.out.println(int[0][1])//输出2
System.out.println(int[1][1])//输出4
System.out.println(int[2][1])//输出6
Arrays类
public class Main {
public static void main(String[] args) {
int[] i={1,2,3,4,5};
System.out.println(Arrays.toString(i));
}
}
-
Arrays类中有很多封装好的方法，如上图的toString()方法就是用来输出数组。
冒泡排序
-
比较数组中，两个相邻的元素，如果第一个比第二个大，就交换他们的位置。
-
每一次比较都会产出一个最大，一个最小
-
下一轮则可以少一次排序
-
依次循环，直到结束。
public class ArraysClass {
public static void main(String[] args) {
int[] array={5,4,2,45,8,61,44};
System.out.println(Arrays.toString(sort(array)));
}
//冒泡排序
public static int[] sort(int[] array){
int a;
//外层循环
for (int i = 0; i < array.length-1 ; i++) {
//内层循环
for (int j = 0; j < array.length-1-i ; j++) {
if (array[j+1]>array[j]){
a = array[j+1];
array[j+1] = array[j];
array[j] = a;
}
}
}
return array;
}
}稀疏数组
-
当一个数组中大部分元素为0，或者为同一值时，可以使用稀疏数组来保存该数组。
-
处理方法：
-
记录数组一共有几行几列，有多少个不同值
-
把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模。
-
public class ArraysClass {
public static void main(String[] args) {
//创建稀疏数组
int [][] array1 = new int[11][11];
array1[1][1] = 1;
array1[2][3] = 1;
//输出原始的数组
System.out.println("输出原始数组");
for (int[] ints :array1){
for (int anInt: ints){
System.out.print(anInt+"\t");
}
System.out.println();
}
//转化为稀疏数组来储存
//获取有效值的个数
int sum = 0;
for (int i = 0; i < 11; i++) {
for (int j = 0; j < 11; j++) {
if (array1[i][j]!=0){
sum++;
}
}
}
System.out.println("有效数组个数为:"+sum);
//创建一个稀疏数组
int[][] array2 = new int[sum+1][3];
array2[0][0] = 11;
array2[0][1] = 11;
array2[0][2] = sum;
//遍历二维数组，将非0的值存入数组中
int count=0;
for (int i = 0; i < 11; i++) {
for (int j = 0; j < 11; j++) {
if (array1[i][j]!=0){
count++;
array2[count][0] = i;
array2[count][1] = j;
array2[count][2] = array1[i][j];
}
}
}
System.out.println("输出稀疏数组");
for (int i = 0; i < array2.length; i++) {
System.out.println(array2[i][0]+"\t"+
array2[i][1]+"\t"+
array2[i][2]+"\t");
}
//还原稀疏数组
//读取稀疏数组的行数，列数
int[][] array3 = new int[array2[0][0]][array2[0][1]];
//给其中的元素还原他的数值
for (int i = 1; i < array2.length ; i++) {
array3[array2[i][0]][array2[i][1]] = array2[i][2];
}
System.out.println("还原后的稀疏数组为：");
//遍历输出数组
for (int[] ints :array3){
for (int anInt: ints){
System.out.print(anInt+"\t");
}
System.out.println();
}
}-
原始的数组为
-
可以看出大部分均为相同数字，只有2个为1；
-
而稀疏数组的作用就是输出不为0或者不是相同数字的数组，根据不同数字的行，列，数值，来输出。
-
![image-20210615210420966]()
-
可以看出以上的第一行描述的意思是描述稀疏数组是11行，11列，一共2个不同数值的数组。
-
第二行输出的是，第一个1在第二行，第二列(数组下标+1)
-
第三行输出的是，第二个1在第三行，第四列。
-
还原稀疏数组的原始数组就可以按照我们输出的稀疏数组的第一行来获取一共有11行，11列，那么二维数组就是arrays3 [11] [11]
-
再根据之后的每一列获取每一个数值相对应的位置。最后遍历输出。
浙公网安备 33010602011771号