201871010121 王方《面向對象程序設計（Java）》第6-7周學習總結

時間 2019-11-18

原文原文鏈接

項目html	內容java
這個做業屬於哪一個課程算法	https://www.cnblogs.com/nwnu-daizh/編程
這個做業的要求在哪裏數組	https://www.cnblogs.com/nwnu-daizh/p/11605051.html安全
學習目標ide	深刻理解程序設計中算法與程序的關係深刻理解Java程序設計中類與對象的關係理解OO程序設計中的第二個特徵：繼承、多態學會採用繼承定義類設計程序可以分析與設計至少包含3個自定義類的程序設計掌握利用父類定義子類的語法規則及對象使用要求

第一部分基礎理論知識函數

類、超類和子類

（1）定義子類學習

關鍵字extends表示繼承。測試

以由Employee類來定義Manager類爲例：

Public class Manager extends Employee

{

添加方法和域

}

Extends代表正在構造的新類派生與一個已經存在的類。已存在的類稱爲父類或超類，新類稱爲子類或派生類。子類比超類擁有更加豐富的功能。以上面的例子爲依據：Manager中含有setBonus,於是屬於Employee類的對象不能使用它。然而屬於Manager的對象可使用屬於Employee類中定義的，這是由於子類會自動繼承父類中的方法。所以能夠將通用的方法放在超類中而將具備特殊用法的放在子類中。

（2）覆蓋方法

若是在父類中定義的方法在子類中不適用時，須要提供新的方法來覆蓋父類中的這個方法。當咱們須要調用父類中的某個方法時能夠用關鍵字super來調用。（super只是一個指示編譯器調用超類方法的特殊關鍵字）在子類中能夠增長域，增長方法或覆蓋超類的方法，但是絕對不能刪除繼承的任何域和方法。方法覆蓋只能在不一樣的類中完成。

（3）子類的構造

一般咱們能夠經過super實現對超類構造器的調用。使用super調用構造器的語句必須是子類構造器的第一條語句。若是子類的構造器沒有顯示的調用父類構造器，則將自動的調用父類默認的構造器（沒有參數）若是父類沒有不帶參數的構造器，並且子類沒有其它的構造器，則將顯示程序錯誤。

一個對象變量能夠指示多種實際類型的現象被稱爲多態。在運行時可以自動地選擇調用哪一個方法的現象稱爲動態綁定。

（4）繼承層次

由一個公共父類派生出來的全部類的集合被稱爲繼承層次。在繼承層次中，在某個特定的類到其祖先的路徑被稱爲該類的鏈。一般一個祖先類能夠擁有多個子孫繼承鏈。由一個祖先類派生出來的幾個子類之間能夠沒有任何關係。

（5）多態

「is-a」規則代表每一個子類的對象也是父類的對象，一樣，它也代表程序中出現超類對象的任何地方均可以用子類對象置換。不能將一個超類的引用賦予子類變量。子類數組的

引用能夠轉化成爲父類數組的引用，而不須要強制類型的轉化。

第四章重點概要

（1）類是具備相同屬性和行爲的一組對象的抽象定義，用class來定義，對象是類的實例：

（2）類的語法格式是：對象名.成員名；

（3）使用預約義類要了解該類的API和類所屬的包。

（4）構造函數在建立對象時初始化對象，構造函數課重載；

（5）Static可定義靜態域和靜態方法。

（6）包是分類組織類的主要手段，包對應磁盤上同名的目錄。

（7）類所屬的包課在類內用package來聲明，可用import來導入須要使用類的包。構造方法在對象建立時被調用，用於初始化對象，初始化動做只執行一次；

（8）通常方法需對象建立後被調用執行，能夠被調用屢次。

（9）封裝（面向對象特徵之一）是指隱藏對象的屬性和顯示細節，僅對外提供公共訪問方式，它的好處在於便於對象的使用，提升重用，安全性。

（10）This:表明對象，就是所在方法所屬對象的引用。

——this對象後跟，調用成員屬性和成員方法（通常方法）：

——this對象後面跟上（）調用本類中對應參數的構造方法

（11）static修飾符：

類中屬於全部對象共享的數據或方法，可進行靜態修飾。

被靜態修飾的類成員，能夠直接被類名所調用：類名..靜態成員名

靜態類成員隨着類的加載而加載。

靜態方法只能訪問靜態成員，不能夠訪問非靜態成員。靜態方法中不能使用this,supper關鍵字。

2.繼承

