a6

Reviewed-on: https://yongyuancv.cn/git/heimoshuiyu/oop/pulls/12

assignment3/Question1/StartGrading.java

@@ -0,0 +1,74 @@
+public class StartGrading {	
+	public static void testMammal() {
+		Mammal m = new Mammal("some name");
+		System.out.println(m.getName() == "some name");
+		System.out.println(m.isCookable() == false); // Message printed too.
+	}
+
+	public static void testHuman() {
+		Human h = new Human();
+		// getName is inherited from Mammal.
+		System.out.println(h.getName() == "Alice");
+		System.out.println(h.isCookable() == false);  // No message printed.
+	}
+
+
+	public static void testRabbit() {
+		Rabbit r = new Rabbit("Bugs Bunny", 20.0);
+		// getName is inherited from Mammal.
+		System.out.println(r.getName() == "Bugs Bunny");
+		System.out.println(r.getWeight() == 20.0);
+		System.out.println(r.isCookable() == true);
+	}
+
+
+	public static void testEuropeanRabbit() {
+		// Testing the first constructor.
+		EuropeanRabbit er1 = new EuropeanRabbit("black bunny", 3.0);
+		// getName is inherited from Mammal.
+		System.out.println(er1.getName() == "black bunny");
+		// getWeight is inherited from Rabbit.
+		System.out.println(er1.getWeight() == 3.0);
+		// isCookable is inherited from Rabbit.
+		System.out.println(er1.isCookable() == true);
+		// Testing the second constructor.
+		EuropeanRabbit er2 = new EuropeanRabbit("white rabbit");
+		// getName is inherited from Mammal.
+		System.out.println(er2.getName() == "white rabbit");
+		// getWeight is inherited from Rabbit.
+		System.out.println(er2.getWeight() == 2.0);
+		// isCookable is inherited from Rabbit.
+		System.out.println(er2.isCookable() == true);
+	}
+
+	public static void testLapinSauteChasseur() {
+		LapinSauteChasseur lsc = new LapinSauteChasseur();
+		// getName is inherited from Mammal.
+		System.out.println(lsc.getName() == "Delicious");
+		// getWeight is inherited from Rabbit.
+		System.out.println(lsc.getWeight() == 0.5);
+		// isCookable is inherited from Rabbit.
+		System.out.println(lsc.isCookable() == true);
+	}
+	
+
+	public static void testFrankTheRabbit() {
+		FrankTheRabbit ftr = new FrankTheRabbit();
+		// getName is inherited from Mammal.
+		System.out.println(ftr.getName() == "Frank");
+		// getWeight is inherited from Rabbit.
+		System.out.println(ftr.getWeight() == 100.0);
+		// isCookable is from FrankTheRabbit itself.
+		System.out.println(ftr.isCookable() == false);
+	}
+
+	public static void main(String[] args) {
+		testMammal();
+		testHuman();
+		testRabbit();
+		testEuropeanRabbit();
+		testLapinSauteChasseur();
+		testFrankTheRabbit();
+	}
+
+}

assignment3/Question2/CastIronPot.java

@@ -26,9 +26,9 @@ public class CastIronPot {
 	}
 
 	public static void testCastIronPot() {
-		Rabbit lsc1 = new Rabbit("LSC1", 3.9);
+		LapinSauteChasseur lsc1 = new LapinSauteChasseur();
 		CastIronPot cip = new CastIronPot(lsc1);
-		Rabbit lsc2 = cip.getRabbit();
+		LapinSauteChasseur lsc2 = (LapinSauteChasseur) cip.getRabbit();
 		System.out.println(lsc1 == lsc2);
 	}
 }

assignment3/Question2/StartGrading.java

@@ -0,0 +1,90 @@
+public class StartGrading {	
+	public static void testMammal() {
+		Mammal m = new Mammal("some name");
+		System.out.println(m.getName() == "some name");
+		System.out.println(m.isCookable() == false); // Message printed too.
+	}
+
+	public static void testHuman() {
+		Human h = new Human();
+		// getName is inherited from Mammal.
+		System.out.println(h.getName() == "Alice");
+		System.out.println(h.isCookable() == false);  // No message printed.
+	}
+
+
+	public static void testRabbit() {
+		Rabbit r = new Rabbit("Bugs Bunny", 20.0);
+		// getName is inherited from Mammal.
+		System.out.println(r.getName() == "Bugs Bunny");
+		System.out.println(r.getWeight() == 20.0);
+		System.out.println(r.isCookable() == true);
+	}
+
+
+	public static void testEuropeanRabbit() {
+		// Testing the first constructor.
+		EuropeanRabbit er1 = new EuropeanRabbit("black bunny", 3.0);
+		// getName is inherited from Mammal.
+		System.out.println(er1.getName() == "black bunny");
+		// getWeight is inherited from Rabbit.
+		System.out.println(er1.getWeight() == 3.0);
+		// isCookable is inherited from Rabbit.
+		System.out.println(er1.isCookable() == true);
+		// Testing the second constructor.
+		EuropeanRabbit er2 = new EuropeanRabbit("white rabbit");
+		// getName is inherited from Mammal.
+		System.out.println(er2.getName() == "white rabbit");
+		// getWeight is inherited from Rabbit.
+		System.out.println(er2.getWeight() == 2.0);
+		// isCookable is inherited from Rabbit.
+		System.out.println(er2.isCookable() == true);
+	}
+
+	public static void testLapinSauteChasseur() {
+		LapinSauteChasseur lsc = new LapinSauteChasseur();
+		// getName is inherited from Mammal.
+		System.out.println(lsc.getName() == "Delicious");
+		// getWeight is inherited from Rabbit.
+		System.out.println(lsc.getWeight() == 0.5);
+		// isCookable is inherited from Rabbit.
+		System.out.println(lsc.isCookable() == true);
+	}
+	
+
+	public static void testFrankTheRabbit() {
+		FrankTheRabbit ftr = new FrankTheRabbit();
+		// getName is inherited from Mammal.
+		System.out.println(ftr.getName() == "Frank");
+		// getWeight is inherited from Rabbit.
+		System.out.println(ftr.getWeight() == 100.0);
+		// isCookable is from FrankTheRabbit itself.
+		System.out.println(ftr.isCookable() == false);
+	}
+
+	public static void testCastIronPot() {
+		// In the testCastIronPot method, create a lapin saute chasseur called lsc1...
+		LapinSauteChasseur lsc1 = new LapinSauteChasseur();
+		// then create a cast iron pot with this lapin saute chasseur in it.
+		CastIronPot cip = new CastIronPot(lsc1); // Implicit upcast from LapinSauteChasseur to Rabbit.
+		// Then get the lapin saute chasseur from the cast iron pot...
+		Rabbit r = cip.getRabbit();
+		// and store it into a local variable called lsc2 of type LapinSauteChasseur.
+		LapinSauteChasseur lsc2 = (LapinSauteChasseur)r; // Downcast mandatory!
+		// Use the == operator to check that lsc1 and lsc2 are the same lapin Saute Chasseur.
+		System.out.println(lsc1 == lsc2);
+	}
+
+
+	public static void main(String[] args) {
+		testMammal();
+		testHuman();
+		testRabbit();
+		testEuropeanRabbit();
+		testLapinSauteChasseur();
+		testFrankTheRabbit();
+		testCastIronPot();
+	}
+
+
+}

assignment4/Question1/Course.java

@@ -0,0 +1,113 @@
+/*
+ * Author: CHEN Yongyuan (Walter) 1930006025 from OOP(1007)
+ * Date: 2022-04-18
+ * Description: This is the Course class.
+ */
+
+public abstract class Course {
+	/**
+	 * The code of the course.
+	 */
+	private String code;
+
+	/**
+	 * The title of the course.
+	 */
+	private String title;
+
+	/**
+	 * The pre-requisite of the course.
+	 *
+	 * A course always has only one pre-requisite course and the pre-requisite
+	 * course cannot be null.
+	 *
+	 * @see Course
+	 */
+	private Course preRequisite;
+
+	/**
+	 * Constructor.
+	 *
+	 * @param code         The code of the course.
+	 * @param title        The title of the course.
+	 * @param preRequisite The pre-requisite of the course. If the pre-requisite
+	 *                     course is null, the constructor will print a message of
+	 *                     "pre-requisite course cannot be null!" and return
+	 *                     directly.
+	 */
+	public Course(String code, String title, Course preRequisite) {
+		if (preRequisite == null) {
+			System.out.println("pre-requisite course cannot be null!");
+			return;
+		}
+
+		this.code = code;
+		this.title = title;
+		this.preRequisite = preRequisite;
+	}
+
+	/**
+	 * Get the code of the course.
+	 *
+	 * @return The code of the course.
+	 */
+	public String getCode() {
+		return code;
+	}
+
+	/**
+	 * Get the title of the course.
+	 *
+	 * @return The title of the course.
+	 */
+	public String getTitle() {
+		return title;
+	}
+
+	/**
+	 * Get the pre-requisite of the course.
+	 *
+	 * @return The pre-requisite of the course.
+	 */
+	public Course getPreRequisite() {
+		return preRequisite;
+	}
+
+	/**
+	 * Indicate whether a course is required or not.
+	 *
+	 * One course could either be a required course or a elective course. Some
+	 * courses are required, while the others are not required.
+	 *
+	 * @return True if the course is required, false if the course is not required.
+	 */
+	public abstract boolean isRequired();
+
+	/**
+	 * Test.
+	 */
+	public static void testCourse() {
+		Course mr = new Course("CS101", "Intro to Java", null) {
+			@Override
+			public boolean isRequired() {
+				return true;
+			}
+		};
+		System.out.println(mr.getCode() == null);
+		System.out.println(mr.getTitle() == null);
+		System.out.println(mr.getPreRequisite() == null);
+		System.out.println(mr.isRequired() == true);
+
+		Course me = new Course("CS102", "Intro to Python", mr) {
+			@Override
+			public boolean isRequired() {
+				return false;
+			}
+		};
+		System.out.println(me.getCode() == "CS102");
+		System.out.println(me.getTitle() == "Intro to Python");
+		System.out.println(me.getPreRequisite() == mr);
+		System.out.println(me.isRequired() == false);
+
+	}
+}

assignment4/Question1/Start.java

@@ -0,0 +1,14 @@
+/**
+ * Answer to the questions.
+ *
+ * - Q: What kinds of tests can you write inside the testCourse method?
+ *
+ * - A: You can inherit the Couse class to annonymous class and override the
+ * isRequired() method.
+ */
+
+public class Start {
+	public static void main(String[] args) {
+		Course.testCourse();
+	}
+}

assignment4/Question1/StartGrading.java

@@ -0,0 +1,12 @@
+public class StartGrading {	
+	public static void testCourse() 
+	{ 
+		//  Since we cannot create any Course object,
+		//the testCourse method of the Course class must be empty. 
+	} 
+  
+	public static void main(String[] args)  
+	{ 
+		testCourse(); 
+	} 
+}

assignment4/Question2/Course.java

@@ -0,0 +1,113 @@
+/*
+ * Author: CHEN Yongyuan (Walter) 1930006025 from OOP(1007)
+ * Date: 2022-04-18
+ * Description: This is the Course class.
+ */
+
+public abstract class Course {
+	/**
+	 * The code of the course.
+	 */
+	private String code;
+
+	/**
+	 * The title of the course.
+	 */
+	private String title;
+
+	/**
+	 * The pre-requisite of the course.
+	 *
+	 * A course always has only one pre-requisite course and the pre-requisite
+	 * course cannot be null.
+	 *
+	 * @see Course
+	 */
+	private Course preRequisite;
+
+	/**
+	 * Constructor.
+	 *
+	 * @param code         The code of the course.
+	 * @param title        The title of the course.
+	 * @param preRequisite The pre-requisite of the course. If the pre-requisite
+	 *                     course is null, the constructor will print a message of
+	 *                     "pre-requisite course cannot be null!" and return
+	 *                     directly.
+	 */
+	public Course(String code, String title, Course preRequisite) {
+		if (preRequisite == null) {
+			System.out.println("pre-requisite course cannot be null!");
+			return;
+		}
+
+		this.code = code;
+		this.title = title;
+		this.preRequisite = preRequisite;
+	}
+
+	/**
+	 * Get the code of the course.
+	 *
+	 * @return The code of the course.
+	 */
+	public String getCode() {
+		return code;
+	}
+
+	/**
+	 * Get the title of the course.
+	 *
+	 * @return The title of the course.
+	 */
+	public String getTitle() {
+		return title;
+	}
+
+	/**
+	 * Get the pre-requisite of the course.
+	 *
+	 * @return The pre-requisite of the course.
+	 */
+	public Course getPreRequisite() {
+		return preRequisite;
+	}
+
+	/**
+	 * Indicate whether a course is required or not.
+	 *
+	 * One course could either be a required course or a elective course. Some
+	 * courses are required, while the others are not required.
+	 *
+	 * @return True if the course is required, false if the course is not required.
+	 */
+	public abstract boolean isRequired();
+
+	/**
+	 * Test.
+	 */
+	public static void testCourse() {
+		Course mr = new Course("CS101", "Intro to Java", null) {
+			@Override
+			public boolean isRequired() {
+				return true;
+			}
+		};
+		System.out.println(mr.getCode() == null);
+		System.out.println(mr.getTitle() == null);
+		System.out.println(mr.getPreRequisite() == null);
+		System.out.println(mr.isRequired() == true);
+
+		Course me = new Course("CS102", "Intro to Python", mr) {
+			@Override
+			public boolean isRequired() {
+				return false;
+			}
+		};
+		System.out.println(me.getCode() == "CS102");
+		System.out.println(me.getTitle() == "Intro to Python");
+		System.out.println(me.getPreRequisite() == mr);
+		System.out.println(me.isRequired() == false);
+
+	}
+}

assignment4/Question2/MajorRequired.java

@@ -0,0 +1,46 @@
+/*
+ * Author: CHEN Yongyuan (Walter) 1930006025 from OOP(1007)
+ * Date: 2022-04-18
+ * Description: This is the MajorRequired class which is used to store the major and required courses.
+ */
+
+public class MajorRequired extends Course {
+	/**
+	 * Constructor.
+	 *
+	 * @param code         The code of the course.
+	 * @param title        The title of the course.
+	 * @param preRequisite The pre-requisite of the course. Type of MajorRequired
+	 *                     and cannot be null.
+	 */
+	public MajorRequired(String code, String title, MajorRequired preRequisite) {
+		super(code, title, preRequisite);
+	}
+
+	/**
+	 * MajorRequired course is required for all students.
+	 *
+	 * @return true
+	 */
+	@Override
+	public boolean isRequired() {
+		return true;
+	}
+
+	/**
+	 * Test.
+	 */
+	public static void testMajorRequired() {
+		MajorRequired mr1 = new MajorRequired("COMP3013", "Database Management System", null);
+		System.out.println(mr1.getCode() == null);
+		System.out.println(mr1.getTitle() == null);
+		System.out.println(mr1.getPreRequisite() == null);
+		System.out.println(mr1.isRequired() == true);
+
+		MajorRequired mr2 = new MajorRequired("COMP3013", "Database Management System", mr1);
+		System.out.println(mr2.getCode() == "COMP3013");
+		System.out.println(mr2.getTitle() == "Database Management System");
+		System.out.println(mr2.getPreRequisite() == mr1);
+		System.out.println(mr2.isRequired() == false);
+	}
+}

assignment4/Question2/Start.java

@@ -0,0 +1,20 @@
+/**
+ * Answer to the questions.
+ *
+ * - Q: What kinds of tests can you write inside the testCourse method?
+ *
+ * - A: You can inherit the Couse class to annonymous class and override the
+ * isRequired() method.
+ *
+ * - Q: What kinds of tests can you write inside the testMajorRequired method?
+ *
+ * - A: You can first create a MajorRequired object with null preRequisite and
+ * do the test as normal.
+ */
+
+public class Start {
+	public static void main(String[] args) {
+		Course.testCourse();
+		MajorRequired.testMajorRequired();
+	}
+}

assignment4/Question2/StartGrading.java

@@ -0,0 +1,17 @@
+public class StartGrading {	
+	public static void testCourse() 
+	{ 
+		//  Since we cannot create any Course object,
+		//the testCourse method of the Course class must be empty. 
+	} 
+	public static void testMajorRequired()  
+	{   
+		//Since we cannot create any MajorRequired object,  
+		//the testMajorRequired method of the Course class must be empty. 
+    } 
+	public static void main(String[] args)  
+	{     
+		testCourse(); 
+		testMajorRequired(); 
+	} 
+}

assignment4/Question3/Course.java

@@ -0,0 +1,113 @@
+/*
+ * Author: CHEN Yongyuan (Walter) 1930006025 from OOP(1007)
+ * Date: 2022-04-18
+ * Description: This is the Course class.
+ */
+
+public abstract class Course {
+	/**
+	 * The code of the course.
+	 */
+	private String code;
+
+	/**
+	 * The title of the course.
+	 */
+	private String title;
+
+	/**
+	 * The pre-requisite of the course.
+	 *
+	 * A course always has only one pre-requisite course and the pre-requisite
+	 * course cannot be null.
+	 *
+	 * @see Course
+	 */
+	private Course preRequisite;
+
+	/**
+	 * Constructor.
+	 *
+	 * @param code         The code of the course.
+	 * @param title        The title of the course.
+	 * @param preRequisite The pre-requisite of the course. If the pre-requisite
+	 *                     course is null, the constructor will print a message of
+	 *                     "pre-requisite course cannot be null!" and return
+	 *                     directly.
+	 */
+	public Course(String code, String title, Course preRequisite) {
+		if (preRequisite == null) {
+			System.out.println("pre-requisite course cannot be null!");
+			return;
+		}
+
+		this.code = code;
+		this.title = title;
+		this.preRequisite = preRequisite;
+	}
+
+	/**
+	 * Get the code of the course.
+	 *
+	 * @return The code of the course.
+	 */
+	public String getCode() {
+		return code;
+	}
+
+	/**
+	 * Get the title of the course.
+	 *
+	 * @return The title of the course.
+	 */
+	public String getTitle() {
+		return title;
+	}
+
+	/**
+	 * Get the pre-requisite of the course.
+	 *
+	 * @return The pre-requisite of the course.
+	 */
+	public Course getPreRequisite() {
+		return preRequisite;
+	}
+
+	/**
+	 * Indicate whether a course is required or not.
+	 *
+	 * One course could either be a required course or a elective course. Some
+	 * courses are required, while the others are not required.
+	 *
+	 * @return True if the course is required, false if the course is not required.
+	 */
+	public abstract boolean isRequired();
+
+	/**
+	 * Test.
+	 */
+	public static void testCourse() {
+		Course mr = new Course("CS101", "Intro to Java", null) {
+			@Override
+			public boolean isRequired() {
+				return true;
+			}
+		};
+		System.out.println(mr.getCode() == null);
+		System.out.println(mr.getTitle() == null);
+		System.out.println(mr.getPreRequisite() == null);
+		System.out.println(mr.isRequired() == true);
+
+		Course me = new Course("CS102", "Intro to Python", mr) {
+			@Override
+			public boolean isRequired() {
+				return false;
+			}
+		};
+		System.out.println(me.getCode() == "CS102");
+		System.out.println(me.getTitle() == "Intro to Python");
+		System.out.println(me.getPreRequisite() == mr);
+		System.out.println(me.isRequired() == false);
+
+	}
+}

assignment4/Question3/MajorElective.java

@@ -0,0 +1,45 @@
+/*
+ * Author: CHEN Yongyuan (Walter) 1930006025 from OOP(1007)
+ * Date: 2022-04-18
+ * Description: This is the MajorElective class which is elective for students.
+ */
+
+public class MajorElective extends Course {
+	/**
+	 * Constructor.
+	 *
+	 * @param code         The code of the course.
+	 * @param title        The title of the course.
+	 * @param preRequisite The pre-requisite of the course. Type of MajorElective
+	 *                     and cannot be null.
+	 */
+	public MajorElective(String code, String title, MajorElective preRequisite) {
+		super(code, title, preRequisite);
+	}
+
+	/**
+	 * MajorRequired course is elective for all students.
+	 *
+	 * @return false
+	 */
+	public boolean isRequired() {
+		return false;
+	}
+
+	/**
+	 * Test.
+	 */
+	public static void testMajorElective() {
+		MajorElective pre = new MajorElective("CSC108", "Intro to Programming", null);
+		System.out.println(pre.getCode() == null);
+		System.out.println(pre.getTitle() == null);
+		System.out.println(pre.getPreRequisite() == null);
+		System.out.println(pre.isRequired() == false);
+
+		MajorElective pre2 = new MajorElective("CSC108", "Intro to Programming", pre);
+		System.out.println(pre2.getCode() == "CSC108");
+		System.out.println(pre2.getTitle() == "Intro to Programming");
+		System.out.println(pre2.getPreRequisite() == pre);
+		System.out.println(pre2.isRequired() == false);
+	}
+}

assignment4/Question3/MajorRequired.java

@@ -0,0 +1,46 @@
+/*
+ * Author: CHEN Yongyuan (Walter) 1930006025 from OOP(1007)
+ * Date: 2022-04-18
+ * Description: This is the MajorRequired class which is used to store the major and required courses.
+ */
+
+public class MajorRequired extends Course {
+	/**
+	 * Constructor.
+	 *
+	 * @param code         The code of the course.
+	 * @param title        The title of the course.
+	 * @param preRequisite The pre-requisite of the course. Type of MajorRequired
+	 *                     and cannot be null.
+	 */
+	public MajorRequired(String code, String title, MajorRequired preRequisite) {
+		super(code, title, preRequisite);
+	}
+
+	/**
+	 * MajorRequired course is required for all students.
+	 *
+	 * @return true
+	 */
+	@Override
+	public boolean isRequired() {
+		return true;
+	}
+
+	/**
+	 * Test.
+	 */
+	public static void testMajorRequired() {
+		MajorRequired mr1 = new MajorRequired("COMP3013", "Database Management System", null);
+		System.out.println(mr1.getCode() == null);
+		System.out.println(mr1.getTitle() == null);
+		System.out.println(mr1.getPreRequisite() == null);
+		System.out.println(mr1.isRequired() == true);
+
+		MajorRequired mr2 = new MajorRequired("COMP3013", "Database Management System", mr1);
+		System.out.println(mr2.getCode() == "COMP3013");
+		System.out.println(mr2.getTitle() == "Database Management System");
+		System.out.println(mr2.getPreRequisite() == mr1);
+		System.out.println(mr2.isRequired() == true);
+	}
+}

