201871010121-王方-《面向对象程序设计》第八周学习总结

项目	内容
这个作业属于哪个课程	https://www.cnblogs.com/nwnu-daizh/
这个作业的要求在哪里	https://www.cnblogs.com/nwnu-daizh/p/11703678.html
作业学习目标	掌握接口定义方法； 掌握实现接口类的定义要求； 掌握实现了接口类的使用要求； 理解程序回调设计模式； 掌握Comparator接口用法； 掌握对象浅层拷贝与深层拷贝方法； 掌握Lambda表达式语法； 了解内部类的用途及语法要求。

第一部分  基础知识

一、第五章知识点巩固

（1）封装、继承和多态是面向对象的主要特征。

（2）继承可提高代码重用性，用extends关键字来实现，处构造方法之外，父类的所有方法和属性都被子类继承。同时也是多态特征的前提。

（3）继承建立了类与类之间的关系，同时也是多态特征的前提。

（3）JAVA值支持单继承，不直接支持多继承（避免两个父类出现同名方法的调用选择困难）。

（4）final类不允许被继承：类中final方法不允许被子类重写。

（5）abstract修饰的抽象类不能被实例化为对象，只能阔展子类：抽象类中的方法充当着占位的角色。他们的具体实现在子类中。

（6）父/子类成员的使用特点：

     属性域：子类中如果想要调用父类中的属性值，需要使用一个关键字：supper

     成员方法：当父/子类中出现同名方法时，建立子类对象则运行子类中的方法。

     构造方法：因为子类继承父类，需继承到父类的数据，所以子类构造方法第一行先调用父类的构造方法（supper方法）

（7）方法多态分类：

         静态（编译）解析：方法重载

         动态绑定解析：方法覆写

    （8）控制可见性的4个访问权限修饰符：public、protected、friendly、private.(必须掌握！！！)

（9）Object类是所有类的超类。Java.lang  

该类的常用API有：—equals()  -toString()   -getname()   -hashCode()

（10）ArrayList类是一个采用类型参数的范数数组类：

       Java.util   例如：ArrayList staff=new ArrayList();

      该类常见的API有：-add()  -size()  -get()

（11）JAVA为解决基本数据类型演变为类对象的问题，JAVA定义与基本数据类型对应的对象包装器类。

（12）对象包装器类：与各个基本类型对应的类，都是从公共包装器类Number继承而来的，这些类有：-Integer  Long  Float   Double  Short  Byte  Character   Void  Boolean

（13）用关键字enum可定义用户自定枚举类：

      用户自定义枚举类的超类是Enum类：java.lang

      Enum类的常见的API有（190）：

   -valueOf()  -toString()  -Ordianl()  -compareTo()

（14）类之间的关系：

      依赖：如果有一个类中的方法操作了另一个类的对象，那么这个类就依赖于另一个类。

      聚合：类A的 对象包含类B的对象。

      继承:表示一个特定的类和一个一般的类之间的关系。一般来说类A继承了类B，那么类A不仅继承类B的方法和状态，而且还有属于自己的方法和状态。

二、第六章知识内容

（1）接口、lambda表达式和内部类

（a）接口：java为了克服单继承的缺点，java使用了接口，一个类可以实现一个或多个接口。

（b）在Java中，接口不是类，而是对类的一组需求描述，有常量和一组抽象方法组成。接口中不包括变量和有具体实现的方法。只要类实现了接口，则该类要遵从接口描述的同意格式进行定义，并且可以在任何需要该接口的地方使用这个类的对象。

（c）接口类型：

a 用户自定义接口，

b 标准接口。

自定义接口的声明：  public  interface  接口名{...}

接口体中包含常量定义和抽象方法定义，在接口中之进行方法的声明，不提供方法的实现。

         C 类似建立类的继承关系，接口也可以扩展

（d）扩展方法：

          Public interface 接口1   extends  接口2

{.......}

注意：通常接口的名字以able或ible结尾。

可以使用extends来继承接口的常量和抽象方法，扩展形成新的接口。

  接口中的所有常量必须是public static final,方法必须是public abstract,这是系统默认的，写不写修饰符都是一样的。

 

（2）接口的实现

在类声明是用implements关键字声明使用一个或多个接口：

Class   Employee   implements  Cloneable, Comparable（实现多接口）

说明：实现接口的类不是抽象类，则必须实现所有接口的所有方法，即为所有的抽象方法定义方法体。

