java入门基础(数组和方法)

原创已于 2025-05-05 00:02:56 修改 · 1.4k 阅读

33 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

标签

#java #开发语言

于 2025-05-04 23:37:03 首次发布

java入门基础

文章目录

java入门基础
一. 数组
二. 方法

一. 数组

1.1 数组的概念和定义

数组概念：相同数据类型元素的集合,是一种引用数据类型,我们将类型相同,逻辑相关的数据,存到数组中
数组的定义
1)定义的语法:

   		数据类型[] 数组名 = new 数据类型[大小];
   		  int[]     arr1  = new   int[5];			//声明整型数组,包含5个元素
   		  double[]  arr2  = new   double[3];		//声明浮点型数组,包含3个元素
   		  boolean[] arr3  = new  boolean[4];		//声明布尔型数组,包含4个元素

声明了整型数组arr,其中包含5个元素,每个元素都是int类型,默认值为0
该格式会在声明的同时分配一块内存空间供该数组使用
整数数据类型所占空间为4个字节,arr保存的元素有5个,所以该数组总共占用4*5=20个字节

2)数组元素的默认值规则
在这里插入图片描述

1.2 数组的初始化

	初始化数组
		1)int[]arr1 =new int[3];		//0,0,0
		2)int[]arr2 ={2,5,8};			//2,5,8
		3)int[]arr3 =new int[]{2,5,8};	//2,5,8
		4)int[]arr4;
		  arr4= new int[]{2,5,8};

int a; //声明一个整型变量,名为a
int[] b; //声明一个整型数组变量,名为b
int a =5;
int[] b= 5; //编译错误,左边是数组,右边是整型

1.3 数组的访问

1.3.1 获取数组的长度

数组的长度即元素的个数
可通过数组名.length

        int[] arr = new int [5];
        System.out.println("数组的长度为："+arr.length);		//数组的长度为:5

1.3.2 通过下标访问数组元素

下标从0开始,最大到(数组长度-1)

		int[] arr = new int [3];
		arr[0]------代表arr中的第一个元素
		arr[1]------代表arr中的第二个元素
		arr[2]------代表arr中的第三个元素

		int[] arr = new int [3];
		System.out.println("数组的长度:"+arr.length);
		System.out.println("数组第一个元素的值为:"+arr[0]);
		arr[0]=100;			//给第一个元素赋值
		arr[1]=200;
		arr[2]=300;
		//arr[4]=400;  		//运行时会发生数组下标越界异常
		System.out.println(arr[2]);//输出第3个元素的值
		System.out.println(arr[arr.length-1]);//300,输出最后一个元素的值

1.4 数组的遍历

遍历/迭代:从头到尾挨个走一遍

int[ ] arr = new int [10];
如果通过arr[0]=100;的方法进行赋值则需要重复写10次,代码大量重复,因此就需要遍历数组

	给每个元素都赋值为100
		int[] arr = new int [10];
		for(int i=0;i<arr.length;i++ ){		//遍历数组
			arr[i] = 100;  					//给每个元素赋值为100
			System.out.println(arr[i])		//输出每个元素的值
		}
		
	生成100个0-99的随机数
		int[] arr1 = new int [100];
		for(int i=0;i<arr.length;i++ ){		//遍历数组
		arr[i] =(int)(Math.random()*100);	//给每个元素赋值为0到99的随机数
		System.out.println(arr1[i]);		//输出每个元素的值
		}
		Math.random()------------生成0.0-0.99999999...的随机数
		*100---------------------生成0.0-99.9999999...的随机数
		(int)--------------------生成0-99的随机数

找最大值/最小值:

	找最大值:
		int[]arr =new int[10];
		int max =arr[0];				//假设第一个元素为最大值
		for(int i=1;i<arr.length;i++ ){	//遍历剩余元素
			if(arr[i]>max){				//若剩余元素大于max
				max=arr[i];				//将max修改为较大的
			}	
		}
		System.out.println("最大值为:"+max);
			
	找最小值:
		int min=arr[0];
		for (int i=1;i<arr.length;i++){
			if (arr[i]<min){
				min=arr[i];
			}
		}
		System.out.println("最小值为:"+min);

1.5 数组的复制

1.5.1 使用Arrays.copyOf()数组的复制

		int[]a={10,20,30,40;50};		//a:源数组
		int[]b=Arrays.copyOf(a,6);		//b:目标数组.长度大于源数组则会添加默认值,即b={10,20,30,40,50,0}
		int[]c=Arrays.copyOf(a,4);		//4为目标数组的长度,长度小于源数组则会截取,c={10,20,30,40}

1.5.2 数组的扩容

