201871010119-帖佼佼《面向對象程序設計（java）》第7周學習總結

時間  2019-11-08
標籤 佼佼 面向對象程序設計（java） 7周 學習 總結 欄目 軟件設計 简体版
原文   原文鏈接

博文正文開頭格式：（2分）html

項目java

內容編程

這個做業屬於哪一個課程數組

 https://www.cnblogs.com/nwnu-daizh/ide

這個做業的要求在哪裏函數

   https://www.cnblogs.com/nwnu-daizh/p/11435127.html工具

做業學習目標post
  1. 掌握四種訪問權限修飾符的使用特色；
  2. 掌握Object類的用途及經常使用API；
  3. 掌握ArrayList類的定義方法及用途；
  4. 掌握枚舉類定義方法及用途；
  5. 結合本章實驗內容，理解繼承與多態性兩個面向對象程序設計特徵，並體會其優勢。

實驗內容和步驟學習

實驗1：在「System.out.println(...);」語句處按註釋要求設計代碼替換...，觀察代碼錄入中IDE提示，以驗證四種權限修飾符的用法。（20分）測試

　　實驗代碼以下：

package ppp;

class Parent {
	private String p1 = "這是Parent的私有屬性";
	public String p2 = "這是Parent的公有屬性";
	protected String p3 = "這是Parent受保護的屬性";
	String p4 = "這是Parent的默認屬性";
	private void pMethod1() {
		System.out.println("我是Parent用private修飾符修飾的方法");
	}
	public void pMethod2() {
		System.out.println("我是Parent用public修飾符修飾的方法");
	}
	protected void pMethod3() {
		System.out.println("我是Parent用protected修飾符修飾的方法");
	}
	void pMethod4() {
		System.out.println("我是Parent無修飾符修飾的方法");
	}
}
class Son extends Parent{
	private String s1 = "這是Son的私有屬性";
	public String s2 = "這是Son的公有屬性";
	protected String s3 = "這是Son受保護的屬性";
	String s4 = "這是Son的默認屬性";
	public void sMethod1() {
		System.out.println(p2);//分別嘗試顯示Parent類的p一、p二、p三、p4值
		System.out.println("我是Son用public修飾符修飾的方法");
	}
	private void sMethod2() {
		System.out.println("我是Son用private修飾符修飾的方法");
	}
	protected void sMethod() {
		System.out.println("我是Son用protected修飾符修飾的方法");
	}
	void sMethod4() {
		System.out.println("我是Son無修飾符修飾的方法");
	}	
}
public class Demo {
	public static void main(String[] args) {
		Parent parent=new Parent();
		Son son=new Son();
		parent.pMethod2();	//分別嘗試用parent調用Paren類的方法、用son調用Son類的方法	
	}
}

　　Parent的代碼以下：

package com.nwnu.demo1;
public class Parent {
	private String p1 = "這是Parent的私有屬性";
	public String p2 = "這是Parent的公有屬性";
	protected String p3 = "這是Parent受保護的屬性";
	String p4 = "這是Parent的默認屬性";
	private void pMethod1() {
		System.out.println("我是Parent用private修飾符修飾的方法");
	}
	public void pMethod2() {
		System.out.println("我是Parent用public修飾符修飾的方法");
	}
	protected void pMethod3() {
		System.out.println("我是Parent用protected修飾符修飾的方法");
	}
	void pMethod4() {
		System.out.println("我是Parent無修飾符修飾的方法");
	}
}

　　Son的代碼以下：

package com.nwnu.demo2;
import com.nwnu.demo1.Parent;
public class Son extends Parent{
	private String s1 = "這是Son的私有屬性";
	public String s2 = "這是Son的公有屬性";
	protected String s3 = "這是Son受保護的屬性";
	String s4 = "這是Son的默認屬性";
	public void sMethod1() {
		System.out.println(p2);//分別嘗試顯示Parent類的p一、p二、p三、p4值
		System.out.println("我是Son用public修飾符修飾的方法");
	}
	private void sMethod2() {
		System.out.println("我是Son用private修飾符修飾的方法");
	}
	protected void sMethod() {
		System.out.println("我是Son用protected修飾符修飾的方法");
	}
	void sMethod4() {
		System.out.println("我是Son無修飾符修飾的方法");
	}	
}