一个类在实现某接口抽象方法时，必须使用完全相同的方法名、参数列表和返回值类型。

接口抽象方法的访问控制符已指定为public,所以立类在实现时，必须现实地使用public修饰符。负责会被警告缩小了接口中定义的方法的访问控制范围。

 （3）接口的使用

接口不能构造接口对象但可以声明接口变量以指向一个实现了该接口的类对象。

例：Comparable x=new Employee(...)

  (4)接口与抽象类

抽象类：用abstract来声明，没有具体实例对象的类，不能用new来创建对象。可包含常规类所包含的任何东西。抽象类必须有子类继承，如果abstract类的子类不是抽象类，那么子类必须重写父类中所有方法的abstract方法。

接口：用interface声明，是抽象方法和常量值定义的集合。接口是一种特殊的抽象类，当中只包含常量和法昂发的定义，二没有变量和的方法。接口中只能定义抽象方法而且这些方法默认的是Publicde .只要实现了接口，就可以在任何需要该接口的地方使用这个类的对象。此外，一个类可以实现多个接口。

（5）接口与抽象类的区别

    a>接口不能实现任何方法二抽象类方法可以。

    b>类可以时下按多个接口但只有一个类。

    c>接口不是类分级的一部分，无任何联系的类可以实现相同的接口。

（6）接口与回调

         回调：可以指出某个特定的事件发生时程序应采取的动作的模式。

（7）Comparator接口

         Comparator接口所在的包为：java.util.*

         Comparator接口定义

         public interface  Comparator{

            int compare(T o1,T o2);.

            ......

            }

         Comparator 接口可用来处理字符串按长度进行排序的操作。

（8）对象克隆

    a>Object类的克隆方法

   当拷贝一个对象变量时，原始变量与拷贝变量引用同一个变量。改变一个变量所引用的对象会对两一个变量产生影响。

   如果要创建一个对象新的Copy,它的最初状态与Original类的克隆方法。

Object类中的clone()方法是一个native方法。

Object类中的Clone()方法被protect修饰符修饰（意味着用户不能直接调用它）。如果要直接调用clone(),就需要覆盖clone()方法，并将Clone()方法属性设置成为public.

Object clone()方法返回一个Object对象。

    b>浅层拷贝与深层拷贝

    浅层拷贝：被拷贝的对象的所有成员域所有常量成员和基本类型属性都有与原来对象相同的拷贝值，而当成员域是一个对象，则被拷贝的对象域的该对象引用任然指向原来的对象。

   深层拷贝：被拷贝的所有成员域都含有域原来对象的相同的值，且对象域将指向被复制过的新对象而不是源于对象被复制过的对象。深层拷贝将拷贝对象内引用的对象也拷贝一遍。

    c>Java中对象克隆的实现

      在子类中实现Cloneable接口。

      为了获取对象的一份拷贝，可以利用Object类中的Clone方法。

      在子类中覆盖超类的clone方法，声明为Public。

      在子类的clone方法中，调用super.clone().

(9)对象克隆的要点

    在类中实现Cloneable接口   

    为了获取对象的一份拷贝，使用Objcet类的clone方法。

    在类中覆盖超类的clone方法，声明为public。

    在类的clone方法中，调用super.clone().

(10)Lambda的表达式

    Lambda的主要用途是提供一个函数化的语法来简化编程。Lambda的表达式本质上是一个匿名方法。

    Public  int  add（int  x, int  y）{

     return  x+y; }

    Lambda表达式的基本语法结构

（argument）—>body

   第二部分 实验内容和步骤

实验1： 导入第6章示例程序，测试程序并进行代码注释。

测试程序1：

l 编辑、编译、调试运行阅读教材214页-215页程序6-1、6-2，理解程序并分析程序运行结果；

l 在程序中相关代码处添加新知识的注释。

l 掌握接口的实现用法；

掌握内置接口Compareable的用法。

程序6-1代码如下：

 

package interfaces;

import java.util.*;

/**
 * This program demonstrates the use of the Comparable interface.//这个程序演示了可比较接口的使用
 * @version 1.30 2004-02-27
 * @author Cay Horstmann
 */
public class EmployeeSortTest
{
   public static void main(String[] args)
   {
      var staff = new Employee[3];
      //新建一个Employee 数组对象 给staff所引用，数组大小为三
      staff[0] = new Employee("Harry Hacker", 35000);
      staff[1] = new Employee("Carl Cracker", 75000);
      staff[2] = new Employee("Tony Tester", 38000);

      Arrays.sort(staff);//数组排序

      // print out information about all Employee objects
      //打印所有员工对象的信息
      for (Employee e : staff)
         System.out.println("name=" + e.getName() + ",salary=" + e.getSalary());
   }
}

 

