java总结三(方法、数组)

一、方法

1.1 什么是方法？

就是使用功能代码块{}（代码块）将核心功能使用{}包起来，并为之取一个名字即可。

举例：

玩游戏“植物大战僵尸”，里面有豌豆芽发射炮弹，

比如“发射炮弹”需要100行代码完成，但是随着关卡越来越多，每次使用都要用到，代码量就非常大；需要优化，那就给这100行代码用{}包起来，并为之取一个名字：方法名，以后用到豌豆发射炮弹，只要调用这个方法名就可以了。

1.2 Java中方法的定义格式：

分两种情况：

1）有具体返回值类型的方法定义

2）没有具体返回值类型的方法定义

public class Demo{
    
//  1. 最简单的无参方法
    void sum1(){
        System.out.println("加法操作"); 
    }
//    2. 拥有修饰符的无参方法 
    public static void sum2(){ 
        System.out.println("加法操作");
    }
//    3. 拥有参数的方法
    public static void sum3(int a,int b){ 
        System.out.println("两数相加结果"+a+b); 
    }
//    4.拥有返回值的方法 
    public static int sum4(int a,int b){

        return a+b;
    }
//        5.声明一个无参数带返回值
    
    public static int sum5(){
        int x=20; 
        int y=28; 
        int z=x+y; 
        return z; 
    }
}
 

1.3 定义固定格式

 

权限修饰符 static 返回值类型 方法名(形式参数类型1 变量名1,形式参数类型2 变量2....){

//功能业务操作

return 结果；

}

解释 ：

        权限修饰符:现在方法访问权限:公共的/公开的,访问权限足够大,public
        static:面向对象在讲,目前来说必须带上static
        返回值类型:数据类型 (目前使用的基本类型)
        方法名:见名知意,满足标识符的规则...(小驼峰命名法)
        形式参数类型:数据类型(目前使用的基本类型)
        变量名:定义参数名称 (见名知意)满足标识符的规则...(小驼峰命名法)

1.4具体返回值类型的方法调用

方法名(实际参数) ;
1)单独调用:没有输出
2)输出调用:可以用,不建议用,因为如果需要将结果进一步操作,写死,不太好!
3)赋值调用:推荐

有返回值类型方法调用:赋值调用

返回值类型 变量名  = 方法名(实际参数名1,实际参数名2....);
使用变量名即可!

1.5 Java中定义方法和调用方法的注意事项(有返回值类型的方法)

1)方法和方法是平级关系,在一个方法中不能嵌套定义另一个方法
    2)Java是一个强类型语言,定义方法的时候,形式参数类型必须携带,不能省略!
    
                            后期学习前端javascript:弱类型语言    
                                            function add(a,b){}
    3)调用方法的时候,实际参数不需要携带数据类型的        

    4)定义方法的时候,后面千万不能来一个分号,这个方法缺少方法主体的,没有意义!
            有{左大括号的地方不能有分号;
            有;号的地方不能有{左大括号
    public static int add(int a,int b);
    {   没有意义
        return a + b ;
    }

1.6没有具体返回值 

void：没有返回值；

数据类型（基本类型，引用类型）。

范例： 定义一个没有返回值，没有参数的方法

public class Demo {
    public static void main(String[] args) {
        print();    //主方法里面直接调用方法
    }
    public static void print() {
        System.out.println("Hello    World!"); //定义方法
    }
}

范例： 定义一个有参数无返回值的方法

public class Demo {
    public static void main(String[] args) {
        print("Hello");    //主方法里面直接调用方法
    }
    public static void print(String s) {    //定义方法
        System.out.print(s); 
    }
}

范例： 有参数有返回值的方法

public class Demo {
    public static void main(String[] args) {
        int sum = add(1, 2);
        System.out.println(sum);
        //既然方法有返回值，那么这些返回值也可以直接输出
        System.out.println(add(1, 3));
    }
    public static int add(int x, int y) {    //定义方法
        return x + y;
    }
}

1.7方法重载

同一个类中，方法名字相同，参数列表不同，则是方法重载。

注意：

参数列表的不同包括，参数个数不同，参数数据类型不同，参数顺序不同

方法的重载与方法的修饰符和返回值没有任何关系

public class Demo {

    public static void main(String[] args) {
        show();
        show(10);
        show("10");
        show("10",10);
    }
    
    public static void show() {
        System.out.println("无参无返回值的show");
    }
    
    public static void show(int a) {
        System.out.println("int的show");
    }
    
    public static void show(String a) {
        System.out.println("String的show");
    }
    
    public static void show(String a,int b) {
        System.out.println("String int的show");
    }
    
}
 

二、数组

2.1、 数组是什么样的容器?

是只能够存储同一种类型的容器,在同一数组中,元素的数据类型必须一致!

2.2、数组定义格式:

数据类型[] 数组名称;
    数据类型 数组名称[] ;

数据类型:学习基本数据类型 ​ ​ 举例: ​ ​

    int[] arr ;  定义了一个int类型的数组变量arr
            int arr[] ;  定义了一个int类型的arr数组变量

2.3、数组的初始化:

1)动态初始化:我们给定数组的长度,元素由系统(Jvm)默认初始化 ​

数据类型[] 数组名称 = new 数据类型[长度] ; 推荐第一种
                数据类型 数组名称[] = new 数据类型[长度] 

            创建一个数组对象
            int[] arr = new int[3] ;
            int arr[] = new int[3] ;

静态初始化:我们给出具体的元素内容,系统默认分配长度

    数据类型[] 数组名称 = new int[]{元素1,元素2,元素3,.....} ; 推荐第一种 
    数据类型 数组名称[] = new int[]{元素1,元素2,元素3,.....} ; 
    
    简化格式:书写代码简单
        数据类型[] 数组名称 = {元素1,元素2,元素3,.....} ;
        数据类型 数组名称[] = {元素1,元素2,元素3,.....} ;
    举例:
        int[] arr = new int[]{1,2,3,4,5,6} ;
        简化格式:
        int[] arr = {1,2,3,4,5,6} ; 

注意事项: 数组的初始化:要么动态初始化/要么静态初始化,不能"动静结合"

        int[] arr = new int[3]{1,2,3} ;  错误的!

数组就是引用类型,引用类型下面经常会出现异常:

2.4、运行时期异常

    ArrayIndexOutOfBoundsException:数组角标越界异常
•               NullPointerException:空指针异常
​
程序在过程中,经常会出现"异常";   后期常用类中讲
程序有问题

​

1)编译时期异常:jvm检查语法不通过; 语法格式存在问题
                举例:
                        同一个变量被定义多次
                        数组格式写错
        
