Java基础-方法(2)和数组

方法的特点

定义方法可以将功能代码进行封装

         封装:两方面含义:

1. 将有特定逻辑的多条代码组合成一个整体!
2. 只暴露想让外界看到的,隐藏不想让外界看到的

对于方法的调用者来说:只能看到方法的返回值,方法内部的操作过程,外界看不到

提高了代码的复用性和可维护性!!!

方法只有被调用才会被执行!!(方法调用的流程)

方法定义和调用练习:

获取最值

/*
定义方法,用于获取两个int数中的最大值
    返回值类型:int
    形参列表:int ,int 
    
    方法定义时,参数称为形参:
    方法调用时,传递的参数称为实参.
        实参有多种形式:
            变量,常量,表达式.
*/

import java.util.Scanner;

public class GetMaxDemo{
    public static void main(String[] args){
        Scanner s = new Scanner(System.in);
        int a = s.nextInt();
        int b = s.nextInt();
        int c = s.nextInt();
        System.out.println(getMax(a,b,c));
    }
    public static int getMax(int x,int y,int z){
        return (((x>y)?x:y)>z)?((x>y)?x:y):z;
    }
}

方法的重载

“两同一不同”:

         同类,同方法名

         形参列表不同

方法的返回值不是判断方法重载的标志!

/*
    方法的重载:
        在同一个类中.出现方法名相同,但是参数列表不同的多个方法,称为方法的重载..
    参数列表不同的含义是:
        1.要么参数的个数不同
        2.要么是参数的类型不同
        
方法的重载:
        五个字:
            两同一不同!!
                同类,同方法名!!!
                形参列表不同!!!
        
    虚拟机就是根据参数列表的不同,去调用不同的方法.
    
    注意:
        1.方法的返回值不能作为方法重载的标志!!
        2.方法调用时,首先找形参列表对应的,如果没有对应的形参列表的方法定义,
            就去找可以隐式转换成类中定义方法的形参列表的方法.
    
*/
public class OverLoadDemo1{
    public static void main(String[] args){
        //
        int a = 10;
        int b = 20;
        System.out.println(add(a,b));
        //
        double d1 = 1.0;
        double d2 = 2.0;
        System.out.println(add(d1,d2));
        
    }
    
    //方法1:
    // public static int add(int a,int b){
        // System.out.println("参数是int型的方法被调用了");
        // return a + b;
    // }
    
    //方法2:double类型的参数可以调用它,int型的参数也可以调用它
    public static double add(double d1,double d2){
        System.out.println("参数是double型的方法被调用了");
        return d1 + d2;
    }
}

数组的概念:

同一种数据类型的多个组成的一个”逻辑单元”.

数组的长度:数组元素的个数.

数组的索引:从0开始,最大值是元素的个数-1.

数组的定义:

数据类型:数组类型,其实就是元素的类型加上[],就表示一个数组类型.

如: int[], double[ ]等

数组类型变量的定义:

int[] arr;

boolean[] booleanArray;

/*
    数组的定义:
        元素类型[] 数组名;
        
    数组初始化方式一:
        动态初始化:定义和赋值相分离
            定义:
            int[] arr1 = new int[3];
            在以后的程序中可以对其中的元素进行赋值
        静态初始化:定义数组时,元素值就定了.
            int[] arr2 = new int[]{1,2,3};
            
            
*/