繼承：用已有類來構建新的類的一種機制。當定義了一個新類繼承了一個類時，這個新類就繼承了這個類的方法和域，同時在新類中添加新的方法和域以適應新狀況。

（Java不支持多繼承）一個子類能夠有多個父類，但一個父類只有一個子類。以

如下程序爲例：

圖中關鍵字代表了繼承的特色。

3.多態性

(1)多態性的概念：

a.多態性泛指在程序中同一個符號在不一樣的狀況下有不一樣解釋的狀況。

b.父類中定義的域方法，被子類繼承以後，能夠具備不一樣的數據類型或表現出不一樣的行爲。

C.使在父類及其各個子類中同名的域或方法具備不一樣的語義。

d.父類的方法能夠在子類重寫

(2)多態性的示例：

shape類自行定義示例

調用父類方法和調用子類方法的關鍵詞

父類：rectObj.getPerimeter();

子類：sqObj.getPerimeter();

4.抽象類

（1）觀察類的繼承層次結構，位於上層的累更具備通用性，甚至更加抽象。

定義抽象類的方法（關鍵字）示例：

abstract class Person

{

Public abstract String getDescription();

......

}

abstract方法只能聲明，不能實現！

（2）爲了提升程序清晰度，包含一個或多個抽象方法的類自己必須被聲明爲抽象類。除了抽象方法以外，抽象類還能夠包含具體數據和具體方法。

（3）抽象方法還充當着佔位的角色，他們的具體實如今子類中。

（4）抽象類不能被實例化，既不能建立對象，只能產生子類。能夠建立抽象類的對象變量，只是這個變量必須指向它的非抽象子類的對象。

5.動態綁定

動態綁定又稱爲運行時綁定，即在運行程序時會自動選擇調用哪一個方法。

Public class Son extends Father

{......}

Son son=new Son();

Son.method();

6.調用方法的執行過程

首先，編譯器檢查對象的聲明類型和方法名，找出全部訪問屬性爲public和method的方法。

編譯器檢查方法調用中提供的參數類型，找出一個徹底匹配方法，這個過程稱爲重載解析。

若是方法是private、static、final修飾的，或者是構造器，那麼編譯器能準確的判斷應該調用哪一個方法，這成爲靜態綁定。程序運行時如今子類找相應方法，

若是子類沒有定義的相應的方法，則在父類的method()中尋找。

方法的名稱和參數列表稱爲方法的簽名。

7.阻止繼承：final類和方法

不容許繼承的類稱爲final類，在類的定義中用final修飾符加以說明。

Final class Executive extends Manager

{......}

類的方法可定義爲final的。這是子類就不能用覆蓋方法。

若是一個類聲明爲final，屬於它的方法會被自動設爲final，但不包括域（若是域定義爲Final,在對象構造之後就不能修改）

Private final int Max=100;

String類是final的一個例子。不能狂戰該類。

8.強制類型轉換

若是要把一個超累對象賦給一個子類對象變量，就必須進行強制類型轉化，格式爲

子類對象 = （子類）（超類對象）

9.訪問權限修飾符

10.訪問修飾符示例

11.訪問修飾符可訪問性

12.Object:全部類的超類

Object是Java全部類的祖先——每個類都由它開展而來，在不給出超累的狀況下，Java會自動把Object做爲要定義的超類。可使用類型爲Object的變量指向任意類型的變量。

13.equals方法：用來檢測兩個對象狀態的相等性時須要在心類中定義須要覆蓋equals方法。

定義子類的equals方法時，可調用超累的equals方法：super.equals(otherObject)

14.toString方法

Object類的toString方法返回一個表明該對象值域的字符串。

定義子類的toString方法時，可先調用超類的toString方法。例Super.toString()

15.泛型數組列表

Java中，利用ArrayList類，可容許程序在運行時肯定數組的大小。

ArrayList是一個採用參數類型的泛型類。爲指定數組列表保存元素的對象類型。例：

ArrayList<Employee>staff=new ArrayList<Employee>();

16.ArrayList定義

（1）ArrayList<T>對象=new ArrayList<T>();

例如：ArrayList<Employee>staff=new ArrayList<Employee>();

（2）API：ArrayList的構造器

-ArrayList<T>()構造一個空數組列表

-ArrayList<T>(int initialCapacity)構造一個具備指定容量的空數組列表。

B.一下爲集中狀況：

17.對象包裝器域自動打包

所欲基本數據類型都有與之相對應的預約義類，它們被稱爲對象包裝器。