assignment4/Question3/Start.java

@@ -0,0 +1,26 @@
+/**
+ * Answer to the questions.
+ *
+ * - Q: What kinds of tests can you write inside the testCourse method?
+ *
+ * - A: You can inherit the Couse class to annonymous class and override the
+ * isRequired() method.
+ *
+ * - Q: What kinds of tests can you write inside the testMajorRequired method?
+ *
+ * - A: You can first create a MajorRequired object with null preRequisite and
+ * do the test as normal.
+ *
+ * - Q: What kinds of tests can you write inside the testMajorElective method?
+ *
+ * - A: You can first create a MajorElective object with null preRequisite and
+ * do the test as normal.
+ */
+
+public class Start {
+	public static void main(String[] args) {
+		Course.testCourse();
+		MajorRequired.testMajorRequired();
+		MajorElective.testMajorElective();
+	}
+}

assignment4/Question3/StartGrading.java

@@ -0,0 +1,26 @@
+public class StartGrading {	
+	public static void testCourse() 
+	{ 
+		//  Since we cannot create any Course object, 
+		//the testCourse method of the Course class must be empty. 
+	}
+	
+	public static void testMajorRequired()  
+	{ 
+		//Since we cannot create any MajorRequired object,  
+		//the testMajorRequired method of the Course class must be empty. 
+    } 
+
+	public static void testMajorElective()  
+	{ 
+		//Since we cannot create any MajorElective object, 
+		//the testMajorElective method of the Course class must be empty. 
+	} 
+
+	public static void main(String[] args)  
+	{ 
+		testCourse(); 
+		testMajorElective(); 
+		testMajorRequired(); 
+	} 
+}

assignment4/Question4/Base.java

@@ -0,0 +1,58 @@
+/*
+ * Author: CHEN Yongyuan (Walter) 1930006025 from OOP(1007)
+ * Date: 2022-04-18
+ * Description: This is the Base Class.
+ */
+
+public class Base {
+	private String code;
+	private String title;
+
+	/**
+	 * Constructor
+	 * 
+	 * @param code  The code of the course
+	 * @param title The title of the course
+	 */
+	public Base(String code, String title) {
+		this.code = code;
+		this.title = title;
+	}
+
+	/**
+	 * Getter of code
+	 *
+	 * @return The code of the course
+	 */
+	public String getCode() {
+		return code;
+	}
+
+	/**
+	 * Getter of title
+	 *
+	 * @return The title of the course
+	 */
+	public String getTitle() {
+		return title;
+	}
+
+	/**
+	 * Get the pre-requisite course. It will return itself.
+	 *
+	 * @return this
+	 */
+	public Base getPreRequisite() {
+		return this;
+	}
+
+	/**
+	 * Test.
+	 */
+	public static void testBase() {
+		Base base = new Base("COMP3013", "Database Management System");
+		System.out.println(base.getCode() == "COMP3013");
+		System.out.println(base.getTitle() == "Database Management System");
+		System.out.println(base.getPreRequisite() == base);
+	}
+}

assignment4/Question4/Course.java

@@ -0,0 +1,113 @@
+/*
+ * Author: CHEN Yongyuan (Walter) 1930006025 from OOP(1007)
+ * Date: 2022-04-18
+ * Description: This is the Course class.
+ */
+
+public abstract class Course {
+	/**
+	 * The code of the course.
+	 */
+	private String code;
+
+	/**
+	 * The title of the course.
+	 */
+	private String title;
+
+	/**
+	 * The pre-requisite of the course.
+	 *
+	 * A course always has only one pre-requisite course and the pre-requisite
+	 * course cannot be null.
+	 *
+	 * @see Course
+	 */
+	private Course preRequisite;
+
+	/**
+	 * Constructor.
+	 *
+	 * @param code         The code of the course.
+	 * @param title        The title of the course.
+	 * @param preRequisite The pre-requisite of the course. If the pre-requisite
+	 *                     course is null, the constructor will print a message of
+	 *                     "pre-requisite course cannot be null!" and return
+	 *                     directly.
+	 */
+	public Course(String code, String title, Course preRequisite) {
+		if (preRequisite == null) {
+			System.out.println("pre-requisite course cannot be null!");
+			return;
+		}
+
+		this.code = code;
+		this.title = title;
+		this.preRequisite = preRequisite;
+	}
+
+	/**
+	 * Get the code of the course.
+	 *
+	 * @return The code of the course.
+	 */
+	public String getCode() {
+		return code;
+	}
+
+	/**
+	 * Get the title of the course.
+	 *
+	 * @return The title of the course.
+	 */
+	public String getTitle() {
+		return title;
+	}
+
+	/**
+	 * Get the pre-requisite of the course.
+	 *
+	 * @return The pre-requisite of the course.
+	 */
+	public Course getPreRequisite() {
+		return preRequisite;
+	}
+
+	/**
+	 * Indicate whether a course is required or not.
+	 *
+	 * One course could either be a required course or a elective course. Some
+	 * courses are required, while the others are not required.
+	 *
+	 * @return True if the course is required, false if the course is not required.
+	 */
+	public abstract boolean isRequired();
+
+	/**
+	 * Test.
+	 */
+	public static void testCourse() {
+		Course mr = new Course("CS101", "Intro to Java", null) {
+			@Override
+			public boolean isRequired() {
+				return true;
+			}
+		};
+		System.out.println(mr.getCode() == null);
+		System.out.println(mr.getTitle() == null);
+		System.out.println(mr.getPreRequisite() == null);
+		System.out.println(mr.isRequired() == true);
+
+		Course me = new Course("CS102", "Intro to Python", mr) {
+			@Override
+			public boolean isRequired() {
+				return false;
+			}
+		};
+		System.out.println(me.getCode() == "CS102");
+		System.out.println(me.getTitle() == "Intro to Python");
+		System.out.println(me.getPreRequisite() == mr);
+		System.out.println(me.isRequired() == false);
+
+	}
+}

assignment4/Question4/MajorElective.java

@@ -0,0 +1,45 @@
+/*
+ * Author: CHEN Yongyuan (Walter) 1930006025 from OOP(1007)
+ * Date: 2022-04-18
+ * Description: This is the MajorElective class which is elective for students.
+ */
+
+public class MajorElective extends Course {
+	/**
+	 * Constructor.
+	 *
+	 * @param code         The code of the course.
+	 * @param title        The title of the course.
+	 * @param preRequisite The pre-requisite of the course. Type of MajorElective
+	 *                     and cannot be null.
+	 */
+	public MajorElective(String code, String title, MajorElective preRequisite) {
+		super(code, title, preRequisite);
+	}
+
+	/**
+	 * MajorRequired course is elective for all students.
+	 *
+	 * @return false
+	 */
+	public boolean isRequired() {
+		return false;
+	}
+
+	/**
+	 * Test.
+	 */
+	public static void testMajorElective() {
+		MajorElective pre = new MajorElective("CSC108", "Intro to Programming", null);
+		System.out.println(pre.getCode() == null);
+		System.out.println(pre.getTitle() == null);
+		System.out.println(pre.getPreRequisite() == null);
+		System.out.println(pre.isRequired() == false);
+
+		MajorElective pre2 = new MajorElective("CSC108", "Intro to Programming", pre);
+		System.out.println(pre2.getCode() == "CSC108");
+		System.out.println(pre2.getTitle() == "Intro to Programming");
+		System.out.println(pre2.getPreRequisite() == pre);
+		System.out.println(pre2.isRequired() == false);
+	}
+}

assignment4/Question4/MajorRequired.java

@@ -0,0 +1,46 @@
+/*
+ * Author: CHEN Yongyuan (Walter) 1930006025 from OOP(1007)
+ * Date: 2022-04-18
+ * Description: This is the MajorRequired class which is used to store the major and required courses.
+ */
+
+public class MajorRequired extends Course {
+	/**
+	 * Constructor.
+	 *
+	 * @param code         The code of the course.
+	 * @param title        The title of the course.
+	 * @param preRequisite The pre-requisite of the course. Type of MajorRequired
+	 *                     and cannot be null.
+	 */
+	public MajorRequired(String code, String title, MajorRequired preRequisite) {
+		super(code, title, preRequisite);
+	}
+
+	/**
+	 * MajorRequired course is required for all students.
+	 *
+	 * @return true
+	 */
+	@Override
+	public boolean isRequired() {
+		return true;
+	}
+
+	/**
+	 * Test.
+	 */
+	public static void testMajorRequired() {
+		MajorRequired mr1 = new MajorRequired("COMP3013", "Database Management System", null);
+		System.out.println(mr1.getCode() == null);
+		System.out.println(mr1.getTitle() == null);
+		System.out.println(mr1.getPreRequisite() == null);
+		System.out.println(mr1.isRequired() == true);
+
+		MajorRequired mr2 = new MajorRequired("COMP3013", "Database Management System", mr1);
+		System.out.println(mr2.getCode() == "COMP3013");
+		System.out.println(mr2.getTitle() == "Database Management System");
+		System.out.println(mr2.getPreRequisite() == mr1);
+		System.out.println(mr2.isRequired() == true);
+	}
+}

assignment4/Question4/Start.java

@@ -0,0 +1,27 @@
+/**
+ * Answer to the questions.
+ *
+ * - Q: What kinds of tests can you write inside the testCourse method?
+ *
+ * - A: You can inherit the Couse class to annonymous class and override the
+ * isRequired() method.
+ *
+ * - Q: What kinds of tests can you write inside the testMajorRequired method?
+ *
+ * - A: You can first create a MajorRequired object with null preRequisite and
+ * do the test as normal.
+ *
+ * - Q: What kinds of tests can you write inside the testMajorElective method?
+ *
+ * - A: You can first create a MajorElective object with null preRequisite and
+ * do the test as normal.
+ */
+
+public class Start {
+	public static void main(String[] args) {
+		Course.testCourse();
+		MajorRequired.testMajorRequired();
+		MajorElective.testMajorElective();
+		Base.testBase();
+	}
+}

assignment4/Question4/StartGrading.java

@@ -0,0 +1,38 @@
+public class StartGrading {	
+	public static void testCourse() 
+	{ 
+		//  Since we cannot create any Course object, 
+		//the testCourse method of the Course class must be empty. 
+	}
+	
+	public static void testMajorRequired()  
+	{ 
+		//Since we cannot create any MajorRequired object,  
+		//the testMajorRequired method of the Course class must be empty. 
+    } 
+
+	public static void testMajorElective()  
+	{ 
+		//Since we cannot create any MajorElective object, 
+		//the testMajorElective method of the Course class must be empty. 
+	} 
+
+	public static void testBase()  
+	{ 
+		Base b = new Base("DS1001", "EntryCourse"); 
+		System.out.println(b.getCode() == "DS1001"); 
+		System.out.println(b.getTitle() == "EntryCourse"); 
+		System.out.println(b.getPreRequisite() == b); 
+	} 
+  
+	public static void main(String[] args)  
+	{ 
+		testCourse(); 
+		testMajorElective(); 
+		testMajorRequired(); 
+		testBase(); 
+	} 
+  
+
+  
+} 

assignment4/Question5/Base.java

@@ -0,0 +1,58 @@
+/*
+ * Author: CHEN Yongyuan (Walter) 1930006025 from OOP(1007)
+ * Date: 2022-04-18
+ * Description: This is the Base Class.
+ */
+
+public class Base implements Learnable {
+	private String code;
+	private String title;
+
+	/**
+	 * Constructor
+	 * 
+	 * @param code  The code of the course
+	 * @param title The title of the course
+	 */
+	public Base(String code, String title) {
+		this.code = code;
+		this.title = title;
+	}
+
+	/**
+	 * Getter of code
+	 *
+	 * @return The code of the course
+	 */
+	public String getCode() {
+		return code;
+	}
+
+	/**
+	 * Getter of title
+	 *
+	 * @return The title of the course
+	 */
+	public String getTitle() {
+		return title;
+	}
+
+	/**
+	 * Get the pre-requisite course. It will return itself.
+	 *
+	 * @return this
+	 */
+	public Learnable getPreRequisite() {
+		return this;
+	}
+
+	/**
+	 * Test.
+	 */
+	public static void testBase() {
+		Base base = new Base("COMP3013", "Database Management System");
+		System.out.println(base.getCode() == "COMP3013");
+		System.out.println(base.getTitle() == "Database Management System");
+		System.out.println(base.getPreRequisite() == base);
+	}
+}

assignment4/Question5/Course.java

@@ -0,0 +1,113 @@
+/*
+ * Author: CHEN Yongyuan (Walter) 1930006025 from OOP(1007)
+ * Date: 2022-04-18
+ * Description: This is the Course class.
+ */
+
+public abstract class Course implements Learnable {
+	/**
+	 * The code of the course.
+	 */
+	private String code;
+
+	/**
+	 * The title of the course.
+	 */
+	private String title;
+
+	/**
+	 * The pre-requisite of the course.
+	 *
+	 * A course always has only one pre-requisite course and the pre-requisite
+	 * course cannot be null.
+	 *
+	 * @see Course
+	 */
+	private Learnable preRequisite;
+
+	/**
+	 * Constructor.
+	 *
+	 * @param code         The code of the course.
+	 * @param title        The title of the course.
+	 * @param preRequisite The pre-requisite of the course. If the pre-requisite
+	 *                     course is null, the constructor will print a message of
+	 *                     "pre-requisite course cannot be null!" and return
+	 *                     directly.
+	 */
+	public Course(String code, String title, Learnable preRequisite) {
+		if (preRequisite == null) {
+			System.out.println("pre-requisite course cannot be null!");
+			return;
+		}
+
+		this.code = code;
+		this.title = title;
+		this.preRequisite = preRequisite;
+	}
+
+	/**
+	 * Get the code of the course.
+	 *
+	 * @return The code of the course.
+	 */
+	public String getCode() {
+		return code;
+	}
+
+	/**
+	 * Get the title of the course.
+	 *
+	 * @return The title of the course.
+	 */
+	public String getTitle() {
+		return title;
+	}
+
+	/**
+	 * Get the pre-requisite of the course.
+	 *
+	 * @return The pre-requisite of the course.
+	 */
+	public Learnable getPreRequisite() {
+		return preRequisite;
+	}
+
+	/**
+	 * Indicate whether a course is required or not.
+	 *
+	 * One course could either be a required course or a elective course. Some
+	 * courses are required, while the others are not required.
+	 *
+	 * @return True if the course is required, false if the course is not required.
+	 */
+	public abstract boolean isRequired();
+
+	/**
+	 * Test.
+	 */
+	public static void testCourse() {
+		Course mr = new Course("CS101", "Intro to Java", null) {
+			@Override
+			public boolean isRequired() {
+				return true;
+			}
+		};
+		System.out.println(mr.getCode() == null);
+		System.out.println(mr.getTitle() == null);
+		System.out.println(mr.getPreRequisite() == null);
+		System.out.println(mr.isRequired() == true);
+
+		Course me = new Course("CS102", "Intro to Python", mr) {
+			@Override
+			public boolean isRequired() {
+				return false;
+			}
+		};
+		System.out.println(me.getCode() == "CS102");
+		System.out.println(me.getTitle() == "Intro to Python");
+		System.out.println(me.getPreRequisite() == mr);
+		System.out.println(me.isRequired() == false);
+
+	}
+}

assignment4/Question5/Learnable.java

@@ -0,0 +1,13 @@
+/*
+ * Author: CHEN Yongyuan (Walter) 1930006025 from OOP(1007)
+ * Date: 2022-04-18
+ * Description: This is the Learnable interface.
+ */
+
+public interface Learnable {
+	public String getCode();
+
+	public String getTitle();
+
+	public Learnable getPreRequisite();
+}

assignment4/Question5/MajorElective.java

@@ -0,0 +1,56 @@
+/*
+ * Author: CHEN Yongyuan (Walter) 1930006025 from OOP(1007)
+ * Date: 2022-04-18
+ * Description: This is the MajorElective class which is elective for students.
+ */
+
+public class MajorElective extends Course {
+	/**
+	 * Constructor.
+	 *
+	 * @param code         The code of the course.
+	 * @param title        The title of the course.
+	 * @param preRequisite The pre-requisite of the course. Type of MajorElective
+	 *                     and cannot be null.
+	 */
+	public MajorElective(String code, String title, Learnable preRequisite) {
+		super(code, title, preRequisite);
+	}
+
+	/**
+	 * MajorRequired course is elective for all students.
+	 *
+	 * @return false
+	 */
+	public boolean isRequired() {
+		return false;
+	}
+
+	/**
+	 * Test.
+	 */
+	public static void testMajorElective() {
+		MajorElective pre = new MajorElective("CSC108", "Intro to Programming", null);
+		System.out.println(pre.getCode() == null);
+		System.out.println(pre.getTitle() == null);
+		System.out.println(pre.getPreRequisite() == null);
+		System.out.println(pre.isRequired() == false);
+
+		MajorElective pre2 = new MajorElective("CSC108", "Intro to Programming", pre);
+		System.out.println(pre2.getCode() == "CSC108");
+		System.out.println(pre2.getTitle() == "Intro to Programming");
+		System.out.println(pre2.getPreRequisite() == pre);
+		System.out.println(pre2.isRequired() == false);
+
+		Base base = new Base("COMP4023", "Software Engineering");
+		System.out.println(base.getCode() == "COMP4023");
+		System.out.println(base.getTitle() == "Software Engineering");
+		System.out.println(base.getPreRequisite() == base);
+
+		MajorElective me = new MajorElective("CSC123", "Big Data", base);
+		System.out.println(me.getCode() == "CSC123");
+		System.out.println(me.getTitle() == "Big Data");
+		System.out.println(me.getPreRequisite() == base);
+		System.out.println(me.isRequired() == false);
+	}
+}

assignment4/Question5/MajorRequired.java

@@ -0,0 +1,57 @@
+/*
+ * Author: CHEN Yongyuan (Walter) 1930006025 from OOP(1007)
+ * Date: 2022-04-18
+ * Description: This is the MajorRequired class which is used to store the major and required courses.
+ */
+
+public class MajorRequired extends Course {
+	/**
+	 * Constructor.
+	 *
+	 * @param code         The code of the course.
+	 * @param title        The title of the course.
+	 * @param preRequisite The pre-requisite of the course. Type of MajorRequired
+	 *                     and cannot be null.
+	 */
+	public MajorRequired(String code, String title, Learnable preRequisite) {
+		super(code, title, preRequisite);
+	}
+
+	/**
+	 * MajorRequired course is required for all students.
+	 *
+	 * @return true
+	 */
+	@Override
+	public boolean isRequired() {
+		return true;
+	}
+
+	/**
+	 * Test.
+	 */
+	public static void testMajorRequired() {
+		MajorRequired mr1 = new MajorRequired("COMP3013", "Database Management System", null);
+		System.out.println(mr1.getCode() == null);
+		System.out.println(mr1.getTitle() == null);
+		System.out.println(mr1.getPreRequisite() == null);
+		System.out.println(mr1.isRequired() == true);
+
+		MajorRequired mr2 = new MajorRequired("COMP3013", "Database Management System", mr1);
+		System.out.println(mr2.getCode() == "COMP3013");
+		System.out.println(mr2.getTitle() == "Database Management System");
+		System.out.println(mr2.getPreRequisite() == mr1);
+		System.out.println(mr2.isRequired() == true);
+
+		Base base = new Base("COMP4023", "Software Engineering");
+		System.out.println(base.getCode() == "COMP4023");
+		System.out.println(base.getTitle() == "Software Engineering");
+		System.out.println(base.getPreRequisite() == base);
+
+		MajorRequired mr3 = new MajorRequired("COMP4101", "Quality Assurance", base);
+		System.out.println(mr3.getCode() == "COMP4101");
+		System.out.println(mr3.getTitle() == "Quality Assurance");
+		System.out.println(mr3.getPreRequisite() == base);
+		System.out.println(mr3.isRequired() == true);
+	}
+}

assignment4/Question5/Start.java

@@ -0,0 +1,27 @@
+/**
+ * Answer to the questions.
+ *
+ * - Q: What kinds of tests can you write inside the testCourse method?
+ *
+ * - A: You can inherit the Couse class to annonymous class and override the
+ * isRequired() method.
+ *
+ * - Q: What kinds of tests can you write inside the testMajorRequired method?
+ *
+ * - A: You can first create a MajorRequired object with null preRequisite and
+ * do the test as normal.
+ *
+ * - Q: What kinds of tests can you write inside the testMajorElective method?
+ *
+ * - A: You can first create a MajorElective object with null preRequisite and
+ * do the test as normal.
+ */
+
+public class Start {
+	public static void main(String[] args) {
+		Course.testCourse();
+		MajorRequired.testMajorRequired();
+		MajorElective.testMajorElective();
+		Base.testBase();
+	}
+}

assignment4/Question5/StartGrading.java

@@ -0,0 +1,64 @@
+public class StartGrading {
+	public static void testCourse() 
+	{	//Since we cannot create any Course object, 
+		//the testAnimal method of the Course class must be empty.  
+	}
+	
+	public static void testMajorRequired()  
+	{   
+		//create a Base object 
+		Base b = new Base("DS1001","EntryCourse"); 
+		//create a first MajorRequired object with the base course as pre-requisite 
+		MajorRequired mr1 = new MajorRequired("DS200X","OOP",b); 
+		//create a second MajorRequired object with the first major required course as pre-requisite 
+		MajorRequired mr2 = new MajorRequired("DS300X","Data Mining",mr1); 
+		 
+		//test mr1 
+		System.out.println(mr1.getCode()=="DS200X"); 
+		System.out.println(mr1.getTitle()=="OOP"); 
+		System.out.println(mr1.getPreRequisite() == b); 
+		 
+		//test mr2 
+		System.out.println(mr2.getCode()=="DS300X"); 
+		System.out.println(mr2.getTitle()=="Data Mining"); 
+		System.out.println(mr2.getPreRequisite() == mr1); 
+    }
+
+	public static void testMajorElective()  
+	{   
+		//create a Base object 
+		Base b = new Base("DS1001","EntryCourse"); 
+		//create a first MajorRequired object with the base course as pre-requisite 
+		MajorRequired mr1 = new MajorRequired("DS200X","OOP",b); 
+		//create a MajorElective object with the major required course as pre-requisite 
+		MajorElective me1 = new MajorElective("DS300X","Data Mining",mr1); 
+		 
+		//test mr1 
+		System.out.println(mr1.getCode()=="DS200X"); 
+		System.out.println(mr1.getTitle()=="OOP"); 
+		System.out.println(mr1.getPreRequisite() == b); 
+		 
+		//test mr2 
+		System.out.println(me1.getCode()=="DS300X"); 
+		System.out.println(me1.getTitle()=="Data Mining"); 
+		System.out.println(me1.getPreRequisite() == mr1); 
+	} 
+	
+	public static void testBase()  
+	{ 
+		Base b = new Base("DS1001", "EntryCourse"); 
+		System.out.println(b.getCode() == "DS1001"); 
+		System.out.println(b.getTitle() == "EntryCourse"); 
+		//System.out.println(b.isRequired() == true); 
+		System.out.println(b.getPreRequisite() == b); 
+	} 
+
+
+	public static void main(String[] args)  
+	{ 
+		testCourse(); 
+		testBase(); 
+		testMajorRequired(); 
+		testMajorElective(); 
+	} 
+} 

