JavaSE基础部分( 二 )——方法、数组及数组的应用

1.Java_方法:

1.1  方法的定义:就是使用{}包起来的内容,给{}独立的代码块起一个名字,以便于复用;
1.2  定义方法的格式:
               情况1:有具体返回值类型的方法定义;
               情况2:没有具体返回值类型的方法定义;
 1.3  有具体返回值类型的方法定义:
        权限修饰符 静态修饰符  返回值类型  方法名(数据类型1 变量名1,数据类型2 变量名2,......){
                业务内容;
                return 结果;
        }
        分析解释以上这个格式:
        权限修饰符: public  公共的,公开的,访问权限最大的;
        静态修饰符: static (面向对象部分重点讲static关键字) 固定写法;

1.3.1  返回值类型:数据类型(目前基本数据类型):
        方法名:给 { } 代码块起一个名字,方法名要遵循"见名知意",(符合标识符的规则);
        形式参数:
            数类类型:数据类型(目前基本数类型);
            变量名:要符合标识符的规则(起名字);
        return:表示结束方法,调用方法的时候,给具体的返回结果; 如果没有return,报错!
        定义完方法了,需要调用方法(目前调用方法是在main方法中调用);
        单独调用: 无意义,没有输出结果;
        输出调用:(没有问题的,但是直接去使用了,不利于后期对该结果操作);
        赋值调用:(推荐的);

 1.4  没有具体返回值类型的方法定义(以及调用)
        定义格式:
        修饰符(public static)  返回值类型 方法名(参数类型1 变量名1,参数类型2 变量名2....){
                要么输出结果要么相关其他业务功能 ,没有return关键字
        }
        Java中针对没有具体返回值类型的方法的定义,要遵循方法的格式,提供一个关键字void 来代替返回值类型
        public static void 方法名(参数类型1 变量名1,参数类型2 变量名2....){
                业务操作; 一般情况都是直接输出
        }

1.5  定义方法以及调用方法的注意事项:
       1)方法和方法是平级关系,不能再一个方法中定义另一个方法
       2)在定义方法的时候,(目前来说)
              必须带上static关键字(该方法目前都在main方法中调用,必须带上static);
      3)在定义一个有返回值类型的方法的时候,知道两个明确
              a)明确方法的返回值类型;
              b)明确参数类型以及参数个数;
      4)定义方法的时候,形式参数必须带上数据类型,否则报错(Java是一种强类型语言)

eg:

class FunctionDemo{
	
	public static void main(String[] args){
	
		//实际参数
		int a = 10 ;
		int b = 20 ;
	
		//赋值调用(推荐方式)
		int result = getSum(a,b); 
		System.out.println("两个数据之和是:"+result) ;	
	}
	/*
	权限修饰符 静态修饰符  返回值类型  方法名(数据类型1 变量名1,数据类型2 变量名2,......){
			内容;
			return 结果;
			
	}
	
	定义方法的时候:两个明确
		1)明确返回值类型 int类型
		2)明确参数类型以及参数格式
				两个参数int类型
	*/
	public static int getSum(int x,int y){//形式参数列表
		//求x,y的和
		int result = x + y ;
		return result ;
	}	
}

2.Java_数组

2.1  数组的概念:
            数组是一种"容器" 可以存储同一种类型的元素的一种"容器" 
            注意:
                必须要保证该容器中存储的类型必须一致!          

2.2   数组的定义:
            数据类型[] 数组名称;            举例:int [] arr  定义了一个int数组的变量arr
            数据类型 数组名称[] ;            举例:int arr []  定义了一个int类型的变量arr数组

2.3   数组的初始化:
        有两种初始化:
            动态初始化:开发者定义数组初始化的时候,指定数组的长度,系统默认给数组中的元素赋值.
            静态初始化:直接指定数组的元素内容,系统指定的数组长度.

2.3.1  数组的动态初始化:
            数据类型[] 数组名称 = new 数据类型[数组长度] ;
            数据类型 数组名称[] = new 数据类型[数组长度] ;     

eg:
    定义一个数组并且动态初始化

    int[] arr = new int[3] ;
    int arr[] = new int[3] ;

2.3.2  数组的静态初始化 : 指定的元素的内容,系统默认长度!

eg:

class ArrayDemo3{
	public static void main(String[] args){
		
		//定义一个数组,静态初始化
		int[] arr = {7,8,9,10} ;
		System.out.println(arr) ;
		System.out.println(arr[0]) ;
		System.out.println(arr[2]) ;
		System.out.println(arr[3]) ;
	}
}

2.3.3 静态的初始化的格式:

标准格式:
              数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,元素3,,,,} ;
               数据类型 数组名称[] = new 数据类型[]{元素1,元素2,元素3,,,,} ;  
简写方式:(推荐)
      数据类型[] 数组名称 = {元素1,元素2,元素3,,,,}  ;
      数据类型 数组名称[] = {元素1,元素2,元素3,,,,}  ;

  eg: 
     int[] arr = new int[]{1,2,3} ;
     int[] arr = {1,2,3} ; 

2.4   二维数组: 其实就是一个元素为一维数组的数组   
2.4.1  定义格式:
                 数据类型[] 数组名称[] ;
                 数据类型[][] 数组名称 ;

2.4.2  动态初始化:
          格式1:
                    数据类型 [] []  数组名称  =  new  数据类型 [m] [n] ;

​
   eg:
         int[][] arr = new int[3][2] ;