Integer Long Float Double Short Byte Character Void Booleaan

對象包裝器時不可變的，即一旦構造了包裝器，就不容許更改包裝在其中的值。且對象包裝器仍是final，所以不能定義他們的子類。

使用對象包裝器的好處：

-羈絆對象轉換爲對象

-定義一些有用的基本方法（Static方法）

將能夠自動的將基本數據類型轉換爲包裝器的對象稱爲自動打包。

打包和拆包時編譯器承認的。

18.參數數量可變的方法

用戶本身能夠定義可變參數的方法，並將參數指定爲任意類型，甚至是基本類型。例：

19.枚舉類

（1）聲明枚舉類

例 Public enum Grade(A,B,C,D,E) 它包括一個關鍵字enum。

（2）枚舉類是一個類，它的隱含超類是Java.Lang.Enum.

枚舉類並非整數類型或其餘類型，是被聲明的枚舉類的自身實例。

枚舉類不能有public修飾的構造函數，構造函數都是隱含praviate，編譯器自動處理。枚舉值隱含都是由public、static、final修飾的，無需本身添加這些修飾符。

在比較兩個枚舉類型的值時，永遠不須要調用equals方法，直接使用「==」進行相等比較。

（3）爲枚舉類增長構造函數

第二部分實驗部分

一、實驗目的與要求

(1) 理解繼承的定義；
(2) 掌握子類的定義要求
(3) 掌握多態性的概念及用法；
(4) 掌握抽象類的定義及用途。

實驗1：導入第5章示例程序，測試並進行代碼註釋。

測試程序1：

在elipse IDE中編輯、調試、運行程序5-1 —5-3（教材152頁-153頁）；

掌握子類的定義及用法；

結合程序運行結果，理解並總結OO風格程序構造特色，理解Employee和Manager類的關係子類的用途，並在代碼中添加註釋；

刪除程序中Manager類、ManagerTest類，背錄刪除類的程序代碼，在代碼錄入中理解父類與子類的關係和使用特色。

5-1程序源代碼爲：

package inheritance;

/**
 * This program demonstrates inheritance.
 * @version 1.21 2004-02-21
 * @author Cay Horstmann
 */
public class ManagerTest
{
   public static void main(String[] args)
   {
      // construct a Manager object
      var boss = new Manager("Carl Cracker", 80000, 1987, 12, 15);
      boss.setBonus(5000);//建立一個新經理，並設置他的獎金，setBonus屬於manager的特有方法

      var staff = new Employee[3];//定義一個包含三個僱員的數組

      // fill the staff array with Manager and Employee objects

      staff[0] = boss;
      staff[1] = new Employee("Harry Hacker", 50000, 1989, 10, 1);
      staff[2] = new Employee("Tommy Tester", 40000, 1990, 3, 15);
      //父類引用子類對象；並將經理和僱員放入數組中
      // print out information about all Employee objects
      for (Employee e : staff)
         System.out.println("name=" + e.getName() + ",salary=" + e.getSalary());
      //輸出每一個人的姓名及薪水
   }
}

輸出結果截圖爲：

5-2程序代碼爲：

package inheritance;

import java.time.*;

public class Employee
{
   private String name;
   private double salary;
   private LocalDate hireDay; //構建成員變量
   //構造器
   public Employee(String name, double salary, int year, int month, int day)
   {
      this.name = name;
      this.salary = salary;
      hireDay = LocalDate.of(year, month, day);
   }
   //域訪問器 
   public String getName()//取得name這個屬性的值
   {
      return name;
   }

   public double getSalary()//取得Salary這個屬性的值
   {
      return salary;
   }

   public LocalDate getHireDay()
   {
      return hireDay;
   }

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

輸出結果截圖爲：

5-3程序代碼爲：

package inheritance;

public class Manager extends Employee
{
   private double bonus;

   /**
    * @param name the employee's name
    * @param salary the salary
    * @param year the hire year
    * @param month the hire month
    * @param day the hire day
    */
 //構造器
   public Manager(String name, double salary, int year, int month, int day)
   {
      super(name, salary, year, month, day);//調用超類構造器
      bonus = 0;
   }

   public double getSalary()
   {
      double baseSalary = super.getSalary();//進行重定義
      return baseSalary + bonus;
   }

   public void setBonus(double b)
   {
      bonus = b;
   }
}

輸出結果截圖爲：

刪除類的程序代碼爲：

package inheritance;

public class Manager extends Employee    
{