assignment4/Question6/Base.java

@@ -0,0 +1,58 @@
+/*
+ * Author: CHEN Yongyuan (Walter) 1930006025 from OOP(1007)
+ * Date: 2022-04-18
+ * Description: This is the Base Class.
+ */
+
+public class Base implements Learnable {
+	private String code;
+	private String title;
+
+	/**
+	 * Constructor
+	 * 
+	 * @param code  The code of the course
+	 * @param title The title of the course
+	 */
+	public Base(String code, String title) {
+		this.code = code;
+		this.title = title;
+	}
+
+	/**
+	 * Getter of code
+	 *
+	 * @return The code of the course
+	 */
+	public String getCode() {
+		return code;
+	}
+
+	/**
+	 * Getter of title
+	 *
+	 * @return The title of the course
+	 */
+	public String getTitle() {
+		return title;
+	}
+
+	/**
+	 * Get the pre-requisite course. It will return itself.
+	 *
+	 * @return this
+	 */
+	public Learnable getPreRequisite() {
+		return this;
+	}
+
+	/**
+	 * Test.
+	 */
+	public static void testBase() {
+		Base base = new Base("COMP3013", "Database Management System");
+		System.out.println(base.getCode() == "COMP3013");
+		System.out.println(base.getTitle() == "Database Management System");
+		System.out.println(base.getPreRequisite() == base);
+	}
+}

assignment4/Question6/Course.java

@@ -0,0 +1,113 @@
+/*
+ * Author: CHEN Yongyuan (Walter) 1930006025 from OOP(1007)
+ * Date: 2022-04-18
+ * Description: This is the Course class.
+ */
+
+public abstract class Course implements Learnable {
+	/**
+	 * The code of the course.
+	 */
+	private String code;
+
+	/**
+	 * The title of the course.
+	 */
+	private String title;
+
+	/**
+	 * The pre-requisite of the course.
+	 *
+	 * A course always has only one pre-requisite course and the pre-requisite
+	 * course cannot be null.
+	 *
+	 * @see Course
+	 */
+	private Learnable preRequisite;
+
+	/**
+	 * Constructor.
+	 *
+	 * @param code         The code of the course.
+	 * @param title        The title of the course.
+	 * @param preRequisite The pre-requisite of the course. If the pre-requisite
+	 *                     course is null, the constructor will print a message of
+	 *                     "pre-requisite course cannot be null!" and return
+	 *                     directly.
+	 */
+	public Course(String code, String title, Learnable preRequisite) {
+		if (preRequisite == null) {
+			System.out.println("pre-requisite course cannot be null!");
+			return;
+		}
+
+		this.code = code;
+		this.title = title;
+		this.preRequisite = preRequisite;
+	}
+
+	/**
+	 * Get the code of the course.
+	 *
+	 * @return The code of the course.
+	 */
+	public String getCode() {
+		return code;
+	}
+
+	/**
+	 * Get the title of the course.
+	 *
+	 * @return The title of the course.
+	 */
+	public String getTitle() {
+		return title;
+	}
+
+	/**
+	 * Get the pre-requisite of the course.
+	 *
+	 * @return The pre-requisite of the course.
+	 */
+	public Learnable getPreRequisite() {
+		return preRequisite;
+	}
+
+	/**
+	 * Indicate whether a course is required or not.
+	 *
+	 * One course could either be a required course or a elective course. Some
+	 * courses are required, while the others are not required.
+	 *
+	 * @return True if the course is required, false if the course is not required.
+	 */
+	public abstract boolean isRequired();
+
+	/**
+	 * Test.
+	 */
+	public static void testCourse() {
+		Course mr = new Course("CS101", "Intro to Java", null) {
+			@Override
+			public boolean isRequired() {
+				return true;
+			}
+		};
+		System.out.println(mr.getCode() == null);
+		System.out.println(mr.getTitle() == null);
+		System.out.println(mr.getPreRequisite() == null);
+		System.out.println(mr.isRequired() == true);
+
+		Course me = new Course("CS102", "Intro to Python", mr) {
+			@Override
+			public boolean isRequired() {
+				return false;
+			}
+		};
+		System.out.println(me.getCode() == "CS102");
+		System.out.println(me.getTitle() == "Intro to Python");
+		System.out.println(me.getPreRequisite() == mr);
+		System.out.println(me.isRequired() == false);
+
+	}
+}

assignment4/Question6/Learnable.java

@@ -0,0 +1,13 @@
+/*
+ * Author: CHEN Yongyuan (Walter) 1930006025 from OOP(1007)
+ * Date: 2022-04-18
+ * Description: This is the Learnable interface.
+ */
+
+public interface Learnable {
+	public String getCode();
+
+	public String getTitle();
+
+	public Learnable getPreRequisite();
+}

assignment4/Question6/MajorElective.java

@@ -0,0 +1,56 @@
+/*
+ * Author: CHEN Yongyuan (Walter) 1930006025 from OOP(1007)
+ * Date: 2022-04-18
+ * Description: This is the MajorElective class which is elective for students.
+ */
+
+public class MajorElective extends Course {
+	/**
+	 * Constructor.
+	 *
+	 * @param code         The code of the course.
+	 * @param title        The title of the course.
+	 * @param preRequisite The pre-requisite of the course. Type of MajorElective
+	 *                     and cannot be null.
+	 */
+	public MajorElective(String code, String title, Learnable preRequisite) {
+		super(code, title, preRequisite);
+	}
+
+	/**
+	 * MajorRequired course is elective for all students.
+	 *
+	 * @return false
+	 */
+	public boolean isRequired() {
+		return false;
+	}
+
+	/**
+	 * Test.
+	 */
+	public static void testMajorElective() {
+		MajorElective pre = new MajorElective("CSC108", "Intro to Programming", null);
+		System.out.println(pre.getCode() == null);
+		System.out.println(pre.getTitle() == null);
+		System.out.println(pre.getPreRequisite() == null);
+		System.out.println(pre.isRequired() == false);
+
+		MajorElective pre2 = new MajorElective("CSC108", "Intro to Programming", pre);
+		System.out.println(pre2.getCode() == "CSC108");
+		System.out.println(pre2.getTitle() == "Intro to Programming");
+		System.out.println(pre2.getPreRequisite() == pre);
+		System.out.println(pre2.isRequired() == false);
+
+		Base base = new Base("COMP4023", "Software Engineering");
+		System.out.println(base.getCode() == "COMP4023");
+		System.out.println(base.getTitle() == "Software Engineering");
+		System.out.println(base.getPreRequisite() == base);
+
+		MajorElective me = new MajorElective("CSC123", "Big Data", base);
+		System.out.println(me.getCode() == "CSC123");
+		System.out.println(me.getTitle() == "Big Data");
+		System.out.println(me.getPreRequisite() == base);
+		System.out.println(me.isRequired() == false);
+	}
+}

assignment4/Question6/MajorRequired.java

@@ -0,0 +1,57 @@
+/*
+ * Author: CHEN Yongyuan (Walter) 1930006025 from OOP(1007)
+ * Date: 2022-04-18
+ * Description: This is the MajorRequired class which is used to store the major and required courses.
+ */
+
+public class MajorRequired extends Course {
+	/**
+	 * Constructor.
+	 *
+	 * @param code         The code of the course.
+	 * @param title        The title of the course.
+	 * @param preRequisite The pre-requisite of the course. Type of MajorRequired
+	 *                     and cannot be null.
+	 */
+	public MajorRequired(String code, String title, Learnable preRequisite) {
+		super(code, title, preRequisite);
+	}
+
+	/**
+	 * MajorRequired course is required for all students.
+	 *
+	 * @return true
+	 */
+	@Override
+	public boolean isRequired() {
+		return true;
+	}
+
+	/**
+	 * Test.
+	 */
+	public static void testMajorRequired() {
+		MajorRequired mr1 = new MajorRequired("COMP3013", "Database Management System", null);
+		System.out.println(mr1.getCode() == null);
+		System.out.println(mr1.getTitle() == null);
+		System.out.println(mr1.getPreRequisite() == null);
+		System.out.println(mr1.isRequired() == true);
+
+		MajorRequired mr2 = new MajorRequired("COMP3013", "Database Management System", mr1);
+		System.out.println(mr2.getCode() == "COMP3013");
+		System.out.println(mr2.getTitle() == "Database Management System");
+		System.out.println(mr2.getPreRequisite() == mr1);
+		System.out.println(mr2.isRequired() == true);
+
+		Base base = new Base("COMP4023", "Software Engineering");
+		System.out.println(base.getCode() == "COMP4023");
+		System.out.println(base.getTitle() == "Software Engineering");
+		System.out.println(base.getPreRequisite() == base);
+
+		MajorRequired mr3 = new MajorRequired("COMP4101", "Quality Assurance", base);
+		System.out.println(mr3.getCode() == "COMP4101");
+		System.out.println(mr3.getTitle() == "Quality Assurance");
+		System.out.println(mr3.getPreRequisite() == base);
+		System.out.println(mr3.isRequired() == true);
+	}
+}

assignment4/Question6/ManyCourses.java

@@ -0,0 +1,51 @@
+/*
+ * Author: CHEN Yongyuan (Walter) 1930006025 from OOP(1007)
+ * Date: 2022-04-18
+ * Description: This is the ManyCourses class.
+ */
+
+import java.util.ArrayList;
+
+public class ManyCourses {
+	private ArrayList<Learnable> courses;
+
+	/**
+	 * Constructor.
+	 */
+	public ManyCourses() {
+		courses = new ArrayList<Learnable>();
+	}
+
+	/**
+	 * Add a course to the list.
+	 *
+	 * @param course
+	 */
+	public void addCourse(Learnable c) {
+		courses.add(c);
+	}
+
+	/**
+	 * Prints on the screen the course code and title.
+	 */
+	public void listCourses() {
+		for (Learnable c : courses) {
+			System.out.println(
+					String.format("%s, %s", c.getCode(), c.getTitle()));
+		}
+	}
+
+	/**
+	 * Test.
+	 */
+	public static void testManyCourses() {
+		Base b = new Base("DS1001", "EntryCourse");
+		MajorRequired mr1 = new MajorRequired("DS200X", "OOP", b);
+		MajorElective me1 = new MajorElective("DS300X", "Data Mining", mr1);
+		ManyCourses mc = new ManyCourses();
+		mc.addCourse(b);
+		mc.addCourse(mr1);
+		mc.addCourse(me1);
+		mc.listCourses();
+	}
+}

assignment4/Question6/Start.java

@@ -0,0 +1,28 @@
+/**
+ * Answer to the questions.
+ *
+ * - Q: What kinds of tests can you write inside the testCourse method?
+ *
+ * - A: You can inherit the Couse class to annonymous class and override the
+ * isRequired() method.
+ *
+ * - Q: What kinds of tests can you write inside the testMajorRequired method?
+ *
+ * - A: You can first create a MajorRequired object with null preRequisite and
+ * do the test as normal.
+ *
+ * - Q: What kinds of tests can you write inside the testMajorElective method?
+ *
+ * - A: You can first create a MajorElective object with null preRequisite and
+ * do the test as normal.
+ */
+
+public class Start {
+	public static void main(String[] args) {
+		Course.testCourse();
+		MajorRequired.testMajorRequired();
+		MajorElective.testMajorElective();
+		Base.testBase();
+		ManyCourses.testManyCourses();
+	}
+}

assignment4/Question6/StartGrading.java

@@ -0,0 +1,76 @@
+public class StartGrading {
+	public static void testCourse() 
+	{	//Since we cannot create any Course object, 
+		//the testAnimal method of the Course class must be empty.  
+	}
+	
+	public static void testMajorRequired()  
+	{   
+		//create a Base object 
+		Base b = new Base("DS1001","EntryCourse"); 
+		//create a first MajorRequired object with the base course as pre-requisite 
+		MajorRequired mr1 = new MajorRequired("DS200X","OOP",b); 
+		//create a second MajorRequired object with the first major required course as pre-requisite 
+		MajorRequired mr2 = new MajorRequired("DS300X","Data Mining",mr1); 
+		 
+		//test mr1 
+		System.out.println(mr1.getCode()=="DS200X"); 
+		System.out.println(mr1.getTitle()=="OOP"); 
+		System.out.println(mr1.getPreRequisite() == b); 
+		 
+		//test mr2 
+		System.out.println(mr2.getCode()=="DS300X"); 
+		System.out.println(mr2.getTitle()=="Data Mining"); 
+		System.out.println(mr2.getPreRequisite() == mr1); 
+    }
+
+	public static void testMajorElective()  
+	{   
+		//create a Base object 
+		Base b = new Base("DS1001","EntryCourse"); 
+		//create a first MajorRequired object with the base course as pre-requisite 
+		MajorRequired mr1 = new MajorRequired("DS200X","OOP",b); 
+		//create a MajorElective object with the major required course as pre-requisite 
+		MajorElective me1 = new MajorElective("DS300X","Data Mining",mr1); 
+		 
+		//test mr1 
+		System.out.println(mr1.getCode()=="DS200X"); 
+		System.out.println(mr1.getTitle()=="OOP"); 
+		System.out.println(mr1.getPreRequisite() == b); 
+		 
+		//test mr2 
+		System.out.println(me1.getCode()=="DS300X"); 
+		System.out.println(me1.getTitle()=="Data Mining"); 
+		System.out.println(me1.getPreRequisite() == mr1); 
+	} 
+	
+	public static void testBase()  
+	{ 
+		Base b = new Base("DS1001", "EntryCourse"); 
+		System.out.println(b.getCode() == "DS1001"); 
+		System.out.println(b.getTitle() == "EntryCourse"); 
+		//System.out.println(b.isRequired() == true); 
+		System.out.println(b.getPreRequisite() == b); 
+	} 
+
+	public static void testManyCourses() 
+	{ 
+		Base b = new Base("DS1001","EntryCourse"); 
+		MajorRequired mr1 = new MajorRequired("DS200X","OOP",b); 
+		MajorElective me1 = new MajorElective("DS300X","Data Mining",mr1); 
+		ManyCourses mc = new ManyCourses(); 
+		mc.addCourse(b); 
+		mc.addCourse(mr1); 
+		mc.addCourse(me1); 
+		mc.listCourses(); 
+	} 
+	
+	public static void main(String[] args)  
+	{ 
+		testCourse(); 
+		testBase(); 
+		testMajorRequired(); 
+		testMajorElective(); 
+		testManyCourses(); 
+	} 
+} 

assignment5/Question1/BadSpeedSetting.java

@@ -0,0 +1,15 @@
+/*
+ * The BadSpeedSetting class is used to test the speed of the program.
+ */
+public class BadSpeedSetting extends Exception {
+	// generate serial ID by class name
+	private static final long serialVersionUID = BadSpeedSetting.class.getName().hashCode();
+
+	public BadSpeedSetting() {
+		super();
+	}
+
+	public BadSpeedSetting(String message) {
+		super(message);
+	}
+}

assignment5/Question1/ExceedSpeedLimit.java

@@ -0,0 +1,15 @@
+/*
+ * The ExceedSpeedLimit class is used to check if the speed limit is exceeded
+ */
+public class ExceedSpeedLimit extends Exception {
+	// generate serial ID by class name
+	private static final long serialVersionUID = ExceedSpeedLimit.class.getName().hashCode();
+
+	public ExceedSpeedLimit() {
+		super();
+	}
+
+	public ExceedSpeedLimit(String message) {
+		super(message);
+	}
+}

assignment5/Question1/Movable.java

@@ -0,0 +1,9 @@
+/*
+ * Author: CHEN Yongyuan (Walter) 1930006025 from OOP(1007)
+ * Date: 2022-04-24
+ * Description: This is a moveable interface.
+ */
+
+public interface Movable {
+	public int accelerate(int amount) throws ExceedSpeedLimit, NotEnoughSpeed;
+}

assignment5/Question1/NotEnoughSpeed.java

@@ -0,0 +1,15 @@
+/*
+ * The NotEnoughSpeed class is used to test the speed of the program.
+ */
+public class NotEnoughSpeed extends Exception {
+	// generate serial ID by class name
+	private static final long serialVersionUID = NotEnoughSpeed.class.getName().hashCode();
+
+	public NotEnoughSpeed() {
+		super();
+	}
+
+	public NotEnoughSpeed(String message) {
+		super(message);
+	}
+}

assignment5/Question1/Start.java

@@ -0,0 +1,5 @@
+public class Start {
+	public static void main(String[] args) {
+		Vehicle.testVehicle();
+	}
+}

assignment5/Question1/StartGrading.java

@@ -0,0 +1,10 @@
+//Q1
+public class StartGrading {
+	public static void testVehicle() {
+//The Vehicle class is abstract. We cannot create objects from this class. Therefore, we cannot test anything
+	}
+
+	public static void main(String[] args) {
+		Vehicle.testVehicle();
+	}
+}

assignment5/Question1/Vehicle.java

@@ -0,0 +1,180 @@
+/*
+ * Author: CHEN Yongyuan (Walter) 1930006025 from OOP(1007)
+ * Date: 2022-04-24
+ * Description: This is the abstract Vehicle class.
+ */
+
+public abstract class Vehicle implements Movable {
+	private int speedLimit;
+	private int speed;
+
+	/**
+	 * Constructor.
+	 *
+	 * @param speedLimit the speed limit of the vehicle
+	 * @param speed      the speed of the vehicle
+	 * @throws BadSpeedSetting if speedLimit or speed is negative. Or if the speed
+	 *                         is greater than speed limit.
+	 */
+	public Vehicle(int speedLimit, int speed) throws BadSpeedSetting {
+		if (speedLimit < 0 || speed < 0) {
+			throw new BadSpeedSetting("Speed cannot be negative!");
+		}
+		if (speed > speedLimit) {
+			throw new BadSpeedSetting("Speed cannot be greater than speed limit!");
+		}
+		this.speedLimit = speedLimit;
+		this.speed = speed;
+	}
+
+	/**
+	 * Getter of speed.
+	 *
+	 * @return the speed of the vehicle
+	 */
+	public int getSpeed() {
+		return speed;
+	}
+
+	/**
+	 * Accelerate the vehicle.
+	 *
+	 * @param amount the amount of acceleration.
+	 * @throws ExceedSpeedLimit if the speed is greater than speed limit after
+	 *                          increased.
+	 * @thorws NotEnoughSpeed if the speed is less than 0 after decreased.
+	 * @return the new speed of the vehicle
+	 */
+	public int accelerate(int amount) throws ExceedSpeedLimit, NotEnoughSpeed {
+		int newSpeed = speed + amount;
+		if (newSpeed > speedLimit) {
+			throw new ExceedSpeedLimit(
+					String.format("Current speed is %d. Accelerate %d will exceed the speed limit!",
+							speed, amount));
+		}
+		if (newSpeed < 0) {
+			throw new NotEnoughSpeed(
+					String.format("Current speed is %d, not enough speed to decelerate!", speed));
+		}
+		speed = newSpeed;
+		return speed;
+	}
+
+	/**
+	 * Whether the vehicle can fly or not.
+	 *
+	 * @return whether the vehicle can fly.
+	 */
+	public abstract boolean canFly();
+
+	/**
+	 * Test.
+	 */
+	public static void testVehicle() {
+		try {
+			Vehicle car;
+			try {
+				car = new Vehicle(-10, -20) {
+					@Override
+					public boolean canFly() {
+						return false;
+					}
+				};
+			} catch (BadSpeedSetting e) {
+				System.out.println(e.getMessage().equals("Speed cannot be negative!"));
+			}
+			try {
+				car = new Vehicle(0, 50) {
+					@Override
+					public boolean canFly() {
+						return false;
+					}
+				};
+			} catch (BadSpeedSetting e) {
+				System.out.println(e.getMessage().equals("Speed cannot be greater than speed limit!"));
+			}
+			car = new Vehicle(100, 50) {
+				@Override
+				public boolean canFly() {
+					return false;
+				}
+			};
+			System.out.println(car.getSpeed() == 50);
+			System.out.println(car.canFly() == false);
+			System.out.println(car.accelerate(10) == 60);
+			System.out.println(car.accelerate(10) == 70);
+			System.out.println(car.accelerate(10) == 80);
+			System.out.println(car.accelerate(10) == 90);
+			System.out.println(car.accelerate(10) == 100);
+			try {
+				System.out.println(car.accelerate(10) == 110);
+				System.out.println("Error: ExceedSpeedLimit should be thrown!");
+			} catch (ExceedSpeedLimit e) {
+				System.out.println(e.getMessage().equals(
+						"Current speed is 100. Accelerate 10 will exceed the speed limit!"));
+			}
+			System.out.println(car.accelerate(-50) == 50);
+			System.out.println(car.accelerate(-50) == 0);
+			try {
+				System.out.println(car.accelerate(-50) == -50);
+				System.out.println("Error: NotEnoughSpeed should be thrown!");
+			} catch (NotEnoughSpeed e) {
+				System.out.println(e.getMessage()
+						.equals("Current speed is 0, not enough speed to decelerate!"));
+			}
+
+			Vehicle plane;
+			try {
+				plane = new Vehicle(-10, -20) {
+					@Override
+					public boolean canFly() {
+						return true;
+					}
+				};
+			} catch (BadSpeedSetting e) {
+				System.out.println(e.getMessage().equals("Speed cannot be negative!"));
+			}
+			try {
+				plane = new Vehicle(0, 50) {
+					@Override
+					public boolean canFly() {
+						return true;
+					}
+				};
+			} catch (BadSpeedSetting e) {
+				System.out.println(e.getMessage().equals("Speed cannot be greater than speed limit!"));
+			}
+			plane = new Vehicle(100, 50) {
+				@Override
+				public boolean canFly() {
+					return true;
+				}
+			};
+			System.out.println(plane.getSpeed() == 50);
+			System.out.println(plane.canFly() == true);
+			System.out.println(plane.accelerate(10) == 60);
+			System.out.println(plane.accelerate(10) == 70);
+			System.out.println(plane.accelerate(10) == 80);
+			System.out.println(plane.accelerate(10) == 90);
+			System.out.println(plane.accelerate(10) == 100);
+			try {
+				System.out.println(plane.accelerate(10) == 110);
+				System.out.println("Error: ExceedSpeedLimit should be thrown!");
+			} catch (ExceedSpeedLimit e) {
+				System.out.println(e.getMessage().equals(
+						"Current speed is 100. Accelerate 10 will exceed the speed limit!"));
+			}
+			System.out.println(plane.accelerate(-50) == 50);
+			System.out.println(plane.accelerate(-50) == 0);
+			try {
+				System.out.println(plane.accelerate(-50) == -50);
+				System.out.println("Error: NotEnoughSpeed should be thrown!");
+			} catch (NotEnoughSpeed e) {
+				System.out.println(e.getMessage()
+						.equals("Current speed is 0, not enough speed to decelerate!"));
+			}
+		} catch (Exception e) {
+			System.out.println("Error: Uncatched exception!");
+		}
+	}
+}

