Java实验二：面向对象

1．定义一个计算机类，要求该类中至少包含3个私有的属性（为每个属性定义设置和获取方法）,该类中至少包含两个构造方法（一个无参，一个有参），以及包含2-4个方法来描述计算机对象的行为（其中一个方法要能打印输出计算机对象的所有属性值）。

Computer.java

/**
 * Created with IntelliJ IDEA.
 * Description: 定义计算机类
 * User: Li_yizYa
 * Date: 2022—05—21
 * Time: 23:13
 */
public class Computer {
    private String computerName;
    private double computerPrice;
    private String computerType;

    //无参的构造方法
    public Computer(){}

    //有参的构造方法
    public Computer(String computerName, double computerPrice, String computerType) {
        this.computerName = computerName;
        this.computerPrice = computerPrice;
        this.computerType = computerType;
    }

    //方法1: 玩游戏
    public void play() {
        System.out.println("使用" + this.computerName + "电脑玩游戏");
    }
    //方法2: 打印电脑的属性
    public void printComputer() {
        System.out.println("============打印电脑属性============");
        System.out.println("电脑品牌为: " + this.computerName);
        System.out.println("电脑类型为: " + this.computerType);
        System.out.println("电脑价格为: " + this.computerPrice);
        System.out.println("=================================");
    }
    //方法3: 追剧
    public void watch() {
        System.out.println("使用" + this.computerName + "电脑追剧");
    }
}

测试类：Test.java

class Test {
    public static void main(String[] args) {
        Computer computer = new Computer("苹果",6555.2,"台式");
        computer.printComputer();
        computer.play();
        computer.watch();
    }
}

运行结果 

2．定义一个类，该类中包含以下几个方法（静态）：

实现两个字符串数组的逆序排序，输出结果为字符串数组；

求两个整形数组的交集；

求两个浮点型数组的并集；

MyClass.java(功能类)

package experiment2;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: Li_yizYa
 * Date: 2022—05—21
 * Time: 23:36
 */
public class Myclass {
    //实现两个字符串数组的逆序排序，输出结果为字符串数组
    public static String[] reverse(String[] str1, String[] str2) {
        String[] ret = new String[str1.length+str2.length];
        int index = 0;
        for(int i = str1.length-1; i >= 0; i--) {
            ret[index++] = str1[i];
        }
        for (int i = str2.length-1; i >= 0 ; i--) {
            ret[index++] = str2[i];
        }
        return ret;
    }
    //求两个整形数组的交集
    public static void intersect(int[] arr1, int[] arr2) {
        int flag = 0;
        for(int i = 0; i < arr1.length; i++) {
            for (int j = 0; j < arr2.length; j++) {
                if(arr1[i] == arr2[j]) {
                    flag = 1;
                    System.out.print(arr1[i] + " ");
                }
            }
        }
        if(flag == 0) {
            System.out.println("两个整形数组的交集为空");
        }
    }
    //求两个浮点型数组的并集
    public static void union(double[] arr1, double[] arr2) {
        double[] ret = new double[arr1.length+arr2.length];
        for (int i = 0; i < ret.length; i++) {
            ret[i] = Integer.MAX_VALUE;
        }
        int index = 0;
        for (int i = 0; i < arr1.length; i++) {
            ret[index++] = arr1[i];
        }
        for (int i = 0; i < arr2.length; i++) {
            int flag = 0;
            for (int j = 0; ret[j] < Integer.MAX_VALUE; j++) {
                if(arr2[i] == ret[j]) {
                    flag = 1;
                }
            }
            if(flag == 0) {
                ret[index++] = arr2[i];
            }
        }
        for (int i = 0; ret[i] < Integer.MAX_VALUE; i++) {
            System.out.print(ret[i] + " ");
        }
    }
}

Test3.java(测试类) 