程序6-2代码如下：

package interfaces;

public class Employee implements Comparable
//使用comparable接口自定义排序
{
   private String name;
   private double salary;

   public Employee(String name, double salary)
   {
      this.name = name;
      this.salary = salary;//用关键字this设置员工的名字及工资
   }

   public String getName()
   {
      return name;
   }

   public double getSalary()
   {
      return salary;
   }

   public void raiseSalary(double byPercent)
   {
      double raise = salary * byPercent / 100;
      salary += raise;
   }

   /**
    * Compares employees by salary//根据工资比较员工
    * @param other another Employee object
    * @return a negative value if this employee has a lower salary than
    * otherObject, 0 if the salaries are the same, a positive value otherwise
    */
   public int compareTo(Employee other)
   {
      return Double.compare(salary, other.salary);
   }
}

程序运行结果截图为：

 

 

测试程序2：

l 编辑、编译、调试以下程序，结合程序运行结果理解程序；

示例代码为：

 

interface  A
{
  double g=9.8;
  void show( );
}
class C implements A
{
  public void show( )
  {System.out.println("g="+g);}
}

class InterfaceTest
{
  public static void main(String[ ] args)
  {
       A a=new C( );
       a.show( );
       System.out.println("g="+C.g);
  }
}

 

补充后的代码为：

package interfaces;

interface  A
{
  double g=9.8;
  void show( );
}
class C implements A
{
  public void show( )
  {System.out.println("g="+g);}
}

class InterfaceTest
{
  public static void main(String[ ] args)
  {
       A a=new C( );
       a.show( );
       System.out.println("g="+C.g);
  }
}

程序输出结果截图为：

 

 

测试程序3：

l 在elipse IDE中调试运行教材223页6-3，结合程序运行结果理解程序；

l 26行、36行代码参阅224页，详细内容涉及教材12章。

l 在程序中相关代码处添加新知识的注释。

l 掌握回调程序设计模式；

程序代码为：

 

package timer;

/**
   @version 1.02 2017-12-14
   @author Cay Horstmann
*/

import java.awt.*;
import java.awt.event.*;
import java.time.*;
import javax.swing.*;

public class TimerTest
{  
   public static void main(String[] args)
   {  
      var listener = new TimePrinter();

      // construct a timer that calls the listener构造一个调用侦听器的计时器
      // once every second每秒一次
      var timer = new Timer(1000, listener);
      timer.start();//构造一个定时器，

      // keep program running until the user selects "OK"使时间一直运行直到使用者停止
      JOptionPane.showMessageDialog(null, "Quit program?");//程序是否终止窗口
      System.exit(0);
   }
}

class TimePrinter implements ActionListener
{  
   public void actionPerformed(ActionEvent event)
   {  
      System.out.println("At the tone, the time is " //输出这一刻的时间
         + Instant.ofEpochMilli(event.getWhen()));
      Toolkit.getDefaultToolkit().beep();//获得默认的工具箱，得到信息并发出一声铃响；
   }
}

 

程序运行结果输出截图为：

 

 

测试程序4：

l 调试运行教材229页-231页程序6-4、6-5，结合程序运行结果理解程序；

l 在程序中相关代码处添加新知识的注释。

l 掌握对象克隆实现技术；

l 掌握浅拷贝和深拷贝的差别。

6-4程序代码为：

 

package clone;

/**
 * This program demonstrates cloning.//这个程序演示了克隆
 * @version 1.11 2018-03-16
 * @author Cay Horstmann
 */
public class CloneTest
{
   public static void main(String[] args) throws CloneNotSupportedException
   {
      var original = new Employee("John Q. Public", 50000);
      original.setHireDay(2000, 1, 1);
      Employee copy = original.clone();//对原先数据进行克隆
      copy.raiseSalary(10);
      copy.setHireDay(2002, 12, 31);
      System.out.println("original=" + original);//输出原始数据
      System.out.println("copy=" + copy);//输出克隆后的数据
   }
}

 

6-5程序代码为;

package clone;

import java.util.Date;
import java.util.GregorianCalendar;

public class Employee implements Cloneable
{
   private String name;
   private double salary;
   private Date hireDay;

