java基础五（方法；数组）

柔情只为你懂 2022-09-30 03:44 129阅读 0赞

方法  
          (1)方法：就是完成特定功能的代码块。

注意：在很多语言里面有函数的定义，而在Java中，函数被称为方法。

main方法是被虚拟机调用的

(2)格式：  
                   修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2...) \{  
                         方法体语句;  
                         return 返回值;  
                   \}  
  
  
                   修饰符：目前就用 public static。后面再详细讲解其他修饰符  
                   返回值类型：就是功能结果的数据类型  
                   方法名：就是起了一个名字，方便我们调用该方法。  
                   参数类型：就是参数的数据类型  
                   参数名：就是变量  
                   参数分类：  
                   实参：实际参与运算的数据  
                   形参：方法上定义的，用于接收实际参数的变量  
                   方法体语句：就是完成功能的代码块  
                   return：结束方法  
                   返回值：就是功能的结果，由return带给调用者。  
        (3)两个明确：  
                   返回值类型：结果的数据类型  
                   参数列表：参数的个数及对应的数据类型  
        (4)方法调用  
                   A:有明确返回值的方法  
                           a:单独调用，没有意义  
                           b:输出调用，不是很好，因为我可能需要不结果进行进一步的操作。  
                           c:赋值调用，推荐方案  
                  B:void类型修饰的方法  
                           a:单独调用  
       (5)案例：

A:求和方案

public class Demo1 {
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		System.out.println(sum(3,4));
    	}
    	public static int sum(int a,int b){
    		
    		return a+b;
    		
    	}
    }

![Center][]

B:获取两个数中的较大值

public class Demo1 {
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		System.out.println("两个数中的较大值："+max(3,4));
    	}
    	public static int max(int a,int b){
    		if(a>b)
    			return a;
    		else
    			return b;
    		
    	}
    }

C:比较两个数据是否相同

public class Demo1 {
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		System.out.println("两个数是否相等："+compare(3,4));
    	}
    	public static String compare(int a,int b){
    		if(a==b)
    			return "是";
    		else
    			return "否";
    	}
    }

D:获取三个数中的最大值

public class Demo1 {
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		System.out.println("三个数中的最大值："+compare(3,4,5));
    	}
    	public static int compare(int a,int b,int c){
    		if(a>b){
    			if(a>c)
    				return a;
    			else 
    				return c;
    		}
    		else{
    			if(b>c)
    				return b;
    			else 
    				return c;
    		}
    			
    	}
    }

E:输出m行n列的星形

import java.util.Scanner;
    
    public class Demo1 {
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		Scanner scan = new Scanner(System.in);
    		System.out.println("请输入需要显示多少行多少列的*");
    		int row = scan.nextInt();
    		int col = scan.nextInt();
    		see(row,col);
    	}
    	public static void see(int row,int col){
    		for(int i=1;i<=row;i++){
    			for(int j=1;j<=col;j++){
    				System.out.print("*");
    			}
    			System.out.println("");
    		}			
    	}
    }

F:输出nn乘法表

上一篇博文中有，将其封装到方法中调用即可

(6)方法的注意事项  
                  A:方法不调用不执行  
                  B:方法之间是平级关系，不能嵌套定义  
                  C:方法定义的时候，参数是用，隔开的  
                  D:方法在调用的时候，不用在传递数据类型

E:如果方法有明确的返回值类型，就必须有return语句返回。

(7)方法重载  
                  在同一个类中，方法名相同，参数列表不同。与返回值无关。调用时，虚拟机通过参数列表的不同来区分同名方法  
  
                          参数列表不同：  
                          参数的个数不同。  
                          参数的对应的数据类型不同。  
         (8)方法重载案例

不同的类型的多个同名方法的比较。

重载练习比较数据是否相等

import java.util.Scanner;
    
    public class Demo1 {
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		byte b1=3;
    		byte b2=4;
    		System.out.println(compare(b1,b2));
    		short s1=3;
    		short s2=4;
    		System.out.println(compare(s1,s2));
    		int i1=3;
    		int i2=4;
    		System.out.println(compare(i1,i2));
    		long l1=3L;
    		long l2=4L;
    		System.out.println(compare(l1,l2));
    		
    	}
    	//byte类型
    	public static boolean compare(byte a,byte b){
    		System.out.println("byte");
    		return a==b;
    	}
    	//short类型
    	public static boolean compare(short a,short b){
    		System.out.println("short");
    		return a==b;
    	}
    	//in类型
    	public static boolean compare(int a,int b){
    		System.out.println("int");
    		return a==b;
    	}
    	//long类型
    	public static boolean compare(long a,long b){
    		System.out.println("long");
    		return a==b;
    	}
    }

