1.6：面向对象（上）

前言：菜鸟一枚，如有问题欢迎大家在评论区指出，我们一起学习。

1.6.1：类和对象

类：类是一类具有相同特性的事物的抽象描述，是一组相关属性和行为的集合

属性：状态信息    行为：基于这些状态能做什么

// 类相当于一个模板 下面定义了一个Student类
public class Student {
// 属性（特征）有初始值  属性属于对象  属性的值属于对象
    public String stuName;
    public int stuAge;
    public String stuGender;

    // 方法(行为动作)
    public void sayHello() {
        System.out.println("你好，我叫" + stuName + ",我今年" + stuAge + "岁了，我是一名" + stuGender + "同学。");
    }

对象：一类事物的具体个体（类的实例化，具有类的属性和行为） 

//需要使用一个类的属性或者方法时必须先创建这个类的对象
/*
Scanner input = new Scanner(System.in);  创建对象
int num = input.nextInt();  使用输入整数这个方法
*/
public class TestStudent {
    public static void main(String[] args) {
//需要使用一个类的属性或者方法时必须先创建这个类的对象        
        Student student1 = new Student();
 使用对象名.属性名来使用属性        
        student1.stuGender = "男";
        student1.stuAge = 20;
        student1.stuName = "Tom";
 使用对象名.方法名来使用方法        
        student1.sayHello();
        Student student2 = new Student();//可以创建无数个对象
        student2.stuGender = "女";
        student2.stuAge = 21;
        student2.stuName = "Jerry";
        student2.sayHello();
    }
}

类和对象的关系：

类是对一类事物的描述，是抽象的。

对象是一类事物的实例，是具体的。

类是对象的模板，对象是类的实体。

1.6.2：包

包的作用：相当于一个特殊文件夹，用来存储类

1.为什么避免类重名，所以类的全名为包名.类名（例如java.util.Scannner）

2.可以控制类的访问权限

3.分类管理类

包的声明：

package 包名;
//必须在首行

 导包：除开使用java.lang包下面的类，使用其他包下面的类一般需要进行导包（public类型的类）

import 包.类名;
import 包.*;

 什么叫public类型的类： 最全Java各修饰符详解（接口、类、方法、变量）_java修饰符-CSDN博客

1.6.3：成员变量

声明成员变量：

【修饰符】 class 类名{
//必须要在类的里面，方法的上面    
    【修饰符】 数据类型  成员变量名; 
}

修饰符：成员变量的修饰符有很多，例如：public、protected、private、static、volatile、transient、final等。其中static可以将成员变量分为两大类，静态变量和非静态变量。其中静态变量又称为类变量，非静态变量又称为实例变量或者属性。

1.6.4：方法（函数）

方法是一段代码的封装，在使用前要先声明。

声明的位置：类中方法外

类{
    方法1(){
        
    }
    方法2(){
        
    }
}


//错误  不能方法里套方法
类{
    方法1(){
        方法2(){  
        
   		}
    }
}

声明格式：

【修饰符】 返回值类型 方法名(【形参列表 】)【throws 异常列表】{
        方法体的功能代码
}

修饰符：可选的。方法的修饰符也有很多，例如：public、protected、private、static、abstract、native、final、synchronized等。其中根据是否有static，可以将方法分为静态方法和非静态方法。其中静态方法又称为类方法，非静态方法又称为实例方法。

返回值类型： 表示方法运行的结果的数据类型，方法执行后将结果返回到调用者

方法名：给方法起一个名字，见名知意，能准确代表该方法功能的名字

参数列表：表示完成方法体功能时需要外部提供的数据列表

方法体：方法体必须有{}括起来，在{}中编写完成方法功能的代码。return语句的作用是结束方法的执行，并将方法的结果返回去（和循环中的break很相似）；如果返回值类型不是void，方法体中必须保证一定有 return 返回值;语句，并且要求该返回值结果的类型与声明的返回值类型一致或兼容。如果返回值类型为void时，方法体中可以没有return语句，如果要用return语句提前结束方法的执行，那么return后面不能跟返回值，直接写return ;就可以。return语句后面就不能再写其他代码了。

无参方法：

public class Student {
    public String stuName;
    public int stuAge;
    public String stuGender;

    public void sayHello() {
        System.out.println("你好，我叫" + stuName + ",我今年" + stuAge + "岁了，我是一名" + stuGender + "同学。");
    }

--------------------------------------------------------------------------------------------------------------------------------

练习：

 1：       

        声明一个日期类MyDate，包含属性：年、月、日，包含String dateToString()方法，返回“xxxx年xx月xx日”

        声明公民类Citizen，包含属性：姓名，生日，身份证号，其中姓名是String类型，生日是MyDate类型，身份证号也是String类型。包含String getInfo()方法，返回“姓名：xx，身份证号码：xx，生日：xxxx年xx月xx日”，包含void setBirthday(int year, int month, int day)：设置生日。

        在测试类的main方法中，创建你们家庭成员的几个对象，并打印信息。 

MyDate类：

public class MyDate {
    int year,month,date;

    public String dateToString(){
        return year + "年" + month +"月" + date + "日";
    }
}