assignment5/Question2/BadSpeedSetting.java

@@ -0,0 +1,15 @@
+/*
+ * The BadSpeedSetting class is used to test the speed of the program.
+ */
+public class BadSpeedSetting extends Exception {
+	// generate serial ID by class name
+	private static final long serialVersionUID = BadSpeedSetting.class.getName().hashCode();
+
+	public BadSpeedSetting() {
+		super();
+	}
+
+	public BadSpeedSetting(String message) {
+		super(message);
+	}
+}

assignment5/Question2/Car.java

@@ -0,0 +1,130 @@
+/*
+ * Author: CHEN Yongyuan (Walter) 1930006025 from OOP(1007)
+ * Date: 2022-04-24
+ * Description: Car class
+ */
+
+public class Car extends Vehicle {
+
+	/**
+	 * Car can not fly.
+	 *
+	 * @return false
+	 */
+	@Override
+	public boolean canFly() {
+		return false;
+	}
+
+	/**
+	 * Constructor.
+	 *
+	 * @param speedLimit The speed limit of the car.
+	 * @param speed      the speed of the car.
+	 * @thorws BadSpeedSetting if speedLimit or speed is negative. Or if the speed
+	 *         is greater than the speed limit.
+	 */
+	public Car(int speedLimit, int speed) throws BadSpeedSetting {
+		super(speedLimit, speed);
+	}
+
+	/**
+	 * Constructor. Default speed limit is 120.
+	 *
+	 * @param speed the speed of the car.
+	 * @thorws BadSpeedSetting if speed is negative. Or if the speed is greater than
+	 *         the speed limit 120.
+	 */
+	public Car(int speed) throws BadSpeedSetting {
+		this(120, speed);
+	}
+
+	/**
+	 * Test.
+	 */
+	public static void testCar() {
+		try {
+			Car c1;
+			try {
+				c1 = new Car(-1, -1);
+			} catch (BadSpeedSetting e) {
+				System.out.println(e.getMessage().equals("Speed cannot be negative!"));
+			}
+			try {
+				c1 = new Car(120, -1);
+			} catch (BadSpeedSetting e) {
+				System.out.println(e.getMessage().equals("Speed cannot be negative!"));
+			}
+			try {
+				c1 = new Car(120, 121);
+			} catch (BadSpeedSetting e) {
+				System.out.println(e.getMessage().equals("Speed cannot be greater than speed limit!"));
+			}
+			c1 = new Car(120, 100);
+			System.out.println(c1.getSpeed() == 100);
+			System.out.println(c1.canFly() == false);
+			System.out.println(c1.accelerate(10) == 110);
+			System.out.println(c1.canFly() == false);
+			System.out.println(c1.accelerate(10) == 120);
+			System.out.println(c1.canFly() == false);
+			try {
+				c1.accelerate(10);
+			} catch (ExceedSpeedLimit e) {
+				System.out.println(e.getMessage().equals(
+						"Current speed is 120. Accelerate 10 will exceed the speed limit!"));
+			}
+			System.out.println(c1.accelerate(-20) == 100);
+			System.out.println(c1.canFly() == false);
+			System.out.println(c1.accelerate(-20) == 80);
+			System.out.println(c1.canFly() == false);
+			System.out.println(c1.accelerate(-20) == 60);
+			System.out.println(c1.canFly() == false);
+			System.out.println(c1.accelerate(-20) == 40);
+			System.out.println(c1.canFly() == false);
+			System.out.println(c1.accelerate(-20) == 20);
+			System.out.println(c1.canFly() == false);
+			System.out.println(c1.accelerate(-20) == 0);
+			System.out.println(c1.canFly() == false);
+			try {
+				c1.accelerate(-20);
+			} catch (NotEnoughSpeed e) {
+				System.out.println(e.getMessage()
+						.equals("Current speed is 0, not enough speed to decelerate!"));
+			}
+
+			Car c2 = new Car(100);
+			System.out.println(c2.getSpeed() == 100);
+			System.out.println(c2.canFly() == false);
+			System.out.println(c2.accelerate(10) == 110);
+			System.out.println(c2.canFly() == false);
+			System.out.println(c2.accelerate(10) == 120);
+			System.out.println(c2.canFly() == false);
+			try {
+				c2.accelerate(10);
+			} catch (ExceedSpeedLimit e) {
+				System.out.println(e.getMessage().equals(
+						"Current speed is 120. Accelerate 10 will exceed the speed limit!"));
+			}
+			System.out.println(c2.accelerate(-20) == 100);
+			System.out.println(c2.canFly() == false);
+			System.out.println(c2.accelerate(-20) == 80);
+			System.out.println(c2.canFly() == false);
+			System.out.println(c2.accelerate(-20) == 60);
+			System.out.println(c2.canFly() == false);
+			System.out.println(c2.accelerate(-20) == 40);
+			System.out.println(c2.canFly() == false);
+			System.out.println(c2.accelerate(-20) == 20);
+			System.out.println(c2.canFly() == false);
+			System.out.println(c2.accelerate(-20) == 0);
+			System.out.println(c2.canFly() == false);
+			try {
+				c2.accelerate(-20);
+			} catch (NotEnoughSpeed e) {
+				System.out.println(e.getMessage()
+						.equals("Current speed is 0, not enough speed to decelerate!"));
+			}
+		} catch (Exception e) {
+			System.out.println("Error uncatched exception: " + e.getMessage());
+		}
+	}
+}

assignment5/Question2/ExceedSpeedLimit.java

@@ -0,0 +1,15 @@
+/*
+ * The ExceedSpeedLimit class is used to check if the speed limit is exceeded
+ */
+public class ExceedSpeedLimit extends Exception {
+	// generate serial ID by class name
+	private static final long serialVersionUID = ExceedSpeedLimit.class.getName().hashCode();
+
+	public ExceedSpeedLimit() {
+		super();
+	}
+
+	public ExceedSpeedLimit(String message) {
+		super(message);
+	}
+}

assignment5/Question2/Movable.java

@@ -0,0 +1,9 @@
+/*
+ * Author: CHEN Yongyuan (Walter) 1930006025 from OOP(1007)
+ * Date: 2022-04-24
+ * Description: This is a moveable interface.
+ */
+
+public interface Movable {
+	public int accelerate(int amount) throws ExceedSpeedLimit, NotEnoughSpeed;
+}

assignment5/Question2/NotEnoughSpeed.java

@@ -0,0 +1,15 @@
+/*
+ * The NotEnoughSpeed class is used to test the speed of the program.
+ */
+public class NotEnoughSpeed extends Exception {
+	// generate serial ID by class name
+	private static final long serialVersionUID = NotEnoughSpeed.class.getName().hashCode();
+
+	public NotEnoughSpeed() {
+		super();
+	}
+
+	public NotEnoughSpeed(String message) {
+		super(message);
+	}
+}

assignment5/Question2/Start.java

@@ -0,0 +1,6 @@
+public class Start {
+	public static void main(String[] args) {
+		Vehicle.testVehicle();
+		Car.testCar();
+	}
+}

assignment5/Question2/StartGrading.java

@@ -0,0 +1,58 @@
+//Q2
+public class StartGrading {
+	public static void testVehicle() {
+//The Vehicle class is abstract. We cannot create objects from this class. Therefore, we cannot test anything
+	}
+
+	public static void testCar() {
+		// test case for constructors
+		try {
+			// exception
+			Car c1 = new Car(70, 80);
+		} catch (BadSpeedSetting e) {
+			System.out.println(e.getMessage().equals("Speed cannot be greater than speed limit!"));
+		}
+		try {
+			// exception
+			Car c2 = new Car(70, -10);
+		} catch (BadSpeedSetting e) {
+			System.out.println(e.getMessage().equals("Speed cannot be negative!"));
+		}
+		// test case for accelerate, canFly and getSpeed methods
+		try {
+			Car c3 = new Car(100, 80);
+			// test the canFly method
+			System.out.println(c3.canFly() == false);
+			c3.accelerate(10);
+			System.out.println(c3.getSpeed() == 90);
+			// test the accelerate with positive amount
+			c3.accelerate(-20);
+			System.out.println(c3.getSpeed() == 70);
+			// test the accelerate with negative amount
+			c3.accelerate(35); // exception
+		} catch (BadSpeedSetting e) {
+			System.out.println("BUG! THIS MUST NEVER HAPPEN!");
+		} catch (ExceedSpeedLimit e) {
+			System.out
+					.println(e.getMessage().equals("Current speed is 70. Accelerate 35 will exceed the speed limit!"));
+		} catch (NotEnoughSpeed e) {
+			System.out.println("BUG! THIS MUST NEVER HAPPEN!");
+		}
+		try {
+			Car c4 = new Car(100, 80);
+			// exception
+			c4.accelerate(-90);
+		} catch (BadSpeedSetting e) {
+			System.out.println("BUG! THIS MUST NEVER HAPPEN!");
+		} catch (ExceedSpeedLimit e) {
+			System.out.println("BUG! THIS MUST NEVER HAPPEN!");
+		} catch (NotEnoughSpeed e) {
+			System.out.println(e.getMessage().equals("Current speed is " + 80 + ", not enough speed to decelerate!"));
+		}
+	}
+
+	public static void main(String[] args) {
+		Vehicle.testVehicle();
+		Car.testCar();
+	}
+}

assignment5/Question2/Vehicle.java

@@ -0,0 +1,180 @@
+/*
+ * Author: CHEN Yongyuan (Walter) 1930006025 from OOP(1007)
+ * Date: 2022-04-24
+ * Description: This is the abstract Vehicle class.
+ */
+
+public abstract class Vehicle implements Movable {
+	private int speedLimit;
+	private int speed;
+
+	/**
+	 * Constructor.
+	 *
+	 * @param speedLimit the speed limit of the vehicle
+	 * @param speed      the speed of the vehicle
+	 * @throws BadSpeedSetting if speedLimit or speed is negative. Or if the speed
+	 *                         is greater than speed limit.
+	 */
+	public Vehicle(int speedLimit, int speed) throws BadSpeedSetting {
+		if (speedLimit < 0 || speed < 0) {
+			throw new BadSpeedSetting("Speed cannot be negative!");
+		}
+		if (speed > speedLimit) {
+			throw new BadSpeedSetting("Speed cannot be greater than speed limit!");
+		}
+		this.speedLimit = speedLimit;
+		this.speed = speed;
+	}
+
+	/**
+	 * Getter of speed.
+	 *
+	 * @return the speed of the vehicle
+	 */
+	public int getSpeed() {
+		return speed;
+	}
+
+	/**
+	 * Accelerate the vehicle.
+	 *
+	 * @param amount the amount of acceleration.
+	 * @throws ExceedSpeedLimit if the speed is greater than speed limit after
+	 *                          increased.
+	 * @thorws NotEnoughSpeed if the speed is less than 0 after decreased.
+	 * @return the new speed of the vehicle
+	 */
+	public int accelerate(int amount) throws ExceedSpeedLimit, NotEnoughSpeed {
+		int newSpeed = speed + amount;
+		if (newSpeed > speedLimit) {
+			throw new ExceedSpeedLimit(
+					String.format("Current speed is %d. Accelerate %d will exceed the speed limit!",
+							speed, amount));
+		}
+		if (newSpeed < 0) {
+			throw new NotEnoughSpeed(
+					String.format("Current speed is %d, not enough speed to decelerate!", speed));
+		}
+		speed = newSpeed;
+		return speed;
+	}
+
+	/**
+	 * Whether the vehicle can fly or not.
+	 *
+	 * @return whether the vehicle can fly.
+	 */
+	public abstract boolean canFly();
+
+	/**
+	 * Test.
+	 */
+	public static void testVehicle() {
+		try {
+			Vehicle car;
+			try {
+				car = new Vehicle(-10, -20) {
+					@Override
+					public boolean canFly() {
+						return false;
+					}
+				};
+			} catch (BadSpeedSetting e) {
+				System.out.println(e.getMessage().equals("Speed cannot be negative!"));
+			}
+			try {
+				car = new Vehicle(0, 50) {
+					@Override
+					public boolean canFly() {
+						return false;
+					}
+				};
+			} catch (BadSpeedSetting e) {
+				System.out.println(e.getMessage().equals("Speed cannot be greater than speed limit!"));
+			}
+			car = new Vehicle(100, 50) {
+				@Override
+				public boolean canFly() {
+					return false;
+				}
+			};
+			System.out.println(car.getSpeed() == 50);
+			System.out.println(car.canFly() == false);
+			System.out.println(car.accelerate(10) == 60);
+			System.out.println(car.accelerate(10) == 70);
+			System.out.println(car.accelerate(10) == 80);
+			System.out.println(car.accelerate(10) == 90);
+			System.out.println(car.accelerate(10) == 100);
+			try {
+				System.out.println(car.accelerate(10) == 110);
+				System.out.println("Error: ExceedSpeedLimit should be thrown!");
+			} catch (ExceedSpeedLimit e) {
+				System.out.println(e.getMessage().equals(
+						"Current speed is 100. Accelerate 10 will exceed the speed limit!"));
+			}
+			System.out.println(car.accelerate(-50) == 50);
+			System.out.println(car.accelerate(-50) == 0);
+			try {
+				System.out.println(car.accelerate(-50) == -50);
+				System.out.println("Error: NotEnoughSpeed should be thrown!");
+			} catch (NotEnoughSpeed e) {
+				System.out.println(e.getMessage()
+						.equals("Current speed is 0, not enough speed to decelerate!"));
+			}
+
+			Vehicle plane;
+			try {
+				plane = new Vehicle(-10, -20) {
+					@Override
+					public boolean canFly() {
+						return true;
+					}
+				};
+			} catch (BadSpeedSetting e) {
+				System.out.println(e.getMessage().equals("Speed cannot be negative!"));
+			}
+			try {
+				plane = new Vehicle(0, 50) {
+					@Override
+					public boolean canFly() {
+						return true;
+					}
+				};
+			} catch (BadSpeedSetting e) {
+				System.out.println(e.getMessage().equals("Speed cannot be greater than speed limit!"));
+			}
+			plane = new Vehicle(100, 50) {
+				@Override
+				public boolean canFly() {
+					return true;
+				}
+			};
+			System.out.println(plane.getSpeed() == 50);
+			System.out.println(plane.canFly() == true);
+			System.out.println(plane.accelerate(10) == 60);
+			System.out.println(plane.accelerate(10) == 70);
+			System.out.println(plane.accelerate(10) == 80);
+			System.out.println(plane.accelerate(10) == 90);
+			System.out.println(plane.accelerate(10) == 100);
+			try {
+				System.out.println(plane.accelerate(10) == 110);
+				System.out.println("Error: ExceedSpeedLimit should be thrown!");
+			} catch (ExceedSpeedLimit e) {
+				System.out.println(e.getMessage().equals(
+						"Current speed is 100. Accelerate 10 will exceed the speed limit!"));
+			}
+			System.out.println(plane.accelerate(-50) == 50);
+			System.out.println(plane.accelerate(-50) == 0);
+			try {
+				System.out.println(plane.accelerate(-50) == -50);
+				System.out.println("Error: NotEnoughSpeed should be thrown!");
+			} catch (NotEnoughSpeed e) {
+				System.out.println(e.getMessage()
+						.equals("Current speed is 0, not enough speed to decelerate!"));
+			}
+		} catch (Exception e) {
+			System.out.println("Error: Uncatched exception!");
+		}
+	}
+}

assignment5/Question3/Aircraft.java

@@ -0,0 +1,127 @@
+/*
+ * Author: CHEN Yongyuan (Walter) 1930006025 from OOP(1007)
+ * Date: 2022-04-24
+ * Description: Aircraft.java inherited from Vehicle class
+ */
+
+public class Aircraft extends Vehicle {
+	/**
+	 * The altitude at which the aircraft is flying.
+	 */
+	private int altitude;
+
+	/**
+	 * Constructor.
+	 *
+	 * @param speedLimit the speed limit of the aircraft
+	 * @param speed      the speed of the aircraft
+	 * @param altitude   the altitude of the aircraft
+	 * @throws BadSpeedSetting    if the speed limit is negative
+	 * @throws BadAltitudeSetting if the altitude is negative
+	 */
+	public Aircraft(int speedLimit, int speed, int altitude) throws BadSpeedSetting, BadAltitudeSetting {
+		super(speedLimit, speed);
+		if (altitude < 0) {
+			throw new BadAltitudeSetting("Altitude cannot be negative!");
+		}
+		this.altitude = altitude;
+	}
+
+	/**
+	 * Getter of altitude.
+	 *
+	 * @return the altitude of the aircraft
+	 */
+	public int getAltitude() {
+		return altitude;
+	}
+
+	/**
+	 * Aircraft can fly.
+	 *
+	 * @return true
+	 */
+	@Override
+	public boolean canFly() {
+		return true;
+	}
+
+	/**
+	 * Test.
+	 */
+	public static void testAircraft() {
+		try {
+			Aircraft aircraft;
+
+			try {
+				aircraft = new Aircraft(-10, 10, 10);
+			} catch (BadSpeedSetting e) {
+				System.out.println(e.getMessage().equals("Speed cannot be negative!"));
+			}
+
+			try {
+				aircraft = new Aircraft(10, -10, 10);
+			} catch (BadSpeedSetting e) {
+				System.out.println(e.getMessage().equals("Speed cannot be negative!"));
+			}
+
+			try {
+				aircraft = new Aircraft(10, 10, -10);
+			} catch (BadAltitudeSetting e) {
+				System.out.println(e.getMessage().equals("Altitude cannot be negative!"));
+			}
+
+			aircraft = new Aircraft(100, 50, 3900);
+			System.out.println(aircraft.getAltitude() == 3900);
+			System.out.println(aircraft.getSpeed() == 50);
+			System.out.println(aircraft.canFly() == true);
+			// acceleration
+			System.out.println(aircraft.accelerate(10) == 60);
+			System.out.println(aircraft.getSpeed() == 60);
+			System.out.println(aircraft.canFly() == true);
+			System.out.println(aircraft.accelerate(10) == 70);
+			System.out.println(aircraft.getSpeed() == 70);
+			System.out.println(aircraft.canFly() == true);
+			System.out.println(aircraft.accelerate(10) == 80);
+			System.out.println(aircraft.getSpeed() == 80);
+			System.out.println(aircraft.canFly() == true);
+			System.out.println(aircraft.accelerate(10) == 90);
+			System.out.println(aircraft.getSpeed() == 90);
+			System.out.println(aircraft.canFly() == true);
+			System.out.println(aircraft.accelerate(10) == 100);
+			System.out.println(aircraft.getSpeed() == 100);
+			System.out.println(aircraft.canFly() == true);
+			try {
+				aircraft.accelerate(10);
+			} catch (ExceedSpeedLimit e) {
+				System.out.println(e.getMessage().equals(
+						"Current speed is 100. Accelerate 10 will exceed the speed limit!"));
+			}
+			// deceleration
+			System.out.println(aircraft.accelerate(-20) == 80);
+			System.out.println(aircraft.getSpeed() == 80);
+			System.out.println(aircraft.canFly() == true);
+			System.out.println(aircraft.accelerate(-20) == 60);
+			System.out.println(aircraft.getSpeed() == 60);
+			System.out.println(aircraft.canFly() == true);
+			System.out.println(aircraft.accelerate(-20) == 40);
+			System.out.println(aircraft.getSpeed() == 40);
+			System.out.println(aircraft.canFly() == true);
+			System.out.println(aircraft.accelerate(-20) == 20);
+			System.out.println(aircraft.getSpeed() == 20);
+			System.out.println(aircraft.canFly() == true);
+			System.out.println(aircraft.accelerate(-20) == 0);
+			System.out.println(aircraft.getSpeed() == 0);
+			System.out.println(aircraft.canFly() == true);
+			try {
+				aircraft.accelerate(-20);
+			} catch (NotEnoughSpeed e) {
+				System.out.println(e.getMessage()
+						.equals("Current speed is 0, not enough speed to decelerate!"));
+			}
+
+		} catch (Exception e) {
+			System.out.println("Error uncaught exception: " + e.getMessage());
+		}
+	}
+}

assignment5/Question3/BadAltitudeSetting.java

@@ -0,0 +1,15 @@
+/*
+ * The BadAltitudeSetting class is used to test the speed of the program.
+ */
+public class BadAltitudeSetting extends Exception {
+	// generate serial ID by class name
+	private static final long serialVersionUID = BadAltitudeSetting.class.getName().hashCode();
+
+	public BadAltitudeSetting() {
+		super();
+	}
+
+	public BadAltitudeSetting(String message) {
+		super(message);
+	}
+}

assignment5/Question3/BadSpeedSetting.java

@@ -0,0 +1,15 @@
+/*
+ * The BadSpeedSetting class is used to test the speed of the program.
+ */
+public class BadSpeedSetting extends Exception {
+	// generate serial ID by class name
+	private static final long serialVersionUID = BadSpeedSetting.class.getName().hashCode();
+
+	public BadSpeedSetting() {
+		super();
+	}
+
+	public BadSpeedSetting(String message) {
+		super(message);
+	}
+}