運行結果以下：

調用p2以及方法2獲得的結果：

調用方法獲得的結果：

調用方法四獲得的結果：

　　　　　　四種權限修飾符的訪問範圍的狀況：

訪問範圍 private friendly（默認） protected public
同一個類 能夠訪問 能夠訪問 能夠訪問 能夠訪問
同一個包內的類 不能夠訪問 能夠訪問 能夠訪問 能夠訪問
不一樣包內的類 不能夠訪問 不能夠訪問 能夠訪問

能夠訪問
不一樣包而且不是子類 不能夠訪問 不能夠訪問 不能夠訪問 能夠訪問

 protected介於public和private之間，只能被類自己的方法和子類訪問，即便子類在不一樣的包中也能夠訪問。

默認訪問的這種修飾符，只能被在同一個包中的類訪問和引用，而不能被其餘包中的類使用，即便其餘包中有該類的子類。

實驗2：測試程序1

l  運行教材程序5-八、5-九、5-10，結合程序運行結果理解程序（教材174頁-177頁）；

實驗代碼以下：

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()
   {
      return name;
   }

   public double getSalary()
   {
      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;   //若是類不相等，則它們不匹配

      // now we know otherObject is a non-null Employee
      Employee other = (Employee) otherObject;     //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 + "]";
   }
}

　　

package equals;

public class Manager extends Employee    //子類Manager類繼承父類Employee類
{
   private double bonus;

   public Manager(String name, double salary, int year, int month, int day)    //Manager構造器
   {
      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;    //檢查是否屬於同一個類
      Manager other = (Manager) otherObject;
      // super.equals checked that this and other belong to the same class
      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;

/**
 * This program demonstrates the equals method.
 * @version 1.12 2012-01-26
 * @author Cay Horstmann
 */
public class EqualsTest
{
   public static void main(String[] args)
   {
      Employee alice1 = new Employee("Alice Adams", 75000, 1987, 12, 15);
      Employee alice2 = alice1;
      Employee alice3 = new Employee("Alice Adams", 75000, 1987, 12, 15);
      Employee 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);

      Manager carl = new Manager("Carl Cracker", 80000, 1987, 12, 15);
      Manager 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());
   }
}

　　運行結果以下：

l  刪除程序中Employee類、Manager類中的equals()、hasCode()、toString()方法，背錄刪除方法，在代碼錄入中理解類中重寫Object父類方法的技術要點。（15分）

Employee類重寫後代碼以下：

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()
   {
      return name;
   }

   public double getSalary()
   {
      return salary;
   }

   public LocalDate getHireDay()
   {
      return hireDay;
   }

   public void raiseSalary(double byPercent)
   {
      double raise = salary * byPercent / 100;   //定義局部變量
      salary += raise;
   }

@Override
public int hashCode() {   //重寫hashCode方法，使相等的兩個對象獲取的HashCode也相等
	// TODO Auto-generated method stub
	return Objects.hash(name, salary, hireDay);
}

@Override
public boolean equals(Object obj) {
	// TODO Auto-generated method stub
	if (this == obj) return true;     //快速測試幾個類的根是否相同，便是否是同一個超類。這個if語句判斷兩個引用是不是同一個，若是是同一個，那麼這兩個對象確定相等。
	if (obj == null) return false;   //若是顯示參數爲空，則返回false
	if (getClass() !=obj.getClass()) return false;   //用getClass（）方法獲得對象的類。若是幾個類不匹配，則它們不相等

    //其餘對象是非空Employee類
    //在以上判斷完成，再將獲得的參數對象強制轉換爲該對象，考慮到父類引用子類的對象的出現，而後再判斷對象的屬性是否相同
    Employee other = (Employee) obj;
    //測試字段是否具備相同的值
    return Objects.equals(name, other.name) && salary == other.salary && Objects.equals(hireDay, other.hireDay);
 }


@Override
public String toString() {  //把其餘類型的數據轉爲字符串類型的數據（toString方法能夠自動生成）
	// TODO Auto-generated method stub
	return getClass().getName() + "[name=" + name + ",salary=" + salary + ",hireDay=" + hireDay + "]";
}

}

　　Manager類重寫以後代碼以下：

