201871010121-王方-《面向對象程序設計》第八週學習總結

項目	內容
這個做業屬於哪一個課程	https://www.cnblogs.com/nwnu-daizh/
這個做業的要求在哪裏	https://www.cnblogs.com/nwnu-daizh/p/11703678.html
做業學習目標	掌握接口定義方法； 掌握實現接口類的定義要求； 掌握實現了接口類的使用要求； 理解程序回調設計模式； 掌握Comparator接口用法； 掌握對象淺層拷貝與深層拷貝方法； 掌握Lambda表達式語法； 瞭解內部類的用途及語法要求。

第一部分  基礎知識

1、第五章知識點鞏固

（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<Employee> staff=new ArrayList<Employee>();

      該類常見的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的方法和狀態，並且還有屬於本身的方法和狀態。

2、第六章知識內容

（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<T>{

            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<Employee>
//使用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<Student> 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<studentlist.size();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 <studentlist.size(); 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<Student> {    //定義實現Comparable<Student>接口的類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);
   }
}

 

程序輸出結果截圖爲：

 

 實驗總總結：屢次實驗操做下來最大的感覺就是變成能力太差，代碼邏輯性不強，下來會繼續多家練習。