assignment5/Question3/Car.java

@@ -0,0 +1,130 @@
+/*
+ * Author: CHEN Yongyuan (Walter) 1930006025 from OOP(1007)
+ * Date: 2022-04-24
+ * Description: Car class
+ */
+
+public class Car extends Vehicle {
+
+	/**
+	 * Car can not fly.
+	 *
+	 * @return false
+	 */
+	@Override
+	public boolean canFly() {
+		return false;
+	}
+
+	/**
+	 * Constructor.
+	 *
+	 * @param speedLimit The speed limit of the car.
+	 * @param speed      the speed of the car.
+	 * @thorws BadSpeedSetting if speedLimit or speed is negative. Or if the speed
+	 *         is greater than the speed limit.
+	 */
+	public Car(int speedLimit, int speed) throws BadSpeedSetting {
+		super(speedLimit, speed);
+	}
+
+	/**
+	 * Constructor. Default speed limit is 120.
+	 *
+	 * @param speed the speed of the car.
+	 * @thorws BadSpeedSetting if speed is negative. Or if the speed is greater than
+	 *         the speed limit 120.
+	 */
+	public Car(int speed) throws BadSpeedSetting {
+		this(120, speed);
+	}
+
+	/**
+	 * Test.
+	 */
+	public static void testCar() {
+		try {
+			Car c1;
+			try {
+				c1 = new Car(-1, -1);
+			} catch (BadSpeedSetting e) {
+				System.out.println(e.getMessage().equals("Speed cannot be negative!"));
+			}
+			try {
+				c1 = new Car(120, -1);
+			} catch (BadSpeedSetting e) {
+				System.out.println(e.getMessage().equals("Speed cannot be negative!"));
+			}
+			try {
+				c1 = new Car(120, 121);
+			} catch (BadSpeedSetting e) {
+				System.out.println(e.getMessage().equals("Speed cannot be greater than speed limit!"));
+			}
+			c1 = new Car(120, 100);
+			System.out.println(c1.getSpeed() == 100);
+			System.out.println(c1.canFly() == false);
+			System.out.println(c1.accelerate(10) == 110);
+			System.out.println(c1.canFly() == false);
+			System.out.println(c1.accelerate(10) == 120);
+			System.out.println(c1.canFly() == false);
+			try {
+				c1.accelerate(10);
+			} catch (ExceedSpeedLimit e) {
+				System.out.println(e.getMessage().equals(
+						"Current speed is 120. Accelerate 10 will exceed the speed limit!"));
+			}
+			System.out.println(c1.accelerate(-20) == 100);
+			System.out.println(c1.canFly() == false);
+			System.out.println(c1.accelerate(-20) == 80);
+			System.out.println(c1.canFly() == false);
+			System.out.println(c1.accelerate(-20) == 60);
+			System.out.println(c1.canFly() == false);
+			System.out.println(c1.accelerate(-20) == 40);
+			System.out.println(c1.canFly() == false);
+			System.out.println(c1.accelerate(-20) == 20);
+			System.out.println(c1.canFly() == false);
+			System.out.println(c1.accelerate(-20) == 0);
+			System.out.println(c1.canFly() == false);
+			try {
+				c1.accelerate(-20);
+			} catch (NotEnoughSpeed e) {
+				System.out.println(e.getMessage()
+						.equals("Current speed is 0, not enough speed to decelerate!"));
+			}
+
+			Car c2 = new Car(100);
+			System.out.println(c2.getSpeed() == 100);
+			System.out.println(c2.canFly() == false);
+			System.out.println(c2.accelerate(10) == 110);
+			System.out.println(c2.canFly() == false);
+			System.out.println(c2.accelerate(10) == 120);
+			System.out.println(c2.canFly() == false);
+			try {
+				c2.accelerate(10);
+			} catch (ExceedSpeedLimit e) {
+				System.out.println(e.getMessage().equals(
+						"Current speed is 120. Accelerate 10 will exceed the speed limit!"));
+			}
+			System.out.println(c2.accelerate(-20) == 100);
+			System.out.println(c2.canFly() == false);
+			System.out.println(c2.accelerate(-20) == 80);
+			System.out.println(c2.canFly() == false);
+			System.out.println(c2.accelerate(-20) == 60);
+			System.out.println(c2.canFly() == false);
+			System.out.println(c2.accelerate(-20) == 40);
+			System.out.println(c2.canFly() == false);
+			System.out.println(c2.accelerate(-20) == 20);
+			System.out.println(c2.canFly() == false);
+			System.out.println(c2.accelerate(-20) == 0);
+			System.out.println(c2.canFly() == false);
+			try {
+				c2.accelerate(-20);
+			} catch (NotEnoughSpeed e) {
+				System.out.println(e.getMessage()
+						.equals("Current speed is 0, not enough speed to decelerate!"));
+			}
+		} catch (Exception e) {
+			System.out.println("Error uncatched exception: " + e.getMessage());
+		}
+	}
+}

assignment5/Question3/ExceedSpeedLimit.java

@@ -0,0 +1,15 @@
+/*
+ * The ExceedSpeedLimit class is used to check if the speed limit is exceeded
+ */
+public class ExceedSpeedLimit extends Exception {
+	// generate serial ID by class name
+	private static final long serialVersionUID = ExceedSpeedLimit.class.getName().hashCode();
+
+	public ExceedSpeedLimit() {
+		super();
+	}
+
+	public ExceedSpeedLimit(String message) {
+		super(message);
+	}
+}

assignment5/Question3/Movable.java

@@ -0,0 +1,9 @@
+/*
+ * Author: CHEN Yongyuan (Walter) 1930006025 from OOP(1007)
+ * Date: 2022-04-24
+ * Description: This is a moveable interface.
+ */
+
+public interface Movable {
+	public int accelerate(int amount) throws ExceedSpeedLimit, NotEnoughSpeed;
+}

assignment5/Question3/NotEnoughSpeed.java

@@ -0,0 +1,15 @@
+/*
+ * The NotEnoughSpeed class is used to test the speed of the program.
+ */
+public class NotEnoughSpeed extends Exception {
+	// generate serial ID by class name
+	private static final long serialVersionUID = NotEnoughSpeed.class.getName().hashCode();
+
+	public NotEnoughSpeed() {
+		super();
+	}
+
+	public NotEnoughSpeed(String message) {
+		super(message);
+	}
+}

assignment5/Question3/Start.java

@@ -0,0 +1,7 @@
+public class Start {
+	public static void main(String[] args) {
+		Vehicle.testVehicle();
+		Car.testCar();
+		Aircraft.testAircraft();
+	}
+}

assignment5/Question3/StartGrading.java

@@ -0,0 +1,125 @@
+//Q3
+public class StartGrading {
+	public static void testVehicle() {
+//The Vehicle class is abstract. We cannot create objects from this class. Therefore, we cannot test anything
+	}
+
+	public static void testCar() {
+		// test case for constructors
+		try {
+			// exception
+			Car c1 = new Car(70, 80);
+		} catch (BadSpeedSetting e) {
+			System.out.println(e.getMessage().equals("Speed cannot be greater than speed limit!"));
+		}
+		try {
+			// exception
+			Car c2 = new Car(70, -10);
+		} catch (BadSpeedSetting e) {
+			System.out.println(e.getMessage().equals("Speed cannot be negative!"));
+		}
+		// test case for accelerate, canFly and getSpeed methods
+		try {
+			Car c3 = new Car(100, 80);
+			// test the canFly method
+			System.out.println(c3.canFly() == false);
+			c3.accelerate(10);
+			System.out.println(c3.getSpeed() == 90);
+			// test the accelerate with positive amount
+			c3.accelerate(-20);
+			System.out.println(c3.getSpeed() == 70);
+			// test the accelerate with negative amount
+			c3.accelerate(35); // exception
+		} catch (BadSpeedSetting e) {
+			System.out.println("BUG! THIS MUST NEVER HAPPEN!");
+		} catch (ExceedSpeedLimit e) {
+			System.out
+					.println(e.getMessage().equals("Current speed is 70. Accelerate 35 will exceed the speed limit!"));
+		} catch (NotEnoughSpeed e) {
+			System.out.println("BUG! THIS MUST NEVER HAPPEN!");
+		}
+		try {
+			Car c4 = new Car(100, 80);
+			// exception
+			c4.accelerate(-90);
+		} catch (BadSpeedSetting e) {
+			System.out.println("BUG! THIS MUST NEVER HAPPEN!");
+		} catch (ExceedSpeedLimit e) {
+			System.out.println("BUG! THIS MUST NEVER HAPPEN!");
+		} catch (NotEnoughSpeed e) {
+			System.out.println(e.getMessage().equals("Current speed is " + 80 + ", not enough speed to decelerate!"));
+		}
+	}
+
+	public static void testAircraft() {
+		// test case for constructors
+		try {
+			// Exception
+			Aircraft a1 = new Aircraft(70, 80, 1000);
+		} catch (BadSpeedSetting e) {
+			System.out.println(e.getMessage().equals("Speed cannot be greater than speed limit!"));
+		} catch (BadAltitudeSetting e) {
+			System.out.println("BUG! THIS MUST NEVER HAPPEN!");
+		}
+		try {
+			// exception
+			Aircraft a2 = new Aircraft(70, -10, 1000);
+		} catch (BadSpeedSetting e) {
+			System.out.println(e.getMessage().equals("Speed cannot be negative!"));
+		} catch (BadAltitudeSetting e) {
+			System.out.println("BUG! THIS MUST NEVER HAPPEN!");
+		}
+		try {
+			// exception
+			Aircraft a3 = new Aircraft(700, 200, -10);
+		} catch (BadSpeedSetting e) {
+			System.out.println("BUG! THIS MUST NEVER HAPPEN!");
+		} catch (BadAltitudeSetting e) {
+			System.out.println(e.getMessage().equals("Altitude cannot be negative!"));
+		}
+		// Test case for accelerate, canFly, getSpeed and getAltitude methods
+		try {
+			Aircraft a4 = new Aircraft(700, 200, 100);
+			// test the getAltitude method
+			System.out.println(a4.getAltitude() == 100);
+			// test the canFly method
+			System.out.println(a4.canFly() == true);
+			a4.accelerate(100);
+			System.out.println(a4.getSpeed() == 300);
+			// test the accelerate with positive amount
+			a4.accelerate(-200);
+			System.out.println(a4.getSpeed() == 100);
+			// test the accelerate with negative amount
+			// exception
+			a4.accelerate(650);
+		} catch (BadSpeedSetting e) {
+			System.out.println("BUG! THIS MUST NEVER HAPPEN!");
+		} catch (BadAltitudeSetting e) {
+			System.out.println("BUG! THIS MUST NEVER HAPPEN!");
+		} catch (ExceedSpeedLimit e) {
+			System.out.println(
+					e.getMessage().equals("Current speed is 100. Accelerate 650 will exceed the speed limit!"));
+		} catch (NotEnoughSpeed e) {
+			System.out.println("BUG! THIS MUST NEVER HAPPEN!");
+		}
+		try {
+			Aircraft a5 = new Aircraft(700, 200, 100);
+			// exception
+			a5.accelerate(-300);
+		} catch (BadSpeedSetting e) {
+			System.out.println("BUG! THIS MUST NEVER HAPPEN!");
+		} catch (BadAltitudeSetting e) {
+			System.out.println("BUG! THIS MUST NEVER HAPPEN!");
+		} catch (ExceedSpeedLimit e) {
+			System.out.println("BUG! THIS MUST NEVER HAPPEN!");
+		} catch (NotEnoughSpeed e) {
+			System.out.println(e.getMessage().equals("Current speed is " + 200 + ", not enough speed to decelerate!"));
+		}
+	}
+
+	public static void main(String[] args) {
+		Vehicle.testVehicle();
+		Car.testCar();
+		Aircraft.testAircraft();
+	}
+}

assignment5/Question3/Vehicle.java

@@ -0,0 +1,180 @@
+/*
+ * Author: CHEN Yongyuan (Walter) 1930006025 from OOP(1007)
+ * Date: 2022-04-24
+ * Description: This is the abstract Vehicle class.
+ */
+
+public abstract class Vehicle implements Movable {
+	private int speedLimit;
+	private int speed;
+
+	/**
+	 * Constructor.
+	 *
+	 * @param speedLimit the speed limit of the vehicle
+	 * @param speed      the speed of the vehicle
+	 * @throws BadSpeedSetting if speedLimit or speed is negative. Or if the speed
+	 *                         is greater than speed limit.
+	 */
+	public Vehicle(int speedLimit, int speed) throws BadSpeedSetting {
+		if (speedLimit < 0 || speed < 0) {
+			throw new BadSpeedSetting("Speed cannot be negative!");
+		}
+		if (speed > speedLimit) {
+			throw new BadSpeedSetting("Speed cannot be greater than speed limit!");
+		}
+		this.speedLimit = speedLimit;
+		this.speed = speed;
+	}
+
+	/**
+	 * Getter of speed.
+	 *
+	 * @return the speed of the vehicle
+	 */
+	public int getSpeed() {
+		return speed;
+	}
+
+	/**
+	 * Accelerate the vehicle.
+	 *
+	 * @param amount the amount of acceleration.
+	 * @throws ExceedSpeedLimit if the speed is greater than speed limit after
+	 *                          increased.
+	 * @thorws NotEnoughSpeed if the speed is less than 0 after decreased.
+	 * @return the new speed of the vehicle
+	 */
+	public int accelerate(int amount) throws ExceedSpeedLimit, NotEnoughSpeed {
+		int newSpeed = speed + amount;
+		if (newSpeed > speedLimit) {
+			throw new ExceedSpeedLimit(
+					String.format("Current speed is %d. Accelerate %d will exceed the speed limit!",
+							speed, amount));
+		}
+		if (newSpeed < 0) {
+			throw new NotEnoughSpeed(
+					String.format("Current speed is %d, not enough speed to decelerate!", speed));
+		}
+		speed = newSpeed;
+		return speed;
+	}
+
+	/**
+	 * Whether the vehicle can fly or not.
+	 *
+	 * @return whether the vehicle can fly.
+	 */
+	public abstract boolean canFly();
+
+	/**
+	 * Test.
+	 */
+	public static void testVehicle() {
+		try {
+			Vehicle car;
+			try {
+				car = new Vehicle(-10, -20) {
+					@Override
+					public boolean canFly() {
+						return false;
+					}
+				};
+			} catch (BadSpeedSetting e) {
+				System.out.println(e.getMessage().equals("Speed cannot be negative!"));
+			}
+			try {
+				car = new Vehicle(0, 50) {
+					@Override
+					public boolean canFly() {
+						return false;
+					}
+				};
+			} catch (BadSpeedSetting e) {
+				System.out.println(e.getMessage().equals("Speed cannot be greater than speed limit!"));
+			}
+			car = new Vehicle(100, 50) {
+				@Override
+				public boolean canFly() {
+					return false;
+				}
+			};
+			System.out.println(car.getSpeed() == 50);
+			System.out.println(car.canFly() == false);
+			System.out.println(car.accelerate(10) == 60);
+			System.out.println(car.accelerate(10) == 70);
+			System.out.println(car.accelerate(10) == 80);
+			System.out.println(car.accelerate(10) == 90);
+			System.out.println(car.accelerate(10) == 100);
+			try {
+				System.out.println(car.accelerate(10) == 110);
+				System.out.println("Error: ExceedSpeedLimit should be thrown!");
+			} catch (ExceedSpeedLimit e) {
+				System.out.println(e.getMessage().equals(
+						"Current speed is 100. Accelerate 10 will exceed the speed limit!"));
+			}
+			System.out.println(car.accelerate(-50) == 50);
+			System.out.println(car.accelerate(-50) == 0);
+			try {
+				System.out.println(car.accelerate(-50) == -50);
+				System.out.println("Error: NotEnoughSpeed should be thrown!");
+			} catch (NotEnoughSpeed e) {
+				System.out.println(e.getMessage()
+						.equals("Current speed is 0, not enough speed to decelerate!"));
+			}
+
+			Vehicle plane;
+			try {
+				plane = new Vehicle(-10, -20) {
+					@Override
+					public boolean canFly() {
+						return true;
+					}
+				};
+			} catch (BadSpeedSetting e) {
+				System.out.println(e.getMessage().equals("Speed cannot be negative!"));
+			}
+			try {
+				plane = new Vehicle(0, 50) {
+					@Override
+					public boolean canFly() {
+						return true;
+					}
+				};
+			} catch (BadSpeedSetting e) {
+				System.out.println(e.getMessage().equals("Speed cannot be greater than speed limit!"));
+			}
+			plane = new Vehicle(100, 50) {
+				@Override
+				public boolean canFly() {
+					return true;
+				}
+			};
+			System.out.println(plane.getSpeed() == 50);
+			System.out.println(plane.canFly() == true);
+			System.out.println(plane.accelerate(10) == 60);
+			System.out.println(plane.accelerate(10) == 70);
+			System.out.println(plane.accelerate(10) == 80);
+			System.out.println(plane.accelerate(10) == 90);
+			System.out.println(plane.accelerate(10) == 100);
+			try {
+				System.out.println(plane.accelerate(10) == 110);
+				System.out.println("Error: ExceedSpeedLimit should be thrown!");
+			} catch (ExceedSpeedLimit e) {
+				System.out.println(e.getMessage().equals(
+						"Current speed is 100. Accelerate 10 will exceed the speed limit!"));
+			}
+			System.out.println(plane.accelerate(-50) == 50);
+			System.out.println(plane.accelerate(-50) == 0);
+			try {
+				System.out.println(plane.accelerate(-50) == -50);
+				System.out.println("Error: NotEnoughSpeed should be thrown!");
+			} catch (NotEnoughSpeed e) {
+				System.out.println(e.getMessage()
+						.equals("Current speed is 0, not enough speed to decelerate!"));
+			}
+		} catch (Exception e) {
+			System.out.println("Error: Uncatched exception!");
+		}
+	}
+}

assignment5/Question4/Aircraft.java

@@ -0,0 +1,127 @@
+/*
+ * Author: CHEN Yongyuan (Walter) 1930006025 from OOP(1007)
+ * Date: 2022-04-24
+ * Description: Aircraft.java inherited from Vehicle class
+ */
+
+public class Aircraft extends Vehicle {
+	/**
+	 * The altitude at which the aircraft is flying.
+	 */
+	private int altitude;
+
+	/**
+	 * Constructor.
+	 *
+	 * @param speedLimit the speed limit of the aircraft
+	 * @param speed      the speed of the aircraft
+	 * @param altitude   the altitude of the aircraft
+	 * @throws BadSpeedSetting    if the speed limit is negative
+	 * @throws BadAltitudeSetting if the altitude is negative
+	 */
+	public Aircraft(int speedLimit, int speed, int altitude) throws BadSpeedSetting, BadAltitudeSetting {
+		super(speedLimit, speed);
+		if (altitude < 0) {
+			throw new BadAltitudeSetting("Altitude cannot be negative!");
+		}
+		this.altitude = altitude;
+	}
+
+	/**
+	 * Getter of altitude.
+	 *
+	 * @return the altitude of the aircraft
+	 */
+	public int getAltitude() {
+		return altitude;
+	}
+
+	/**
+	 * Aircraft can fly.
+	 *
+	 * @return true
+	 */
+	@Override
+	public boolean canFly() {
+		return true;
+	}
+
+	/**
+	 * Test.
+	 */
+	public static void testAircraft() {
+		try {
+			Aircraft aircraft;
+
+			try {
+				aircraft = new Aircraft(-10, 10, 10);
+			} catch (BadSpeedSetting e) {
+				System.out.println(e.getMessage().equals("Speed cannot be negative!"));
+			}
+
+			try {
+				aircraft = new Aircraft(10, -10, 10);
+			} catch (BadSpeedSetting e) {
+				System.out.println(e.getMessage().equals("Speed cannot be negative!"));
+			}
+
+			try {
+				aircraft = new Aircraft(10, 10, -10);
+			} catch (BadAltitudeSetting e) {
+				System.out.println(e.getMessage().equals("Altitude cannot be negative!"));
+			}
+
+			aircraft = new Aircraft(100, 50, 3900);
+			System.out.println(aircraft.getAltitude() == 3900);
+			System.out.println(aircraft.getSpeed() == 50);
+			System.out.println(aircraft.canFly() == true);
+			// acceleration
+			System.out.println(aircraft.accelerate(10) == 60);
+			System.out.println(aircraft.getSpeed() == 60);
+			System.out.println(aircraft.canFly() == true);
+			System.out.println(aircraft.accelerate(10) == 70);
+			System.out.println(aircraft.getSpeed() == 70);
+			System.out.println(aircraft.canFly() == true);
+			System.out.println(aircraft.accelerate(10) == 80);
+			System.out.println(aircraft.getSpeed() == 80);
+			System.out.println(aircraft.canFly() == true);
+			System.out.println(aircraft.accelerate(10) == 90);
+			System.out.println(aircraft.getSpeed() == 90);
+			System.out.println(aircraft.canFly() == true);
+			System.out.println(aircraft.accelerate(10) == 100);
+			System.out.println(aircraft.getSpeed() == 100);
+			System.out.println(aircraft.canFly() == true);
+			try {
+				aircraft.accelerate(10);
+			} catch (ExceedSpeedLimit e) {
+				System.out.println(e.getMessage().equals(
+						"Current speed is 100. Accelerate 10 will exceed the speed limit!"));
+			}
+			// deceleration
+			System.out.println(aircraft.accelerate(-20) == 80);
+			System.out.println(aircraft.getSpeed() == 80);
+			System.out.println(aircraft.canFly() == true);
+			System.out.println(aircraft.accelerate(-20) == 60);
+			System.out.println(aircraft.getSpeed() == 60);
+			System.out.println(aircraft.canFly() == true);
+			System.out.println(aircraft.accelerate(-20) == 40);
+			System.out.println(aircraft.getSpeed() == 40);
+			System.out.println(aircraft.canFly() == true);
+			System.out.println(aircraft.accelerate(-20) == 20);
+			System.out.println(aircraft.getSpeed() == 20);
+			System.out.println(aircraft.canFly() == true);
+			System.out.println(aircraft.accelerate(-20) == 0);
+			System.out.println(aircraft.getSpeed() == 0);
+			System.out.println(aircraft.canFly() == true);
+			try {
+				aircraft.accelerate(-20);
+			} catch (NotEnoughSpeed e) {
+				System.out.println(e.getMessage()
+						.equals("Current speed is 0, not enough speed to decelerate!"));
+			}
+
+		} catch (Exception e) {
+			System.out.println("Error uncaught exception: " + e.getMessage());
+		}
+	}
+}

