Highlights of Previous Lecture

Transcription

1 Highlights of Previous Lecture Inheritance vs. Composition IS-A-KIND-OF vs. HAS-A relationships Java vs. C++: differences in ability to access base class behavior Interfaces as contracts, as types, supporting de-coupling Abstract classes vs. Interfaces 1

2 Highlights of Previous Meeting Design Patterns - nuggets of reusable software experience Intention Revealing Name - supports polymorphism Type Safe Enumeration - supports compile time checking Type Safe Homogeneous Collection- supports run time safety 2

3 Homework issues Comment your code more Provide a README file with instruction on running your program from the command line. Make sure your JAR archives are in the proper form. 3

4 Inheritance homework requirements Create three classes/types of air planes: BigPlane, MediumPlane, and SmallPlane. All three classes will have the following characteristics: An identifying string ("1", "2",... etc. is sufficient), A total number of seats. Once assigned this does not change for an Airplane though different Airplanes of the same type may have different total number of seats. A number of currently available seats. A cost per seat in each of several categories, see below. A method to change the cost per seat for a seat category. An implementation of the public String tostring() method that will return a String containing the type of airplane (Big, Medium, Small), the airplane ID and the current costs per seat. However, these three classes should differ from each other in the following ways: The total number of seats should be between for BigPlanes, for MediumPlanes, and 8-50 for SmallPlanes. Bigplanes and MediumPlanes should have three costs per seat, one each for FirstClass, BusinessClass, and EconomyClass. SmallPlanes should have only BusinessClass and EconomyClass cost per seat values. Create an abstract base class, AirPlane. Use this class to model the characteristics that are common to all three air plane classes above. You decide what belongs in the base class and what belongs in the specific classes. You should try to push as much common information into the base class. Unnecessary code duplication in derived classes is to be avoided. The base Airplane class should not have any knowledge of specific derived classes. 4

5 Modify the Airline class from the previous assignments, if necessary, to use AirPlane references. You may use my sample solution version or your own. The Airline objects should save the Airplane references in a collection class. The Airline class should not have any knowledge of specific classes derived from Airplane. Modify the test class from the second assignment or create a new test class to create several of each kind of airplane. Add these airplanes one at a time through a call to Airline s addairplane method to one or more Airline objects. (An airplane should only be added to one airline s collection.) Have each Airline object list all the Airplanes in its collection: their class, id, and current cost per seat values. 5

6 Inheritance homework solution - Abstract Base class Notice how, using a collection, the base class can deal with any number of seat categories. Notice how clients update and get seat costs by specifying a category. version1/airplane.java import java.util.iterator; import java.util.set; import java.util.hashmap; /** A base class to encapsulate information need for an ** airplane: its identifier, the number of seats (total ** and currently available) and the current costs per ** seat. public abstract class Airplane { private static int nextid = 0; /** An identifying number for the airplane */ private String id; /** The total number of seats */ private int totalseats; /** The number of currently available (un-sold) seats */ private int availseats; /** The current cost for a seat in several categories */ private HashMap costsperseat = new HashMap(3); // Each derived class has a minimum and and maximum number of seats private int lowrange; private int highrange; /** Create an airplane. seats initial capacity in seats low least seats plane will have high most seats plane will have protected Airplane(int seats, int low, int high) { if (seats < low seats > high) { 6