public class ArrayDemo{
    public static void main(String[] args){
        //定义一个元素为int型的数组.
        // int[] arr1;
        //动态初始化一个int型数组,长度是3.
        //其中的元素值是默认值:int -> 0,float,double->0.0,boolean -> false
        /*
        int[] arr1 = new int[3];
        System.out.println(arr1);//[I@15db9742 : 内存地址的一个映射
        System.out.println(arr1[0]);
        System.out.println(arr1[1]);
        System.out.println(arr1[2]);
        */
        
        /*
        //静态初始化:定义数组时,就指定元素值
        int[] arr2 = new int[]{1,2,3};
        System.out.println(arr2);//[I@15db9742 : 内存地址的一个映射
        
        //考察数组中的元素值
        System.out.println(arr2[0]);
        System.out.println(arr2[1]);
        System.out.println(arr2[2]);
        */
        
        double[] arr3 = new double[3];
        System.out.println(arr3[0]);//0.0   double默认值为0.0
        System.out.println(arr3[1]);
        System.out.println(arr3[2]);
        System.out.println(arr3);  //[D@15db9742
        
        
        boolean[] arr4 = new boolean[2];
        System.out.println(arr4[0]);  //false  boolean默认是false
        System.out.println(arr4[1]);
        System.out.println(arr4);  //[Z@6d06d69c
        
        
        
        
        
        
    }
}

数组的初始化:

1.动态初始化:先定义数组的长度,其中元素的值在以后的程序中赋值.此时元素有默认值.

2.静态初始化:定义数组的时候,就把其中的元素值定了.

不论是动态还是静态初始化,元素的值都可以再次进行修改,因为数组元素其本质就是一段内存空间而已!!!

JVM虚拟机的内存管理:

主要有三个区域:

栈:主要用于存储局部变量(方法中定义的变量),方法在被调用时,就进入到栈中.

         栈空间的特点是:先进后出,或者是后进先出.

堆:主要是存放程序中创建出来的对象或者是实例.也就是凡是使用new创建的都出现在堆空间中.堆空间往往比较大.通常用来保存长时间驻留内存的对象.

堆内存也最容易产生垃圾,Java的垃圾回收器线程会在不确定的时间去回收堆内存的空间.

方法区:(面向对象再讲)

方法中定义的变量:

基本数据类型:就在方法所在的栈空间中.

引用数据类型:真实的对象在堆空间中,方法所在的栈空间中只是保存了对象的一个引用而已.

数组常见操作异常

1.数组索引越界异常:

索引值不在正常范围之内.

2.空指针异常:

数组变量不再指向数组实例,也就无法通过数组名+索引的方式访问到元素所在的空间.

两种异常都是运行时异常,在编译器不会报错!!!

/*
    JVM内存划分:
        引用数据类型变量的含义:保存的是内存地址值.
    数组操作常见的异常:
        1.数组索引越界异常
        2.空指针异常
*/
public class ArrayDemo2{
    public static void main(String[] args){
        int[] arr1 = {1,5,2};
        /*
        //数组索引越界异常
        // System.out.println(arr1[1]);
        System.out.println(arr1[3]); // java.lang.ArrayIndexOutOfBoundsException: 3
        */
        /*
        //空指针异常
        arr1 = null; // 让arr1变量不再保存数组实例的内存地址
        System.out.println(arr1[2]); // java.lang.NullPointerException
        */
        
    }
}

数组的遍历:

循环:长度属性值
int[] arr = {1,3,5};
for(int i = 0;i<arr.length;i++){
    System.out.println(arr[i]);
}

/*
    数组遍历:提供一种途径,可以访问到数组中的每个元素.
    数组的属性:length
        
    
*/
public class ArrayDemo3{
    public static void main(String[] args){
        
        //静态初始化int型数组
        int[] arr = {15,75,48,59,3};
        //
        // System.out.println(arr[0]);
        // System.out.println(arr[1]);
        
        //用循环改进访问元素
        // for(int i = 0;i<5;i++){
            
            // System.out.println(arr[i] + " ");
        // }
        
        //数组的长度,不是数出来的,是利用数组的属性值得到的
        // System.out.println("数组的长度(元素的个数)是: " + arr.length);
        
        //使用数组的length属性来确定循环中的边界值
        // for(int i = 0;i<arr.length;i++){
            // System.out.print(arr[i] + " ");
        // }
        
        printArray(arr);
        
    }
    //定义方法:打印数组的元素
    //两个明确:void
    //数组
    public static void printArray(int[] arr){
        
        for(int i = 0;i<arr.length;i++){
            
            System.out.print(arr[i] + " ");
        }
        System.out.println();
        
    }
    
}