assignment5/Question4/BadAltitudeSetting.java

@@ -0,0 +1,15 @@
+/*
+ * The BadAltitudeSetting class is used to test the speed of the program.
+ */
+public class BadAltitudeSetting extends Exception {
+	// generate serial ID by class name
+	private static final long serialVersionUID = BadAltitudeSetting.class.getName().hashCode();
+
+	public BadAltitudeSetting() {
+		super();
+	}
+
+	public BadAltitudeSetting(String message) {
+		super(message);
+	}
+}

assignment5/Question4/BadSpeedSetting.java

@@ -0,0 +1,15 @@
+/*
+ * The BadSpeedSetting class is used to test the speed of the program.
+ */
+public class BadSpeedSetting extends Exception {
+	// generate serial ID by class name
+	private static final long serialVersionUID = BadSpeedSetting.class.getName().hashCode();
+
+	public BadSpeedSetting() {
+		super();
+	}
+
+	public BadSpeedSetting(String message) {
+		super(message);
+	}
+}

assignment5/Question4/Car.java

@@ -0,0 +1,130 @@
+/*
+ * Author: CHEN Yongyuan (Walter) 1930006025 from OOP(1007)
+ * Date: 2022-04-24
+ * Description: Car class
+ */
+
+public class Car extends Vehicle {
+
+	/**
+	 * Car can not fly.
+	 *
+	 * @return false
+	 */
+	@Override
+	public boolean canFly() {
+		return false;
+	}
+
+	/**
+	 * Constructor.
+	 *
+	 * @param speedLimit The speed limit of the car.
+	 * @param speed      the speed of the car.
+	 * @thorws BadSpeedSetting if speedLimit or speed is negative. Or if the speed
+	 *         is greater than the speed limit.
+	 */
+	public Car(int speedLimit, int speed) throws BadSpeedSetting {
+		super(speedLimit, speed);
+	}
+
+	/**
+	 * Constructor. Default speed limit is 120.
+	 *
+	 * @param speed the speed of the car.
+	 * @thorws BadSpeedSetting if speed is negative. Or if the speed is greater than
+	 *         the speed limit 120.
+	 */
+	public Car(int speed) throws BadSpeedSetting {
+		this(120, speed);
+	}
+
+	/**
+	 * Test.
+	 */
+	public static void testCar() {
+		try {
+			Car c1;
+			try {
+				c1 = new Car(-1, -1);
+			} catch (BadSpeedSetting e) {
+				System.out.println(e.getMessage().equals("Speed cannot be negative!"));
+			}
+			try {
+				c1 = new Car(120, -1);
+			} catch (BadSpeedSetting e) {
+				System.out.println(e.getMessage().equals("Speed cannot be negative!"));
+			}
+			try {
+				c1 = new Car(120, 121);
+			} catch (BadSpeedSetting e) {
+				System.out.println(e.getMessage().equals("Speed cannot be greater than speed limit!"));
+			}
+			c1 = new Car(120, 100);
+			System.out.println(c1.getSpeed() == 100);
+			System.out.println(c1.canFly() == false);
+			System.out.println(c1.accelerate(10) == 110);
+			System.out.println(c1.canFly() == false);
+			System.out.println(c1.accelerate(10) == 120);
+			System.out.println(c1.canFly() == false);
+			try {
+				c1.accelerate(10);
+			} catch (ExceedSpeedLimit e) {
+				System.out.println(e.getMessage().equals(
+						"Current speed is 120. Accelerate 10 will exceed the speed limit!"));
+			}
+			System.out.println(c1.accelerate(-20) == 100);
+			System.out.println(c1.canFly() == false);
+			System.out.println(c1.accelerate(-20) == 80);
+			System.out.println(c1.canFly() == false);
+			System.out.println(c1.accelerate(-20) == 60);
+			System.out.println(c1.canFly() == false);
+			System.out.println(c1.accelerate(-20) == 40);
+			System.out.println(c1.canFly() == false);
+			System.out.println(c1.accelerate(-20) == 20);
+			System.out.println(c1.canFly() == false);
+			System.out.println(c1.accelerate(-20) == 0);
+			System.out.println(c1.canFly() == false);
+			try {
+				c1.accelerate(-20);
+			} catch (NotEnoughSpeed e) {
+				System.out.println(e.getMessage()
+						.equals("Current speed is 0, not enough speed to decelerate!"));
+			}
+
+			Car c2 = new Car(100);
+			System.out.println(c2.getSpeed() == 100);
+			System.out.println(c2.canFly() == false);
+			System.out.println(c2.accelerate(10) == 110);
+			System.out.println(c2.canFly() == false);
+			System.out.println(c2.accelerate(10) == 120);
+			System.out.println(c2.canFly() == false);
+			try {
+				c2.accelerate(10);
+			} catch (ExceedSpeedLimit e) {
+				System.out.println(e.getMessage().equals(
+						"Current speed is 120. Accelerate 10 will exceed the speed limit!"));
+			}
+			System.out.println(c2.accelerate(-20) == 100);
+			System.out.println(c2.canFly() == false);
+			System.out.println(c2.accelerate(-20) == 80);
+			System.out.println(c2.canFly() == false);
+			System.out.println(c2.accelerate(-20) == 60);
+			System.out.println(c2.canFly() == false);
+			System.out.println(c2.accelerate(-20) == 40);
+			System.out.println(c2.canFly() == false);
+			System.out.println(c2.accelerate(-20) == 20);
+			System.out.println(c2.canFly() == false);
+			System.out.println(c2.accelerate(-20) == 0);
+			System.out.println(c2.canFly() == false);
+			try {
+				c2.accelerate(-20);
+			} catch (NotEnoughSpeed e) {
+				System.out.println(e.getMessage()
+						.equals("Current speed is 0, not enough speed to decelerate!"));
+			}
+		} catch (Exception e) {
+			System.out.println("Error uncatched exception: " + e.getMessage());
+		}
+	}
+}

assignment5/Question4/ExceedSpeedLimit.java

@@ -0,0 +1,15 @@
+/*
+ * The ExceedSpeedLimit class is used to check if the speed limit is exceeded
+ */
+public class ExceedSpeedLimit extends Exception {
+	// generate serial ID by class name
+	private static final long serialVersionUID = ExceedSpeedLimit.class.getName().hashCode();
+
+	public ExceedSpeedLimit() {
+		super();
+	}
+
+	public ExceedSpeedLimit(String message) {
+		super(message);
+	}
+}

assignment5/Question4/Movable.java

@@ -0,0 +1,9 @@
+/*
+ * Author: CHEN Yongyuan (Walter) 1930006025 from OOP(1007)
+ * Date: 2022-04-24
+ * Description: This is a moveable interface.
+ */
+
+public interface Movable {
+	public int accelerate(int amount) throws ExceedSpeedLimit, NotEnoughSpeed, TrainSpeedChange;
+}

assignment5/Question4/NotEnoughSpeed.java

@@ -0,0 +1,15 @@
+/*
+ * The NotEnoughSpeed class is used to test the speed of the program.
+ */
+public class NotEnoughSpeed extends Exception {
+	// generate serial ID by class name
+	private static final long serialVersionUID = NotEnoughSpeed.class.getName().hashCode();
+
+	public NotEnoughSpeed() {
+		super();
+	}
+
+	public NotEnoughSpeed(String message) {
+		super(message);
+	}
+}

assignment5/Question4/Start.java

@@ -0,0 +1,8 @@
+public class Start {
+	public static void main(String[] args) {
+		Vehicle.testVehicle();
+		Car.testCar();
+		Aircraft.testAircraft();
+		Train.testTrain();
+	}
+}

assignment5/Question4/StartGrading.java

@@ -0,0 +1,164 @@
+//Q4
+public class StartGrading {
+	public static void testVehicle() {
+//The Vehicle class is abstract. We cannot create objects from this class. Therefore, we cannot test anything
+	}
+
+	public static void testCar() {
+		// test case for constructors
+		try {
+			// exception
+			Car c1 = new Car(70, 80);
+		} catch (BadSpeedSetting e) {
+			System.out.println(e.getMessage().equals("Speed cannot be greater than speed limit!"));
+		}
+		try {
+			// exception
+			Car c2 = new Car(70, -10);
+		} catch (BadSpeedSetting e) {
+			System.out.println(e.getMessage().equals("Speed cannot be negative!"));
+		}
+		// test case for accelerate, canFly and getSpeed methods
+		try {
+			Car c3 = new Car(100, 80);
+			// test the canFly method
+			System.out.println(c3.canFly() == false);
+			c3.accelerate(10);
+			System.out.println(c3.getSpeed() == 90);
+			// test the accelerate with positive amount
+			c3.accelerate(-20);
+			System.out.println(c3.getSpeed() == 70);
+			// test the accelerate with negative amount
+			c3.accelerate(35); // exception
+		} catch (BadSpeedSetting e) {
+			System.out.println("BUG! THIS MUST NEVER HAPPEN!");
+		} catch (ExceedSpeedLimit e) {
+			System.out
+					.println(e.getMessage().equals("Current speed is 70. Accelerate 35 will exceed the speed limit!"));
+		} catch (NotEnoughSpeed e) {
+			System.out.println("BUG! THIS MUST NEVER HAPPEN!");
+		} catch (TrainSpeedChange e) {
+			System.out.println("BUG! THIS MUST NEVER HAPPEN!");
+		}
+		try {
+			Car c4 = new Car(100, 80);
+			// exception
+			c4.accelerate(-90);
+		} catch (BadSpeedSetting e) {
+			System.out.println("BUG! THIS MUST NEVER HAPPEN!");
+		} catch (ExceedSpeedLimit e) {
+			System.out.println("BUG! THIS MUST NEVER HAPPEN!");
+		} catch (NotEnoughSpeed e) {
+			System.out.println(e.getMessage().equals("Current speed is " + 80 + ", not enough speed to decelerate!"));
+		} catch (TrainSpeedChange e) {
+			System.out.println("BUG! THIS MUST NEVER HAPPEN!");
+		}
+	}
+
+	public static void testAircraft() {
+		// test case for constructors
+		try {
+			// Exception
+			Aircraft a1 = new Aircraft(70, 80, 1000);
+		} catch (BadSpeedSetting e) {
+			System.out.println(e.getMessage().equals("Speed cannot be greater than speed limit!"));
+		} catch (BadAltitudeSetting e) {
+			System.out.println("BUG! THIS MUST NEVER HAPPEN!");
+		}
+		try {
+			// exception
+			Aircraft a2 = new Aircraft(70, -10, 1000);
+		} catch (BadSpeedSetting e) {
+			System.out.println(e.getMessage().equals("Speed cannot be negative!"));
+		} catch (BadAltitudeSetting e) {
+			System.out.println("BUG! THIS MUST NEVER HAPPEN!");
+		}
+		try {
+			// exception
+			Aircraft a3 = new Aircraft(700, 200, -10);
+		} catch (BadSpeedSetting e) {
+			System.out.println("BUG! THIS MUST NEVER HAPPEN!");
+		} catch (BadAltitudeSetting e) {
+			System.out.println(e.getMessage().equals("Altitude cannot be negative!"));
+		}
+		// Test case for accelerate, canFly, getSpeed and getAltitude methods
+		try {
+			Aircraft a4 = new Aircraft(700, 200, 100);
+			// test the getAltitude method
+			System.out.println(a4.getAltitude() == 100);
+			// test the canFly method
+			System.out.println(a4.canFly() == true);
+			a4.accelerate(100);
+			System.out.println(a4.getSpeed() == 300);
+			// test the accelerate with positive amount
+			a4.accelerate(-200);
+			System.out.println(a4.getSpeed() == 100);
+			// test the accelerate with negative amount
+			// exception
+			a4.accelerate(650);
+		} catch (BadSpeedSetting e) {
+			System.out.println("BUG! THIS MUST NEVER HAPPEN!");
+		} catch (BadAltitudeSetting e) {
+			System.out.println("BUG! THIS MUST NEVER HAPPEN!");
+		} catch (ExceedSpeedLimit e) {
+			System.out.println(
+					e.getMessage().equals("Current speed is 100. Accelerate 650 will exceed the speed limit!"));
+		} catch (NotEnoughSpeed e) {
+			System.out.println("BUG! THIS MUST NEVER HAPPEN!");
+		} catch (TrainSpeedChange e) {
+			System.out.println("BUG! THIS MUST NEVER HAPPEN!");
+		}
+		try {
+			Aircraft a5 = new Aircraft(700, 200, 100);
+			// exception
+			a5.accelerate(-300);
+		} catch (BadSpeedSetting e) {
+			System.out.println("BUG! THIS MUST NEVER HAPPEN!");
+		} catch (BadAltitudeSetting e) {
+			System.out.println("BUG! THIS MUST NEVER HAPPEN!");
+		} catch (ExceedSpeedLimit e) {
+			System.out.println("BUG! THIS MUST NEVER HAPPEN!");
+		} catch (NotEnoughSpeed e) {
+			System.out.println(e.getMessage().equals("Current speed is " + 200 + ", not enough speed to decelerate!"));
+		} catch (TrainSpeedChange e) {
+			System.out.println("BUG! THIS MUST NEVER HAPPEN!");
+		}
+	}
+
+	public static void testTrain() {
+		// test case for constructors
+		try {
+			// exception
+			Train t1 = new Train(350, 400);
+		} catch (BadSpeedSetting e) {
+			System.out.println(e.getMessage().equals("Speed cannot be greater than speed limit!"));
+		}
+		try {
+			// exception
+			Train t2 = new Train(350, -100);
+		} catch (BadSpeedSetting e) {
+			System.out.println(e.getMessage().equals("Speed cannot be negative!"));
+		}
+		// test case for accelerate, canFly and getSpeed methods
+		try {
+			Train t3 = new Train(350, 300);
+			// test the canFly method
+			System.out.println(t3.canFly() == false);
+			// test the getSpeed
+			System.out.println(t3.getSpeed() == 300);
+			// exception
+			t3.accelerate(50);
+		} catch (BadSpeedSetting e) {
+			System.out.println("BUG! THIS MUST NEVER HAPPEN!");
+		} catch (TrainSpeedChange e) {
+			System.out.println(e.getMessage().equals("Do not try to accelerate or decelerate the train!"));
+		}
+	}
+
+	public static void main(String[] args) {
+		Vehicle.testVehicle();
+		Car.testCar();
+		Aircraft.testAircraft();
+		Train.testTrain();
+	}
+}

assignment5/Question4/Train.java

@@ -0,0 +1,71 @@
+/*
+ * Author: CHEN Yongyuan (Walter) 1930006025 from OOP(1007)
+ * Date: 2022-04-24
+ * Description: Train class inherited from Vehicle class
+ */
+
+public class Train extends Vehicle {
+	/**
+	 * Constructor.
+	 *
+	 * @param speedLimit the speed limit of the train
+	 * @param speed the speed of the train
+	 * @throws BadSpeedSetting
+	 */
+	public Train(int speedLimit, int speed) throws BadSpeedSetting {
+		super(speedLimit, speed);
+	}
+
+	/**
+	 * Train can not fly.
+	 *
+	 * @return false
+	 */
+	@Override
+	public boolean canFly() {
+		return false;
+	}
+
+	/**
+	 * Tain speed can not be changed.
+	 *
+	 * @throws TrainSpeedChange
+	 */
+	@Override
+	public int accelerate(int amount) throws TrainSpeedChange {
+		throw new TrainSpeedChange("Do not try to accelerate or decelerate the train!");
+	}
+
+	/**
+	 * Test.
+	 */
+	public static void testTrain() {
+		try {
+			Train train;
+			try {
+				train = new Train(-1, -1);
+			} catch (BadSpeedSetting e) {
+				System.out.println(e.getMessage().equals("Speed cannot be negative!"));
+			}
+			try {
+				train = new Train(100, -1);
+			} catch (BadSpeedSetting e) {
+				System.out.println(e.getMessage().equals("Speed cannot be negative!"));
+			}
+			try {
+				train = new Train(100, 101);
+			} catch (BadSpeedSetting e) {
+				System.out.println(e.getMessage().equals("Speed cannot be greater than speed limit!"));
+			}
+			train = new Train(100, 50);
+			System.out.println(train.getSpeed() == 50);
+			try {
+				train.accelerate(1);
+			} catch (TrainSpeedChange e) {
+				System.out.println(e.getMessage().equals("Do not try to accelerate or decelerate the train!"));
+			}
+		} catch (Exception e) {
+			System.out.println("Error: uncaught exception " + e.getClass() + ": " + e.getMessage());
+		}
+	}
+}

assignment5/Question4/TrainSpeedChange.java

@@ -0,0 +1,15 @@
+/*
+ * The TrainSpeedChange class is used to test the speed of the program.
+ */
+public class TrainSpeedChange extends Exception {
+	// generate serial ID by class name
+	private static final long serialVersionUID = TrainSpeedChange.class.getName().hashCode();
+
+	public TrainSpeedChange() {
+		super();
+	}
+
+	public TrainSpeedChange(String message) {
+		super(message);
+	}
+}

assignment5/Question4/Vehicle.java

@@ -0,0 +1,180 @@
+/*
+ * Author: CHEN Yongyuan (Walter) 1930006025 from OOP(1007)
+ * Date: 2022-04-24
+ * Description: This is the abstract Vehicle class.
+ */
+
+public abstract class Vehicle implements Movable {
+	private int speedLimit;
+	private int speed;
+
+	/**
+	 * Constructor.
+	 *
+	 * @param speedLimit the speed limit of the vehicle
+	 * @param speed      the speed of the vehicle
+	 * @throws BadSpeedSetting if speedLimit or speed is negative. Or if the speed
+	 *                         is greater than speed limit.
+	 */
+	public Vehicle(int speedLimit, int speed) throws BadSpeedSetting {
+		if (speedLimit < 0 || speed < 0) {
+			throw new BadSpeedSetting("Speed cannot be negative!");
+		}
+		if (speed > speedLimit) {
+			throw new BadSpeedSetting("Speed cannot be greater than speed limit!");
+		}
+		this.speedLimit = speedLimit;
+		this.speed = speed;
+	}
+
+	/**
+	 * Getter of speed.
+	 *
+	 * @return the speed of the vehicle
+	 */
+	public int getSpeed() {
+		return speed;
+	}
+
+	/**
+	 * Accelerate the vehicle.
+	 *
+	 * @param amount the amount of acceleration.
+	 * @throws ExceedSpeedLimit if the speed is greater than speed limit after
+	 *                          increased.
+	 * @thorws NotEnoughSpeed if the speed is less than 0 after decreased.
+	 * @return the new speed of the vehicle
+	 */
+	public int accelerate(int amount) throws ExceedSpeedLimit, NotEnoughSpeed, TrainSpeedChange {
+		int newSpeed = speed + amount;
+		if (newSpeed > speedLimit) {
+			throw new ExceedSpeedLimit(
+					String.format("Current speed is %d. Accelerate %d will exceed the speed limit!",
+							speed, amount));
+		}
+		if (newSpeed < 0) {
+			throw new NotEnoughSpeed(
+					String.format("Current speed is %d, not enough speed to decelerate!", speed));
+		}
+		speed = newSpeed;
+		return speed;
+	}
+
+	/**
+	 * Whether the vehicle can fly or not.
+	 *
+	 * @return whether the vehicle can fly.
+	 */
+	public abstract boolean canFly();
+
+	/**
+	 * Test.
+	 */
+	public static void testVehicle() {
+		try {
+			Vehicle car;
+			try {
+				car = new Vehicle(-10, -20) {
+					@Override
+					public boolean canFly() {
+						return false;
+					}
+				};
+			} catch (BadSpeedSetting e) {
+				System.out.println(e.getMessage().equals("Speed cannot be negative!"));
+			}
+			try {
+				car = new Vehicle(0, 50) {
+					@Override
+					public boolean canFly() {
+						return false;
+					}
+				};
+			} catch (BadSpeedSetting e) {
+				System.out.println(e.getMessage().equals("Speed cannot be greater than speed limit!"));
+			}
+			car = new Vehicle(100, 50) {
+				@Override
+				public boolean canFly() {
+					return false;
+				}
+			};
+			System.out.println(car.getSpeed() == 50);
+			System.out.println(car.canFly() == false);
+			System.out.println(car.accelerate(10) == 60);
+			System.out.println(car.accelerate(10) == 70);
+			System.out.println(car.accelerate(10) == 80);
+			System.out.println(car.accelerate(10) == 90);
+			System.out.println(car.accelerate(10) == 100);
+			try {
+				System.out.println(car.accelerate(10) == 110);
+				System.out.println("Error: ExceedSpeedLimit should be thrown!");
+			} catch (ExceedSpeedLimit e) {
+				System.out.println(e.getMessage().equals(
+						"Current speed is 100. Accelerate 10 will exceed the speed limit!"));
+			}
+			System.out.println(car.accelerate(-50) == 50);
+			System.out.println(car.accelerate(-50) == 0);
+			try {
+				System.out.println(car.accelerate(-50) == -50);
+				System.out.println("Error: NotEnoughSpeed should be thrown!");
+			} catch (NotEnoughSpeed e) {
+				System.out.println(e.getMessage()
+						.equals("Current speed is 0, not enough speed to decelerate!"));
+			}
+
+			Vehicle plane;
+			try {
+				plane = new Vehicle(-10, -20) {
+					@Override
+					public boolean canFly() {
+						return true;
+					}
+				};
+			} catch (BadSpeedSetting e) {
+				System.out.println(e.getMessage().equals("Speed cannot be negative!"));
+			}
+			try {
+				plane = new Vehicle(0, 50) {
+					@Override
+					public boolean canFly() {
+						return true;
+					}
+				};
+			} catch (BadSpeedSetting e) {
+				System.out.println(e.getMessage().equals("Speed cannot be greater than speed limit!"));
+			}
+			plane = new Vehicle(100, 50) {
+				@Override
+				public boolean canFly() {
+					return true;
+				}
+			};
+			System.out.println(plane.getSpeed() == 50);
+			System.out.println(plane.canFly() == true);
+			System.out.println(plane.accelerate(10) == 60);
+			System.out.println(plane.accelerate(10) == 70);
+			System.out.println(plane.accelerate(10) == 80);
+			System.out.println(plane.accelerate(10) == 90);
+			System.out.println(plane.accelerate(10) == 100);
+			try {
+				System.out.println(plane.accelerate(10) == 110);
+				System.out.println("Error: ExceedSpeedLimit should be thrown!");
+			} catch (ExceedSpeedLimit e) {
+				System.out.println(e.getMessage().equals(
+						"Current speed is 100. Accelerate 10 will exceed the speed limit!"));
+			}
+			System.out.println(plane.accelerate(-50) == 50);
+			System.out.println(plane.accelerate(-50) == 0);
+			try {
+				System.out.println(plane.accelerate(-50) == -50);
+				System.out.println("Error: NotEnoughSpeed should be thrown!");
+			} catch (NotEnoughSpeed e) {
+				System.out.println(e.getMessage()
+						.equals("Current speed is 0, not enough speed to decelerate!"));
+			}
+		} catch (Exception e) {
+			System.out.println("Error: Uncatched exception!");
+		}
+	}
+}

