Java基础语法（二）

1.数组

1.1一维数组

定义格式：

数据类型[] 数组名 = new 数据类型[元素个数或数组长度];

    int[] x = new int[100]; //定义了100个int类型的变量
    等价于
    int[] x;              // 声明一个int[]类型的变量
    x = new int[100];   // 创建一个长度为100的数组

数组赋值

 public class ArrayDemo02 {
    public static void main(String[] args) {
        int[] arr = new int[4]; // 定义可以存储4个整数的数组
        arr[0] = 1; // 为第1个元素赋值1
        arr[1] = 2; // 为第2个元素赋值2
        // 下面的代码是打印数组中每个元素的值
        System.out.println("arr[0]=" + arr[0]);
        System.out.println("arr[1]=" + arr[1]);
        System.out.println("arr[2]=" + arr[2]);
        System.out.println("arr[3]=" + arr[3]);
    }
 }

在上述代码中，第3行代码定义了一个数组，此时数组中每个元素都为默认初始值0。第2、3行代码通过赋值语句将数组中的元素arr[0]和arr[1]分别赋值为1和2，而元素arr[2]和arr[3]没有赋值，其值仍为0，因此打印结果中四个元素的值依次为1、2、0、0。
在定义数组时只指定数组的长度，由系统自动为元素赋初值的方式称作动态初始化。
在初始化数组时还有一种方式叫做静态初始化。

public class ArrayDemo03 {
        public static void main(String[] args) {
            int[] arr = { 1, 2, 3, 4 }; // 静态初始化
            // 下面的代码是依次访问数组中的元素
            System.out.println("arr[0] = " + arr[0]);
            System.out.println("arr[1] = " + arr[1]);
            System.out.println("arr[2] = " + arr[2]);
            System.out.println("arr[3] = " + arr[3]);
        }
    }

第3行代码千万不可写成int[] arr = new int[4]{1,2,3,4};，这样写编译器会报错。原因在于编译器会认为数组限定的元素个数[4]与实际存储的元素{1,2,3,4}个数有可能不一致，存在一定的安全隐患。

数组遍历
1.for循环遍历

public class ArrayDemo04 {
   public static void main(String[] args) {
       int[] arr = { 1, 2, 3, 4, 5 }; // 定义数组
       // 使用for循环遍历数组的元素
       for (int i = 0; i < arr.length; i++) {
           System.out.println(arr[i]); // 通过索引访问元素
       }
   }
}

获取数组的最值

public class ArrayDemo05 {
    public static void main(String[] args) {
        int[] arr = { 4, 1, 6, 3, 9, 8 }; // 定义一个数组
int max = arr[0]; // 定义变量max用于记住最大数，首先假设第一个元素为最大值
        // 下面通过一个for循环遍历数组中的元素
        for (int x = 1; x < arr.length; x++) {
            if (arr[x] > max) { // 比较 arr[x]的值是否大于max
                max = arr[x]; // 条件成立，将arr[x]的值赋给max
            }
        }
        System.out.println("max=" + max); // 打印最大值
    }
}

空指针异常
在使用变量引用一个数组时，变量必须指向一个有效的数组对象，如果该变量的值为null，则意味着没有指向任何数组，此时通过该变量访问数组的元素会出现空指针异常

 1  public class ArrayDemo07 {
 2      public static void main(String[] args) {
 3          int[] arr = new int[3]; // 定义一个长度为3的数组
 4          arr[0] = 5; // 为数组的第一个元素赋值
 5          System.out.println("arr[0]=" + arr[0]); // 访问数组的元素
 6          arr = null; // 将变量arr置为null
 7          System.out.println("arr[0]=" + arr[0]); // 访问数组的元素
 8      }
 9  }

当第7行代码再次访问数组时就出现了空指针异常NullPointerException

1.2 二维数组

定义格式

1.第一种方式：

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

2.第二种方式：

int[][] arr = new int [3][];
arr[0] = new int[] {1,2};
arr[1] = new int[] {3,4,5};
arr[2] = new int[] {6,,7,8,9};

shuzu2.png

3.第三种方式

int[][] arr = {{1,2},{3,4,5},{7,8,9}};

访问二维数组

arr[0][1];

demo1