package equals;

public class Manager extends Employee     //子類：Manager類繼承Employee類
{
   private double bonus;     //建立私有屬性bouns

   public Manager(String name, double salary, int year, int month, int day)
   {
      super(name, salary, year, month, day);    //子類直接調用超類中已建立的屬性
      bonus = 0;      //給bouns賦初值爲空
   }

   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;
      Manager other = (Manager) otherObject;
       //使用super.equals檢查這個類和其餘是否屬於同一個類
      return bonus == other.bonus;
   }

   public int hashCode()    //重寫hashCode方法，使相等的兩個對象獲取的HashCode也相等
   {
      return java.util.Objects.hash(super.hashCode(), bonus);
   }

   public String toString()    //把其餘類型的數據轉爲字符串類型的數據（toString方法能夠自動生成）
   {
      return super.toString() + "[bonus=" + bonus + "]";
   }
}

　　EmployeeTest類代碼以下：

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)
   {
      Employee alice1 = new Employee("Alice Adams", 75000, 1987, 12, 15);
      Employee alice2 = alice1;
      Employee alice3 = new Employee("Alice Adams", 75000, 1987, 12, 15);
      Employee 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);

      Manager carl = new Manager("Carl Cracker", 80000, 1987, 12, 15);
      Manager 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());
   }
}

　　運行結果以下：

一、equals方法：

　　Object類中的equals方法用於檢測某個對象是否同另外一個對象相等。它在Object類中的實現是判斷兩個對象是否相等的引用。若是兩個對象具備相同的引用，它們必定是相等的；

　　若是須要檢測兩個對象狀態的相等性，就須要在新類的定義中須要覆蓋equals方法；

　　定義子類的equals方法時，可調用超累的equals方法；

　　　　super. equals (otherObjecct)

二、hashCode方法：

　　Object類中的哈hashCode方法導出某個對象的散列碼。散列碼時任意整數，表示dui過的存儲地址；

　　兩個相等對象的散列碼相等。

三、toString方法：

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

　　定義子類的toString方法時，可先調用超類的toString方法；

　　super.toString()

　　toString方法是很是重要的調試工具。標準類庫中，多數類定義了toString方法，以便用戶得到對象狀態的必要信息。

實驗2：測試程序2   

l  在elipse IDE中調試運行程序5-11（教材182頁），結合程序運行結果理解程序；

l  掌握ArrayList類的定義及用法；

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

實驗代碼以下：

package arrayList;

import java.util.*;

/**
 * This program demonstrates the ArrayList class.
 * @version 1.11 2012-01-26
 * @author Cay Horstmann
 */
public class ArrayListTest
{
   public static void main(String[] args)
   {
      // fill the staff array list with three Employee objects
      ArrayList<Employee> staff = new ArrayList<Employee>();   //用三個Employee對象填充數組

      staff.add(new Employee("Carl Cracker", 75000, 1987, 12, 15));
      staff.add(new Employee("Harry Hacker", 50000, 1989, 10, 1));
      staff.add(new Employee("Tony Tester", 40000, 1990, 3, 15));

      // raise everyone's salary by 5% 
      for (Employee e : staff)    //把每一個人的薪資提升%5
         e.raiseSalary(5);

      // print out information about all Employee objects
      for (Employee e : staff)   //輸出全部僱員對象的信息
         System.out.println("name=" + e.getName() + ",salary=" + e.getSalary() + ",hireDay=" 
            + e.getHireDay());    //利用getName()，getSalary() 和getHireDay()方法輸出全部僱員對象的信息
   }
}

　　

package arrayList;

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)   //Employee構造器
   {
      this.name = name; 
      this.salary = salary;
      hireDay = LocalDate.of(year, month, day);
   }

   public String getName()
   {
      return name;
   }

   public double getSalary()
   {
      return salary;
   }

   public LocalDate getHireDay()
   {
      return hireDay;
   }

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

　　運行結構以下：

l  設計適當的代碼，測試ArrayList類的set()、get()、remove()、size()等方法的用法。（15分）

實驗代碼以下：

package arrayList;

import java.util.*;

/**
 * This program demonstrates the ArrayList class.
 * @version 1.11 2012-01-26
 * @author Cay Horstmann
 */