assignment5/Question5/Aircraft.java

@@ -0,0 +1,127 @@
+/*
+ * Author: CHEN Yongyuan (Walter) 1930006025 from OOP(1007)
+ * Date: 2022-04-24
+ * Description: Aircraft.java inherited from Vehicle class
+ */
+
+public class Aircraft extends Vehicle {
+	/**
+	 * The altitude at which the aircraft is flying.
+	 */
+	private int altitude;
+
+	/**
+	 * Constructor.
+	 *
+	 * @param speedLimit the speed limit of the aircraft
+	 * @param speed      the speed of the aircraft
+	 * @param altitude   the altitude of the aircraft
+	 * @throws BadSpeedSetting    if the speed limit is negative
+	 * @throws BadAltitudeSetting if the altitude is negative
+	 */
+	public Aircraft(int speedLimit, int speed, int altitude) throws BadSpeedSetting, BadAltitudeSetting {
+		super(speedLimit, speed);
+		if (altitude < 0) {
+			throw new BadAltitudeSetting("Altitude cannot be negative!");
+		}
+		this.altitude = altitude;
+	}
+
+	/**
+	 * Getter of altitude.
+	 *
+	 * @return the altitude of the aircraft
+	 */
+	public int getAltitude() {
+		return altitude;
+	}
+
+	/**
+	 * Aircraft can fly.
+	 *
+	 * @return true
+	 */
+	@Override
+	public boolean canFly() {
+		return true;
+	}
+
+	/**
+	 * Test.
+	 */
+	public static void testAircraft() {
+		try {
+			Aircraft aircraft;
+
+			try {
+				aircraft = new Aircraft(-10, 10, 10);
+			} catch (BadSpeedSetting e) {
+				System.out.println(e.getMessage().equals("Speed cannot be negative!"));
+			}
+
+			try {
+				aircraft = new Aircraft(10, -10, 10);
+			} catch (BadSpeedSetting e) {
+				System.out.println(e.getMessage().equals("Speed cannot be negative!"));
+			}
+
+			try {
+				aircraft = new Aircraft(10, 10, -10);
+			} catch (BadAltitudeSetting e) {
+				System.out.println(e.getMessage().equals("Altitude cannot be negative!"));
+			}
+
+			aircraft = new Aircraft(100, 50, 3900);
+			System.out.println(aircraft.getAltitude() == 3900);
+			System.out.println(aircraft.getSpeed() == 50);
+			System.out.println(aircraft.canFly() == true);
+			// acceleration
+			System.out.println(aircraft.accelerate(10) == 60);
+			System.out.println(aircraft.getSpeed() == 60);
+			System.out.println(aircraft.canFly() == true);
+			System.out.println(aircraft.accelerate(10) == 70);
+			System.out.println(aircraft.getSpeed() == 70);
+			System.out.println(aircraft.canFly() == true);
+			System.out.println(aircraft.accelerate(10) == 80);
+			System.out.println(aircraft.getSpeed() == 80);
+			System.out.println(aircraft.canFly() == true);
+			System.out.println(aircraft.accelerate(10) == 90);
+			System.out.println(aircraft.getSpeed() == 90);
+			System.out.println(aircraft.canFly() == true);
+			System.out.println(aircraft.accelerate(10) == 100);
+			System.out.println(aircraft.getSpeed() == 100);
+			System.out.println(aircraft.canFly() == true);
+			try {
+				aircraft.accelerate(10);
+			} catch (ExceedSpeedLimit e) {
+				System.out.println(e.getMessage().equals(
+						"Current speed is 100. Accelerate 10 will exceed the speed limit!"));
+			}
+			// deceleration
+			System.out.println(aircraft.accelerate(-20) == 80);
+			System.out.println(aircraft.getSpeed() == 80);
+			System.out.println(aircraft.canFly() == true);
+			System.out.println(aircraft.accelerate(-20) == 60);
+			System.out.println(aircraft.getSpeed() == 60);
+			System.out.println(aircraft.canFly() == true);
+			System.out.println(aircraft.accelerate(-20) == 40);
+			System.out.println(aircraft.getSpeed() == 40);
+			System.out.println(aircraft.canFly() == true);
+			System.out.println(aircraft.accelerate(-20) == 20);
+			System.out.println(aircraft.getSpeed() == 20);
+			System.out.println(aircraft.canFly() == true);
+			System.out.println(aircraft.accelerate(-20) == 0);
+			System.out.println(aircraft.getSpeed() == 0);
+			System.out.println(aircraft.canFly() == true);
+			try {
+				aircraft.accelerate(-20);
+			} catch (NotEnoughSpeed e) {
+				System.out.println(e.getMessage()
+						.equals("Current speed is 0, not enough speed to decelerate!"));
+			}
+
+		} catch (Exception e) {
+			System.out.println("Error uncaught exception: " + e.getMessage());
+		}
+	}
+}

assignment5/Question5/BadAltitudeSetting.java

@@ -0,0 +1,15 @@
+/*
+ * The BadAltitudeSetting class is used to test the speed of the program.
+ */
+public class BadAltitudeSetting extends Exception {
+	// generate serial ID by class name
+	private static final long serialVersionUID = BadAltitudeSetting.class.getName().hashCode();
+
+	public BadAltitudeSetting() {
+		super();
+	}
+
+	public BadAltitudeSetting(String message) {
+		super(message);
+	}
+}

assignment5/Question5/BadSpeedSetting.java

@@ -0,0 +1,15 @@
+/*
+ * The BadSpeedSetting class is used to test the speed of the program.
+ */
+public class BadSpeedSetting extends Exception {
+	// generate serial ID by class name
+	private static final long serialVersionUID = BadSpeedSetting.class.getName().hashCode();
+
+	public BadSpeedSetting() {
+		super();
+	}
+
+	public BadSpeedSetting(String message) {
+		super(message);
+	}
+}

assignment5/Question5/Car.java

@@ -0,0 +1,130 @@
+/*
+ * Author: CHEN Yongyuan (Walter) 1930006025 from OOP(1007)
+ * Date: 2022-04-24
+ * Description: Car class
+ */
+
+public class Car extends Vehicle {
+
+	/**
+	 * Car can not fly.
+	 *
+	 * @return false
+	 */
+	@Override
+	public boolean canFly() {
+		return false;
+	}
+
+	/**
+	 * Constructor.
+	 *
+	 * @param speedLimit The speed limit of the car.
+	 * @param speed      the speed of the car.
+	 * @thorws BadSpeedSetting if speedLimit or speed is negative. Or if the speed
+	 *         is greater than the speed limit.
+	 */
+	public Car(int speedLimit, int speed) throws BadSpeedSetting {
+		super(speedLimit, speed);
+	}
+
+	/**
+	 * Constructor. Default speed limit is 120.
+	 *
+	 * @param speed the speed of the car.
+	 * @thorws BadSpeedSetting if speed is negative. Or if the speed is greater than
+	 *         the speed limit 120.
+	 */
+	public Car(int speed) throws BadSpeedSetting {
+		this(120, speed);
+	}
+
+	/**
+	 * Test.
+	 */
+	public static void testCar() {
+		try {
+			Car c1;
+			try {
+				c1 = new Car(-1, -1);
+			} catch (BadSpeedSetting e) {
+				System.out.println(e.getMessage().equals("Speed cannot be negative!"));
+			}
+			try {
+				c1 = new Car(120, -1);
+			} catch (BadSpeedSetting e) {
+				System.out.println(e.getMessage().equals("Speed cannot be negative!"));
+			}
+			try {
+				c1 = new Car(120, 121);
+			} catch (BadSpeedSetting e) {
+				System.out.println(e.getMessage().equals("Speed cannot be greater than speed limit!"));
+			}
+			c1 = new Car(120, 100);
+			System.out.println(c1.getSpeed() == 100);
+			System.out.println(c1.canFly() == false);
+			System.out.println(c1.accelerate(10) == 110);
+			System.out.println(c1.canFly() == false);
+			System.out.println(c1.accelerate(10) == 120);
+			System.out.println(c1.canFly() == false);
+			try {
+				c1.accelerate(10);
+			} catch (ExceedSpeedLimit e) {
+				System.out.println(e.getMessage().equals(
+						"Current speed is 120. Accelerate 10 will exceed the speed limit!"));
+			}
+			System.out.println(c1.accelerate(-20) == 100);
+			System.out.println(c1.canFly() == false);
+			System.out.println(c1.accelerate(-20) == 80);
+			System.out.println(c1.canFly() == false);
+			System.out.println(c1.accelerate(-20) == 60);
+			System.out.println(c1.canFly() == false);
+			System.out.println(c1.accelerate(-20) == 40);
+			System.out.println(c1.canFly() == false);
+			System.out.println(c1.accelerate(-20) == 20);
+			System.out.println(c1.canFly() == false);
+			System.out.println(c1.accelerate(-20) == 0);
+			System.out.println(c1.canFly() == false);
+			try {
+				c1.accelerate(-20);
+			} catch (NotEnoughSpeed e) {
+				System.out.println(e.getMessage()
+						.equals("Current speed is 0, not enough speed to decelerate!"));
+			}
+
+			Car c2 = new Car(100);
+			System.out.println(c2.getSpeed() == 100);
+			System.out.println(c2.canFly() == false);
+			System.out.println(c2.accelerate(10) == 110);
+			System.out.println(c2.canFly() == false);
+			System.out.println(c2.accelerate(10) == 120);
+			System.out.println(c2.canFly() == false);
+			try {
+				c2.accelerate(10);
+			} catch (ExceedSpeedLimit e) {
+				System.out.println(e.getMessage().equals(
+						"Current speed is 120. Accelerate 10 will exceed the speed limit!"));
+			}
+			System.out.println(c2.accelerate(-20) == 100);
+			System.out.println(c2.canFly() == false);
+			System.out.println(c2.accelerate(-20) == 80);
+			System.out.println(c2.canFly() == false);
+			System.out.println(c2.accelerate(-20) == 60);
+			System.out.println(c2.canFly() == false);
+			System.out.println(c2.accelerate(-20) == 40);
+			System.out.println(c2.canFly() == false);
+			System.out.println(c2.accelerate(-20) == 20);
+			System.out.println(c2.canFly() == false);
+			System.out.println(c2.accelerate(-20) == 0);
+			System.out.println(c2.canFly() == false);
+			try {
+				c2.accelerate(-20);
+			} catch (NotEnoughSpeed e) {
+				System.out.println(e.getMessage()
+						.equals("Current speed is 0, not enough speed to decelerate!"));
+			}
+		} catch (Exception e) {
+			System.out.println("Error uncatched exception: " + e.getMessage());
+		}
+	}
+}

assignment5/Question5/ExceedSpeedLimit.java

@@ -0,0 +1,15 @@
+/*
+ * The ExceedSpeedLimit class is used to check if the speed limit is exceeded
+ */
+public class ExceedSpeedLimit extends Exception {
+	// generate serial ID by class name
+	private static final long serialVersionUID = ExceedSpeedLimit.class.getName().hashCode();
+
+	public ExceedSpeedLimit() {
+		super();
+	}
+
+	public ExceedSpeedLimit(String message) {
+		super(message);
+	}
+}

assignment5/Question5/ManyVehicles.java

@@ -0,0 +1,58 @@
+/*
+ * Author: CHEN Yongyuan (Walter) 1930006025 from OOP(1007)
+ * Date: 2022-04-24
+ * Description: ManyVehicles class manipulate many vehicles
+ */
+
+import java.util.ArrayList;
+
+public class ManyVehicles {
+	private ArrayList<Vehicle> vehicles;
+
+	/**
+	 * Constructor.
+	 */
+	public ManyVehicles() {
+		// initialise instance variables
+		vehicles = new ArrayList<Vehicle>();
+	}
+
+	/**
+	 * Add any kind of vehicle to the arraylist.
+	 *
+	 * @param v the vehicle to be added
+	 */
+	public void addVehicle(Vehicle v) {
+		vehicles.add(v);
+	}
+
+	/**
+	 * Calculate the avergae speed of all vehicles.
+	 *
+	 * @return the average speed of all vehicles
+	 */
+	public double calcAvgSpeed() {
+		double totalSpeed = 0;
+		for (Vehicle v : vehicles) {
+			totalSpeed += v.getSpeed();
+		}
+		return totalSpeed / vehicles.size();
+	}
+
+	/**
+	 * Test.
+	 */
+	public static void testManyVehicles() {
+		try {
+			ManyVehicles mv = new ManyVehicles();
+			mv.addVehicle(new Car(100, 100));
+			mv.addVehicle(new Car(90));
+			mv.addVehicle(new Aircraft(100, 70, 3900));
+			mv.addVehicle(new Train(100, 60));
+
+			System.out.println(mv.calcAvgSpeed() == 80.0);
+		} catch (Exception e) {
+			System.out.println("Error uncaught exception: " + e.getClass().getName() + e.getMessage());
+		}
+	}
+}

assignment5/Question5/Movable.java

@@ -0,0 +1,9 @@
+/*
+ * Author: CHEN Yongyuan (Walter) 1930006025 from OOP(1007)
+ * Date: 2022-04-24
+ * Description: This is a moveable interface.
+ */
+
+public interface Movable {
+	public int accelerate(int amount) throws ExceedSpeedLimit, NotEnoughSpeed, TrainSpeedChange;
+}

assignment5/Question5/NotEnoughSpeed.java

@@ -0,0 +1,15 @@
+/*
+ * The NotEnoughSpeed class is used to test the speed of the program.
+ */
+public class NotEnoughSpeed extends Exception {
+	// generate serial ID by class name
+	private static final long serialVersionUID = NotEnoughSpeed.class.getName().hashCode();
+
+	public NotEnoughSpeed() {
+		super();
+	}
+
+	public NotEnoughSpeed(String message) {
+		super(message);
+	}
+}

assignment5/Question5/Start.java

@@ -0,0 +1,9 @@
+public class Start {
+	public static void main(String[] args) {
+		Vehicle.testVehicle();
+		Car.testCar();
+		Aircraft.testAircraft();
+		Train.testTrain();
+		ManyVehicles.testManyVehicles();
+	}
+}

assignment5/Question5/StartGrading.java

@@ -0,0 +1,190 @@
+//Q5
+public class StartGrading {
+	public static void testVehicle() {
+//The Vehicle class is abstract. We cannot create objects from this class. Therefore, we cannot test anything
+	}
+
+	public static void testCar() {
+		// test case for constructors
+		try {
+			// exception
+			Car c1 = new Car(70, 80);
+		} catch (BadSpeedSetting e) {
+			System.out.println(e.getMessage().equals("Speed cannot be greater than speed limit!"));
+		}
+		try {
+			// exception
+			Car c2 = new Car(70, -10);
+		} catch (BadSpeedSetting e) {
+			System.out.println(e.getMessage().equals("Speed cannot be negative!"));
+		}
+		// test case for accelerate, canFly and getSpeed methods
+		try {
+			Car c3 = new Car(100, 80);
+			// test the canFly method
+			System.out.println(c3.canFly() == false);
+			c3.accelerate(10);
+			System.out.println(c3.getSpeed() == 90);
+			// test the accelerate with positive amount
+			c3.accelerate(-20);
+			System.out.println(c3.getSpeed() == 70);
+			// test the accelerate with negative amount
+			c3.accelerate(35); // exception
+		} catch (BadSpeedSetting e) {
+			System.out.println("BUG! THIS MUST NEVER HAPPEN!");
+		} catch (ExceedSpeedLimit e) {
+			System.out
+					.println(e.getMessage().equals("Current speed is 70. Accelerate 35 will exceed the speed limit!"));
+		} catch (NotEnoughSpeed e) {
+			System.out.println("BUG! THIS MUST NEVER HAPPEN!");
+		} catch (TrainSpeedChange e) {
+			System.out.println("BUG! THIS MUST NEVER HAPPEN!");
+		}
+		try {
+			Car c4 = new Car(100, 80);
+			// exception
+			c4.accelerate(-90);
+		} catch (BadSpeedSetting e) {
+			System.out.println("BUG! THIS MUST NEVER HAPPEN!");
+		} catch (ExceedSpeedLimit e) {
+			System.out.println("BUG! THIS MUST NEVER HAPPEN!");
+		} catch (NotEnoughSpeed e) {
+			System.out.println(e.getMessage().equals("Current speed is " + 80 + ", not enough speed to decelerate!"));
+		} catch (TrainSpeedChange e) {
+			System.out.println("BUG! THIS MUST NEVER HAPPEN!");
+		}
+	}
+
+	public static void testAircraft() {
+		// test case for constructors
+		try {
+			// Exception
+			Aircraft a1 = new Aircraft(70, 80, 1000);
+		} catch (BadSpeedSetting e) {
+			System.out.println(e.getMessage().equals("Speed cannot be greater than speed limit!"));
+		} catch (BadAltitudeSetting e) {
+			System.out.println("BUG! THIS MUST NEVER HAPPEN!");
+		}
+		try {
+			// exception
+			Aircraft a2 = new Aircraft(70, -10, 1000);
+		} catch (BadSpeedSetting e) {
+			System.out.println(e.getMessage().equals("Speed cannot be negative!"));
+		} catch (BadAltitudeSetting e) {
+			System.out.println("BUG! THIS MUST NEVER HAPPEN!");
+		}
+		try {
+			// exception
+			Aircraft a3 = new Aircraft(700, 200, -10);
+		} catch (BadSpeedSetting e) {
+			System.out.println("BUG! THIS MUST NEVER HAPPEN!");
+		} catch (BadAltitudeSetting e) {
+			System.out.println(e.getMessage().equals("Altitude cannot be negative!"));
+		}
+		// Test case for accelerate, canFly, getSpeed and getAltitude methods
+		try {
+			Aircraft a4 = new Aircraft(700, 200, 100);
+			// test the getAltitude method
+			System.out.println(a4.getAltitude() == 100);
+			// test the canFly method
+			System.out.println(a4.canFly() == true);
+			a4.accelerate(100);
+			System.out.println(a4.getSpeed() == 300);
+			// test the accelerate with positive amount
+			a4.accelerate(-200);
+			System.out.println(a4.getSpeed() == 100);
+			// test the accelerate with negative amount
+			// exception
+			a4.accelerate(650);
+		} catch (BadSpeedSetting e) {
+			System.out.println("BUG! THIS MUST NEVER HAPPEN!");
+		} catch (BadAltitudeSetting e) {
+			System.out.println("BUG! THIS MUST NEVER HAPPEN!");
+		} catch (ExceedSpeedLimit e) {
+			System.out.println(
+					e.getMessage().equals("Current speed is 100. Accelerate 650 will exceed the speed limit!"));
+		} catch (NotEnoughSpeed e) {
+			System.out.println("BUG! THIS MUST NEVER HAPPEN!");
+		} catch (TrainSpeedChange e) {
+			System.out.println("BUG! THIS MUST NEVER HAPPEN!");
+		}
+		try {
+			Aircraft a5 = new Aircraft(700, 200, 100);
+			// exception
+			a5.accelerate(-300);
+		} catch (BadSpeedSetting e) {
+			System.out.println("BUG! THIS MUST NEVER HAPPEN!");
+		} catch (BadAltitudeSetting e) {
+			System.out.println("BUG! THIS MUST NEVER HAPPEN!");
+		} catch (ExceedSpeedLimit e) {
+			System.out.println("BUG! THIS MUST NEVER HAPPEN!");
+		} catch (NotEnoughSpeed e) {
+			System.out.println(e.getMessage().equals("Current speed is " + 200 + ", not enough speed to decelerate!"));
+		} catch (TrainSpeedChange e) {
+			System.out.println("BUG! THIS MUST NEVER HAPPEN!");
+		}
+	}
+
+	public static void testTrain() {
+		// test case for constructors
+		try {
+			// exception
+			Train t1 = new Train(350, 400);
+		} catch (BadSpeedSetting e) {
+			System.out.println(e.getMessage().equals("Speed cannot be greater than speed limit!"));
+		}
+		try {
+			// exception
+			Train t2 = new Train(350, -100);
+		} catch (BadSpeedSetting e) {
+			System.out.println(e.getMessage().equals("Speed cannot be negative!"));
+		}
+		// test case for accelerate, canFly and getSpeed methods
+		try {
+			Train t3 = new Train(350, 300);
+			// test the canFly method
+			System.out.println(t3.canFly() == false);
+			// test the getSpeed
+			System.out.println(t3.getSpeed() == 300);
+			// exception
+			t3.accelerate(50);
+		} catch (BadSpeedSetting e) {
+			System.out.println("BUG! THIS MUST NEVER HAPPEN!");
+		} catch (TrainSpeedChange e) {
+			System.out.println(e.getMessage().equals("Do not try to accelerate or decelerate the train!"));
+		}
+	}
+
+	public static void testManyVehicles() {
+		ManyVehicles mv = new ManyVehicles();
+// Add any kind of vehicles to the arraylist.
+		try {
+			Train t = new Train(350, 300);
+			mv.addVehicle(t);
+		} catch (BadSpeedSetting e) {
+			System.out.println("BUG! THIS MUST NEVER HAPPEN!");
+		}
+		try {
+			Car c = new Car(100, 80);
+			mv.addVehicle(c);
+		} catch (BadSpeedSetting e) {
+			System.out.println("BUG! THIS MUST NEVER HAPPEN!");
+		}
+		try {
+			Aircraft a = new Aircraft(700, 200, 100);
+			mv.addVehicle(a);
+		} catch (BadSpeedSetting e) {
+			System.out.println("BUG! THIS MUST NEVER HAPPEN!");
+		} catch (BadAltitudeSetting e) {
+			System.out.println("BUG! THIS MUST NEVER HAPPEN!");
+		}
+		System.out.println(mv.calcAvgSpeed() == 193);
+	}
+
+	public static void main(String[] args) {
+		Vehicle.testVehicle();
+		Car.testCar();
+		Aircraft.testAircraft();
+		Train.testTrain();
+	}
+}

