一,理論知識學習部分

6.1.1 介面概念

兩種含義：一，Java介面，Java語言中存在的結構，有特定的語法和結構；二，一個類所具有的方法的特徵集合，是一種邏輯上的抽象。前者叫做“Java介面”，後者叫做“介面”。用interface宣告，是抽象方法和常量值定義的集 合。從本質上講，介面是一種特殊的抽象類。

抽象類和介面：如果你擁有一些方法並且想讓它們中的一些有預設實現，那麼使用抽象類吧。如果你想實現多重繼承，那麼你必須使用介面。子類不能夠繼承多個類，但可以實現多個介面。因此你就可以使用介面來解決它。如果基本功能在不斷改變，那麼就需要使用抽象類。如果不斷改變基本功能並且使用介面，那麼就需要改變所有實現了該介面的類。

6.1.2介面的特性

介面可以被例項化；

實現類必須實現介面的所有方法；

實現類可以實現多個介面；

介面中的變數都是靜態變數；

6.1.3抽象類和介面

如果你擁有一些方法並且想讓它們中的一些有預設實現，那麼使用抽象類吧。

如果你想實現多重繼承，那麼你必須使用介面。子類不能夠繼承多個類，但可以實現多個介面。因此你就可以使用介面來解決它。

如果基本功能在不斷改變，那麼就需要使用抽象類。如果不斷改變基本功能並且使用介面，那麼就需要改變所有實現了該介面的類。

抽象類：用abstract來宣告,沒有具體例項物件的類，不 能用new來建立物件。

6.1.5預設方法

介面中的所有常量必須是static final，方法必須是public abstract，這是 系統預設的，不管你在定義介面時，寫不寫 修飾符都是一樣的.

介面的實現:一個類使用了某個介面，那麼這個類必須實現該 介面的所有方法，即為這些方法提供方法體。一個類可以實現多個介面，介面間應該用逗號分 隔開。

介面的使用:介面不能構造介面物件，但可以宣告介面變數以指向一個實現了該介面的類物件。

可以用instanceof檢查物件是否實現了某個介面。

抽象類：用abstract來宣告,沒有具體例項物件的類，不 能用new來建立物件。

6.2 介面示例

回撥(callback)：一種程式設計模式，在這種模 式中，可指出某個特定事件發生時程式應該採取 的動作。Comparator介面所在包： java.util.*

Oject類的Clone方法:當拷貝一個物件變數時，原始變數與拷貝變數 引用同一個物件。這樣，改變一個變數所引用 的物件會對另一個變數產生影響。如果要建立一個物件新的copy，它的最初狀態與 original一樣，但以後可以各自改變狀態，就需 要使用Object類的clone方法。Object.clone()方法返回一個Object物件。必須進行強 制型別轉換才能得到需要的型別。淺層拷貝與深層拷貝Java中物件克隆的實現:在子類中實現Cloneable介面。在子類的clone方法中，呼叫super.clone()。

6.3 lambda表示式

Java Lambda 表示式是 Java  引入的一個新的功能，主 要用途是提供一個函式化的語法來簡化編碼。

Lambda 表示式的語法基本結構 (arguments) -> body

有如下幾種情況： 1、引數型別可推導時，不需要指定型別，如 (a) -> System.out.println(a)  只有一個引數且型別可推導時，不強制寫 (), 如 a -> System.out.println(a) ，  引數指定型別時，必須有括號，如 (int a) -> System.out.println(a) ， 引數可以為空，如 () -> System.out.println(“hello”)    body 需要用 {} 包含語句，當只有一條語句時 {} 可省略

內部類：是定義在一個類內部的類。使用內部類的原因有以下三個： –內部類方法可以訪問該類定義所在的作用域中 的資料，包括私有資料。–內部類能夠隱藏起來，不為同一包中的其他類 所見–想要定義一個回撥函式且不想編寫大量程式碼時， 使用匿名內部類比較便捷。內部類可以直接訪問外部類的成員，包括 private成員，但是內部類的成員卻不能被外部 類直接訪問。內部類並非只能在類內定義，也可以在程式塊內 定義區域性內部類。如果構造引數的閉圓括號跟一個開花括號，表明正 在定義的就是匿名內部類。

二.實驗部分

1、實驗目的與要求

(1) 掌握介面定義方法；

(2) 掌握實現介面類的定義要求；

(3) 掌握實現了介面類的使用要求；

(4) 掌握程式回撥設計模式；

(5) 掌握Comparator介面用法；

(6) 掌握物件淺層拷貝與深層拷貝方法；

(7) 掌握Lambda表示式語法；

(8) 瞭解內部類的用途及語法要求。

2、實驗內容和步驟

實驗1： 匯入第6章示例程式，測試程式並進行程式碼註釋。

測試程式1：

l 編輯、編譯、除錯執行閱讀教材214頁-215頁程式6-1、6-2，理解程式並分析程式執行結果；

l 在程式中相關程式碼處新增新知識的註釋。

l 掌握介面的實現用法；