   public Employee(String name, double salary)
   {
      this.name = name;
      this.salary = salary;
      hireDay = new Date();
   }

   public Employee clone() throws CloneNotSupportedException
   {
      // call Object.clone()克隆程序
      Employee cloned = (Employee) super.clone();

      // clone mutable fields克隆可变字段
      cloned.hireDay = (Date) hireDay.clone();

      return cloned;
   }

   /**
    * Set the hire day to a given date. 将租用日期设置为给定日期
    * @param year the year of the hire day
    * @param month the month of the hire day
    * @param day the day of the hire day
    */
   public void setHireDay(int year, int month, int day)
   {
      Date newHireDay = new GregorianCalendar(year, month - 1, day).getTime();
      
      // example of instance field mutation
      //实例字段变异示例
      hireDay.setTime(newHireDay.getTime());
   }

   public void raiseSalary(double byPercent)
   {
      double raise = salary * byPercent / 100;
      salary += raise;
   }

   public String toString()
   {
      return "Employee[name=" + name + ",salary=" + salary + ",hireDay=" + hireDay + "]";
   }
}

程序运行结果输出截图为：

 

 

实验2： 导入第6章示例程序6-6，学习Lambda表达式用法。

l 调试运行教材233页-234页程序6-6，结合程序运行结果理解程序；

l 在程序中相关代码处添加新知识的注释。

将27-29行代码与教材223页程序对比，将27-29行代码与此程序对比，体会Lambda表达式的优点。

程序代码为：

 

package lambda;

import java.util.*;

import javax.swing.*;
import javax.swing.Timer;

/**
 * This program demonstrates the use of lambda expressions.这个程序演示了lambda表达式的使用
 * @version 1.0 2015-05-12
 * @author Cay Horstmann
 */
public class LambdaTest
{
   public static void main(String[] args)
   {
      var planets = new String[] { "Mercury", "Venus", "Earth", "Mars", 
         "Jupiter", "Saturn", "Uranus", "Neptune" };
      System.out.println(Arrays.toString(planets));
      System.out.println("Sorted in dictionary order:");
      Arrays.sort(planets);
      System.out.println(Arrays.toString(planets));
      System.out.println("Sorted by length:");
      Arrays.sort(planets, (first, second) -> first.length() - second.length());
      System.out.println(Arrays.toString(planets));
            
      var timer = new Timer(1000, event ->
         System.out.println("The time is " + new Date()));
      timer.start();//构造一个定时器，   
         
      // keep program running until user selects "OK"使时间一直运行直到使用者停止
      JOptionPane.showMessageDialog(null, "Quit program?");//程序是否终止窗口
      System.exit(0);         
   }
}

 

程序运行结果输出截图为：

 

 

实验3: 编程练习

l 编制一个程序，将身份证号.txt 中的信息读入到内存中；

l 按姓名字典序输出人员信息；

l 查询最大年龄的人员信息；

l 查询最小年龄人员信息；

l 输入你的年龄，查询身份证号.txt中年龄与你最近人的姓名、身份证号、年龄、性别和出生地；

l 查询人员中是否有你的同乡。

程序源代码为：

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Scanner;
 