    private int bouns;

    public Manager(String name, double salary, int year, int month, int day) {
        super(name, salary, year, month, day);
        // TODO Auto-generated constructor stub
        bouns=0;
    }

    public int getBouns() {
        return bouns;
    }

    public void setBouns(int bouns) {
        this.bouns = bouns;
    }

    @Override
    public double getSalary() {
        // TODO Auto-generated method stub
        return super.getSalary();
    }
 
}

關鍵在於@Override，它的引入爲在source裏面點Override，而後引入程序中須要的，例如上面程序中繼承的爲父類的getSalary()。繼承的有點在因而程序看起來整潔，清晰。

輸出結果截圖爲：

測試程序2：

編輯、編譯、調試運行教材PersonTest程序（教材163頁-165頁)；

掌握超類的定義及其使用要求；

掌握利用超類擴展子類的要求；

在程序中相關代碼處添加新知識的註釋；

刪除程序中Person類、PersonTest類，背錄刪除類的程序代碼，在代碼錄入中理解抽象類與子類的關係和使用特色。

5-4的程序代碼爲：

package abstractClasses;

/**
 * This program demonstrates abstract classes.
 * @version 1.01 2004-02-21
 * @author Cay Horstmann
 */
public class PersonTest
{
   public static void main(String[] args)
   {
      var people = new Person[2];//超類

      // fill the people array with Student and Employee objects
      people[0] = new Employee("Harry Hacker", 50000, 1989, 10, 1);
      people[1] = new Student("Maria Morris", "computer science");//子類；將僱員和學生填充到Person引用數組

      // print out names and descriptions of all Person objects
      for (Person p : people)
         System.out.println(p.getName() + ", " + p.getDescription());//輸出對象的姓名和星描述
   }
}

輸出結果截圖爲：

5-5程序代碼爲：

package abstractClasses;
//定義一個抽象類Person
public abstract class Person
{
   public abstract String getDescription();
   private String name;

   public Person(String name)
   {
      this.name = name;
   }

   public String getName()
   {
      return name;
   }
}

輸出結果截圖爲：

5-6程序代碼爲：

package abstractClasses;

import java.time.*;//導入java.time包

public class Employee extends Person
{
   private double salary;
   private LocalDate hireDay;//構建成員變量
    //構造器
   public Employee(String name, double salary, int year, int month, int day)
   {
      super(name);   //使用關鍵字super調用超類
      this.salary = salary;//this:當前對象
      hireDay = LocalDate.of(year, month, day);
   }
    //域訪問器 
   public double getSalary()
   {
      return salary;
   }

   public LocalDate getHireDay()
   {
      return hireDay;
   }

   public String getDescription()
   {
      return String.format("an employee with a salary of $%.2f", salary);
   }

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

輸出結果截圖爲：

5-7程序代碼爲：

package abstractClasses;

public class Student extends Person
{
   private String major;

   /**
    * @param name the student's name
    * @param major the student's major
    */
   public Student(String name, String major)
   {
      // pass name to superclass constructor
      super(name);
      this.major = major;
   }