掌握內建介面Compareable的用法。

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) { Employee[] staff = new Employee[3];//普通陣列  staff[0] = new Employee("Harry Hacker", 35000); staff[1] = new Employee("Carl Cracker", 75000); staff[2] = new Employee("Tony Tester", 38000); Arrays.sort(staff);//靜態方法sort // print out information about all Employee objects for (Employee e : staff) System.out.println("name=" + e.getName() + ",salary=" + e.getSalary()); } }

package interfaces;

public class Employee implements Comparable<Employee>//Employee實現JDK內建介面Comparable { private String name; private double salary; //構造方法 public Employee(String name, double salary) { this.name = name; this.salary = salary; } //訪問器 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);//靜態Double.compare方法  } }

結果如下：

測試程式2：

l 編輯、編譯、除錯以下程式，結合程式執行結果理解程式；

public interface  A
    {
      double g=9.8;
      void show( ); }

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

package InterfaceTest;
public 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 在程式中相關程式碼處新增新知識的註釋。

4）掌握回撥程式設計模式

package timer;

/**
   @version 1.01 2015-05-12
   @author Cay Horstmann */ import java.awt.*; import java.awt.event.*; import java.util.*; import javax.swing.*; import javax.swing.Timer; // to resolve conflict with java.util.Timer public class TimerTest { public static void main(String[] args) { ActionListener listener = new TimePrinter(); //實現了ActionListener的類物件 // construct a timer that calls the listener // once every 10 seconds Timer t = new Timer(10000, listener);//定義間隔  t.start(); 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 " + new Date()); Toolkit.getDefaultToolkit().beep(); } }

結果如下：

測試程式4：

l 除錯執行教材229頁-231頁程式6-4、6-5，結合程式執行結果理解程式；

l 在程式中相關程式碼處新增新知識的註釋。

l 掌握物件克隆實現技術；

l 掌握淺拷貝和深拷貝的差別。

package clone;

/**
 * This program demonstrates cloning.
 * @version 1.10 2002-07-01
 * @author Cay Horstmann
 */
public class CloneTest { public static void main(String[] args) { try { Employee original = new Employee("John Q. Public", 50000); //Employee是一個自定義類 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); } catch (CloneNotSupportedException e) { e.printStackTrace(); } } }

結果如下：

實驗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. * @version 1.0 2015-05-12 * @author Cay Horstmann */ public class LambdaTest { public static void main(String[] args) { String[] planets = new String[] { "Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune" };//定義陣列planets System.out.println(Arrays.toString(planets));//靜態方法 System.out.println("Sorted in dictionary order:"); Arrays.sort(planets);//Arrays.sort方法接收實驗Lambda類的物件  System.out.println(Arrays.toString(planets)); System.out.println("Sorted by length:"); Arrays.sort(planets, (first, second) -> first.length() - second.length());//Lambda表示式  System.out.println(Arrays.toString(planets)); Timer t = new Timer(1000, event -> System.out.println("The time is " + new Date()));//Lambda表示式  t.start(); // keep program running until user selects "Ok" JOptionPane.showMessageDialog(null, "Quit program?"); System.exit(0); //返回型別  } }

package clone;

import java.util.Date;
import java.util.GregorianCalendar; public class Employee implements Cloneable { //定義三個私有屬性 private String name;//string類在lang包 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 + "]"; } }

 

實驗3: 程式設計練習

l 編制一個程式，將身份證號.txt 中的資訊讀入到記憶體中；

l 按姓名字典序輸出人員資訊；

l 查詢最大年齡的人員資訊；

l 查詢最小年齡人員資訊；

l 輸入你的年齡，查詢身份證號.txt中年齡與你最近人的姓名、身份證號、年齡、性別和出生地；

|查詢人員中是否有你的同鄉

package ID;
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 Main{ private static ArrayList<People> Peoplelist; public static void main(String[] args) { Peoplelist = new ArrayList<>(); Scanner scanner = new Scanner(System.in); File file = new File("D:\\java\\1\\身份證號.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 ID = linescanner.next(); String sex = linescanner.next(); String age = linescanner.next(); String place =linescanner.nextLine(); People People = new people(); People.setname(name); People.setID(ID); People.setsex(sex); int a = Integer.parseInt(age); People.setage(a); People.setbirthplace(place); Peoplelist.add(People); } } catch (FileNotFoundException e) { System.out.println("查詢不到資訊"); e.printStackTrace(); } catch (IOException e) { System.out.println("資訊讀取有誤"); e.printStackTrace(); } boolean isTrue = true; while (isTrue) { System.out.println("————————————————————————————————————————"); System.out.println("1:按姓名字典序輸出人員資訊"); System.out.println("2:查詢最大年齡人員資訊和最小年齡人員資訊"); System.out.println("3：輸入你的年齡,查詢年齡與你最近人的所有資訊"); System.out.println("4:查詢人員中是否有你的同鄉"); int nextInt = scanner.nextInt(); switch (nextInt) { case 1: Collections.sort( Peoplelist); System.out.println( Peoplelist.toString()); break; case 2: int max=0,min=100;int j,k1 = 0,k2=0; for(int i=1;i< Peoplelist.size();i++) { j= Peoplelist.get(i).getage(); if(j>max) { max=j; k1=i; } if(j<min) { min=j; k2=i; } } System.out.println("年齡最大："+ Peoplelist.get(k1)); System.out.println("年齡最小："+ Peoplelist.get(k2)); break; case 3: System.out.println("place?"); String find = scanner.next(); String place=find.substring(0,3); String place2=find.substring(0,3); for (int i = 0; i < Peoplelist.size(); i++) { if( Peoplelist.get(i).getbirthplace().substring(1,4).equals(place)) System.out.println(Peoplelist.get(i)); } break; case 4: System.out.println("年齡："); int yourage = scanner.nextInt(); int near=agenear(yourage); int d_value=yourage-Peoplelist.get(near).getage(); System.out.println(""+Peoplelist.get(near)); /* for (int i = 0; i < Peoplelist.size(); i++) { int p=Personlist.get(i).getage()-yourage; if(p<0) p=-p; if(p==d_value) System.out.println(Peoplelist.get(i)); } */ break; case 5: isTrue = false; System.out.println("退出程式!"); break; default: System.out.println("輸入有誤"); } } } public static int agenear(int age) { int min=25,d_value=0,k=0; for (int i = 0; i < Peoplelist.size(); i++) { d_value= Peoplelist.get(i).getage()-age; if(d_value<0) d_value=-d_value; if (d_value<min) { min=d_value; k=i; } } return k; } }

 

package ID;
public abstract class  People implements Comparable<People> { private String name; private String ID; private int age; private String sex; private String birthplace; public String getname() { return name; } public void setname(String name) { this.name = name; } public String getID() { return ID; } public void setID(String ID) { this.ID= ID; } public int getage() { return age; } public void setage(int age) { // int a = Integer.parseInt(age); this.age= age; } public String getsex() { return sex; } public void setsex(String sex) { this.sex= sex; } public String getbirthplace() { return birthplace; } public void setbirthplace(String birthplace) { this.birthplace= birthplace; } public int compareTo(People o) { return this.name.compareTo(o.getname()); } public String toString() { return name+"\t"+sex+"\t"+age+"\t"+ID+"\t"+birthplace+"\n"; } }

結果如下：

實驗4：內部類語法驗證實驗

實驗程式1：

l 編輯、除錯執行教材246頁-247頁程式6-7，結合程式執行結果理解程式；

l 瞭解內部類的基本用法。

package innerClass;

import java.awt.*;
import java.awt.event.*; import java.util.*; import javax.swing.*; import javax.swing.Timer; /** * This program demonstrates the use of inner classes. * @version 1.11 2015-05-12 * @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 user selects "Ok" JOptionPane.showMessageDialog(null, "Quit program?"); System.exit(0);//  } } /** * A clock that prints the time in regular intervals. */ class 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) { this.interval = interval; this.beep = beep; }//構造方法 /** * Starts the clock. */ public void start() { ActionListener listener = new TimePrinter(); Timer t = new Timer(interval, listener); t.start(); } public class TimePrinter implements ActionListener//實現ActionListener的公共類TimePrinter  { public void actionPerformed(ActionEvent event) { System.out.println("At the tone, the time is " + new Date()); if (beep) Toolkit.getDefaultToolkit().beep(); } } }

結果如下：

實驗程式2：

l 編輯、除錯執行教材254頁程式6-8，結合程式執行結果理解程式；

瞭解匿名內部類的用法。

package anonymousInnerClass;

import java.awt.*;
import java.awt.event.*; import java.util.*; import javax.swing.*; import javax.swing.Timer; /** * This program demonstrates anonymous inner classes. * @version 1.11 2015-05-12 * @author Cay Horstmann */ public class AnonymousInnerClassTest { public static void main(String[] args) { TalkingClock clock = new TalkingClock();//TalkingClock類宣告為私有的 clock.start(1000, true); // keep program running until 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) { ActionListener listener = new ActionListener() { public void actionPerformed(ActionEvent event) { System.out.println("At the tone, the time is " + new Date()); if (beep) Toolkit.getDefaultToolkit().beep(); //外圍類引用.  } }; Timer t = new Timer(interval, listener); t.start(); } }

結果如下：

實驗程式3：

l 在elipse IDE中除錯執行教材257頁-258頁程式6-9，結合程式執行結果理解程式；

瞭解靜態內部類的用法。

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) { double[] d = new double[20]; for (int i = 0; i < d.length; i++) d[i] = 100 * Math.random();//演算法 ArrayAlg.Pair p = ArrayAlg.minmax(d); 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); } }

結果如下：

 

實驗總結：

      通過本次實驗，以及上一週的學習，我初步對介面有了瞭解和認識，通過實驗驗證了介面在程式的作用，也學習到了在程式中如何定義介面的方法，也掌握了Comparator介面用法，但還是需要大量的理解程式和編寫此類程式才能運用好這種介面，也能在此基礎上掌握更多介面用法，對於物件淺層拷貝與深層拷貝的方法還不是很理解，希望在這周通過學習以及老師和學長的講解中徹底的能理解解決這個問題。