数组

(1)数组：存储同一种数据类型的多个元素的容器（集合）。

可以存储基本类型，也可以存储引用类型

(2)特点：每一个元素都有编号，从0开始，最大编号是长度-1。

编号的专业叫法：索引

通过数组访问数据的格式：数组名\[索引\]

(3)定义格式  
                   A:数据类型\[\] 数组名;  
                   B:数据类型 数组名\[\];  
  
                  推荐是用A方式。

(4)数组的初始化（使用变量必须初始化）

数组初始化：为数组中的数组元素分配内存空间（new），并为每个数组元素赋值

A:动态初始化  
                              只给长度，系统给出默认值

举例：int\[\] arr = new int\[3\];  //定义了一个int型的数组，可以存储3个int型的值

System.out.println(arr);//输出的是地址值

B:静态初始化  
                               给出值，系统决定长度  
  
                                举例：int\[\] arr = new int\[\]\{1,2,3\};

简化版：int\[\] arr = \{1,2,3\};

不要同时静态和动态进行

如下格式：int \[\] arr = new int\[3\]\{1,2,3\};  //错误

(5)Java的内存分配  
                  A:栈 存储局部变量（栈内存中的数据用完就释放掉）  
                  B:堆 存储所有new出来的（每一个new出来的都有地址值）  
                  C:方法区(面向对象部分详细讲解)  
                  D:本地方法区(系统相关)  
                  E:寄存器(CPU使用)  
  
       注意：  
               a:局部变量 在方法定义中或者方法声明上定义的变量。  
               b:栈内存和堆内存的区别  
                      栈：数据使用完毕，就消失。  
                      堆：每一个new出来的东西都有地址  
                                   每一个变量都有默认值  
                                              byte,short,int,long 0  
                                              float,double 0.0  
                                              char '\\u0000'（空字符）  
                                              boolean false  
                                              引用类型 null（引用类型的常量：空常量）

数据使用完毕后，但是并没有立即回收，在垃圾回收器空闲的时候回收。

栈内存的两个引用指向同一个堆内存空间，无论是他们谁的操作，都是针对同一个地方

ArrayIndexOutOfBoundsException:数组索引越界异常

NullPointerException：空指针异常

数组已经不再指向堆内存了

(6)数组内存图  
                       A:一个数组  
                       B:二个数组  
                       C:三个数组(两个栈变量指向同一个堆内存)  
        (7)数组的常见操作  
                       A:遍历  
                            方式1：

public static void printArray(int[] arr) {
     for(int x=0; x<arr.length; x++) {
     System.out.println(arr[x]);
     }
    }

方式2：

public static void printArray(int[] arr) {
     System.out.print("[");
     for(int x=0; x<arr.length; x++) {
     if(x == arr.length-1) {
     System.out.println(arr[x]+"]");
     }else {
     System.out.println(arr[x]+", ");
     }
     }
    }

B:最值  
最大值：

public static int getMax(int[] arr) {
     int max = arr[0];
    
     for(int x=1; x<arr.length; x++) {
     if(arr[x] > max) {
     max = arr[x];
     }
     }
    
     return max;
    }

最小值：

public static int getMin(int[] arr) {
     int min = arr[0];
    
     for(int x=1; x<arr.length; x++) {
     if(arr[x] < min) {
     min = arr[x];
     }
     }
    
     return min;
    }

C:逆序  
方式1：

public static void reverse(int[] arr) {
     for(int x=0; x<arr.length/2; x++) {
     int temp = arr[x];
     arr[x] = arr[arr.length-1-x];
     arr[arr.length-1-x] = temp;
     }
    }

方式2：

public static void reverse(int[] arr) {
     for(int start=0,end=arr.length-1; start<=end; start++,end--) {
     int temp = arr[start];
     arr[start] = arr[end];
     arr[end] = temp;
     }
    }

D:查表

public static String getString(String[] strArray,int index) {
     return strArray[index];
    }

E:基本查找  
方式1：

public static int getIndex(int[] arr,int value) {
     for(int x=0; x<arr.length; x++) {
     if(arr[x] == value) {
     return x;
     }
     }
    
     return -1;
    }

方式2：

public static int getIndex(int[] arr,int value) {
     int index = -1;
    
     for(int x=0; x<arr.length; x++) {
     if(arr[x] == value) {
     index = x;
     break;
     }
     }
    
     return index;
    }

二维数组  
         (1)元素是一维数组的数组。  
         (2)格式：

A:数据类型\[\]\[\] 数组名 = new 数据类型\[m\]\[n\];

或：数据类型 \[\]数组名\[\] = new 数据类型 \[m\]\[n\];

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

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