public class ArrayListTest
{
   private static final Employee element = null;
   private static final int index = 0;

   public static void main(String[] args)
   {
      // fill the staff array list with three Employee objects
      ArrayList<Employee> staff = new ArrayList<Employee>();   //用三個Employee對象填充數組

      staff.add(new Employee("Carl Cracker", 75000, 1987, 12, 15));
      staff.add(new Employee("Harry Hacker", 50000, 1989, 10, 1));
      staff.add(new Employee("Tony Tester", 40000, 1990, 3, 15));
      ArrayList<Employee> list = new ArrayList<Employee>(); 
      
    //size()的用法
      int size=staff.size();
      System.out.println("arrayList中的元素個數是："+size);
      for(int i=0;i<staff.size();i++)
      {
          //get()的用法
          Employee e=staff.get(i);
          System.out.println("name=" + e.getName() + ",salary=" + e.getSalary() + ",hireDay=" 
                    + e.getHireDay());
      }
      //set()的用法
      staff.set(0, new Employee("llx", 20000, 1999, 11, 06));
      Employee e=staff.get(0);
      System.out.println("修改後的數據爲：name=" + e.getName() + ",salary=" + e.getSalary() + ",hireDay=" 
                + e.getHireDay());
      
      //remove()的用法
      staff.remove(2);
      System.out.println("將第一個數據刪除後：");
      int size1=staff.size();
      System.out.println("arrayList中的元素個數是："+size1);
      for(int i=0;i<staff.size();i++)
      {
          Employee p=staff.get(i);
          System.out.println("name=" + p.getName() + ",salary=" + p.getSalary() + ",hireDay=" 
                    + p.getHireDay());
      }
     
      // raise everyone's salary by 5% 
      for (Employee e1 : staff)    //把每一個人的薪資提升%5
         e1.raiseSalary(5);

      // print out information about all Employee objects
      for (Employee e1 : staff)   //輸出全部僱員對象的信息
         System.out.println("name=" + e1.getName() + ",salary=" + e1.getSalary() + ",hireDay=" 
            + e1.getHireDay());    //利用getName()，getSalary() 和getHireDay()方法輸出全部僱員對象的信息
   }
}

　　運行結果以下：

1五、泛型數組列表：

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

　　ArrayList是一個採用類型參數的泛型類。爲指定數組列表保存元素的對象類型，須要用一對尖括號將數組元素的對象類名括起來加在後面；

　　沒有<>的ArrayList類將被認爲是一個刪去了類型參數的「原始」類型。

1六、數組列表的操做：

　　ArrayList的定義：ArrayList<T> 對象 = new ArrayList<T>（）；

　　API：

　　（1）ArrayList的構造器

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

　　　　——ArrayList<T>（int  initialCapacity）構造一個具備指定容量的空數組列表；

　　（2）添加新元素：

　　API：boolean   add（T obj）把元素obj追加到數組列表的結尾；

　　（3）統計個數：

　　API：int size（）      返回數組列表中當前元素的個數；

　　（4）調整大小：

　　API：void trimToSize（）    把數組列表的存儲空間調整到當前的大小；

　　（5）訪問：

　　API：void Set（int  index， T obj）   將obj放入到數組列表index的位置，將覆蓋這個位置原來的內容；

　　API：T get（int index）       將得到指定位置index的元素值；

　　（6）增長與刪除：

　　API:boolean   add（T obj）              向後移動元素，在第n個位置插入obj；

　　API：T   remove（int   index）         將第n個位置存放的對象刪除，並將後面的元素向前

實驗2：測試程序3   

l  編輯、編譯、調試運行程序5-12（教材189頁），結合運行結果理解程序；

l  掌握枚舉類的定義及用法；

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

實驗代碼以下：

package enums;

import java.util.*;

/**
 * This program demonstrates enumerated types.
 * @version 1.0 2004-05-24
 * @author Cay Horstmann
 */