数组的长度在创建数组后是不可改变的,数组元素的内存空间是连续的
扩容指创建一个更大的新数组并将源数组的内容复制进去

		int[]a={10,20,30,40,50};		//数组扩容后原数组会被回收
		a=Arrays.copyOf(a,a.length+1);	//扩容

二. 方法

2.1 方法的意义

每种编程语言中都有方法的概念,也称为:函数,过程(面向对象中称方法,面向过程称函数概念其实是相同的)
方法作用:用于封装一段特定的业务逻辑功能

		System.out.println("hello");  	
		int a =scan.nextlnt();
		double b=scan.nextDouble();
		int=[] b=Arrays.copyOf();
		以上代码中println,nextlnt,nextDouble,copyOf均为方法

方法可以被反复调用,
通过方法可以减少代码重复,有利于代码维护
只要是一个独立的业务就可以封装到一个方法中

2.2 方法的定义

定义方法的五要素:访问修饰词,返回值类型,方法名,参数列表,方法体

	[访问修饰符] [static] [返回值类型] 方法名称([参数列表]) {
    	方法体
    	[return 返回值;]
	}

访问修饰词:控制方法的可见性(如public,private,protected或默认不写)
static:表示静态方法,可直接通过类名调用
返回值类型: 方法返回值的数据类型,无返回值时用void
参数列表:传入方法的参数，(类型参数1,类型参数2,…)
返回值return:
return用法:
1)return 值; 结束方法的执行 ,返回结果给调用方
—用在有返回值的方法中
2)return; &emsp结束方法的执行
—用在无返回值的方法中

	无返回值方法
		public static void main(String[] args) {
        	say(); 					//调用say方法
       		say("张三"); 			//String name="张三"------------------实参
        	say("李四",25); 		//调用有String和int参数的say方法
    	}
    无参无返回值
    	public static void say(){
       		System.out.println("大家好");
    	}
    有参无返回值
    	public static void say(String name){ //()中的即为参数--------------形参
       		System.out.println("大家好，我叫"+name);
    	}
    有参无返回值
    	public static void say(String name,int age){ //-------------------形参
        	if(age>=60){ 	//在某种特定条件下，提前结束方法
           	return; 		//结束方法
        	}
        	System.out.println("大家好，我叫"+name+"，今年"+age+"岁了");
		}

	有返回值方法
		public static void main(String[] args) {
	        int a = sum(5,6); 		//sum(5,6)的值就是return后的那个数
	        System.out.println(a); 	//11---模拟对返回值的后续操作
	        int m=5,n=6;
	        int b = sum(m,n); 		//传的是m和n里面的数
	        System.out.println(b); 	//11---模拟对返回值的后续操作
	    }
	有参有返回值
	    public static int sum(int num1,int num2){
        	int num = num1+num2;
        	return num; 			//返回的是num里面的那个数
        	//return num1+num2; 	//返回的是num1与num2的和
    	}

2.3 方法的重载

2.3.1方法的签名:方法名+参数列表

		public static void say(){..}
	java规定:在同一类中,不允许出现签名完全相同的方法
		public class Test{
			public static void say(){..}
			public static void say(){..}   //错误,不能出现重名
			public static int say(){return 1}	//错误,与返回值类型无关
		}

2.3.2方法的重载(overloading)

定义:发生在同一类中,方法名相同,但参数类型和参数的个数不同
重载的核心规则‌:
1. 方法名必须相同‌ say()
2. 参数列表必须不同‌（满足以下任一条件）：
1)参数类型不同‌ say(String a)
2)参数‌个数不同 ‌say(String a,int b)
3)参数‌顺序不同‌（类型差异需明确）‌say(int b,String a)

		public class Test{
			public static void say(){..}
			public static void say(String name){..}	//参数类型为string
			public static void say(int age){..}		//参数类型为int	
			public static void say(String name,int age){..}	//参数个数不同
			public static void say(int age,String name){..}	//参数顺序不同
		}

3. 返回类型可以不同‌（但返回类型不同不足以构成重载,也就是重载与返回值类型无关）

		public static void say(){
        	System.out.println("hello world");
    	}	
    	public static int say(){ 	//发生错误,重载与返回值类型无关,与say()方法重复
        	return 10;
    	}

4. 访问修饰符和异常声明可以不同‌

绑定:编译器在编译时会根据方法的签名自动绑定方法

		public static void main(String[] args) {
        	say(); 					//调用say方法
       		say("张三"); 			//调用String参数的say方法
       		say(15);				//调用int参数的say方法

system.out.println()方法也属于重载方法

		System.out.println();			//实际void println()
		System.out.println(25);    		//void printlin (int a)
		System.out.println(43.2);		//void printlin (double a)
		System.out.println(true);		//void printlin (boolean a)
		System.out.println('ni');		//void printlin (char a)
		System.out.println("hello");	//void printlin (String a)