assignment5/Question5/Train.java

@@ -0,0 +1,71 @@
+/*
+ * Author: CHEN Yongyuan (Walter) 1930006025 from OOP(1007)
+ * Date: 2022-04-24
+ * Description: Train class inherited from Vehicle class
+ */
+
+public class Train extends Vehicle {
+	/**
+	 * Constructor.
+	 *
+	 * @param speedLimit the speed limit of the train
+	 * @param speed the speed of the train
+	 * @throws BadSpeedSetting
+	 */
+	public Train(int speedLimit, int speed) throws BadSpeedSetting {
+		super(speedLimit, speed);
+	}
+
+	/**
+	 * Train can not fly.
+	 *
+	 * @return false
+	 */
+	@Override
+	public boolean canFly() {
+		return false;
+	}
+
+	/**
+	 * Tain speed can not be changed.
+	 *
+	 * @throws TrainSpeedChange
+	 */
+	@Override
+	public int accelerate(int amount) throws TrainSpeedChange {
+		throw new TrainSpeedChange("Do not try to accelerate or decelerate the train!");
+	}
+
+	/**
+	 * Test.
+	 */
+	public static void testTrain() {
+		try {
+			Train train;
+			try {
+				train = new Train(-1, -1);
+			} catch (BadSpeedSetting e) {
+				System.out.println(e.getMessage().equals("Speed cannot be negative!"));
+			}
+			try {
+				train = new Train(100, -1);
+			} catch (BadSpeedSetting e) {
+				System.out.println(e.getMessage().equals("Speed cannot be negative!"));
+			}
+			try {
+				train = new Train(100, 101);
+			} catch (BadSpeedSetting e) {
+				System.out.println(e.getMessage().equals("Speed cannot be greater than speed limit!"));
+			}
+			train = new Train(100, 50);
+			System.out.println(train.getSpeed() == 50);
+			try {
+				train.accelerate(1);
+			} catch (TrainSpeedChange e) {
+				System.out.println(e.getMessage().equals("Do not try to accelerate or decelerate the train!"));
+			}
+		} catch (Exception e) {
+			System.out.println("Error: uncaught exception " + e.getClass() + ": " + e.getMessage());
+		}
+	}
+}

assignment5/Question5/TrainSpeedChange.java

@@ -0,0 +1,15 @@
+/*
+ * The TrainSpeedChange class is used to test the speed of the program.
+ */
+public class TrainSpeedChange extends Exception {
+	// generate serial ID by class name
+	private static final long serialVersionUID = TrainSpeedChange.class.getName().hashCode();
+
+	public TrainSpeedChange() {
+		super();
+	}
+
+	public TrainSpeedChange(String message) {
+		super(message);
+	}
+}

assignment5/Question5/Vehicle.java

@@ -0,0 +1,180 @@
+/*
+ * Author: CHEN Yongyuan (Walter) 1930006025 from OOP(1007)
+ * Date: 2022-04-24
+ * Description: This is the abstract Vehicle class.
+ */
+
+public abstract class Vehicle implements Movable {
+	private int speedLimit;
+	private int speed;
+
+	/**
+	 * Constructor.
+	 *
+	 * @param speedLimit the speed limit of the vehicle
+	 * @param speed      the speed of the vehicle
+	 * @throws BadSpeedSetting if speedLimit or speed is negative. Or if the speed
+	 *                         is greater than speed limit.
+	 */
+	public Vehicle(int speedLimit, int speed) throws BadSpeedSetting {
+		if (speedLimit < 0 || speed < 0) {
+			throw new BadSpeedSetting("Speed cannot be negative!");
+		}
+		if (speed > speedLimit) {
+			throw new BadSpeedSetting("Speed cannot be greater than speed limit!");
+		}
+		this.speedLimit = speedLimit;
+		this.speed = speed;
+	}
+
+	/**
+	 * Getter of speed.
+	 *
+	 * @return the speed of the vehicle
+	 */
+	public int getSpeed() {
+		return speed;
+	}
+
+	/**
+	 * Accelerate the vehicle.
+	 *
+	 * @param amount the amount of acceleration.
+	 * @throws ExceedSpeedLimit if the speed is greater than speed limit after
+	 *                          increased.
+	 * @thorws NotEnoughSpeed if the speed is less than 0 after decreased.
+	 * @return the new speed of the vehicle
+	 */
+	public int accelerate(int amount) throws ExceedSpeedLimit, NotEnoughSpeed, TrainSpeedChange {
+		int newSpeed = speed + amount;
+		if (newSpeed > speedLimit) {
+			throw new ExceedSpeedLimit(
+					String.format("Current speed is %d. Accelerate %d will exceed the speed limit!",
+							speed, amount));
+		}
+		if (newSpeed < 0) {
+			throw new NotEnoughSpeed(
+					String.format("Current speed is %d, not enough speed to decelerate!", speed));
+		}
+		speed = newSpeed;
+		return speed;
+	}
+
+	/**
+	 * Whether the vehicle can fly or not.
+	 *
+	 * @return whether the vehicle can fly.
+	 */
+	public abstract boolean canFly();
+
+	/**
+	 * Test.
+	 */
+	public static void testVehicle() {
+		try {
+			Vehicle car;
+			try {
+				car = new Vehicle(-10, -20) {
+					@Override
+					public boolean canFly() {
+						return false;
+					}
+				};
+			} catch (BadSpeedSetting e) {
+				System.out.println(e.getMessage().equals("Speed cannot be negative!"));
+			}
+			try {
+				car = new Vehicle(0, 50) {
+					@Override
+					public boolean canFly() {
+						return false;
+					}
+				};
+			} catch (BadSpeedSetting e) {
+				System.out.println(e.getMessage().equals("Speed cannot be greater than speed limit!"));
+			}
+			car = new Vehicle(100, 50) {
+				@Override
+				public boolean canFly() {
+					return false;
+				}
+			};
+			System.out.println(car.getSpeed() == 50);
+			System.out.println(car.canFly() == false);
+			System.out.println(car.accelerate(10) == 60);
+			System.out.println(car.accelerate(10) == 70);
+			System.out.println(car.accelerate(10) == 80);
+			System.out.println(car.accelerate(10) == 90);
+			System.out.println(car.accelerate(10) == 100);
+			try {
+				System.out.println(car.accelerate(10) == 110);
+				System.out.println("Error: ExceedSpeedLimit should be thrown!");
+			} catch (ExceedSpeedLimit e) {
+				System.out.println(e.getMessage().equals(
+						"Current speed is 100. Accelerate 10 will exceed the speed limit!"));
+			}
+			System.out.println(car.accelerate(-50) == 50);
+			System.out.println(car.accelerate(-50) == 0);
+			try {
+				System.out.println(car.accelerate(-50) == -50);
+				System.out.println("Error: NotEnoughSpeed should be thrown!");
+			} catch (NotEnoughSpeed e) {
+				System.out.println(e.getMessage()
+						.equals("Current speed is 0, not enough speed to decelerate!"));
+			}
+
+			Vehicle plane;
+			try {
+				plane = new Vehicle(-10, -20) {
+					@Override
+					public boolean canFly() {
+						return true;
+					}
+				};
+			} catch (BadSpeedSetting e) {
+				System.out.println(e.getMessage().equals("Speed cannot be negative!"));
+			}
+			try {
+				plane = new Vehicle(0, 50) {
+					@Override
+					public boolean canFly() {
+						return true;
+					}
+				};
+			} catch (BadSpeedSetting e) {
+				System.out.println(e.getMessage().equals("Speed cannot be greater than speed limit!"));
+			}
+			plane = new Vehicle(100, 50) {
+				@Override
+				public boolean canFly() {
+					return true;
+				}
+			};
+			System.out.println(plane.getSpeed() == 50);
+			System.out.println(plane.canFly() == true);
+			System.out.println(plane.accelerate(10) == 60);
+			System.out.println(plane.accelerate(10) == 70);
+			System.out.println(plane.accelerate(10) == 80);
+			System.out.println(plane.accelerate(10) == 90);
+			System.out.println(plane.accelerate(10) == 100);
+			try {
+				System.out.println(plane.accelerate(10) == 110);
+				System.out.println("Error: ExceedSpeedLimit should be thrown!");
+			} catch (ExceedSpeedLimit e) {
+				System.out.println(e.getMessage().equals(
+						"Current speed is 100. Accelerate 10 will exceed the speed limit!"));
+			}
+			System.out.println(plane.accelerate(-50) == 50);
+			System.out.println(plane.accelerate(-50) == 0);
+			try {
+				System.out.println(plane.accelerate(-50) == -50);
+				System.out.println("Error: NotEnoughSpeed should be thrown!");
+			} catch (NotEnoughSpeed e) {
+				System.out.println(e.getMessage()
+						.equals("Current speed is 0, not enough speed to decelerate!"));
+			}
+		} catch (Exception e) {
+			System.out.println("Error: Uncatched exception!");
+		}
+	}
+}

assignment6/Question1/IShape.java

@@ -0,0 +1,17 @@
+import java.awt.Graphics;
+
+public interface IShape {
+	public int getX();
+
+	public int getY();
+
+	public void setX(int x);
+
+	public void setY(int y);
+
+	public boolean isVisible(int w, int h);
+
+	public boolean isIn(int x, int y);
+
+	public void draw(Graphics g);
+}

assignment6/Question1/Shape.java

@@ -0,0 +1,51 @@
+import java.awt.Color;
+import java.awt.Graphics;
+
+public abstract class Shape {
+	private int x;
+	private int y;
+	private Color color;
+
+	/**
+	 * Constructor for Shape
+	 *
+	 * @param x
+	 * 	  the x coordinate of the shape
+	 * @param y
+	 * 	  the y coordinate of the shape
+	 */
+	public Shape(int x, int y) {
+		this.x = x;
+		this.y = y;
+		color = new Color((float) Math.random(), (float) Math.random(), (float) Math.random());
+	}
+
+	public int getX() {
+		return x;
+	}
+
+	public void setX(int x) {
+		this.x = x;
+	}
+
+	public int getY() {
+		return y;
+	}
+
+	public void setY(int y) {
+		this.y = y;
+	}
+
+	public abstract boolean isVisible(int w, int h);
+
+	public abstract boolean isIn(int x, int y);
+
+	public void draw(Graphics g) {
+		g.setColor(color);
+	}
+
+	public static void testShape() {
+		// TODO: implement this method
+		// Because this is the abstract so we don't test anything here.
+	}
+}

assignment6/Question1/Start.java

@@ -0,0 +1,5 @@
+public class Start {
+	public static void main(String[] args) {
+		Shape.testShape();
+	}
+}

assignment6/Question2/Bubble.java

@@ -0,0 +1,89 @@
+import java.awt.Graphics;
+
+public class Bubble extends Shape {
+	private double radius;
+
+	/**
+	 * Constructor for the Bubble class.
+	 *
+	 * @param x the x coordinate of the center of the bubble
+	 * @param y the y coordinate of the center of the bubble
+	 */
+	public Bubble(int x, int y) {
+		super(x, y);
+		this.radius = 10;
+	}
+
+	// Find the point (wx, wy) inside the window which is closest to the
+	// center (x, y) of the circle. In other words, find the wx in the
+	// interval [0, w - 1] which is closest to x, and find the wy in the
+	// interval [0, h - 1] which is closest to y.
+	// If the distance between (wx, wy) and (x, y) is less than the radius
+	// of the circle (using Pythagoras's theorem) then at least part of
+	// the circle is visible in the window.
+	// Note: if the center of the circle is inside the window, then (wx, wy)
+	// is the same as (x, y), and the distance is 0.
+	@Override
+	public boolean isVisible(int w, int h) {
+		double x = getX();
+		double y = getY();
+		double wx = (x < 0 ? 0 : (x > w - 1 ? w - 1 : x));
+		double wy = (y < 0 ? 0 : (y > h - 1 ? h - 1 : y));
+		double dx = wx - x;
+		double dy = wy - y;
+		return dx * dx + dy * dy <= radius * radius;
+	}
+
+	/**
+	 * Whether the point at xy is currently inside the bubble
+	 *
+	 * @param x the x coordinate of the point
+	 * @param y the y coordinate of the point
+	 * @return true if the point is inside the bubble, false otherwise
+	 */
+	@Override
+	public boolean isIn(int x, int y) {
+		double dx = x - getX();
+		double dy = y - getY();
+		return dx * dx + dy * dy < radius * radius;
+	}
+
+	/**
+	 * Draw the bubble.
+	 *
+	 * @param g the graphics context
+	 */
+	@Override
+	public void draw(Graphics g) {
+		super.draw(g);
+		g.drawOval(
+				getX() - (int) radius,
+				getY() - (int) radius,
+				(int) radius * 2,
+				(int) radius * 2);
+	}
+
+	public static void testBubble() {
+		Bubble b = new Bubble(20, 30);
+
+		System.out.println(b.getX() == 20);
+		System.out.println(b.getY() == 30);
+
+		b.setX(40);
+		System.out.println(b.getX() == 40);
+		System.out.println(b.getY() == 30);
+
+		b.setY(60);
+		System.out.println(b.getX() == 40);
+		System.out.println(b.getY() == 60);
+		System.out.println(b.isVisible(100, 100) == true);
+
+		b.setX(50);
+		b.setY(0);
+		System.out.println(b.isVisible(100, 100) == true);
+
+		b.setX(99);
+		b.setY(50);
+		System.out.println(b.isVisible(100, 100) == true);
+	}
+}

assignment6/Question2/IShape.java

@@ -0,0 +1,17 @@
+import java.awt.Graphics;
+
+public interface IShape {
+	public int getX();
+
+	public int getY();
+
+	public void setX(int x);
+
+	public void setY(int y);
+
+	public boolean isVisible(int w, int h);
+
+	public boolean isIn(int x, int y);
+
+	public void draw(Graphics g);
+}

assignment6/Question2/Shape.java

@@ -0,0 +1,42 @@
+import java.awt.Color;
+import java.awt.Graphics;
+
+public abstract class Shape {
+	private int x;
+	private int y;
+	private Color color;
+
+	public Shape(int x, int y) {
+		this.x = x;
+		this.y = y;
+		color = new Color((float) Math.random(), (float) Math.random(), (float) Math.random());
+	}
+
+	// getters and setters
+	public int getX() {
+		return x;
+	}
+
+	public void setX(int x) {
+		this.x = x;
+	}
+
+	public int getY() {
+		return y;
+	}
+
+	public void setY(int y) {
+		this.y = y;
+	}
+
+	public abstract boolean isVisible(int w, int h);
+
+	public abstract boolean isIn(int x, int y);
+
+	public void draw(Graphics g) {
+		g.setColor(color);
+	}
+
+	public static void testShape() {
+	}
+}

assignment6/Question2/Start.java

@@ -0,0 +1,6 @@
+public class Start {
+	public static void main(String[] args) {
+		Shape.testShape();
+		Bubble.testBubble();
+	}
+}

assignment6/Question3/Bubble.java

@@ -0,0 +1,65 @@
+import java.awt.Graphics;
+
+public class Bubble extends Shape implements IShape {
+	// instance variables
+	private double radius;
+
+	// constructor
+	public Bubble(int x, int y) {
+		super(x, y);
+		this.radius = 10;
+	}
+
+	// Find the point (wx, wy) inside the window which is closest to the
+	// center (x, y) of the circle. In other words, find the wx in the
+	// interval [0, w - 1] which is closest to x, and find the wy in the
+	// interval [0, h - 1] which is closest to y.
+	// If the distance between (wx, wy) and (x, y) is less than the radius
+	// of the circle (using Pythagoras's theorem) then at least part of
+	// the circle is visible in the window.
+	// Note: if the center of the circle is inside the window, then (wx, wy)
+	// is the same as (x, y), and the distance is 0.
+	@Override
+	public boolean isVisible(int w, int h) {
+		double x = getX();
+		double y = getY();
+		double wx = (x < 0 ? 0 : (x > w - 1 ? w - 1 : x));
+		double wy = (y < 0 ? 0 : (y > h - 1 ? h - 1 : y));
+		double dx = wx - x;
+		double dy = wy - y;
+		return dx * dx + dy * dy <= radius * radius;
+	}
+
+	@Override
+	public boolean isIn(int x, int y) {
+		double dx = x - getX();
+		double dy = y - getY();
+		return dx * dx + dy * dy < radius * radius;
+	}
+
+	@Override
+	public void draw(Graphics g) {
+		super.draw(g);
+		g.drawOval(
+				getX() - (int) radius,
+				getY() - (int) radius,
+				(int) radius * 2,
+				(int) radius * 2);
+	}
+
+	public static void testBubble() {
+		Bubble b = new Bubble(20, 30);
+		System.out.println(b.getX() == 20);
+		System.out.println(b.getY() == 30);
+		b.setX(40);
+		System.out.println(b.getX() == 40);
+		System.out.println(b.getY() == 30);
+		b.setY(60);
+		System.out.println(b.getX() == 40);
+		System.out.println(b.getY() == 60);
+		System.out.println(b.isVisible(100, 100) == true);
+		b.setX(50);
+		b.setY(0);
+		System.out.println(b.isVisible(100, 100) == true);
+	}
+}

assignment6/Question3/IShape.java

@@ -0,0 +1,17 @@
+import java.awt.Graphics;
+
+public interface IShape {
+	public int getX();
+
+	public int getY();
+
+	public void setX(int x);
+
+	public void setY(int y);
+
+	public boolean isVisible(int w, int h);
+
+	public boolean isIn(int x, int y);
+
+	public void draw(Graphics g);
+}

assignment6/Question3/Model.java

@@ -0,0 +1,105 @@
+import java.awt.Graphics;
+import java.util.ArrayList;
+
+public class Model {
+	// instance variables
+	private int score;
+	private ArrayList<IShape> bubbles;
+
+	// constructor
+	public Model() {
+		score = 0;
+		bubbles = new ArrayList<IShape>();
+	}
+
+	// getters and setters
+	public int getScore() {
+		return score;
+	}
+
+	/**
+	 * @param w
+	 * @param h
+	 */
+	public void addBubble(int w, int h) {
+		bubbles.add(new Bubble((int) (w * Math.random()), (int) (h * Math.random())));
+	}
+
+	/**
+	 * @param dx
+	 * @param dy
+	 */
+	public void moveAll(int dx, int dy) {
+		for (int i = 0; i < bubbles.size(); i++) {
+			bubbles.get(i).setX(bubbles.get(i).getX() + dx);
+			bubbles.get(i).setY(bubbles.get(i).getY() + dy);
+		}
+	}
+
+	/**
+	 * clear all bubbles
+	 * 
+	 * @param w
+	 * @param h
+	 */
+	public void clearInvisibles(int w, int h) {
+		for (int i = bubbles.size() - 1; i >= 0; i--) {
+			if (!bubbles.get(i).isVisible(w, h)) {
+				bubbles.remove(i);
+				score--;
+			}
+		}
+	}
+
+	/**
+	 * delete bubbles that are hit by the mouse
+	 * 
+	 * @param x
+	 * @param y
+	 */
+	public void deleteBubblesAtPoint(int x, int y) {
+		for (int i = bubbles.size() - 1; i >= 0; i--) {
+			if (bubbles.get(i).isIn(x, y)) {
+				bubbles.remove(i);
+				score++;
+			}
+		}
+	}
+
+	/**
+	 * draw all bubbles
+	 *
+	 * @param g
+	 */
+	public void drawAll(Graphics g) {
+		for (IShape bubble : bubbles) {
+			bubble.draw(g);
+		}
+	}
+
+	public static void testModel() {
+		Model m = new Model();
+		System.out.println(m.getScore() == 0);
+		System.out.println(m.bubbles.size() == 0);
+		m.addBubble(100, 100);
+		m.addBubble(100, 100);
+		System.out.println(m.getScore() == 0);
+		System.out.println(m.bubbles.size() == 2);
+		m.clearInvisibles(200, 200);
+		System.out.println(m.getScore() == 0);
+		System.out.println(m.bubbles.size() == 2);
+		m.clearInvisibles(0, 0);
+		System.out.println(m.getScore() == -2);
+		System.out.println(m.bubbles.size() == 0);
+		m.addBubble(100, 100);
+		m.addBubble(100, 100);
+		System.out.println(m.getScore() == -2);
+		System.out.println(m.bubbles.size() == 2);
+		m.moveAll(200, 200);
+		System.out.println(m.getScore() == -2);
+		System.out.println(m.bubbles.size() == 2);
+		m.clearInvisibles(200, 200);
+		System.out.println(m.getScore() == -4);
+		System.out.println(m.bubbles.size() == 0);
+	}
+}

assignment6/Question3/Shape.java

@@ -0,0 +1,41 @@
+import java.awt.Color;
+import java.awt.Graphics;
+
+public abstract class Shape {
+	private int x;
+	private int y;
+	private Color color;
+
+	public Shape(int x, int y) {
+		this.x = x;
+		this.y = y;
+		color = new Color((float) Math.random(), (float) Math.random(), (float) Math.random());
+	}
+
+	public int getX() {
+		return x;
+	}
+
+	public void setX(int x) {
+		this.x = x;
+	}
+
+	public int getY() {
+		return y;
+	}
+
+	public void setY(int y) {
+		this.y = y;
+	}
+
+	public abstract boolean isVisible(int w, int h);
+
+	public abstract boolean isIn(int x, int y);
+
+	public void draw(Graphics g) {
+		g.setColor(color);
+	}
+
+	public static void testShape() {
+	}
+}

assignment6/Question3/Start.java

@@ -0,0 +1,7 @@
+public class Start {
+	public static void main(String[] args) {
+		Shape.testShape();
+		Bubble.testBubble();
+		Model.testModel();
+	}
+}

finalproject/Question1/IUser.java

@@ -0,0 +1,13 @@
+/*
+ * Author: CHEN Yongyuan (Walter) 1930006025 from OOP(1007)
+ * Date: 2022-04-25
+ * Description: This is the interface of IUser.
+ */
+
+public interface IUser {
+	public String getName();
+
+	public int getBook();
+
+	public void moreBook(int number);
+}

finalproject/Question1/Test.java

@@ -0,0 +1,5 @@
+public class Test {
+	public static void main(String[] args) {
+		User.testUser();
+	}
+}