​
•   2)运行时期异常:开发者:代码书写不严谨导致的问题
​
​
•       
​
•           键盘录入:代码书写---->录入int类型
​
#####                               int num = 键盘录入对象.nextInt() ;
​
​
•                                   

java.lang.ArrayIndexOutOfBoundsException:数组角标越界异常
    出现的原因:访问了数组中不存在的角标(索引值)
    如何解决:检查代码,更改索引值

    java.lang.NullPointerException:空指针异常
    引用类型的默认值都是null;
    String s = null ;  字符串是一种特殊的引用类型
    出现的原因:某一个对象已经为空了,null(没有堆内存地址),这个时候还要去访问元素或者调用
    这个对象的方法,那么就出现空指针;
    如何解决:
        使用逻辑判断语句,对该对象进行非空判断

2.5 、数组遍历

public static void main(String[] args){     
​
•       //创建一数组,静态初始化
•       int[] arr = {11,22,33,44,55} ;
•       for(int x = 0 ; x < 5 ; x ++){
•           System.out.println(arr[x]) ;
•       }
•       System.out.println("----------------------------") ;
​
​

2.6 、数组逆序

public static void  reverse2(int[] arr){
        //定义两个变量
        //start:起始索引:0开始
        //end:最终索引:arr.length-1
        for(int start = 0,end = arr.length-1; start < end; start++,end--){
            //定义中间变量
            //元素互换
            int temp = arr[start] ; //temp = arr[0 ]
            
​
        arr[start] = arr[end] ;//arr[0] = arr[arr.length-1] ;
        arr[end] = temp ;//arr[arr.length-1] = temp ;
    }
}

//优化代码:上面代码冗余度很高,循环思想改进
        for(int x = 0 ; x < arr.length/2; x ++){
            //互换
            int temp = arr[x] ; //arr[0]
            arr[x] = arr[arr.length-1-x] ; //arr[arr.length-1-0] ;
            arr[arr.length-1-x] = temp ;
        }

2.7 数组最大最小值

class ArrayTest2{
    public static void main(String[] args){
            //创建一个数组,静态初始化
    int[] arr = {69,27,58,13,24,98,76} ;
​
    //定义一个参照物,作为最大值(假设为最大值)
    int max = arr[0] ;
    
    //遍历其他元素,   for(int x = 1 ;x < arr.length; x ++){
        //一一获取到角标1以及后面的所有角标对应的元素
        //依次使用这些元素和参照物进行比较
        if(arr[x] > max){
            //后面的元素就是最大值
            max = arr[x] ; 
        }
    }
    System.out.println("数组中的最大值是:"+max) ;
    
    System.out.println("----------------------------------------") ;

//调用:获取数组中的最大值的方法
    int max2 = getMax(arr) ;
    System.out.println("数组中最大值是:"+max2) ;
    
    System.out.println("----------------------------------------") ;
    
    int min = getMin(arr) ;
    System.out.println("数组中最小值是:"+min) ;
}
/*

定一个方法:获取数组中的最小值 ​ 两个明确 ​ ​ 1)明确返回值类型:int类型, ​ 2)明确参数类型以及参数个数 ​ int[]的数组,1个参数 */

public static int getMin(int[] arr){
    //定义一个参照物
    int min = arr[0] ;
    //遍历其他元素
    for(int x = 1; x < arr.length; x++){
        //如果后面的元素比min小,就是最小值
        if(arr[x] < min){
            min = arr[x] ;
        }
    }
    return min ;
}

/* 定义一个方法:获取数组中的最大值的方法 两个明确

1)明确返回值类型:int类型,具体的最大值
2)明确参数类型以及参数个数
        int[]的数组,1个参数

*/
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 ;
}
​
}