   public String getDescription()
   {
      return "a student majoring in " + major;
   }
}

輸出結果截圖爲：

刪除類的程序爲：

package abstractClasses;
import java.time.*;
public class Employee extends Person
{
   public Employee(String name) {
        super(name);
        // TODO Auto-generated constructor stub
    }
private double salary;
   private LocalDate hireDay;
@Override
public String getDescription() {
    // TODO Auto-generated method stub
    return String.format("an employee with a salary of $%.2f", salary);
}
@Override
protected Object clone() throws CloneNotSupportedException {
    // TODO Auto-generated method stub
    return super.clone();
}
@Override
public boolean equals(Object obj) {
    // TODO Auto-generated method stub
    return super.equals(obj);
}
@Override
protected void finalize() throws Throwable {
    // TODO Auto-generated method stub
    super.finalize();
}
@Override
public int hashCode() {
    // TODO Auto-generated method stub
    return super.hashCode();
}
@Override
public String toString() {
    // TODO Auto-generated method stub
    return super.toString();
}
public double getSalary() {
    return salary;
}
public void setSalary(double salary) {
    this.salary = salary;
}
public LocalDate getHireDay() {
    return hireDay;
}
public void setHireDay(LocalDate hireDay) {
    this.hireDay = hireDay;
}
}

同理，在刪除類的程序中，關鍵在於引入@Override，繼承相應的父類方法。

（1）觀察類的繼承層次結構，位於上層的累更具備通用性，甚至更加抽象。

（2）爲了提升程序清晰度，包含一個或多個抽象方法的類自己必須被聲明爲抽象類。除了抽象方法以外，抽象類還能夠包含具體數據和具體方法。

（3）抽象方法還充當着佔位的角色，他們的具體實如今子類中。

（4）抽象類不能被實例化，既不能建立對象，只能產生子類。能夠建立抽象類的對象變量，只是這個變量必須指向它的非抽象子類的對象。

測試程序3：

編輯、編譯、調試運行教材程序5-8、5-9、5-10，結合程序運行結果理解程序（教材174頁-177頁）；

掌握Object類的定義及用法；

在程序中相關代碼處添加新知識的註釋。

5-8程序代碼爲：

package equals;

/**
 * This program demonstrates the equals method.
 * @version 1.12 2012-01-26
 * @author Cay Horstmann
 */
public class EqualsTest
{
   public static void main(String[] args)
   {
      var alice1 = new Employee("Alice Adams", 75000, 1987, 12, 15);//對alice1進行初始化
      var alice2 = alice1;//將alice1的值賦給alice2
      var alice3 = new Employee("Alice Adams", 75000, 1987, 12, 15);//對alice3進行初始化
      var bob = new Employee("Bob Brandson", 50000, 1989, 10, 1);

      System.out.println("alice1 == alice2: " + (alice1 == alice2));

      System.out.println("alice1 == alice3: " + (alice1 == alice3));

      System.out.println("alice1.equals(alice3): " + alice1.equals(alice3));

      System.out.println("alice1.equals(bob): " + alice1.equals(bob));

      System.out.println("bob.toString(): " + bob);

      var carl = new Manager("Carl Cracker", 80000, 1987, 12, 15);
      var boss = new Manager("Carl Cracker", 80000, 1987, 12, 15);
      boss.setBonus(5000);
      System.out.println("boss.toString(): " + boss);
      System.out.println("carl.equals(boss): " + carl.equals(boss));
      System.out.println("alice1.hashCode(): " + alice1.hashCode());
      System.out.println("alice3.hashCode(): " + alice3.hashCode());
      System.out.println("bob.hashCode(): " + bob.hashCode());
      System.out.println("carl.hashCode(): " + carl.hashCode());
   }
}

輸出結果截圖爲：

5-9程序代碼爲：

package equals;

import java.time.*;
import java.util.Objects;

public class Employee
{
   private String name;
   private double salary;
   private LocalDate hireDay; //構建成員變量

   public Employee(String name, double salary, int year, int month, int day)
   {
      this.name = name;
      this.salary = salary;
      hireDay = LocalDate.of(year, month, day);
   }
 //域訪問器 
   public String getName()//取得name這個屬性的值
   {
      return name;
   }

   public double getSalary()//取得Salary這個屬性的值
   {
      return salary;
   }

   public LocalDate getHireDay()
   {
      return hireDay;
   }

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

   public boolean equals(Object otherObject)
   {
      // a quick test to see if the objects are identical
      if (this == otherObject) return true;//判斷兩個引用是不是同一個

      // must return false if the explicit parameter is null
      if (otherObject == null) return false;// // 若參數爲空，則返回false

      // if the classes don't match, they can't be equal
      if (getClass() != otherObject.getClass()) return false;//getClass()：獲得對象的類

      // now we know otherObject is a non-null Employee
      var other = (Employee) otherObject;

      // test whether the fields have identical values
      return Objects.equals(name, other.name) 
         && salary == other.salary && Objects.equals(hireDay, other.hireDay);
   }

   public int hashCode()
   {
      return Objects.hash(name, salary, hireDay); 
   }

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

輸出結果截圖爲：

5-10程序代碼爲：

package equals;

public class Manager extends Employee
{
   private double bonus;

   public Manager(String name, double salary, int year, int month, int day)
   {
      super(name, salary, year, month, day);
      bonus = 0;
   }

   public double getSalary()
   {
      double baseSalary = super.getSalary();
      return baseSalary + bonus;
   }

   public void setBonus(double bonus)
   {
      this.bonus = bonus;
   }

   public boolean equals(Object otherObject)
   {
      if (!super.equals(otherObject)) return false;
      var other = (Manager) otherObject;
      // super.equals checked that this and other belong to the same classs
      //檢查是否屬於同一類
      return bonus == other.bonus;
   }