7 throw new IllegalArgumentException( seats + " seats is out of range " + low + " - " + high); this.id = String.valueOf(++nextId); this.totalseats = seats; availseats = totalseats; this.lowrange = low; this.highrange = high; /** Set the cost per seat to a new amount for a category. ** protected so that derived classes (posibly in other ** packages) can set their own seat cost. protected void setcostperseat(object category, double newcost) { Amount costpercategory = new Amount(newCost); costsperseat.put(category, costpercategory); /** Set the cost per seat to a new amount, but only for ** existing categories. Package protected so only ** objects in the same package can update the seat cost. void updatecostperseat(object category, double newcost) { if (! costsperseat.containskey(category)) { throw new IllegalArgumentException( getclass().getname() + " does not have a seat category \"" + category + "\""); // Replace it Amount costpercategory = new Amount(newCost); costsperseat.put(category, costpercategory); /** Get the cost per seat for a category */ double getcostperseat(object category) { Amount costforcategory = (Amount) costsperseat.get(category); if (costforcategory == null) { // someone asked for a category that doesn t exist throw new IllegalArgumentException( category + " seats don t exist for " + getclass().getname()); else return costforcategory.getasdouble(); /** Return the airplane s identifier as a String */ String getid() { 7

8 return id; // The platform specific end of line character: private static final String endl = System.getProperty("line.separator"); public String tostring() { StringBuffer buf = new StringBuffer("Airplane:"); buf.append(getid()); buf.append(" seats:"); buf.append(totalseats); buf.append(" avail:"); buf.append(availseats); Set keys = costsperseat.keyset(); for ( Iterator i = keys.iterator(); i.hasnext(); ) { Object key = i.next(); buf.append(endl); buf.append("\t"); buf.append(key); // calls tostring() on key buf.append(":"); double value = getcostperseat((string) key); buf.append(value); // calls tostring() on value (Amount) return buf.tostring(); 8

9 Inheritance homework solution - Derived classes Derived classes are little more than class constant definitions. version1/bigplane.java public class BigPlane extends Airplane { // Constants for seat categories; package protected so // that other classes in same package can request seat // cost changes, e.g., // plane.setcostperseat(bigplane.business_class, 550.); static final Object FIRST_CLASS = "FirstClass"; static final Object BUSINESS_CLASS = "BusinessClass"; static final Object ECONOMY_CLASS = "EconomyClass"; // Constants (instead of magic numbers) for initial costs private static final double INITIAL_FIRST_CLASS_COST = 500.; private static final double INITIAL_BUSINESS_CLASS_COST = 350.; private static final double INITIAL_ECONOMY_CLASS_COST = 200.; // Constants for allowable number of seats private static final int LEAST_SEATS = 200; private static final int MOST_SEATS = 300; private static final int DEFAULT_SEATS = 250; public BigPlane() { this(default_seats); public BigPlane(int numseats) { // Base class will check that numseats is within range super(numseats, LEAST_SEATS, MOST_SEATS); // Assign initial seat categories and costs setcostperseat(first_class, INITIAL_FIRST_CLASS_COST); setcostperseat(business_class, INITIAL_BUSINESS_CLASS_COST); setcostperseat(economy_class, INITIAL_ECONOMY_CLASS_COST); 9

10 public String tostring() { return "Big" + super.tostring(); version1/mediumplane.java public class MediumPlane extends Airplane { // Seat categories for this kind of Airplane static final Object FIRST_CLASS = "FirstClass"; static final Object BUSINESS_CLASS = "BusinessClass"; static final Object ECONOMY_CLASS = "EconomyClass"; // Constants (instead of magic numbers) for initial costs private static final double INITIAL_FIRST_CLASS_COST = 500.; private static final double INITIAL_BUSINESS_CLASS_COST = 350.; private static final double INITIAL_ECONOMY_CLASS_COST = 200.; // Constants for allowable number of seats private static final int LEAST_SEATS = 50; private static final int MOST_SEATS = 200; private static final int DEFAULT_SEATS = 150; public MediumPlane() { this(default_seats); public MediumPlane(int numseats) { // Base class will check that numseats is within range super(numseats, LEAST_SEATS, MOST_SEATS); // Assign initial seat categories and costs setcostperseat(first_class, INITIAL_FIRST_CLASS_COST); setcostperseat(business_class, INITIAL_BUSINESS_CLASS_COST); setcostperseat(economy_class, INITIAL_ECONOMY_CLASS_COST); 10

11 public String tostring() { return "Medium" + super.tostring(); version1/smallplane.java public class SmallPlane extends Airplane { // Seat categories for this kind of Airplane static final Object BUSINESS_CLASS = "BusinessClass"; static final Object ECONOMY_CLASS = "EconomyClass"; // Constants (instead of magic numbers) for initial costs private static final double INITIAL_BUSINESS_CLASS_COST = 200.; private static final double INITIAL_ECONOMY_CLASS_COST = 150.; // Constants for allowable number of seats private static final int LEAST_SEATS = 8; private static final int MOST_SEATS = 50; private static final int DEFAULT_SEATS = 25; public SmallPlane() { this(default_seats); public SmallPlane(int numseats) { // Base class will check that numseats is within range super(numseats, LEAST_SEATS, MOST_SEATS); setcostperseat(business_class, INITIAL_BUSINESS_CLASS_COST); setcostperseat(economy_class, INITIAL_ECONOMY_CLASS_COST); public String tostring() { return "Small" + super.tostring(); 11

12 Alternative solution - Abstract Base class Notice how the base class can require a method in the derived class. Notice how the base class relies on that required method to enforce some behavior. version2/airplane.java import java.util.iterator; import java.util.set; import java.util.hashmap; /** A base class to encapsulate information need for an ** airplane: its identifier, the number of seats (total ** and currently available) and the current costs per ** seat. public abstract class Airplane { private static int nextid = 0; /** An identifying number for the airplane */ private String id; /** The total number of seats */ private int totalseats; /** The number of currently available (un-sold) seats */ private int availseats; /** The current cost for a seat in several categories */ private HashMap costsperseat = new HashMap(3); // Each derived class has a minimum and and maximum number of seats private int lowrange; private int highrange; /** Create an airplane. seats initial capacity in seats low least seats plane will have high most seats plane will have protected Airplane(int seats, int low, int high, Iterator categories) { if (seats < low seats > high) { throw new IllegalArgumentException( 12

13 seats + " seats is out of range " + low + " - " + high); this.id = String.valueOf(++nextId); this.totalseats = seats; availseats = totalseats; this.lowrange = low; this.highrange = high; // Assign initial seat categories and costs while (categories.hasnext()) { Object category = categories.next(); costsperseat.put(category, new Amount(getInitialCost(category))); /** Return the initial cost for a seat in the specified category protected abstract double getinitialcost(object category); // This method will have to be implemented in every // derived class (or in at least one derived class that // others extend.) /** Set the cost per seat to a new amount, but only for ** existing categories. Package protected so only ** objects in the same package can update the seat cost. void updatecostperseat(object category, double newcost) { if (! costsperseat.containskey(category)) { throw new IllegalArgumentException( getclass().getname() + " does not have a seat category \"" + category + "\""); // Replace it Amount costpercategory = new Amount(newCost); costsperseat.put(category, costpercategory); /** Get the cost per seat for a category */ double getcostperseat(object category) { Amount costforcategory = (Amount) costsperseat.get(category); if (costforcategory == null) { // someone asked for a category that doesn t exist throw new IllegalArgumentException( category + " seats don t exist for " + getclass().getname()); else return costforcategory.getasdouble(); 13

14 /** Return the airplane s identifier as a String */ String getid() { return id; // The platform specific end of line character: private static final String endl = System.getProperty("line.separator"); public String tostring() { StringBuffer buf = new StringBuffer("Airplane:"); buf.append(getid()); buf.append(" seats:"); buf.append(totalseats); buf.append(" avail:"); buf.append(availseats); Set keys = costsperseat.keyset(); for ( Iterator i = keys.iterator(); i.hasnext(); ) { Object key = i.next(); buf.append(endl); buf.append("\t"); buf.append(key); // calls tostring() on key buf.append(":"); double value = getcostperseat((string) key); buf.append(value); // calls tostring() on value (Amount) return buf.tostring(); 14

15 Alternative solution - Derived classes Notice how base class and derived classes interact. version2/bigplane.java public class BigPlane extends Airplane { // Objects identifying seat categories static final Object FIRST_CLASS = "FirstClass"; static final Object BUSINESS_CLASS = "BusinessClass"; static final Object ECONOMY_CLASS = "EconomyClass"; // Limits on capacity of this kind of Plane private static final int LEAST_SEATS = 200; private static final int MOST_SEATS = 300; private static final int DEFAULT_SEATS = 250; // Initial costs for seat categories for this type Airplane. private static java.util.map initialcosts = new java.util.hashmap(3); // Initialize that information when class is loaded. static { initialcosts.put(first_class, new Double(500.)); initialcosts.put(business_class, new Double(350.)); initialcosts.put(economy_class, new Double(200.)); public BigPlane() { this(default_seats); public BigPlane(int numseats) { // Base class will check that numseats is within range super(numseats, LEAST_SEATS, MOST_SEATS, initialcosts.keyset().iterator()); 15

16 protected double getinitialcost(object category) { Double initialcost = (Double) initialcosts.get(category); if (initialcost!= null) return initialcost.doublevalue(); else throw new IllegalArgumentException( category + " not recognized for " + getclass().getname()); public String tostring() { return "Big" + super.tostring(); version2/mediumplane.java import java.util.hashmap; public class MediumPlane extends Airplane { // Limits on capacity of this kind of Plane private static final int LEAST_SEATS = 50; private static final int MOST_SEATS = 200; private static final int DEFAULT_SEATS = 150; // Objects that will be used to identify seat categories // for this type of Plane. static final Object FIRST_CLASS = "FirstClass"; static final Object BUSINESS_CLASS = "BusinessClass"; static final Object ECONOMY_CLASS = "EconomyClass"; // This information, shared among all the instances of // the class, will be used to assign initial costs for // each seat category for this type of Airplane. private static HashMap initialcosts = new HashMap(3); // This code block initializes that information the first // time the class is loaded. Since maps can only contain // objects, the cost values need to be wrapped in an // object type. static { initialcosts.put(first_class, new Double(400.)); initialcosts.put(business_class, new Double(300.)); 16

17 initialcosts.put(economy_class, new Double(200.)); public MediumPlane() { this(default_seats); public MediumPlane(int numseats) { // The base class will check that numseats is within // range and will call getinitialcosts to set seat // category costs for each category in the initialcosts // map. super(numseats, LEAST_SEATS, MOST_SEATS, initialcosts.keyset().iterator()); protected double getinitialcost(object category) { Double initialcost = (Double) initialcosts.get(category); if (initialcost!= null) return initialcost.doublevalue(); else throw new IllegalArgumentException( category + " not recognized for " + getclass().getname()); public String tostring() { return "Medium" + super.tostring(); version2/smallplane.java public class SmallPlane extends Airplane { // Objects identifying seat categories static final Object BUSINESS_CLASS = "BusinessClass"; static final Object ECONOMY_CLASS = "EconomyClass"; // Limits on capacity of this kind of Plane private static final int LEAST_SEATS = 8; private static final int MOST_SEATS = 50; private static final int DEFAULT_SEATS = 25; 17

18 // Initial costs for seat categories for this type Airplane. private static final java.util.map initialcosts = new java.util.hashmap(2); // Initialize that information when class is loaded. static { initialcosts.put(business_class, new Double(200.)); initialcosts.put(economy_class, new Double(150.)); public SmallPlane() { this(default_seats); public SmallPlane(int numseats) { // Base class will check that numseats is within range super(numseats, LEAST_SEATS, MOST_SEATS, initialcosts.keyset().iterator()); protected double getinitialcost(object category) { Double initialcost = (Double) initialcosts.get(category); if (initialcost!= null) return initialcost.doublevalue(); else throw new IllegalArgumentException( category + " not recognized for " + getclass().getname()); public String tostring() { return "Small" + super.tostring(); 18

19 Inheritance homework - Additional classes Virtually unchanged from earlier implementations version1/amount.java /** An encapsulation of an amount of currency public class Amount { private long amount; // currently maintained in whole cents public Amount(double d) { amount = (long) (d * 100); /** Converts from internal representation back to double. public double getasdouble() { return ((double) amount) / 100.; // Class (static) data to do a nice formatting job on amounts // when needed. private static java.text.numberformat formatter; private static final int fracdigits = 2; static { // This block of code is a "static initializer": it gets // executed once automatically when the class is loaded. You // use them when you need more initialization than you can // accomplish by just creating a new object and to avoid // having to have special Class.init() methods. formatter = java.text.numberformat.getcurrencyinstance(); formatter.setgroupingused(false); formatter.setmaximumfractiondigits(fracdigits); formatter.setminimumfractiondigits(fracdigits); // Private helper method private String formatamount() { String num = formatter.format(getasdouble()); return num; 19

20 public String tostring() { return formatamount(); Slight difference in the way Airplanes are constructed. version1/cmdlineairlinetest.java /** A class that will be used to test Airline and Airplane capabilities public class CmdLineAirlineTest { // Going to distribute airplanes between theseo airlines private String[] airlinenames = { "USAirways", "United", "AirFrance" ; private Airline[] sampleairlines; public void createairline(string[] types) { // Create a new Airlines sampleairlines = new Airline[airlineNames.length]; for (int i = 0; i < airlinenames.length; i++) { sampleairlines[i] = new Airline(airlineNames[i]); Airplane plane; for (int i = 0; i < types.length; i++) { // Request the Airline to add several new Airplanes // of the requested types String type = types[i]; if (type.touppercase().startswith("b")) plane = new BigPlane(); else if (type.touppercase().startswith("m")) plane = new MediumPlane(); else if (type.touppercase().startswith("s")) plane = new SmallPlane(); 20

21 else { throw new IllegalArgumentException( type + " not a recognized kind of Airplane"); // Assign the airplane to one of the Airlines Airline whichone = sampleairlines[i % sampleairlines.length]; whichone.addairplane(plane); public void changeairline() { // Cause the Airline objects to adjust their prices for (int i = 0; i < sampleairlines.length; i++) { sampleairlines[i].adjustprices( (i+1) *.1); // i0% increase public void identifyairline(java.io.printstream out) { // Cause the Airline object and the Airplane objects to // identify themselves and, in the case of the Airplanes, // their current cost per seat. for (int i = 0; i < sampleairlines.length; i++) { out.println( sampleairlines[i].tostring() ); public static void main(string[] args) { if ( args.length < 1 ) { System.out.println( "usage: CmdLineAirlineTest planetypes" + "\nwhere planetypes are big medium small"); else { CmdLineAirlineTest tester = new CmdLineAirlineTest(); tester.createairline(args); tester.changeairline(); tester.identifyairline(system.out); 21

22 Inheritance homework - A Problem Problem - Derived class specific constants. version1/airline.java public class Airline { /** The name for the airline */ String name; /** A collection of Airplanes */ java.util.arraylist airplanes = new java.util.arraylist(); /** Constructor name name of the airline public Airline(String name) { this.name = name; /** Add an airplane to the airlines s collection */ public void addairplane(airplane plane) { airplanes.add(plane); /** Adjust the prices of airplanes in the collection */ public void adjustprices(double percent) { for (int i = 0; i < airplanes.size(); i++) { Airplane plane = (Airplane) airplanes.get(i); double cost; // This kind of coding style is an indication that // polymorphism is not adequately supported by the // Airplane base class. // Here the problem is that the costs for each plane // class are tied to class specific constants. 22

23 if (plane instanceof BigPlane) { cost = plane.getcostperseat(bigplane.first_class); cost += (cost * percent); plane.updatecostperseat(bigplane.first_class, cost); cost = plane.getcostperseat(bigplane.business_class); cost += (cost * percent); plane.updatecostperseat(bigplane.business_class, cost); cost = plane.getcostperseat(bigplane.economy_class); cost += (cost * percent); plane.updatecostperseat(bigplane.economy_class, cost); else if (plane instanceof MediumPlane) { cost = plane.getcostperseat(mediumplane.first_class); cost += (cost * percent); plane.updatecostperseat(mediumplane.first_class, cost); cost = plane.getcostperseat(mediumplane.business_class); cost += (cost * percent); plane.updatecostperseat(mediumplane.business_class, cost); cost = plane.getcostperseat(mediumplane.economy_class); cost += (cost * percent); plane.updatecostperseat(mediumplane.economy_class, cost); else if (plane instanceof SmallPlane) { cost = plane.getcostperseat(smallplane.business_class); cost += (cost * percent); plane.updatecostperseat(smallplane.business_class, cost); cost = plane.getcostperseat(smallplane.economy_class); cost += (cost * percent); plane.updatecostperseat(smallplane.economy_class, cost); else { // And here s the real tip off that inheritance / // polymorphism isn t being used System.err.println("don t know how to adjust prices of " + plane.getclass().getname()); /** Provide identifying information for the airline 23

24 public String tostring() { StringBuffer buf = new StringBuffer("Airline:"); buf.append(name); for (int i = 0; i < airplanes.size(); i++) { buf.append("\nplane"); buf.append(i); buf.append(":"); buf.append(airplanes.get(i)); return buf.tostring(); Results in brittle client / consumer classes: objects that use Airplanes are forced to be aware of derived classes. Changes in the object hierarchy / addition of new derived classes will have ripple effects. Similar to some homework solutions that defined separate methods for each seat category. That breaks polymorphism. Does not meet the requirement that the Airline class should not have any knowledge of specific classes derived from Airplane. 24

25 Part of the answer: Type Safe Enumeration version3/seatcategory.java /** A simple typesafe enumeration of seat categories public class SeatCategory { private final String name; private SeatCategory(String name) { this.name = name; public String tostring() { return name; public static final SeatCategory FIRST_CLASS = new SeatCategory("First Class"); public static final SeatCategory BUSINESS_CLASS = new SeatCategory("Business Class"); public static final SeatCategory ECONOMY_CLASS = new SeatCategory("Economy Class"); 25

26 Abstract Base class The use of a type safe enumeration reduces the freedom of derived classes to define their own categories. version3/airplane.java import java.util.iterator; import java.util.set; import java.util.hashmap; /** A base class to encapsulate information need for an ** airplane: its identifier, the number of seats (total ** and currently available) and the current costs per ** seat. public abstract class Airplane { /** kkeps track of id number to be assigned next */ private static int nextid = 0; /** An identifying number for the airplane instance */ private String id; /** The total number of seats */ private int totalseats; /** The number of currently available (un-sold) seats */ private int availseats; /** The current cost for a seat in several categories */ private HashMap costsperseat = new HashMap(); // Each derived class has a minimum and and maximum number of seats private int lowrange; private int highrange; /** Create an airplane (from derived classes) seats initial capacity in seats low least seats plane will have high most seats plane will have IllegalArgumentException if numnber of seats exceeds range protected Airplane(int seats, int low, int high) { if (seats < low seats > high) { 26

27 throw new IllegalArgumentException( seats + " seats is out of range " + low + " - " + high); this.id = String.valueOf(++nextId); this.totalseats = seats; availseats = totalseats; this.lowrange = low; this.highrange = high; /** Set the cost per seat to a new amount for a category */ protected void setcostperseat(seatcategory category, double newcost) { Amount costpercategory = new Amount(newCost); costsperseat.put(category, costpercategory); /** Set the cost per seat to a new amount, but only for ** existing categories (and only from other classes in ** the same package. category seat class to update cost for newcost updated cost of SeatCategory seat IllegalArgumentException if category void updatecostperseat(seatcategory category, double newcost) { if (! costsperseat.containskey(category)) { throw new IllegalArgumentException( getclass().getname() + " does not have a seat category \"" + category + "\""); // Replace it Amount costpercategory = new Amount(newCost); costsperseat.put(category, costpercategory); /** Get the cost per seat for a specified SeatCategory */ protected double getcostperseat(seatcategory category) { Amount costforcategory = (Amount) costsperseat.get(category); if (costforcategory == null) { // someone asked for a category that doesn t exist throw new IllegalArgumentException( category + " seats don t exist for " + getclass().getname()); else return costforcategory.getasdouble(); /** Return the airplane s identifier as a String */ String getid() { 27

28 return id; // The platform specific end of line character: private static final String endl = System.getProperty("line.separator"); public String tostring() { StringBuffer buf = new StringBuffer("Airplane:"); buf.append(getid()); buf.append(" seats:"); buf.append(totalseats); buf.append(" avail:"); buf.append(availseats); Set keys = costsperseat.keyset(); for ( Iterator i = keys.iterator(); i.hasnext(); ) { Object key = i.next(); buf.append(endl); buf.append("\t"); buf.append(key); // calls tostring() on key (SeatCategory) buf.append(":"); double value = getcostperseat((seatcategory) key); buf.append(value); // calls tostring() on value (Amount) return buf.tostring(); 28

29 Derived classes version3/bigplane.java public class BigPlane extends Airplane { // Constants for initial, default seat costs private static final double INITIAL_FIRST_CLASS_COST = 500.; private static final double INITIAL_BUSINESS_CLASS_COST = 350.; private static final double INITIAL_ECONOMY_CLASS_COST = 200.; // Constants for allowable number of seats private static final int LEAST_SEATS = 200; private static final int MOST_SEATS = 300; private static final int DEFAULT_SEATS = 250; public BigPlane() { this(default_seats); public BigPlane(int numseats) { // Base class will check that numseats is within range super(numseats, LEAST_SEATS, MOST_SEATS); // Assign initial seat categories and costs setcostperseat(seatcategory.first_class, INITIAL_FIRST_CLASS_COST); setcostperseat(seatcategory.business_class, INITIAL_BUSINESS_CLASS_COST); setcostperseat(seatcategory.economy_class, INITIAL_ECONOMY_CLASS_COST); public String tostring() { return "Big" + super.tostring(); version3/mediumplane.java public class MediumPlane extends Airplane { // Constants for initial, default seat costs private static final double INITIAL_FIRST_CLASS_COST = 400.; private static final double INITIAL_BUSINESS_CLASS_COST = 200.; private static final double INITIAL_ECONOMY_CLASS_COST = 150.; // Constants for allowable number of seats 29

30 private static final int LEAST_SEATS = 50; private static final int MOST_SEATS = 200; private static final int DEFAULT_SEATS = 150; public MediumPlane() { this(default_seats); public MediumPlane(int numseats) { // Base class will check that numseats is within range super(numseats, LEAST_SEATS, MOST_SEATS); // Assign initial seat categories and costs setcostperseat(seatcategory.first_class, INITIAL_FIRST_CLASS_COST); setcostperseat(seatcategory.business_class, INITIAL_BUSINESS_CLASS_COST); setcostperseat(seatcategory.economy_class, INITIAL_ECONOMY_CLASS_COST); public String tostring() { return "Medium" + super.tostring(); version3/smallplane.java public class SmallPlane extends Airplane { // Constants for initial, default seat costs private static final double INITIAL_BUSINESS_CLASS_COST = 200.; private static final double INITIAL_ECONOMY_CLASS_COST = 150.; // Constants for allowable number of seats private static final int LEAST_SEATS = 8; private static final int MOST_SEATS = 50; private static final int DEFAULT_SEATS = 25; public SmallPlane() { this(default_seats); public SmallPlane(int numseats) { // Base class will check that numseats is within range super(numseats, LEAST_SEATS, MOST_SEATS); // Assign initial seat categories and costs setcostperseat(seatcategory.business_class, INITIAL_BUSINESS_CLASS_COST); setcostperseat(seatcategory.economy_class, INITIAL_ECONOMY_CLASS_COST); 30

31 public String tostring() { return "Small" + super.tostring(); 31

32 Client class uses polymorphic access version3/airline.java public class Airline { /** The name for the airline */ String name; /** A collection of Airplanes */ java.util.arraylist airplanes = new java.util.arraylist(); /** Constructor name name of the airline public Airline(String name) { this.name = name; /** Add an airplane to the airlines s collection */ public void addairplane(airplane plane) { airplanes.add(plane); /** Adjust the prices of airplanes in the collection */ public void adjustprices(double percent) { SeatCategory[] categories = { SeatCategory.FIRST_CLASS, SeatCategory.BUSINESS_CLASS, SeatCategory.ECONOMY_CLASS, ; for (int i = 0; i < airplanes.size(); i++) { Airplane plane = (Airplane) airplanes.get(i); double cost; for (int c = 0; c < categories.length; c++) { 32

33 SeatCategory category = categories[c]; try { cost = plane.getcostperseat(category); cost = cost + (cost * percent); plane.updatecostperseat(category, cost); catch (IllegalArgumentException e) { // We tried to change a category that doesn t exist // for this type of Airplane. /** Provide identifying information for the airline public String tostring() { StringBuffer buf = new StringBuffer("Airline:"); buf.append(name); for (int i = 0; i < airplanes.size(); i++) { buf.append("\nplane"); buf.append(i); buf.append(":"); buf.append(airplanes.get(i)); return buf.tostring(); 33

34 Improving the Type Safe Enumeration SeatCategory now provides a (private) Iterator implementation version4/seatcategory.java import java.util.iterator; /** A simple typesafe enumeration of seat categories public class SeatCategory { private final String name; private SeatCategory(String name) { this.name = name; public String tostring() { return name; public static final SeatCategory FIRST_CLASS = new SeatCategory("First Class"); public static final SeatCategory BUSINESS_CLASS = new SeatCategory("Business Class"); public static final SeatCategory ECONOMY_CLASS = new SeatCategory("Economy Class"); public static Iterator iterator() { SeatCategory[] categories = { FIRST_CLASS, BUSINESS_CLASS, ECONOMY_CLASS, 34

35 ; return new SeatCategoryIterator( categories ); class SeatCategoryIterator implements Iterator { SeatCategory[] categories; int next = 0; SeatCategoryIterator (SeatCategory[] categories) { this.categories = categories; public boolean hasnext() { return (next < categories.length); public Object next() { if (next >= categories.length) throw new java.util.nosuchelementexception(); else return categories[next++]; public void remove() { throw new UnsupportedOperationException(); 35

36 Client class is more independent version4/airline.java import java.util.iterator; public class Airline { /** The name for the airline */ String name; /** A collection of Airplanes */ java.util.list airplanes = new java.util.arraylist(); /** Constructor name name of the airline public Airline(String name) { this.name = name; /** Add an airplane to the airlines s collection */ public void addairplane(airplane plane) { airplanes.add(plane); /** Adjust the prices of airplanes in the collection */ public void adjustprices(double percent) { for (int i = 0; i < airplanes.size(); i++) { Airplane plane = (Airplane) airplanes.get(i); double cost; // Now Airline objects are independent of changes in // the kinds of SeatCategories that might be added // (although in a real situation, each Airline might // define its own SeatCategories and manage them.) for ( Iterator c = SeatCategory.iterator(); c.hasnext(); ) { SeatCategory category = (SeatCategory) c.next(); try { 36

37 cost = plane.getcostperseat(category); cost = cost + (cost * percent); plane.updatecostperseat(category, cost); catch (IllegalArgumentException e) { // We tried to change a category that doesn t exist // for this type of Airplane. /** Provide identifying information for the airline public String tostring() { StringBuffer buf = new StringBuffer("Airline:"); buf.append(name); for (int i = 0; i < airplanes.size(); i++) { buf.append("\nplane"); buf.append(i); buf.append(":"); buf.append(airplanes.get(i)); return buf.tostring(); 37

38 Homework Reading Chapter 9 - Formalizing Requirements through Use Cases Chapter 10 - Modeling the Static / Data Aspects of the System 38