public class EnumTest
{  
   public static void main(String[] args)
   {  
      Scanner in = new Scanner(System.in);     //首先構造一個Scanner對象，而且與 「標準輸入流」 System.in關聯
      System.out.print("Enter a size: (SMALL, MEDIUM, LARGE, EXTRA_LARGE) ");   //將該字符串輸出在控制檯上
      String input = in.next().toUpperCase();   //定義一個String類 變量input
      Size size = Enum.valueOf(Size.class, input);
      System.out.println("size=" + size);
      System.out.println("abbreviation=" + size.getAbbreviation());
      if (size == Size.EXTRA_LARGE)   //判斷語句
         System.out.println("Good job--you paid attention to the _.");      
   }
}

enum Size
{
   SMALL("S"), MEDIUM("M"), LARGE("L"), EXTRA_LARGE("XL");

   private Size(String abbreviation) { this.abbreviation = abbreviation; }
   public String getAbbreviation() { return abbreviation; }

   private String abbreviation;
}

　　運行結果以下：

一、建立枚舉類型要使用 Enum 關鍵字。

二、枚舉類對象的屬性不該容許被改動, 因此應該使用 private final 修飾。

三、枚舉類的使用private final 修飾的屬性應該在構造器中爲其賦值。
四、若枚舉類顯式的定義了帶參數的構造器,則在列出枚舉值時也必須對應的傳入參數。

五、枚舉類說明：

　　1）枚舉類是一個類，它的隱含超類是Java.lang.Enum。

　　2）枚舉值並非整型或其餘類型，是被聲明的枚舉類自己實例；

　　3）枚舉類不能有public 修飾的構造函數，構造函數都是隱含private，編譯器自動處理；

　　4）枚舉值隱含都是由public、static、final修飾的，無需本身添加這些修飾符；

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

實驗2：測試程序4   

錄入如下代碼，結合程序運行結果瞭解方法的可變參數用法（5分）

實驗代碼以下：

public class TestVarArgus {  
    public static void dealArray(int... intArray){     //定義爲整型，在下面就只能輸入整型，不能輸入其餘的，例如字符串等等
        for (int i : intArray)  
            System.out.print(i +" ");  
          
        System.out.println();  
    }        
    public static void main(String args[]){  
        dealArray();  
        dealArray(1);  
        dealArray(1, 2, 3); 
        dealArray(1, 2, 3, 4, 5); 
        dealArray(1, 2, 3, 4, 5, 6);
    }  
}

　　運行結果以下：

定義爲字符串類型實驗代碼以下：

public class TestVarArgus {  
    public static void dealArray(String... StringArray){     //定義爲字符串，在下面就只能輸入字符串，不能輸入其餘的，例如整型等等
        for (String string : StringArray)  
            System.out.print(string +" ");  
          
        System.out.println();  
    }        
    public static void main(String args[]){  
        dealArray();  
        dealArray("Welcome to normal university!");  
        dealArray("She hates to go my heaven alone!"); 
        dealArray("It will be yours!"); 
        dealArray("Envy!!!!!!!!!!");
    }  
}

　　運行結果以下：

實驗3：編程練習   參照輸出樣例補全程序，使程序輸出結果與輸出樣例一致。（ 10分）

實驗代碼以下：

public class Demo {
	public static void main(String[] args) {
		Son son = new Son();
		son.method();
	}
}
class Parent {
	Parent() {
		System.out.println("Parent's Constructor without parameter");
	}
	Parent(boolean b) {
		System.out.println("Parent's Constructor with a boolean parameter");
	}
	public void method() {
		System.out.println("Parent's method()");
	}
}
class Son extends Parent {
//補全本類定義
	Son(){
		super(false);
		System.out.println("Son's Constructor without parameter");
	}
	public void method() {
		System.out.println("Son's method()");
		super.method();
	}
}

　　運行結果以下

3. 實驗總結：（15分）

　　在前幾周的學習基礎上，這周接着學習了第五章，相比國慶節前，加深了對繼承類、抽象類以及多態的學習。但對於後面學習的各類方法以及枚舉類等新知識，在學習理論知識時，能夠跟着老師的思路，以爲已經掌握了知識點，但在實驗過程當中發現本身仍是不會運用，肯平時沒有多看書，對基礎知識掌握不到位。對於老師設計的簡單編程題，因爲本身的知識還不夠，所以幾乎不能獨立的作出完整的實驗。因此在之後的學習中，我會多看翁愷老師的視頻以及老師的課件來學習編程，來寫出完整的程序。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程