   public int hashCode()
   {
      return java.util.Objects.hash(super.hashCode(), bonus);
   }

   public String toString()
   {
      return super.toString() + "[bonus=" + bonus + "]";
   }
}
package equals;

public class Manager extends Employee
{
   private double bonus;

   public Manager(String name, double salary, int year, int month, int day)
   {
      super(name, salary, year, month, day);
      bonus = 0;
   }

   public double getSalary()
   {
      double baseSalary = super.getSalary();
      return baseSalary + bonus;
   }

   public void setBonus(double bonus)
   {
      this.bonus = bonus;
   }

   public boolean equals(Object otherObject)
   {
      if (!super.equals(otherObject)) return false;
      var other = (Manager) otherObject;
      // super.equals checked that this and other belong to the same classs
      //檢查是否屬於同一類
      return bonus == other.bonus;
   }

   public int hashCode()
   {
      return java.util.Objects.hash(super.hashCode(), bonus);
   }

   public String toString()
   {
      return super.toString() + "[bonus=" + bonus + "]";
   }
}

輸出結果截圖爲：

Object類的定義及用法：

Object: 全部類的超類，Object是Java全部類的祖先——每個類都由它開展而來，在不給出超累的狀況下，Java會自動把Object做爲要定義的超類。

可使用類型爲Object的變量指向任意類型的變量。

實驗2：編程練習

定義抽象類Shape：

屬性：不可變常量double PI，值爲3.14；

方法：public double getPerimeter()；public double getArea())。

讓Rectangle與Circle繼承自Shape類。

編寫double sumAllArea方法輸出形狀數組中的面積和和double sumAllPerimeter方法輸出形狀數組中的周長和。

main方法中

1）輸入整型值n，而後創建個不一樣的形狀。若是輸入n，則再輸入長和寬。若是輸入，則再輸入半徑。
2）而後輸出全部的形狀的周長之和，面積之和。並將全部的形狀信息以樣例的格式輸出。
3）最後輸出每一個形狀的類型與父類型，使用相似shape.getClass()(得到類型，shape.getClass().getSuperclass()(得到父類型思考sumAllArea和方法放在哪一個類中更合適？

3
rect
1 1
rect
2 2
cir
1
輸出樣例:
18.28
8.14
[Rectangle [width=1, length=1], Rectangle [width=2, length=2], Circle [radius=1]]
class Rectangle,class Shape
class Rectangle,class Shape
class Circle,class Shape

程序代碼爲：

package ;
    import java.util.Scanner;
    public class Test {
     public static void main(String[] args) {
      Scanner in = new Scanner(System.in);
      System.out.println("個數");
      int a = in.nextInt();
      System.out.println("種類");
      String rect="rect";
            String cir="cir";
      Shape[] num=new Shape[a];
      for(int i=0;i<a;i++){
       String input=in.next();
       if(input.equals(rect)) {
       System.out.println("長和寬");
       int length = in.nextInt();
       int width = in.nextInt();
             num[i]=new Rectangle();
             System.out.println("Rectangle["+"length:"+length+"  width:"+width+"]");
             }
       if(input.equals(cir)) {
             System.out.println("半徑");
          int radius = in.nextInt();
          num[i]=new Circle();
          System.out.println("Circle["+"radius:"+radius+"]");
             }
             }
             Test c=new Test();
             System.out.println("求和");
             System.out.println(c.sumAllPerimeter(num));
             System.out.println(c.sumAllArea(num));
             
             for(Shape s:num) {
                 System.out.println(s.getClass()+","+s.getClass().getSuperclass());
                 }
             }
     
               public double sumAllArea(Shape score[])
               {
               double sum=0;
               for(int i=0;i<score.length;i++)
                   sum+= score[i].getArea1();
                   return sum;
               }
               public double sumAllPerimeter(Shape score[])
               {
               double sum=0;
               for(int i=0;i<score.length;i++)
                   sum+= score[i].getPerimeter();
                   return sum;
               }    
    }

package;

public class Shape {

    public double getArea11() {
        // TODO Auto-generated method stub
        return 0;
    }

    public double getPerimeter1() {
        // TODO Auto-generated method stub
        return 0;
    }

    public double getArea1() {
        // TODO Auto-generated method stub
        return 0;
    }

    double getArea() {
        // TODO Auto-generated method stub
        return 0;
    }

    double getPerimeter() {
        // TODO Auto-generated method stub
        return 0;
    }

}