列数没有给出，可以动态的给，这一次是一个变化的列数

C:数据类型\[\]\[\] 数组名 = new 数据类型\[\]\[\]\{ \{...\},\{...\},\{...\}\};

D:数据类型\[\]\[\] 数组名 = \{ \{...\},\{...\},\{...\}\};

![Center 1][]

(3)案例:

A:二维数组的遍历

import java.util.Scanner;
    
    public class Demo1 {
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		int [][]arr = {
       {1,2,3},{4,5,6},{7,8,9}};
    		for(int i=0;i<arr.length;i++){
    			for(int j=0;j<arr[i].length;j++){
    				System.out.print(arr[i][j]);
    			}
    		}
    	}
    }

B:二维数组的求和

import java.util.Scanner;
    /*
     公司年销售额求和
     某公司按照季度和月份统计的数据如下，单位（万元）
     第一季度：22,66,44
     第二季度：77,33,88
     第三季度：25,45,65
     第四季度：11,66,99
     */
    public class Demo1 {
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		int [][]arr = {
       {22,66,44},{77,33,88},{25,45,65},{11,66,99}};
    		int sum = 0;
    		for(int i=0;i<arr.length;i++){
    			for(int j=0;j<arr[i].length;j++){
    				sum +=arr[i][j];
    			}
    		}
    		System.out.println("元素累加结果为："+sum+"万元");
    	}
    }

C:杨辉三角形

import java.util.Scanner;
    /*
     打印杨辉三角（行数可以键盘录入）
     1
     1  1
     1  2  1
     1  3  3  1
     1  4  6  4  1
     1  5  10 10 5  1
     步骤：
     首先定义一个二维数组，行数如果是n，我们把列数也先定义为n
     这个n的数据来自键盘录入
     给这个二维数组任何一行和最后一列赋值为1
     按照规律给其他元素赋值
        从第三行开始，每一个数据是它上一行的前一列和它上一行的本列之和
    遍历这个二维数组
     */
    public class Demo1 {
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		Scanner scan = new Scanner(System.in);
    		System.out.println("请输入一个数据");
    		int row = scan.nextInt();
    		int [][] arr = new int [row][row];
    		for(int i = 0;i<arr.length;i++){
    			arr[i][0] = 1;
    			arr[i][i] = 1;
    		}
    		for(int i = 2;i<arr.length;i++){
    			for(int j = 1;j<=i-1;j++){
    				arr[i][j]=arr[i-1][j-1]+arr[i-1][j];				
    			}
    		}
    		for(int i=0;i<arr.length;i++){
    			for(int j=0;j<=i;j++){
    				System.out.print(arr[i][j]+"\t");
    			}
    			System.out.println("");
    		}
    	}
    }

两个思考题  
          (1)Java中的参数传递问题  
                   Java中只有值传递。基本数据传递的是数据值，引用类型传递的是地址值  
  
                 基本类型：形式参数的改变不影响实际参数

引用类型：形式参数的改变直接影响实际参数

![Center 2][]

(2)数据加密问题

某个公司采用公用电话传递数据信息，数据是小于8位的整数，为了确保安全，在传递过程中需要加密，加密规则如下：

首先将数据倒序，然后将每位数字都加上5，再用和除以10的余数代替该数字

最后将第一位和最后一位数字交换，请任意给定一个小于8位的整数，然后，把加密后的结果在控制台打印出来

import java.util.Scanner;
    /*
     数据是小于8位的整数
    	定义一个int类型的数据
    	int number = 123456;
    加密规则：
    	首先将数据倒序    654321
    	然后将每位数字都加上5，再用和除以10的余数代替该数字   109876
    	 最后将第一位和最后一位数字交换  609871
     */
    public class Demo1 {
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		Scanner scan = new Scanner(System.in);
    		System.out.println("请输入一个8位的整数");
    		int number = scan.nextInt();
    		int [] arr=new int[8];
    		int index=0;
    		while(number>0){
    			arr[index] = number%10;
    			index++;
    			number/=10;
    		}
    		for(int i=0;i<index;i++){
    			arr[i]=(arr[i]+5)%10;
    		}
    		int temp = arr[0];
    		arr[0]=arr[index-1];
    		arr[index-1]=temp;
    		for(int i=0;i<index;i++){
    			System.out.print(arr[i]);
    		}
    	}
    }

[Center]: /images/20220708/0e4d216823a7483aa4e057eac9d8f056.png
[Center 1]: /images/20220708/1418bfadb86b4dc8b8613aa9a32b1f5b.png
[Center 2]: /images/20220708/b01d46b7bb7743b88815ebc4e0ce31d7.png