class ArrayDemo08 {
    public static void main(String[] args){
    
        //定义二维数组的方式
        int[][] arr = new int[3][4];
    
        System.out.println( arr ); //输出地址
        System.out.println("二维数组的长度: " + arr.length);
        //获取二维数组的3个元素
        System.out.println( arr[0] ); //输出地址
        System.out.println( arr[1] ); //输出地址
        System.out.println( arr[2] ); //输出地址
        
        System.out.println("打印第一个一维数组的元素值");
        System.out.println( arr[0][0] );
        System.out.println( arr[0][1] );//访问的为二维数组中第1个一维数组的第2个元素
        System.out.println( arr[0][2] );
        System.out.println( arr[0][3] );
        
        System.out.println("打印第二个一维数组的元素值");
        System.out.println( arr[1][0] );
        System.out.println( arr[1][1] );
        System.out.println( arr[1][2] );
        System.out.println( arr[1][3] );
        
        System.out.println("打印第三个一维数组的元素值");
        System.out.println( arr[2][0] );
        System.out.println( arr[2][1] );
        System.out.println( arr[2][2] );
        System.out.println( arr[2][3] );
    }
}

一维数组、二维数组元素遍历和数组元素累加和

public class Person {
    public static void main(String[] args) {
        //一维数组的求累加和、遍历
        int[] arr1 = {10,20,30,40,50};
        int sum = 0;
        for(int i = 0; i < arr1.length; i++){
            sum += arr1[i];
        }
        System.out.println(sum);
        
        
        //二维数组的求和、遍历
        int[][] arr2 = {{1,2},{3,4,5},{6,7,8,9,10}};
        int sum2 = 0;
        for(int i = 0; i < arr2.length; i++){
            for(int j = 0; j < arr2[i].length; j++){
                sum2 += arr2[i][j];
            }
        }
        System.out.println(sum2);
    }
}

demo2

public class Demo2 {
    public static void main(String[] args) {
        int[][] arr = new int[3][];
        arr[0] = new int[] {11,22,33};
        arr[1] = new int[] {21,22,34};
        arr[2] = new int[] {44,55,66};
        
        int sum = 0;
        for(int i = 0; i < arr.length; i++){
            int groupSum = 0;
            for(int j = 0; j < arr[i].length; j++){
                groupSum += arr[i][j];
            }
            sum += groupSum;
            System.out.println(groupSum);
        }
        System.out.println(sum);
    }
}

2. 方法

2.1方法的定义格式：

 修饰符 返回值类型  方法名 ( 参数类型 参数名1,  参数类型 参数名2,．．．．．．){ 
      执行语句
      ……… 
      return 返回值;
}

demo1

public class MethodDemo01 {
    public static void main(String[] args) {
        int area = getArea(3, 5); // 调用 getArea方法
        System.out.println(" The area is " + area);
    }

    // 下面定义了一个求矩形面积的方法，接收两个参数，其中x为高，y为宽
    public static int getArea(int x, int y) {
        int temp = x * y; // 使用变量temp记住运算结果
        return temp; // 将变量temp的值返回
    }
}

图解getArea()方法调用过程

getArea()方法的调用过程.png

在程序运行期间，参数x和y相当于在内存中定义的两个变量。当调用getArea()方法时，传入的参数3和5分别赋值给变量x和y，并将x*y的结果通过return语句返回，整个方法的调用过程结束，变量x和y被释放。

2.1 方法重载

Java允许在一个类中定义多个名称相同的方法，但是参数的类型或个数必须不同，这就是方法的重载。

下面的三个方法互为重载关系
 public static int add(int x,int y) {逻辑} //两个整数加法
 public static int add(int x,int y,int z) {逻辑} //三个整数加法
 public static int add(double x,double y) {逻辑} //两个小数加法

demo2

public class MethodDemo03 {
    public static void main(String[] args) {
        // 下面是针对求和方法的调用
        int sum1 = add(1, 2);
        int sum2 = add(1, 2, 3);
        double sum3 = add(1.2, 2.3);
        // 下面的代码是打印求和的结果
        System.out.println("sum1=" + sum1);
        System.out.println("sum2=" + sum2);
        System.out.println("sum3=" + sum3);
    }

    // 下面的方法实现了两个整数相加
    public static int add(int x, int y) {
        return x + y;
    }
    // 下面的方法实现了三个整数相加
    public static int add(int x, int y, int z) {
        return x + y + z;
    }
    // 下面的方法实现了两个小数相加
    public static double add(double x, double y) {
        return x + y;
    }
}

2.2参数传递

基本数据类型参数传递