public class Test3 {
    public static void main(String[] args) {
        String[] str1 = {"abc","bcd","abd"};
        String[] str2 = {"cda","aaa","bbb"};
        String[] ret = Myclass.reverse(str1,str2);
        System.out.println("字符串1逆序后的结果为: ");
        for (int i = 0; i < str1.length; i++) {
            System.out.print(ret[i] + " ");
        }
        System.out.println();
        System.out.println("字符串2逆序后的结果为: ");
        for (int i = 0; i < str2.length; i++) {
            System.out.print(ret[i] + " ");
        }
        System.out.println();
        System.out.println("=======================");
        int[] arr1 = {1,3,5,7,9};
        int[] arr2 = {2,4,9,8};
        System.out.println("两个整型数组的交集为: ");
        Myclass.intersect(arr1,arr2);
        System.out.println();
        System.out.println("=======================");
        double[] arr3 = {3.2,4.1,5.8,6.9};
        double[] arr4 = {3.3,6.9,9.2,7.1};
        System.out.println("两个浮点型数组的并集为: ");
        Myclass.union(arr3,arr4);
    }
}

运行结果 

 

 

3．定义一个表示学生信息的类Student，要求如下：

  （1）类Student的成员变量：

sNO　表示学号；sName表示姓名；sSex表示性别；sAge表示年龄；sJava：表示Java课程成绩。

  （2）类Student带参数的构造方法：

在构造方法中通过形参完成对成员变量的赋值操作。

 （3）类Student的方法成员：

getNo（）：获得学号；

getName（）：获得姓名；

getSex（）：获得性别；

getAge（）获得年龄；

getJava（）：获得Java 课程成绩

setNo（）：设置学号；

setName（）：设置姓名；

setSex（）：设置性别；

setAge（）；设置年龄

setJava（）：设置Java 课程成绩

具体代码

/**
 * Created with IntelliJ IDEA.
 * Description: 学生信息类
 * User: Li_yizYa
 * Date: 2022—05—22
 * Time: 0:32
 */
public class Student {
    private int sNo;
    private String sName;
    private String sSex;
    private int sAge;
    private int sJava;

    public Student(int sNo, String sName, String sSex, int sAge, int sJava) {
        this.sNo = sNo;
        this.sName = sName;
        this.sSex = sSex;
        this.sAge = sAge;
        this.sJava = sJava;
    }

    public int getsNo() {
        return sNo;
    }

    public void setsNo(int sNo) {
        this.sNo = sNo;
    }

    public String getsName() {
        return sName;
    }

    public void setsName(String sName) {
        this.sName = sName;
    }

    public String getsSex() {
        return sSex;
    }

    public void setsSex(String sSex) {
        this.sSex = sSex;
    }

    public int getsAge() {
        return sAge;
    }

    public void setsAge(int sAge) {
        this.sAge = sAge;
    }

    public int getsJava() {
        return sJava;
    }

    public void setsJava(int sJava) {
        this.sJava = sJava;
    }

    @Override
    public String toString() {
        return "学号: " + sNo +
                ", 姓名: " + sName + ' ' +
                ", 性别: " + sSex + ' ' +
                ", 年龄: " + sAge +
                ", Java成绩: " + sJava;
    }
}

根据类Student的定义，创建五个该类的对象，输出每个学生的信息，计算并输出这五个学生Java语言成绩的平均值，以及计算并输出他们Java语言成绩的最大值和最小值。

public class Test2 {
    public static void main(String[] args) {
        Student[] students = new Student[5];
        students[0] = new Student(1,"张三","男",18,92);
        students[1] = new Student(2,"李四","男",19,81);
        students[2] = new Student(3,"王五","男",18,76);
        students[3] = new Student(4,"张三金","男",20,99);
        students[4] = new Student(5,"赵东","男",18,87);
        int count = 0;
        int maxScore = 0;
        int minScore = 100;
        System.out.println("=====================学生信息表========================");
        for (Student student : students) {
            //计算五名学生总分
            count += student.getsJava();
            //获取最高成绩
            if(student.getsJava() > maxScore) {
                maxScore = student.getsJava();
            }
            //获取最低成绩
            if(student.getsJava() < minScore) {
                minScore = student.getsJava();
            }
            System.out.println(student.toString());
        }
        System.out.println("=====================================================");
        System.out.println();
        System.out.println("Java语言成绩最高分为: " + maxScore);
        System.out.println("Java语言成绩最低分为: " + minScore);
        System.out.println("Java语言成绩平均分为: " + (double)count/ students.length);
    }
}

运行结果