 Citizen类：

public class Citizen {
    String name;
    MyDate birthDate;
    String id;

    public String getInfo() {
        return "姓名：" + name + ",身份证号：" + id + ",生日：" + birthDate.dateToString();
    }

    void setBirthday(int year, int month, int date) {
        birthDate = new MyDate();//第一次做忘记初始化
        birthDate.year = year;
        birthDate.month = month;
        birthDate.date = date;
    }
}

TestBirthday类：

public class TestBirthday {
    public static void main(String[] args) {
        Citizen me = new Citizen();
        me.setBirthday(2024,6,25);
        me.name = "张飞";
        me.id = "5201314";
        System.out.println(me.getInfo());
    }
}

结果： 

-------------------------------------------------------------------------------------------------------------------------------- 

        2：声明一个数组工具类ArrayTools，包含如下方法：

• int max(int[] arr)：求所有元素的最大值

• int valueCount(int[] arr, int value)：查找value在arr数组中出现的次数，如果不存在返回0

• int[] maxIndex(int[] arr)：找出所有最大值

• void sort(int[] arr)：实现元素从小到大排序

• void reverse(int[] arr, int start, int end)：反转[start,end]范围内的元素

• int[] copyOf(int[] arr, int newLength)：复制arr数组，新数组的长度newLength。如果newLength<=arr.length，则复制arr数组的[0, newLength-1]范围的元素，如果newLength>arr.length，则复制arr数组的所有元素到新数组，剩下的元素则默认就可以。

• boolean equals(int[] arr1, int[] arr2)：判断两个数组的长度和元素是否都相等，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。

• void fill(int[] arr, int start, int end, int value) ：将arr数组[start,end]范围的元素赋值为value。

• String toString(int[] arr)：将元素拼接为"{元素1，元素2，......}"的字符串返回。

在测试类的main方法中，调用方法测试例如：

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

ArrayTools类： 

public class ArrayTools {
    int max(int[] arr){
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if(arr[i] > max){
                max = arr[i];
            }
        }
        return max;
    }
    int valueCount(int[] arr, int value){
        int count = 0;
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] == value){
                count ++;
            }
        }
        return count;
    }
    int[] maxIndex(int[] arr){
        int max = max(arr);
        int count = valueCount(arr, max);
        int[] all = new int[count];
        for (int i = 0,j = 0; i < arr.length; i++) {
            if(arr[i] == max) {
          //      all[j++] = i; 错误
                all[j] = arr[i];
                j++;
             }
        }
        return all;
    }
    void sort(int[] arr){
        for (int i = 1; i < arr.length; i++) {
            for (int j = 0; j < arr.length-i; j++) {
                if(arr[j] > arr[j+1]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
    }
    void reverse(int[] arr, int start, int end){
        for(int i=0; i<(end-start)/2; i++){
            int temp = arr[i+start];
            arr[i+start] = arr[end-i];
            arr[end-i] = temp;
        }
    }

    int[] copyOf(int[] arr, int newLength){
        int[] newArr = new int[newLength];
        for (int i = 0; i < newArr.length && i<arr.length; i++) {
            newArr[i] = arr[i];
        }
        return newArr;
    }

    boolean equals(int[] arr1, int[] arr2){
        if(arr1.length != arr2.length){
            return false;
        }
        for (int i = 0; i < arr1.length; i++) {
            if(arr1[i] != arr2[i]){
                return false;
            }
        }
        return true;
    }

    void fill(int[] arr, int start, int end, int value){
        for (int i = start; i <= end; i++) {
            arr[i] = value;
        }
    }
    String toString(int[] arr){
        String result = "{";
        for (int i = 0; i < arr.length; i++) {
            if(i<arr.length-1){
                result += arr[i] + ",";
            }else{
                result += arr[i];
            }
        }
        result += "}";
        return result;
    }
}

public class ArrayToolsTest {
    public static void main(String[] args) {
        ArrayTools tools = new ArrayTools();
        int[] arr = {1,2,10,4,5,10,7,8,9,10};

        System.out.println("arr数组为：" +tools.toString(arr));
        int maxValue = tools.max(arr);
        System.out.println("arr数组中的最大值：" + maxValue);
        System.out.println("最大值的个数：" + tools.valueCount(arr,maxValue));
        int[] indexs = tools.maxIndex(arr);
        System.out.println("所有最大值下标：" + tools.toString(indexs));

        tools.sort(arr);
        System.out.println("排序后arr：" + tools.toString(arr));
        tools.reverse(arr, 1,5);
        System.out.println("反转[1,5]下标范围的元素后："+ tools.toString(arr));

        int[] before = tools.copyOf(arr, 5);
        System.out.println("复制前面5个元素：" + tools.toString(before));
        int[] doubleArr = tools.copyOf(arr, arr.length*2);
        System.out.println("arr的两倍大数组：" + tools.toString(doubleArr));
        tools.fill(doubleArr, arr.length, doubleArr.length-1, 6);
        System.out.println("doubleArr新扩展的元素用6填充后：" + tools.toString(doubleArr));
    }
}

结果：