​

分析2.4.2举例:
        = 号左边:
            int: 当前数组存储的是int类型的元素
            [] []: 定义的是一个二维数组
            arr : 数组对象名称
        = 号右边:
            new : 在堆内存中创建该数组的对象(产生堆内存空间地址)
            int: 当前数组存储的是int类型的元素
            [ 3 ]: 当前定义的这个二维数组中有3个一维数组
            [ 2 ]: 每一个一维数组中有2个长度
            
    注意:
        在一些笔试题:定义变量 进行初始化
            int x, y ;  x 和y是两个int类型的变量
            int x [],y[] ;x和y都是int类型的数组
            int x[][],y[] ; x是一个二维数组,y是一个一维数组

      格式2: 指定了一维数组的个数,一维数组的长度需要动态给定
                  数据类型[][] 数组名称 = new 数据类型[m][] ;

    eg:
        int[][] arr = new int[3][] ;
        

       格式3: 就是静态初始化
        数据类型  [ ] [ ]  数组名称 = new 数据类型 [ ] [ ]{{元素1,元素2,元素3..},{元素1,元素2,元素3,...},{,}};
        简写格式:
               数据类型 [][] 数组名称 = {{元素1,元素2,元素3..},{元素1,元素2,元素3,...},{,}};
         

eg:
    int[][] arr = new int[][]{{1,2,3},{4,5,6},{7,8,9}} ;
            
    简写格式:
    int[][] arr = {{1,2,3},{4,5,6},{7,8,9}} ;

2.4.3  数组的应用 : 将数组中的元素进行“遍历”,遍历就是将元素的内容一一输出来。

          二维数组的遍历:外层循环:其实是一维数组的个数(arr.length)、 内层循环:其实每一个一维数组的长度(arr[x].length)

eg:
class Array2Test{
	public static void main(String[] args){
		
		//定义一个二维数组,静态初始化:
		int[][] arr = {{1,2,3},{4,5},{6,7,8}};  
	
		//调用遍历的功能
		printArray2(arr) ;
	}
	/*
		两个明确
			1)明确返回值类型:void
			2)明确参数类型以及参数个数
				1个参数 int类型二维数组
					
	*/
	public static void printArray2(int[][] arr){
		//输出以下左大括号
		System.out.print("{");
		//遍历
		for(int x = 0 ; x < arr.length; x++){//外层循环是一维数组的个数
			//先输出左大括号
			System.out.print("{");
			//遍历一维数组的元素
			for(int y = 0 ; y < arr[x].length ; y++){
				//判断
				//如果是二维数组的最后一个元素
				if(y == arr[arr.length-1].length-1){
					//输出元素值以及后面的}
					System.out.print(arr[x][y]+"}") ;
					
					//如果当前元素取到的一维数组的最后一个元素
				}else if(y == arr[x].length-1){
					//输出元素内容以及}以及,
					System.out.print(arr[x][y]+"}"+",") ;
				}else{
					System.out.print(arr[x][y]+",") ;
				}
			}
			
		}
		//输出整个右}
		System.out.print("}");
	}
}

2.4.4  数组的另一个应用:
          元素逆序:
          特点:
          arr:是一个数组
            将0索引对应的元素和arr.length-1索引对应的元素进行互换
            将1索引对应的元素和arr.length-1-1索引对应的元素进行互换
            ...
            ...
            只要保证  数组长度 arr.length/2

eg:
class ArrayTest3{
    //方法1
	public static void main(String[] args){
	
		//定义一个数组,静态初始化
		int[] arr = {57,87,96,13,24} ;
		
		//在逆序之前,先去遍历这个数组(将元素一一打印)
		System.out.println("逆序之前:") ;
		printArray(arr) ;
		
		//逆序
		//调用逆序的功能
		//reverse(arr) ;
		reverse2(arr) ;
		
	}
		//遍历一下
		System.out.println("逆序后:");
		printArray(arr) ;	
	//方式2
	public static void reverse2(int[] arr){
		//在一个for循环中定义一个两个变量
		//start:表示开始索引
		//end:(int[] arr){
		//进行交互
		//将0索引对应的元素和arr.length-1索引的元素进行互换
		/*
		//第一次交换:
		int temp = arr[0最终最大索引
		for(int start = 0,end = arr.length -1 ; start<=end ;start ++,end -- ){
			//中间第三方变量
			int temp = arr[start] ;
			arr[start] = arr[end] ;
			arr[end] = temp ;
		}
	}
	
	/*
		定义一个逆序的功能
		两个明确:
			1)明确返回值类型:void
			2)明确参数类型以及参数个数
				int类型的数组 1个参数
	*/
	
	//方式1;
	public static void reverse] ;
		arr[0] = arr[arr.length-1-0] ;
		arr[arr.length-1-0]  = temp ;
		
		//第二次互换
		temp = arr[1] ;
		arr[1] = arr[arr.length-1-1] ;
		arr[arr.length-1-1] = temp ;
		
		//第三次互换..
		//...
		*/
		//最终的代码
		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 ;
		}
	}

	//遍历的功能
	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.print(arr[x]+", ") ;
			}
		}
	}

}

2.5  数组的基本查找法:(数组的元素内容可以无序)
               从数组中的开始索引一直查询到末尾,查询出元素第一次在数组中的索引值
               数组的高级查找:二分搜索法(折半查找): 前提条件:数组的元素必须有序!

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值