JAVA基本语法(三):变量+方法+数组

最新推荐文章于 2023-04-10 17:03:34 发布

qq_49281675

最新推荐文章于 2023-04-10 17:03:34 发布

阅读量190

点赞数

分类专栏： JAVA基础文章标签： java

本文链接：https://blog.csdn.net/qq_49281675/article/details/109375071

版权

JAVA基础专栏收录该内容

5 篇文章 0 订阅

订阅专栏

1.变量

1.1 概念:

可以改变的数，称为变量。一般通过三部分来描述一个变量。变量类型，变量名，变量值。其中三部分都是可以改变的，根据需要来确定即可。

变量的使用原则：就近原则。尽量控制到最小范围

分类:
局部变量:定义在方法里，或者局部代码块中。
注意：必须手动初始化，来分配内存。如：int i=5;
作用域也就是方法里或者局部代码块里，方法运行完内存就释放了。
成员变量:定义在类里。
注意：不用初始化，也会自动被初始化成默认值。
作用域是整个类中，类消失了，变量才释放。
在这里插入图片描述

1.2 测试

//测试变量
public class Test01 {
	//2,成员变量:位置是在类里方法外  +  有默认值 + 作用范围是整个类里
	double count ;
	
	//3,就近原则---前提是---当成员变量 和 局部变量同名时,你使用的一定是局部变量
	int sum = 20 ;
	
	//单元测试junit :要求方法要有标志@Test + 方法必须是public的 + 方法返回值是void
	@Test
	public void show() {
		//1,局部变量:位置是在方法里 + 必须初始化  + 作用范围是方法里
		int sum = 10;
		System.out.println(sum);//10,就近原则
		System.out.println(count);//0.0 --->默认值
	}
	
}

2.方法

2.1 概念

被命名的代码块，方法可以含参数可以不含参数;可以提高代码的复用性
特点 : 1.方法与方法之间是同级关系 ; 2. 不调用不执行

2.1.1 语法

语法: **方法与方法之间是同级关系**
	方法的修饰符 方法的返回值 方法名([参数列表]){
		方法体/java代码
	}

2.1.2 方法的调用

测试
在这里插入图片描述

2.1.3 方法参数

//测试方法传参
public class Test01 {
	public static void main(String[] args) {
		
		method(5);//调用指定的方法
		method2("jack");
		method3(5,"jack");
		method4(10,5);
		
		int m = 10 ; 
		String n="rose";
		method5(n,m);
		
	}
//5,创建方法时method5(n,m),类型必须匹配,多个参数逗号隔开
	public static void method5(String a,int b) {
		System.out.println(a);
		System.out.println(b);
	}
	
//4,创建方法时method4(10,5),类型必须匹配,多个参数逗号隔开
	public static void method4(int a,int b) {
		System.out.println(a);
		System.out.println(b);
	}
	
//3,创建方法时method3(5,"jack"),类型必须匹配,多个参数逗号隔开
	public static void method3(int a,String b) {
		System.out.println(a);
		System.out.println(b);
	}
	
//2,创建方法时method2("jack"),匹配传递过来的参数--参数类型 参数名--类型必须匹配
	public static void method2(String b) {
		System.out.println(b);
	}
	
	
//1,创建方法时method(5),匹配传递过来的参数--参数类型 参数名--类型必须匹配
	public static void method(int a) {
		System.out.println(a);
	}
	
}

2.1.4 方法的返回值

//测试方法返回值
public class Test01 {
	public static void main(String[] args) {
		
		//3,接收方法返回来的值,交给sum保存
		int sum = function(10);
		System.out.println(sum);//10
		
		int sum2 = function2(5,10);
		System.out.println(sum2);//15
		
		String sum3 = function3("jack",10,5);
		System.out.println(sum3);//jack105
		
		String sum4 = function4(10,5,"jack");
		System.out.println(sum4);//15jack
	}
	//创建function4(10,5,"jack")
	public static String function4(int a,int b,String c) {
		//5,  +号:数字间做加法运算,只要和字符串+就是拼接字符串
		return	a+b+c;
	}
	//创建function3("jack",10,5)
	public static String function3(String a,int b,int c) {
		//4,字符串和什么数据 进行+ 都是在拼串!!!
		return a+b+c;
	}
	//创建function2(5,10)
	public static int function2(int a,int b) {
		return a+b ; //2,通过return关键字把值返回给 sum2保存
	}
	//1,创建function(10)--需要写明方法返回值的  类型
	public static int function(int x) {
		//2,通过return关键字,把方法返回值返回给调用位置
		return x ;
	}
	
}