public class ArgumentsDemo01 {
    public static void main(String[] args) {
        int a = 1;
        int b = 2;
        change(a, b);//调用方法时，传入的数值称为实际参数
        System.out.println("a=" + a);
        System.out.println("b=" + b);
    }

    public static void change(int a, int b){//方法中指定的多个参数称为形式参数
        a = a+b;
        b = b+a;
    }
}

程序执行步骤：
1）main()方法首先压栈执行，
2）a=1 , b=2
3）change(a,b) change方法压栈执行 change(1,2) a=3 b=5 然后change() 方法就出栈。（未改变main()中的实参）
4）sop(a)
5）sop(b)
图解：

方法参数是基本数据类型.JPG

引用数据类型参数传递

public class ArgumentsDemo02 {
    public static void main(String[] args) {
        int[] arr = { 1, 2, 3 };
        change(arr);// 调用方法时，传入的数值称为实际参数
        
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }

    public static void change(int[] arr) {// 方法中指定的多个参数称为形式参数
        for (int i = 0; i < arr.length; i++) {
            arr[i] *= 2;
        }
    }
}

程序执行步骤：
1）main() 方法首先压栈执行 int[] arr -->1,2,3 ; change(arr)
2)change(int[] arr) 压栈执行
for (int i = 0; i < arr.length; i++) {
arr[i] *= 2;
}
因为传递的是地址，change()方法改变了堆内数组的值，然后出栈。
3）sop(arr[0]),sop(arr[1]),sop(arr[2]), 重新指向数组地址。

引用参数传递.png

3.引用数据类型（类）

Java提供的类，自己创建的类

3.1 类的定义与使用

类的定义格式

创建java文件，与类名相同
public class 类名{
    数据类型  属性名称1；
    数据类型  属性名称2；
    …
}

类的使用格式

导包：我们将所有的类放到同一个文件夹下，可以避免导包。
创建对象：数据类型  变量名 = new 数据类型();
调用方法：目前我们定义的自定义类不涉及方法，只是属性（自定义类中的方法部分在面向对象部分讲解）
访问属性：变量名.属性 (这是当前的方式，后期会采取调用方法的方式替代掉直接访问的方式来完成对属性的访问。)

4. ArrayList集合

4.1创建集合的常用格式

导包：import java.util.ArrayList;
创建对象：与其他普通的引用数据类型创建方式完全相同，但是要指定容器中存储的数据类型：
ArrayList<要存储元素的数据类型> 变量名 = new ArrayList<要存储元素的数据类型>();

demo

   存储String类型的元素
      ArrayList<String> list = new ArrayList<String>();
   存储int类型的数据
      ArrayList<Integer> list = new ArrayList<Integer>(); 
   存储Phone类型的数据
      ArrayList<Phone> list = new ArrayList<Phone>();

4.2 集合中常用方法

方法说明	功能描述
boolean add（Object obj）	将指定元素obj追加到集合的末尾
Object get（int index）	返回集合中指定位置上的元素
int size（）	返回集合中的元素个数
boolean add（int index, Object obj）	在集合中指定index位置，添加新元素obj
Object remove（int index）	从集合中删除指定index处的元素，返回该元素
void clear（）	清空集合中所有元素.
Object set（int index, Object obj）	用指定元素obj替代集合中指定位置上的元素

import java.util.ArrayList;
public class ArrayListDemo01 {
    public static void main(String[] args) {
        // 创建ArrayList集合
        ArrayList<String> list = new ArrayList<String>();
        // 向集合中添加元素
        list.add("stu1");
        list.add("stu2");
        list.add("stu3");
        list.add("stu4");
        // 获取集合中元素的个数
        System.out.println("集合的长度：" + list.size());
        // 取出并打印指定位置的元素
        System.out.println("第1个元素是：" + list.get(0));
        System.out.println("第2个元素是：" + list.get(1));
        System.out.println("第3个元素是：" + list.get(2));
        System.out.println("第4个元素是：" + list.get(3));
    }
}

ArrayList集合相当于是一个长度可变的数组，所以访问集合中的元素也是采用索引方式访问，第一个元素存储在索引0的位置，第二个元素存储在索引1的位置，依次类推

4.3 集合的遍历

import java.util.ArrayList;

public class ArrayListDemo {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<Integer>();
        list.add(12);
        list.add(13);
        list.add(14);
        list.add(15);
        
         for(int i = 0; i < list.size(); i++){
                          int n = list.get(i);
             System.out.println(n);
         }
    }
}

这里要强调一点，get方法返回值的类型为集合中元素的类型