Java2.1(方法、数组、类、private关键字、this、构造方法)

方法

格式

修饰符 返回值类型 方法名(参数类型 参数名1，
参数类型 参数名2...) {
//方法体语句；
return 返回值；
}

如main方法：

public static void main(String[] args) {
//方法体
System.out.println("HelloWorld");
return;
}

调用方式
A：通过方法名调用方法
B：根据形式参数列表将实际参数传递给方法
形参：定义方法时需要明确方法参数的形式，比如参数的类型和个数，故方法定义时的参数列表称为形式参数
实参：调用方法时传递给方法的数据，必须符合形式参数的个数和对应位置的数据类型

案例：比较两个整数是否相同

import  java.util.Scanner;
public class CSDN {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入第一个整数：");
        int n1 = sc.nextInt();
        System.out.println("请输入第二个整数：");
        int n2 = sc.nextInt();
        boolean is = compare(n1, n2);
        System.out.println(is);
    }
    public static  boolean compare(int a, int b) {
        return a == b;
    }
}

注意事项：

方法重载
同一类中的多个方法，方法名相同，参数列表不同（参数的个数不同、对应位置的参数类型不同）

案例：比较两个数是否相同，分别比较两个int/long/double的数据，判断是否相同

public class CSDN {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        boolean flag1 = compare(a,b);
        System.out.println(flag1);
        System.out.println("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
        long c = 10L;
        long d = 20L;
        boolean flag2 = compare(a,b);
        System.out.println(flag2);
        System.out.println("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
        double e = 2.71;
        double f = 3.14;
        boolean flag3 = compare(a,b);
        System.out.println(flag3);
    }
    public static  boolean compare(int a, int b) {
        return a == b;
    }
    public static  boolean compare(long a, long b) {
        return a == b;
    }
    public static  boolean compare(double a, double b) {
        return a == b;
    }
}

数组

数组的定义
格式一：

数据类型[ ] 数组名 = new 数据类型[长度]；
//定义一个长度为3的整型数组
int[] arr = new int[3];

格式二：

数据类型[] 数组名 = new 数据类型[]{元素1，元素2，元素3…}；
//定义一个长度为3的整型数组
int[] arr2 = new int[]{1,2,3};

格式三：

数据类型[] 数组名 = {元素1，元素2，元素3…}；
//定义一个长度为3的整型数组
int[] arr3 = {1,2,3};

数组的访问
格式：
取值：数组名[索引]
赋值：数组名[索引] = 值；
索引：也叫下标、脚标，是数组元素距离数组起始位置的偏移量，第一个元素偏移量为0。

int[] arr3 = {1,2,3};//索引为arr3[1],arr3[1],arr3[2]
arr3[1] = 4;//赋值

数组的遍历
给定一个int型数组，输出数组中的每一个元素

public class CSDN {
    public static void main(String[] args) {
       int[] arr = new int[]{3,9,6,7,10};
       System.out.println("数组的长度是："+ arr.length);
       for(int i = 0; i < arr.length; i++){
           System.out.println(arr[i]);
       }
    }
}

数组的初始化
动态初始化：只指定长度，由系统给出默认值

int[] arr = new int[5];

整型： 0
浮点型： 0.0
字符型： ‘\u0000’（空字符）
布尔型： false
引用类型： null
静态初始化：给出初始化值，由系统决定数组长度

int[] arr = new int[]{1,2,3,4,5};
//或者
int[] arr = {1,2,3,4,5};

数组使用中两个常见问题
数组索引越界异常：访问了不存在的索引时

int[] arr1 = new int[3];
System.out.print(arr1[3]);//报错

空指针异常：数组引用存储的值为null而非数组的地址时

int[] arr2 = new int[]{1,2,3};
arr2 = null;
System.out.print(arr2[1]);//报错

案例
①获取数组中的最大值，给定一个int型数组，找出它的最大元素

public class CSDN {
    public static void main(String[] args) {
       int[] arr = {3,9,6,7,10};
       int temp = arr[0];
       for(int i = 1; i < arr.length; i++){
           if(arr[i] > temp) {
               temp = arr[i];
           }
       }
        System.out.println(temp);
    }

}

②定义打印数组元素的方法并调用，给定一个int型数组，调用自定义方法打印数组的每一个元素

public class CSDN {
    public static void main(String[] args) {
       int[] arr = {3,9,6,7,10};
       printArray(arr);
    }
    public static void printArray(int[] arr) {
        for(int i = 0; i < arr.length; i++) {
            System.out.println("arr[" + i +"]:" + arr[i]);
        }
    }
}

类

创建对象：

类名 对象名 = new 类名();

使用对象：

对象名.变量名
对象名.方法名(...)

案例：手机类的定义和使用

//定义类
public class Phone {
    String brand;
    String model;
    String name;
    public void call(String name) {
        System.out.println("给" + name + "打电话");
    }
    public  void sendMessage() {
        System.out.println("发短信");
    }
    public  void playGame() {
        System.out.println("玩游戏");
    }
}

//测试类
public class CSDN {
    public static void main(String[] args) {
       //创建对象
      Phone p = new Phone();
      //调用成员变量
      //给成员变量赋值
      p.brand = "红米";
      p.model = "K40";
      p.name = "liya";
      //打印成员变量
        System.out.println(p.brand);
        System.out.println(p.model);
        System.out.println(p.name);

        //调用成员方法
        p.call("liya");
        p.sendMessage();
        p.playGame();
    }
}

成员变量和局部变量的区别

位置
成员变量:类中、方法外
局部变量：方法中，或形式参数
初始化值
成员变量：有默认初始化值
局部变量：无默认初始化值，必须先赋值在使用
作用范围
成员变量：在类中
局部变量：在方法中
内存位置
成员变量：堆内存
局部变量：栈内存
周期
成员变量：随着对象的创建而存在，随着对象的消失而消失
局部变量：随着方法的调用而存在，随着方法调用完毕而消失

private关键字

用于封装，私有的，修饰类的成员，被修饰的类只能在本类中访问
用法：

private 数据类型 变量名；
private 返回值类型 方法名(参数列表) {}

this

用法：

this.属性名；
this.方法名(参数)；

==案例：private修饰成员变量，给phone类的成员变量使用private修饰，然后在测试类中正确使用该成员变量==
类：

```java
private String brand;
    public String getBrand() {
        return brand;
    }
    public void setBrand(String brand) {
        this.brand = brand;
    }

测试：

 Phone p = new Phone();
      p.setBrand("红米");
        System.out.println(p.getBrand());

构造方法

格式：

修饰符 构造方法名(参数列表) {
//方法体
}

注：方法名必须与类名相同，没有返回值，没有返回值类型

public class Phone {
    private String brand;
    String model;
    String name;
    //无参构造
    public Phone() {}
    //带参构造
    public Phone(String brand, String model, String name) {
        this.brand = brand;
        this.model = model;
        this.name = name;
    }