3. 方法的重载(重点)----->overload

3.1 概念

方法重载是指在一个类中定义多个同名的方法，但要求每个方法具有不同的参数列表(也就是说参数的个数和类型不同)。
程序调用方法时，可以通过传递给它们的不同个数和类型的参数来决定具体使用哪个方法。

3.2 测试一

//测试方法重载
//需求:数字求和
public class Test01 {
	//测试方法重载overload:在一个类里,都是同名的方法,但是,参数列表不同.
	//好处:对于程序员而言,需要记忆的方法名很简单.只需要记同一个名字的方法即可
	//方法的参数可以很灵活的传入.
	public static void main(String[] args) {
	 
		add(5,10);
		add(5.0,10.0);
		add(5,10,"Tom");
		add("Tom",5,10);
		
	}
	//add(1,2)
	public static void add(int a,int b) {
		System.out.println(a+b);
	}
	//add(1.1,2.2)
	public static void add(double a,double b) {
		System.out.println(a+b);
	}
	//add(1,2,"Tom")
	public static void add(int a,int b,String c) {
		System.out.println(a+b+c);
	}
	//add("Tom";1,2)
	public static void add(String a,int b,int c) {
		System.out.println(a+b);
	}
	
	
}

测试二

//测试方法重载
//需求:数据打印
public class Test01 {
	 
		public static void main(String[] args) {
			print(10);
			print(2.2);
			print(true);
			print("jack");
		}
		//提供了重载形式的print()
		public static void print(int a) {
			System.out.println(a);
		}
		public static void print(double a) {
			System.out.println(a);
		}
		public static void print(boolean a) {
			System.out.println(a);
		}
		public static void print(String a) {
			System.out.println(a);
		}
	}

4 .数组(重点)----->Array

4.1 概念

--1,概念
	英文名字叫Array,标志是[]
	作用是用来存储多个  相同类型的  数据.
--2,特点
	数组中的每个元素,都有下标,默认从0开始.
	数组一旦创建，长度不可变.
--3,创建数组:  数组类型  数组名 = 数组对象;
	--一般分为动态初始化和静态初始化
	--动态初始化
		int[] a = new int[5];
	--静态初始化
		int[] b = new int[]{9,8,7,6,5};
		int[] c = {9,8,7,6,5};

数组与下标的关系:

底层创建数组的过程:

4.1.1 测试

package cn.tedu;
//测试数组:存放"hello"
public class Test01 { 
	public static void main(String[] args) {
		//1.静态创建数组----->char类型的默认值是'\u0000'
		char[] a = new char[] {'h','e','l','l','o'};
		char[] b = {'h','e','l','l','o'};
		//2.动态创建数组
		char[] c = new char[5];
		c[0] = 'h';
		c[1] = 'e';
		c[2] = 'l';
		c[3] = 'l';
		c[4] = 'o';
		System.out.println(a);
		System.out.println(b);
		System.out.println(c);
		//3.获取数组的长度----->数组.length
		System.out.println(a.length);
	}
}

4.1.2 数组的遍历

测试一:

package cn.tedu;
//测试数组的遍历
public class Test01 { 
	public static void main(String[] args) {
		//练习1:输出每个月的天数
		//1,静态  -- 创建数组
		int[] a= {31,28,31,30,31,30,31,31,30,31,30,31};
		//2,遍历数组/循环数组--获取每个元素
		for(int i = 0;i<=a.length-1;i++) {
			System.out.println(i+1+"月有"+a[i]+"天");
		}
	}
}

测试二:

package cn.tedu;
//测试数组的遍历
public class Test01 { 
	public static void main(String[] args) {
		//遍历数组，存入1到10
		//1,动态  -- 创建数组
		int[] b = new int[10];//默认值0
		
		//2,遍历数组,把默认值改为1-10
		for(int i = 0 ; i <= b.length-1 ; i++) {	
			b[i] = i+1 ; //修改每个元素的默认值,改成0-10 
		}
		
		//3,查看数组里的元素
		for(int i = 0 ; i <= b.length-1 ; i++) {
			System.out.println(b[i]);//根据下标i获取元素
		}
	}
}

测试三:

package cn.tedu;

import java.util.Random;

//测试数组的遍历
public class Test01 { 
	public static void main(String[] args) {
		//创建数组,并存入随机数
		int[] c = new int[10];
		for(int i = 0;i<c.length;i++) {
			c[i] = new Random().nextInt(100);
		}
		for(int i=0;i<c.length;i++) {
			System.out.println(c[i]);
		}
	}
}

4.2 数组工具类------>Arrays

一,数组工具类Arrays:用来对数组提供丰富的功能.
1,Arrays.toString(数组):把指定数组里的数据,变成字符串展示
2,Arrays.sort(数组):把无序数组进行排序
3,Arrays.copyOf(原数组，新的长度):把原数组里的数据进行复制

1.Arrays.toString(数组)
把数组里的数据，用逗号连接成一个字符串。

格式：[10, 14, 20, 46, 51]

2.Arrays.sort(数组)
对数组排序，对于基本类型的数组使用优化后的快速排序算法，效率高。

对引用类型数组，使用优化后的合并排序算法。

3.Arrays.copyOf(数组，新的长度)
把数组复制成一个指定长度的新数组。

新数组长度大于原数组，相当于复制，并增加位置。–数组的扩容

新数组长度小于原数组，相当于截取前一部分数据。–数组的缩容

测试:

package cn.tedu.arrays;
		import java.util.Arrays;
		//测试数组工具类Arrays
		//为什么sort()没有返回值?    --  因为sort(),只是把数组里的数据改一下位置而已,直接改就行,不需要返回值
		//为什么copyOf()没有返回值?  --   因为数组一旦创建,长度不可变.你在进行扩容或者缩容时,原数组的长度都不会变,此时,只能产生新数组
		public class Test1_Arrays {
			public static void main(String[] args) {
				method();//toString()
				method2();//sort()
				method3();//copyOf()
			}
			//copyOf()--把原数组里的数据进行复制
			public static void method3() {
				//1,创建原数组
				String a[] = {"熊大","熊二","美队","钢铁侠","钟南山" } ;
				
				//2,复制
				//copyOf(m,n)  -- m是原数组名  - - n是新数组长度
				//第二个参数是新数组长度.当新数组长度  >  原数组长度时, 会在数据末尾处再添加新的位置,并完成初始化赋值--扩容
				String[] newA = Arrays.copyOf(a, 10) ;
				//[熊大, 熊二, 美队, 钢铁侠, 钟南山, null, null, null, null, null]
				System.out.println( Arrays.toString(newA) );
				
				
				//第二个参数是新数组长度.当新数组长度 <  原数组长度时,相当于数据的截取 --缩容
				String[] newB = Arrays.copyOf(a, 3) ;
				//[熊大, 熊二, 美队]
				System.out.println( Arrays.toString(newB) );
				
				
				System.out.println( Arrays.toString(a) );
				
			}
			//sort()--把无序数组进行排序
			public static void method2() {
				//1,创建无序数组
				int a[] = {46, 42, 53, 44, 54, 3, 71, 62, 59, 97} ;
				
				//2,排序  --  默认是从小到大
				Arrays.sort(a);
				
				//3,打印  //  [3, 42, 44, 46, 53, 54, 59, 62, 71, 97]
				System.out.println(  Arrays.toString(a)  );
				
			}
			//toString()--把指定数组里的数据,变成字符串展示
			public static void method() {
				//1,静态创建数组
				int a[] = {1,2,3,4,5,6,7,8,9,10};
				
				//2,遍历数组并打印数据
		//		for (int i = 0; i < a.length; i++) {
		//			System.out.println(a[i]);
		//		}
				System.out.println(a);//地址值: [I@659e0bfd
				
				String s = Arrays.toString(a) ;
				System.out.println(s);//[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
				
				System.out.println(  Arrays.toString(a)   );//[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
			}
			
		}