public class IDTest{
    private static ArrayList studentlist;     
    public static void main(String[] args) {
        studentlist = new ArrayList<>();
        Scanner scanner = new Scanner(System.in);
        File file = new File("D:\\java\\身份证号.txt");     //将文件引入
         
        try {
            FileInputStream fis = new FileInputStream(file);
            BufferedReader in = new BufferedReader(new InputStreamReader(fis));
            String temp = null;
            while ((temp = in.readLine()) != null) {
                 
                Scanner linescanner = new Scanner(temp);
                 
                linescanner.useDelimiter(" ");    
                String name = linescanner.next();
                String number = linescanner.next();
                String sex = linescanner.next();
                String age = linescanner.next();
                String province =linescanner.nextLine();
                Student student = new Student();
                student.setName(name);
                student.setnumber(number);
                student.setsex(sex);
                int a = Integer.parseInt(age);
                student.setage(a);
                student.setprovince(province);
                studentlist.add(student);
 
            }
        } catch (FileNotFoundException e) {
            System.out.println("学生信息文件找不到");
            e.printStackTrace();
        } catch (IOException e) {
            System.out.println("学生信息文件读取错误");
            e.printStackTrace();
        }
        boolean isTrue = true;
        while (isTrue) {
            System.out.println("1:按姓名字典序输出人员信息；");
            System.out.println("2:查询最大年龄与最小年龄人员信息；");
            System.out.println("3.输入你的年龄，查询身份证号.txt中年龄与你最近人的姓名、身份证号、年龄、性别和出生地");
            System.out.println("4：按省份找你的同乡；");
            System.out.println("5：退出");
            String m = scanner.next();
            switch (m) {
            case "1":
                Collections.sort(studentlist);  
                System.out.println("排序后的结果为：" + "\n");
                System.out.println(studentlist.toString());
                break;
            case "2":
                 int max=0,min=100;
                 int j,k1 = 0,k2=0;
                 for(int i=1;i)
                 {
                     j=studentlist.get(i).getage();
                 if(j>max)
                 {
                     max=j; 
                     k1=i;
                 }
                 if(j<min)
                 {
                   min=j; 
                   k2=i;
                 }
                  
                 }  
                 System.out.println("Max  age："+studentlist.get(k1));
                 System.out.println("Min  age："+studentlist.get(k2));
                break;
            case "3":
                System.out.println("age：");
                int yourage = scanner.nextInt();
                int near=agenear(yourage);
                int value=yourage-studentlist.get(near).getage();
                System.out.println("年龄与你最近的人的姓名、身份证号、年龄、性别和出生地为：" + "\n");
                System.out.println(""+studentlist.get(near));
                break;
            case "4":
                System.out.println(" Which province were you born in?");
                String find = scanner.next();        
                String place=find.substring(0,3);
                for (int i = 0; i ) 
                {
                    if(studentlist.get(i).getprovince().substring(1,4).equals(place))
                        System.out.println("查找到的老乡有：" + "\n" +studentlist.get(i));
                }             
                break;
                 
            case "5":
                isTrue = false;
                System.out.println("退出程序!！！！");
                break;
                default:
                System.out.println("信息输入有误！！！");
 
            }
        }
    }
        public static int agenear(int age) {      
        int j=0,min=53,value=0,k=0;
         for (int i = 0; i < studentlist.size(); i++)
         {
             value=studentlist.get(i).getage()-age;
             if(value<0) value=-value; 
             if (value<min) 
             {
                min=value;
                k=i;
             } 
          }    
         return k;         
      }
 
}
public class Student implements Comparable {    //定义实现Comparable接口的类Student
 
    private String name;          //私有变量的定义
    private String number ;
    private String sex ;
    private int age;
    private String province;
    
    public String getName() {          //构造器
        return name;      
    }
    public void setName(String name) {    //访问器
        this.name = name;
    }
    public String getnumber() {
        return number;
    }
    public void setnumber(String number) {   
        this.number = number;
    }
    public String getsex() {
        return sex ;
    }
    public void setsex(String sex ) {
        this.sex =sex ;
    }
    public int getage() {
 
        return age;
        }
    public void setage(int age) {
        this.age= age;
        }
 
    public String getprovince() {
        return province;
    }
    public void setprovince(String province) {
        this.province=province ;
    }
 
    public int compareTo(Student o) {       //compareTo方法将会返回一个整型数值
       return this.name.compareTo(o.getName());
    }
 
    public String toString() {
        return  name+"\t"+sex+"\t"+age+"\t"+number+"\t"+province+"\n";
    }    
}

 

结果没有输出，变成有问题会继续改进的

 

实验4：内部类语法验证实验

 

实验程序1：

 

l 编辑、调试运行教材246页-247页程序6-7，结合程序运行结果理解程序；

 

l 了解内部类的基本用法。

程序源代码为：

 

package innerClass;
 
import java.awt.*;
import java.awt.event.*;
import java.time.*;
 
import javax.swing.*;
 
/**
 * This program demonstrates the use of inner classes.
 * @version 1.11 2017-12-14
 * @author Cay Horstmann
 */
public class InnerClassTest
{
   public static void main(String[] args)
   {
      TalkingClock clock = new TalkingClock(1000, true);      //创建TalkingClock对象，
      clock.start();         
 
      // keep program running until the user selects "OK"
      JOptionPane.showMessageDialog(null, "Quit program?");     //当程序开始运行的时候立即出现写有“Quit program”的对话框
      System.exit(0);
   }
}
 
/**
 * A clock that prints the time in regular intervals.
 */
class TalkingClock           //抽象一个TalkingClock类
{
   private int interval;       //构造语音时钟时所需要的两个参数：发布通告的间隔以及开关铃声的标志
   private boolean beep;
 
   /**
    * Constructs a talking clock
    * @param interval the interval between messages (in milliseconds)
    * @param beep true if the clock should beep
    */
   public TalkingClock(int interval, boolean beep)             //TalkingClock构造器
   {
      this.interval = interval;
      this.beep = beep;
   }
 
   /**
    * Starts the clock.
    */
   public void start()     //方法声明
   {
      TimePrinter listener = new TimePrinter();           //创建一个TimePrinter对象，其在TalkingClock的内部
      Timer timer = new Timer(interval, listener);
      timer.start();      //启动
   }
 
   public class TimePrinter implements ActionListener     //将TimePrinter类声明为实现ActionListener接口
   {
      public void actionPerformed(ActionEvent event)      //actionPerformed方法在发出铃声之前检查了beep标志
      {
         System.out.println("At the tone, the time is "
            + Instant.ofEpochMilli(event.getWhen()));
         if (beep) Toolkit.getDefaultToolkit().beep();
      }
   }
}

 

程序运行结果输出截图为：

 

 

实验程序2：

l 编辑、调试运行教材254页程序6-8，结合程序运行结果理解程序；

l 掌握匿名内部类的用法。

程序源代码为：

 

package anonymousinnerClass;

import java.awt.*;
import java.awt.event.*;
import java.time.*;

import javax.swing.*;

/**
 * This program demonstrates anonymous inner classes.
 * @version 1.12 2017-12-14
 * @author Cay Horstmann
 */
public class AnonymousInnerClassTest
{
   public static void main(String[] args)
   {
      var clock = new TalkingClock();
      clock.start(1000, true);

      // keep program running until the user selects "OK"
      JOptionPane.showMessageDialog(null, "Quit program?");
      System.exit(0);
   }
}

/**
 * A clock that prints the time in regular intervals.
 */
class TalkingClock
{
   /**
    * Starts the clock.
    * @param interval the interval between messages (in milliseconds)
    * @param beep true if the clock should beep
    */
   public void start(int interval, boolean beep)
   {
      var listener = new ActionListener()
         {
            public void actionPerformed(ActionEvent event)
            {
               System.out.println("At the tone, the time is " 
                  + Instant.ofEpochMilli(event.getWhen()));
               if (beep) Toolkit.getDefaultToolkit().beep();
            }
         };
      var timer = new Timer(interval, listener);
      timer.start();
   }
}

 

程序输出结果截图为：

 

 

实验程序3：

l 在elipse IDE中调试运行教材257页-258页程序6-9，结合程序运行结果理解程序；

l 了解静态内部类的用法。

程序源代码为：

 

package staticInnerClass;

/**
 * This program demonstrates the use of static inner classes.
 * @version 1.02 2015-05-12
 * @author Cay Horstmann
 */
public class StaticInnerClassTest
{
   public static void main(String[] args)
   {
      var values = new double[20];
      for (int i = 0; i < values.length; i++)
         values[i] = 100 * Math.random();
      ArrayAlg.Pair p = ArrayAlg.minmax(values);
      System.out.println("min = " + p.getFirst());
      System.out.println("max = " + p.getSecond());
   }
}

class ArrayAlg
{
   /**
    * A pair of floating-point numbers
    */
   public static class Pair
   {
      private double first;
      private double second;

      /**
       * Constructs a pair from two floating-point numbers
       * @param f the first number
       * @param s the second number
       */
      public Pair(double f, double s)
      {
         first = f;
         second = s;
      }

      /**
       * Returns the first number of the pair
       * @return the first number
       */
      public double getFirst()
      {
         return first;
      }

      /**
       * Returns the second number of the pair
       * @return the second number
       */
      public double getSecond()
      {
         return second;
      }
   }

   /**
    * Computes both the minimum and the maximum of an array
    * @param values an array of floating-point numbers
    * @return a pair whose first element is the minimum and whose second element
    * is the maximum
    */
   public static Pair minmax(double[] values)
   {
      double min = Double.POSITIVE_INFINITY;
      double max = Double.NEGATIVE_INFINITY;
      for (double v : values)
      {
         if (min > v) min = v;
         if (max < v) max = v;
      }
      return new Pair(min, max);
   }
}

 

程序输出结果截图为：

 

 实验总总结：多次实验操作下来最大的感受就是变成能力太差，代码逻辑性不强，下来会继续多家练习。