Blakes 21 Days Chapter 6 Document

• External Links
  • Version (23) | Blakes 21 Days: Chapter 1 & Appendix A | Book's Website | 21 Days | Download JDK 8 (Oracle) | Download NetBeans 8.0.2 (netbeans) | reserve
  • Chapter 1 & Appendix A | (1) | (2) | (3) | (4) | (5) | (6) | (7) | (8) | (9) | (10) | (11) | (12) | (13) | (14) | (15) | (16) | (17) | (18) | (19) | (20) | (21) | (A) | (D) | reserve | Project Files | Grid | Blank

• Internal Links
  • Chapter 6 pages 157 to 190 | 123 - 95 = 33 pages | 13 is the mid way point for this chapter | Current Page 187 - 157 = 30 | Comments: 3 more pages till the end | reserve
  • page 157 | Modifiers | Access Control for Methods and Variables | Default Access | Private Access | Public Access | Protected Access | reserve
  • Comparing Levels of Access Control | Access Control and Inheritance | Accessor Methods | Static Variables and Methods | First Program | Run Program | reserve
  • Final Classes, Methods, and Variables | Variables | Methods | Classes | Abstract Classes and Methods | Packages | The import Declaration | Class Name Conflicts | reserve
  • Creating Your Own Packages | Picking a Package Name | Creating the Folder Structure | Adding a Class to a Package | Packages and Class Access Control | reserve
  • Interfaces | The Problem of Single Inheritance | Interfaces and Classes | Implementing and Using Interfaces | Implementing Multiple Interfaces | Other Uses of Interfaces | reserve
  • Creating and Extending Interfaces | New Interfaces | Methods Inside Interfaces | Extending Interfaces | reserve
  • Creating an Online Storefront (Second Program) | Listing 6.2 | Explanation | reserve
  • Third Program | Explanation | Fourth Program | Explanation | Summary | reserve

Day 6, Packages, Interfaces, and Other Class Features

• Top
• 157 Classes, the templates used to create objects that can store data and accomplish tasks, turn up in everything you do with the Java language.
  • Today, you extend your knowledge of classes by learning more about how to create them, use them, organize them, and establish rules for how other classes can use them.
• 157 The following subjects are covered
  • Controlling access to methods and variables from outside a class
  • Finalizing classes, methods, and variables so that their values or definitions cannot be overridden in subclasses
  • Creating abstract classes and methods for factoring common behavior into superclasses
  • Grouping classes into packages
  • Using interfaces to bridge gaps in a class hierarchy

Modifiers

• Top
• 158 During the week, you have learned how to define classes, methods, and variables in Java.
  • The programming techniques you learn today involve different ways of thinking about how a class is organized.
  • All these techniques use special modifiers in the Java language.
  • Modifiers are keywords that you add to those definitions to change their meanings.

• 158 The Java language has a wide variety of modifiers:
  • Modifiers for controlling access to a class, method, or variable:
    • public, protected, and private.
  • The static modifier for creating methods and variables
  • The final modifier for finalizing the implementations of classes, methods, and variables
  • The abstract modifier for creating abstract classes and methods
  • The synchronized and volatile modifiers, which are used for threads

• Top
• 158 To add a modifier, you include its keyword in the definition of a class, method, or variable.
  • The modifier precedes the rest of the statement, as in the following examples:
  • 
    public class RedButton extends java.swing.JButton {
        // ...
    }
    
    
  • private boolean offline;
    
    
  • static final double WEEKS = 9.5;
    
    
  • protected static final int MEANING_OF_LIFE = 42;
  • 
    public static void main(String[] arguments {
        // body of method
    }
    
    

• Top
• 158 If you're using more than one modifier in a statement, you can place them in any order, as long as all modifiers precede the element they are modifying.
  • Be sure to avoid treating a method's return type, such as void, as if it were one of the modifiers.
  • The return type must precede the method name, with no modifiers between them.
• 158 Modifiers are optional, as you might have recognized after using some of them in the preceding five days.
  • However, there are many good reasons to use them in your programs.

Access Control for Methods and Variables

• Top
• 159 The modifiers that you will use most often control access to methods and variables, public, protected, and private.
  • These modifiers determine which variables and methods of a class are visible to other classes.

• 159 By using access control, you can dictate how your class is used by other classes.
  • Some variables and methods is a class are of use only within the class itself and should be hidden from other classes.
  • This process is called encapsulation, an object controls what the outside world can know about it and how the outside world can interact with it.
  • Encapsulation is the process that prevents class variables from being read or modified by other classes.
  • The only way to use these variables is by calling methods of a class if they are available.

• 159 The Java language provides four levels of access control: public, private, protected, and a default level specified by using none of these access control modifiers.

Default Access

• Top
• 159 Variables and methods can be declared without modifiers, as in the following examples:
  • String version = "0.7a";
    
    
  • boolean processOrder();
        // body of method
        return true;
    }
    

• 159 A variable or method declared without an access control modifier is available to any other class in the same package.
  • The Java Class Library is organized into packages such as javax.swing,
    • a collection of windowing classes for use in graphical user interface programming, and java.util, a useful group of utility classes.
  • Any variable declared without a modifier can be read or changed by any other class in the same package.
  • Any method declared the same way can be called by any other class in the same package.
  • No other classes can access these elements in any way.

Private Access

• Top
• 159 To completely hide a method or variable and keep it from being used by other classes, use the private modifier.
  • The only place these methods or variables can be accessed is within their own class.
• 160 A private instance variable can be used by methods in its own class but not by objects of any other class.
  • Private methods can be called by other methods in their own class but cannot be called by any others.
  • This restriction also affects inheritance: Neither private variables nor private methods are inherited by subclasses.

• 160 Private variables are useful in two circumstances:
  • When other classes have no reason to use that variable
  • When another class could wreak havoc by changing the variable in an inappropriate way

• 160 For example, consider a Java class called CouponMachine that generates discounts for an Internet shopping site.
  • A variable in that class called salesRatio could control the size of discounts based on product sales.
  • This variable has a big impact on the business's bottom line.
  • If the variable were changed by other classes, CouponMachine's performance would change significantly.
  • To guard against this scenario, you could declare the salesRatio variable as private.

• Top
• 160 The following class uses private access control:
  • class Logger {
        private String format;
    
        public String getFormat() {
            return this.format
        }
    
        public void setFormat(String fmt) {
            if ( (fmt.equals("common")) || (fmt.equals("combined")) ) {
                this.format = fmt;
            }
        }
    }
    
  • In this code example, the format variable of the Logger class is private, so there's no way for other classes to retrieve or set its value directly.
    • Instead, it's available through two public methods:
      • getFormat(), which returns the value of format,
      • and setFormat(String), which sets its value.
  • The latter method contains logic that allows the variable to be set to only "common" pr "combined".
    • This demonstrates a benefit of using public methods as the only means of accessing instance variables of a class:
      • The methods can give the class control over how the variable is accessed and limit the values it can take.

• Top
• 161 Using the private modifier is the main way in which an object encapsulates itself.
  • You can't limit the ways in which a class is used without using private to hide variables and methods.
  • Another class is free to change the variables inside a class and call its methods in many possible ways if you don't control access.
• 161 A big advantage of privacy is that it lets the implementation of a class change without affecting the users of that class.
  • If you come up with a better way to accomplish something, you can rewrite the class as long as its public methods take the same arguments and return the same kind of values.

Public Access

• Top
• 161 In some cases, you might want a method or variable in a class to be completely available to any other class that wants to use it.
  • For example, the Color class in the java.awt package has public variables for common colors such as black.
  • This variable is used when a graphical class wants to use the color black, so black should have no access control.
• 161 Class variables often are declared to be public.
  • An example is a set of variables in a Football class that represent the number of points used in scoring.
  • The TOUCHDOWN variable could equal 6, the FIELD_GOAL variable could equal 3, and SAFETY could equal 2.
  • If these variables are public, other classes could use them in statements such as the following:
  • 
    if (yard < 0 ) {
        System.out.println("Touchdown!");
        score = score + Football.TOUCHDOWN;
    }
    
    
  • The public modifier makes a method or variable completely available to all classes.
  • You have used it in every application you have written so far in their main() methods:
  • 
    public static void main(String[] arguments) {
        // ...
    }
    
    
  • The main() method of an application has to be public.
  • Otherwise, it could not be called by a Java Virtual Machine (JVM) to run the class.
  • Because of class inheritance, all public methods and variables of a class are inherited by its subclasses.

Protected Access

• Top
• 162 The next level of access control is to limit a method and variable to use by the following two groups:
  • Subclasses of a class
  • Other classes in the same package
• 162 You do so by using the protected modifier, as in the following statement:
  • protected boolean outOfData = true;

• Top
• 162 NOTE: You might be wondering how these two groups differ.
  • After all, aren't subclasses part of the same package as their superclass?
  • Not always.
  • An example is the java.sql.Date class, which represents calendar dates in a SQL database.
  • It is a subclass of java.util.Date, a more generic date class.
  • Protected access differs from default access in this way, protected variables are available to subclasses, even if they aren't in the same package.

• Top
• 162 This level of access control is useful if you want to make it easier for a subclass to be implemented.
  • Your class might use a method or variable to help the class do its job.
  • Because a subclass inherits much of the same behavior and attributes, it might have the same job to do.
  • Protected access gives the subclass a chance to use the helper method or variable while preventing an unrellated class from trying to use it.

• 162 Consider the example of a class called AudioPlayer that plays an audio file.
  • AudioPlayer has a method called openSpeaker(), which interacts with the hardware to prepare the speaker for playing.
  • AudioPlayer isn't important to anyone outside the AudioPlayer class, so at first glance you might want to make it private.
  • A snippet of AudioPlayer might look something like this:
  • 
    class AudioPlayer {
    
        private boolean openSpeaker(Speaker sp) {
            // implementation here
        }
    }
    
    
  • This code works fine if AudioPlayer won't be subclassed.
    • But what if later you need a class called StreamingAudioPlayer that is a subclass of AudioPlayer ?
    • That class needs access to the openSpeaker() method to override it and provide support for streaming audio devices.
    • You still don't want the method to be generally available to random objects, so it shouldn't be public, but you want any subclasses to have access to it.

Comparing Levels of Access Control

• Top
• 163 The differences among the various protection types can be confusing, particularly in the case of protected methods and variables.
  • Table 6.1, which summarizes exactly what is allowed where, helps clarify the differences from the least restrictive (public) to the most restrictive (private) forms of protection.

Access Control and Inheritance

• Top
• 163 One last issue regarding access control for methods involves subclasses.
  • When you create a subclass and override a method, you must consider the access control in place on the original method.

• 163 As a general rule, you cannot override a method in Java and make the new method more restrictively controlled than the original.
  • You can, however, make it more public.
  • The method in a subclass can't reduce the visibility of the one it overrides.
  • The following rules for inherited methods are enforced:
    • Methods declared public in a superclass also must be public in all subclasses.
    • Methods declared protected in a superclass must be either protected or public in subclasses, the cannot be private.
    • Methods declared without access control (no modifier was used) can be declared more private in subclasses.
  • Methods declared private are not inherited, so the rules don't apply.

Accessor Methods

• Top
• 164 In many cases, you may have an instance variable in a class that has strict rules for the values it can contain.
  • An example is a zipCode variable.
    • A Zip Code in the United States must be a five-digit number.
    • There also is a Zip+4 format that's nine digits.
  • To prevent an external class from setting the zipCode variable incorrectly, you can declare it private:
    • private int zipCode;
  • However, what if other classes must be able to set the zipCode variable for the class to be useful ?
    • In that circumstance, you can give other classes access to a private variable by using an accessor method inside the same class as zipCode.
  • An accessor method provides access to a variable that otherwise would be off-limits.
    • By using a method to provide access to a private variable, you can control how that variable is used.
    • Inn the Zip Code example, the class could prevent anyone else from setting zipCode to an incorrect value.
  • Often, separate accessor methods to read and write a variable are available.
    • Reading methods have a name beginning with get, and writing methods have a name beginning with set, as in setZipCode(int) and getZipCode(int).
  • There's one exception to this convention:
    • If the variable being accessed is a Boolean, the accessor method doesn't begin with get.
    • Instead, start it with is as in isValid() for the boolean variable valid.
    • Here's an example:
      • 
        private boolean empty;
        
        public boolean isEmpty() {
            return empty;
        }
        
        
  • Using methods to access instance variables is a common technique in object-oriented programming.
    • This approach makes classes more reusble by guarding against improper use.

Static Variables and Methods

• Top
• 164 A modifier that you already have used in program is static, which was described in detail during Day 5, "Creating Classes and Methods."
  • The static modifier is used to create class methods and variables, as in the following example:
    • 
      public class Circle {
          public static double PI = 3.14159265F;
          public double radius;
      
          public double area() {
              return PI * radius * radius;
          }
      }
      
      

• Top
• 165 Class variables and methods can be accessed using the class name followed by a dot and the name of the variable or method, as in Color.black or Circle.PI.
  • You also can use the name of an object belonging to the class, but for class variables and methods, using the class name is better.
  • This approach makes it more clear what kind of variable or method you're working with, instance variables and methods never can be referred to by a class name.
• 165 The following statements use the class variables and methods:
  • double circumference = 2 * Circle.PI * radius;
  • double randomNumber = Math.random();

• Top
• 165 TIP: For the same reason as instance variables, class variables can benefit from being private and limiting their use to accessor methods only.

First Program

• Top
• 165 The first project you undertake today is a class called InstanceCounter that uses class and instance variables to keep track of how many objects of that class have been created.
  • In NetBeans, create an empty Java file named InstanceCounter in the com.java21days package you've been using for most of this book.
    • run NetBeans and create a new Java program by taking these steps
    1. Choose the menu command File, New File. The "New File" dialog box opens.
    2. In the Categories pane, choose Java
    3. In the "File Types" pane, choose "Empty Java File" and click the "Next" button. The "Empty Java File" dialog box opens.
    4. In the "Class Name" text field, enterInstanceCounter, which will give the source code file the name InstanceCounter.java
    5. In the "Package Name" text field, enter com.java21days.
    6. Click the "Finish" button.
  • Enter the code shown in Listing 6.1 in the source code file, and save it when you're done.

• Top
• I wasn't able to get the Empty Java File window to display itself on the submenu
• I was able to fix that by selecting File, Open Recent Project, then selecting Java21.
  • Some older programs open up, but at least I can now utilize the "Empty Java File" window.

Listing 6.1

• Top
• page 165 - 166
  
  package com.java21days;
  
  public class InstanceCounter {
      private static int numInstances = 0;
  
      protected static int getCount() {
          return numInstances;
      }
  
      private static void addInstance() {
          numInstances++;
      }
  
      InstanceCounter() {
          InstanceCounter.addInstance();
      }
  
      public static void main(String[] arguments) {
          System.out.println("Starting with " +
              InstanceCounter.getCount() + " objects");
          for (int i = 0; i < 500; ++i) {
              new InstanceCounter();
          }
          System.out.println("Created " +
              InstanceCounter.getCount() + " objects");
      }
  }
  
  

Run Program

• Top
• 166 NetBeans attempts to compile a Java class when it is saved or run.
  • Save the file by choosing File, Save
  • If there are no errors, you can run it to see the output contained in Figure 6.1
  • Run the program by choosing Run, Run File.

Figure 6.1 goes here, but you can see my "Output" panel just above.

• Top
• 166 This application demonstrates several features of the Java language.
  • In line 4, a private class variable is declared to hold the number of objects.
  • It is a class variable (declared static) because the number of objects is relevant to the class as a whole, not to any particular object.
  • It's private so that it can be retrieved with only an accessor method.
• 166 Note the initialization of numInstance.
  • Just as an instance variable is initialized when its instance is created, a class variable is initialized when its class is created.
  • This class initialization happens essentially before anything else can happen to that class, or its instances, so that the class in the example will work as planned.
• 166 In lines 6 - 8, a get method is defined so that the private instance variable's value can be retrieved.
  • This method also is declared as a class method because it applies directly to the class variable.
  • The getCount() method is declared protected, as opposed to public, because only this class and perhaps its subclasses are interested in that value,
    • other random classes, therefore, are restricted from seeing it.
• 166 Note that there is no accessor method to set the value.
  • The value of the variable should be incremented only when a new instance is created,
    • it should not be set to any random value.
  • Instead of creating an accessor method,
    • a special private method called addInstance() is defined in lines 10 - 12 that increments the value of numInstance() by 1.
• 167 Lines 14 - 16 create the constructor for this class.
  • Constructors are called when a new object is created,
    • which makes this the most logical place to call addInstance() and to increment the variable.
• 167 The main() method indicates that you can run this as a Java application and test all the other methods.
  • In the main() method, 500 objects of the InstanceCounter class are created,
    • and then the value of the numInstance class variable is displayed.

Final Classes, Methods, and Variables

• Top
• 167 The final modifier is used with classes, methods, and variables to indicate that they will never be changed.
  • It has different meanings for each thing that can be made final, as follows:
    • A final class cannot be subclassed.
    • A final method cannot be overridden by any subclasses.
    • A final variable cannot change in value.

Variables

• Top
• 167 Final variables often are called constants (or constant variables) because they do not change in value at any time.
• 167 With Variables, the final modifier is used with static when making a constant a class variable.
  • If the value never changes, you don't have much reason to give each object in the same class its own copy of the value.
  • They all can use the class variable with the same functionality.
• 167 The following statements are examples of declared constants:
  • public static final int TOUCHDOWN = 6;
  • static final String TITLE = "Captain";

Methods

• Top
• 167 Final methods never can be overridden by a subclass.
  • You declare them using the final modifier in the class declaration, as in the following example:
  • 
    public final void getSignature() {
        // body of method
    }
    

• Top
• 168 The most common reason to declare a method final is to make the class run more efficiently.
  • Normally, when the JVM runs a method, first it checks the current class to find the method, then it checks its superclass, and so on up the class hierarchy until the method is found.
  • This process sacrufices some speed in the name of flexibility and ease of development.
• 168 If a method is final, the Java compiler can put the method's executable bytecode directly into any program that calls the method
  • because the method will never change because of the subclass that overrides it.
• 168 When you develop a class, you don't have much reason to use final.
  • However, if you need to make the class execute more quickly, you can change a few methods into final methods to speed up the process.
  • Doing so removes the possibility that the method later will be overridden in a subclass, so consider this change carefully before continuing.
• 168 The Java Class Library declares many of the commonly used methods final so that they can be executed more quickly when used in programs that call them.

• Top
• 168 NOTE: Private methods are final without being declared that way because they can't be overridden in a subclass under any circumstance.

Classes

• Top
• 168 You make a class impossible to subclass by using the final modifier in the class's declaration, as in the following:
  • 
    public final class ChatServer {
        // body of method
    }
    
    
• 168 A final class cannot appear after extends in a class declaration to create a subclass.
  • As with final methods, this process introduces some speed benefits to the Java language at the expense of flexibility.
• 168 If you're wondering what you lose by using final classes, you must not have tried to subclass anything in the Java Class Library.
  • Many of the popular classes are final, such as java.lang.String, and java.lang.Math, and java.net.URL.
  • If you want to create a class that behaves like strings but with some new changes, you can't subclass String and define only the behavior that is different.
  • You have to start from scratch.
• 168 All methods in a final class are automatically final themselves, so you don't have to use a modifier in their declarations.
• 169 Because classes that can provide behavior and attributes to subclasses are much more useful,
  • you should strongly consider whether the benefit of using final on one of your classes is outweighed by the cost.

Abstract Classes and Methods

• Top
• 169 In a class hierarchy, the higher the class, the more abstract its definition.
  • A class at the top of the hierarchy of other classes can define only the behavior and attributes common to all the classes.
  • More-specific behavior and attributes fall somewhere lower down the hierarchy.
• 169 When you factor out common behavior and attributes during the process of defining a hierarchy of classes,
  • you might at times find yourself with a class that never needs to be instantiated directly.
  • Instead, such a class serves as a place to hold common behavior and attributes chared by their subclasses.
• 169 These classes are called abstract classes, and they are created using the abstract modifier.
  • The following is an example:
  • 
    public abstract class Palette {
        // ...
    }
    
    
• 169 An example of an abstract class is java.awt.Component, the superclass of graphical user interface components.
  • Because numerous components inherit from this class, it contains methods and variables useful to each of them.
  • However, there's no such thing as a generic component that can be added to a user interface, so you would never need to create a Component object in a program.
• 169 Abstract classes can contain anything a normal class can, including constructors, because their subclasses might need to inherit them.
  • Abstract classes also can contain abstract methods, which are method signitures with no implementation.
  • These methods are implemented in the subclasses of the abstract class.
  • Abstract methods are declared with the abstract modifier.
  • You cannot declare an abstract method in a class that isn't itself abstract.
  • If an abstract class has nothing but abstract methods, you're better off using an interface, as you'll see later today.

Packages

• Top
• 169 Using packages is a way of organizing groups of classes.
  • A package contains classes that are related in purpose, in scope, or by inheritance.
• 170 If your programs are small and use limited number of classes, you might find that you don't need to explore packages.
  • But as you begin creating more sophisticated projects with many classes related to each other by inheritance, you might discover the benefit of organizing them into packages.
• 170 Packages are useful for several broad reasons:
  • They enable you to organize your classes into units.
    • Just as you have folders on your hard drive to organize your files and applications,
    • packages enable you to organize your classes into groups so that you use only what you need for each program.
  • They reduce problems with conflicts about names.
    • As the number of Java classes grows, so does the likelihood that you'll use the same class name as another developer.
    • This intoduces the possibility of naming clashes and error messages if you try to integrate groups of classes into a single program.
    • Packages provide a way to refer specifically to the desired class, even if it shares a name with a class in another package.
  • They enable you to protect classes, variables, and methods in larger ways than on a class-by class basis.
    • You learn more about protections with packages later.
  • Packages can be used to uniquely identify your work

• Top
• 170 Every time you use the import command or refer to a class by its full package name (java.util.StringTokenizer, for example), you are using packages.
• 170 To use a class contained in a package, you use one of these techniques:
  • If the class you want to use is in the package java.lang (for example, System or Date), you can use the class name to refer to that class.
    • The java.lang classes are automatically available to you in all your programs.
  • If the class you want to use is in some other package,
    • you can refer to that class by its full name, including any package names (for example, java.awt.Font).
  • For classes that you use frequently from other packages, you can import individual classes or a whole package of classes.
    • After a class or package has been imported, you can refer to that class by its class name.
• 170 If you don't declare that your class belongs to a package, it is put into an unnamed default package.
  • You can refer to that class and any other unpackaged class by its class name anywhere in other classes.
• 170 To refer to a class in another package, you always can use its full name: the class name preceded by its package.
  • You do not have to import the class or package to use it in this manner:
  • java.awt.Font text = new java.awt.Font();
• 171 For classes that you use only once or twice in your program, using the full name might make sense.
  • If you use a class multiple times, you can import the class to save yourself some typing.
  • But there's no reason not to use import, so you may decide to follow this book's convention of always using it so that class names are short and code is more readable.

The import Declaration

• Top
• 171 To import classes from a package, use the import declaration.
  • You can import an individual class, as in this statement:
  • import java.util.ArrayList;
  • You can import an entire package of classes using an asterisk * in place of an individual class name:
  • import java.awt.*;
  • In an import statement, the asterisk can be used only in place of a class name.
    • It does not make it possible to import multiple packages with similar names.
  • For example, the Java Class Library includes the java.util, java.util.jar and java.util.prefs packages.
  • You could not import all three packages with the following statement:
  • import java.util.*;
  • This merely imports the java.util package.
  • To make all three available in a class, the following statements are required:
  • 
    import java.util.*;
    import java.util.jar.*;
    import java.util.prefs.*;
    
    
  • Also, you cannot indicate partial class names (such as L* to import all the classes that begin with the letter L).
    • Your only options when using an import declaration are to identify a single class or use an asterisk to load all the classes in a package.
  • The import declarations in your class definition go at the top of the file, before any class definitions but after the package declaration, as you'll see in the next section.
• 171 Using individual import declarations or importing packages is mostly a question of your own coding style.
  • Importing a group of classes does not slow down your program or make it any larger,
    • only the classes that you actually use in your code are loaded as they are needed.
  • Importing specific classes makes it easier for readers of your code to figure out what classes are being used in the code.

• Top
• 172 NOTE: If you're familiar with C or C++, you might expect the import declaration to work like #include
  • and potentially result in a large executable program because it includes source code from another file.
  • This isn't the case in Java.
  • The import keyword's only function is to tell the Java compiler where to look for the full name of a class when its short name is used.
  • It doesn't actually import code from any classes.

• Top
• 172 The import statement also can be used to refer to constants in a class by name.
• 172 Normally, class constants must be prefaced with the name of the class, as in Color.black, MATH.PI, and File.separator.
• 172 An import static statement makes the contents in an identified class available in shorter form.
  • The keywords import static are followed by the name of an interface or class and an asterisk.
  • For example:
  • import static java.lang.Math.*;
  • This statement makes it possible to refer to the constants in the Math class, E and PI, using only their names.
  • Here's a short example of a class that takes advantage of this feature:
  • 
    import static java.lang.Math.*;
    
    public class ShortConstants {
        public static void main(String[] arguments) {
            System.out.println("PI: " + PI);
            System.out.println("" + (PI * 3));
        }
    }
    
    

Class Name Conflicts

• Top
• 172 After you have imported a class or a package of classes, you usually can refer to a class by its name without the package identifier.
  • However, you must be more explicit when you import two classes from different packages that have the same class name.
• 172 One situation where a naming conflict might occur is during database programming.
  • which you undertake on Day 18, "Accessing Databases with JDBC 4.2 and Derby."
  • This kind of programming can involve the java.util and java.sql packages, which both contain a class named Date.
• 172 If you're working with both packages in a class that reads or writes data in a database, you could import them with these statements:
  • 
    import java.sql.*;
    import java.util.*;
    
    
• 173 When both these packages are imported,
  • a compiler error occurs when you refer to the Date class without specifying a package name,
  • as in this statement:
  • Date now = new Date();
  • The error occurs because the Java compiler has no way of knowing which Date class is being referred to in the statement.
  • The package must be included in the statement, like this:
  • java.util.Date = new java.util.Date();

• Top
• 173 TIP: NetBeans makes it easy to import individual classes as you write a program.
  • As you enter statements in the source code editor, NetBeans will detect that a class you use hasn't been imported.
  • A warning icon (lightbulb and red circle) appears in the left edge of the editor on that line.
  • When you click the icon, a pop-up menu appears with a command to import the class.
  • Choose it and an import statement is added at the top of the class.

Creating Your Own Packages

• Top
• 173 Creating a package for your class in Java is not much more complicated than creating a class.

Picking a Package Name

• Top
• 173 The first step is to decide on a name.
  • The name you choose for your package depends on how you will use those classes.
  • Perhaps you name your package after yourself or a part of the Java system you're working on (such as graphics or messaging).
  • If you intend to distribute your package as an open source or commercial product, use a package name that uniquely identifies its authorship.
• 173 Oracle recommends that Java developers use an Internet domain name that you control as the basis for a unique package name.
• 173 To form the name, reverse the elements of the domain so that the last part becomes the first part of the package name, followed by the second-to-last part.
  • Following this convention, because my personal domain name is cadenhead.org, Java packages I create begin with the name org.cadenhead, such as org.cadenhead.game, and org.cadenhead.xml
• 174 This book's website is at domain java21days.com, so the package for the classes created in its pages is com.java21days.
  • This convention provides a resonable assurance that no other Java developers will offer a package with the same name, as long as they follow the same rule themselves (as most developers do).
• 174 By another convention, package names use no capital letters, which distinguishes them from class names.
  • For example, in the full name of the class java.lang.String, you can easily distinguish the package name java.lang from the class name String.

Creating the Folder Structure

• Top
• 174 The second step in creating packages is to create a folder structure that matches the package name, which requires a separate folder for each part of the name.
• The package org.cadenhead.rss requires an org folder, a cadenhead folder inside org, and an rss folder inside cadenhead.
  • org
    • cadenhead
      • rss
• 174 The classes in the package then are stored in the rss folder.
• 174 In NetBeans, when you put a class in a package, the folders are created automatically and the source code and class files are stored in the correct subfolder.
  • All you have to worry about is choosing the package name.
• 174 To see this, click the Files tab in the Projects pane to bring it to the front (Figure 6.2).
  • The files and folders of the Java21 project are shown.
  • You have been using the package com.java21days on your programs in this book.
  • Expand the src folder, then the com subfolder, then the java21days subfolder.
  • All the Java source files for classes in this package will be listed.

Figure 6.2 goes here

Adding a Class to a Package

• Top
• 175 The final step of putting a class inside a package is to add a statement above any import declaration and the class declaration.
  • The package declaration is followed by the full name of the package:
    • package org.cadenhead.rss;
  • The package declaration must be the first line of code in your source file, disregarding comments or blank lines.

Packages and Class Access Control

• Top
• 175 Earlier today, you learned about access control modifiers for methods and variables.
  • You also can control access to classes.
• 175 Classes have the default access control if no modifier is specified,
  • which means that the class is available to all other classes in the same package
    • but is not visible or available outside that package.
  • The class cannot be imported or referred to by name,
    • classes with package protection are hidden inside the package in which they are contained.

• Top
• 175 To allow a class to be visible and importable outside your package, you can give it public protection by adding the public modifier to its definition:
  • 
    public class Visible {
        // ...
    }
    
    
  • Classes declared as public can be accessed by other classes outside the package.
  • Note that when you see an import statement with an asterisk, you import only the public classes inside that package.
  • Other classes remain hidden and can be used only by the other classes in that package.

• Top
• 175 Why would you want to hide a class inside a package ?
  • For the same reasons that you want to hide variables and methods inside a class:
    • so that you can have utility classes and behavior that are useful only to your implementation,
    • or so that you can limit your program's interface to minimize the effect of larger changes.
  • As you design your classes, consider the whole package,
    • and decide which classes you want to declare public and which you want to be hidden.
  • Creating a good package consists of defining a small, clean set of public classes and methods for other classes to use
    • and then implementing them by using any number of hidden support classes.
  • You'll see another use for private classes later today.

Interfaces

• Top
• 176 Interfaces, like abstract classes and methods, provide templates of behavior that other classes are expected to implement.
  • They also offer significant advantages in class and object design that complement Java's single-inheritance approach to object-oriented programming.

The Problem of Single Inheritance

• Top
• 176 As you begin turning a project into a hierarchy of classes related by inheritance, you might discover that the simplicity of the class organization is restrictive.
  • This is especially true when you have some behavior that needs to be used by classes that do not share a common superclass.
• 176 Other object-oriented programming (OOP) languages include the concept of multiple inheritance,
  • which solves this problem by letting a class inherit from more than one superclass,
  • acquiring behavior and attributes from all its superclasses at once.
• 176 This concept makes a programming language more challenging to learn and use.
  • Questions of method invocation and how the class hierarchy is organized become far more complicated with multiple inheritance.
  • They also become more open to congusion and ambiguity.
• 176 Because one of the goals of Java was to be simpler than languages that inspired its creation, multiple inheritance was rejected in favor of single inheritance.

• 176 A Java interface is a collection of abstract behavior that can be adopted by any class without being inherited from a superclass.
  • An interface contains abstract method definitions and constants.
  • It has no instance variables or method implementations.
• 176 Interfaces are implemented and used throughout the Java Class Library when behavior is expected to be implemented by a number of disparate classes.
  • Later today, you'll use one of the interfaces, java.lang.Comparable.

Interfaces and Classes

• Top
• 176 Classes and interfaces, despite their different definitions, have a great deal in common.
  • Both are declared in source files and compiled into .class files.
  • In most cases, an interface can be used anywhere you can use a class.
• 176 You can substitute an interface name for a class name in almost every example in this book.
  • Java programmers often say "class" when they actually mean "class or interface."
• 177 Interfaces complement and extend the power of classes, and the two can be treated almost the same,
  • but an interface cannot be instantiated: new can only create an instance of a non-abstract class.

Implementing and Using Interfaces

• Top
• 177 You can do two things with interfaces: use them in your own classes and define your own.
  • For now, start with using them in your own classes.
• 177 To use an interface, include the implements keyword as part of your class definition:
  • 
    public class AnimatedSign extends Sign
        implements Runnable {
        // ...
    }
    
    
  • In this example, the Runnable interface extends the behavior of the AnimatedSign class, which is a subclass of Sign.
  • Because interfaces provide nothing but abstract definitions, you must implement those methods in your own classes using the same method signatures in the interface.
  • To implement an interface, you must offer all the methods in that interface - you can't pick and choose the methods you need.
  • By implementing an interface, you're telling users of your class that you support the entire interface.
  • After your class implements an interface, subclasses of your class inherit those new methods and can override or overload them.
  • If your class inherits from a superclass that implements a given interface, you don't have to include the implements keyword in your own class definition.

Implementing Multiple Interfaces

• Top
• 177 Unlike inheritance, where a class can have only one superclass, you can include as many interfaces as you need in a class.
  • Your class must implement the combined behavior of all the included interfaces.
  • To include multiple interfaces in a class, separate their names with commas:
  • 
    public class AnimatedSign extends Sign
        implements Runnable, Observer {
        // ...
    }
    
    
• 178 Note that complications might arise from implementing multiple interfaces.
  • What happens if two different interfaces both define the same method ?
  • You can solve this problem in three ways:
    • If the methods in each interface have identical signatures,
      • you implement one method in your class, and that definition satisfies both interfaces.
    • If the methods have different argument lists,
      • it is a simple case of method overloading: you implement both method signatures,
      • and each definition satisfies its respective interface definition.
    • If the methods have the same argument lists but different return types, you cannot create a method that satisfies both
      • (Remember that a method signature does not include the method's return type.)
      • In this case, trying to compile a class that implements both interfaces would produce a compiler error message.
      • Encountering this problem suggests that your interfaces have some design flaws that you might need to reexamine.

Other Uses of Interfaces

• Top
• 178 Almost everywhere that you can use a class, you can use an interface instead.
  • For example, you can declare a variable to be of an interface type:
    • Iterator loop;
  • When a variable is declared to be of an interface type, it must be used to hold an object that implements the interface.
    • Any class that implements the Iterator interface can be stored in Loop.
    • In this case, because loop is an object of the type Iterator, the assumption is that you can call all three of the interface's methods on that object:
    • hasNext(), next(), and remove().
  • You can cast objects to an interface, just as you can cast objects to other classes.

Creating and Extending Interfaces

• Top
• 178 After you use interfaces for a while, the next step is to define your own interfaces.
  • Interfaces look a lot like classes, they are declared in much the same way and can be arranged into a hierarchy.
  • However, you must follow certain rules for declaring them.

New Interfaces

• Top
• 178 To create a new interface, you declare it like this:
  • 
    interface Expandable {
        // ...
    }
    
    
• 179 This declaration is effectively, the same as a class definition, with the word interface replacing the word class.
  • Inside the interface definition are methods and variables.
• 179 The method definitions inside the interface are public and abstract.
  • You can explicitly declare them as such, or they will be turned public and abstract methods if you do not include those modifiers.
  • You cannot declare a method inside an interface to be either private or protected.
• 179 As an example, here's an Expandable interface with one method explicitly declared public and abstract and one declared implicitly:
  • 
    public interface Expandable {
        public abstract void expand(); // explicitly public and abstract
        void contract(); // effectively public and abstract
    }
    
    
  • Both methods are public and abstract.
  • Like abstract methods in classes, methods inside interfaces do not have bodies.
    • An interface consists of only method signatures, no implementation is involved.
  • In addition to methods, interfaces can have variables, but thode variables must be declared public, static, and final (making them constant).
  • As with methods, you can explicitly define a variable to be these modifiers or it is implicitly defined as such if you don't use those modifiers.
  • Here's that same Expandable definition with two new variables:
  • 
    public interface Expandable {
        public static final int INCREMENT = 10;
        long CAPACITY = 15000; // becomes public static and final
    
        public abstract void expand();
        void contract(); // effectively public and abstract
    }
    
    
• 179 Interfaces must have either public or package protection, just like classes.
  • Note, however, that interfaces without the public modifier do not automatically convert their methods to public and abstract nor their constants to public.
  • A non-public interface also has non-public methods and constants that can be used only by classes and other interfaces in the same package.
• 179 Interfaces, like classes, can belong to a package.
  • Interfaces also can import other interfaces and classes from other packages, just as classes can.

Methods Inside Interfaces

• Top
• 180 Here's one trick to note about methods inside interfaces:
  • Those methods are supposed to be abstract and apply to any kind of class, but how can you define arguments to those methods ?
  • You don't know what class will be using them!
  • The answer liees in the fact that you use an interface name anywhere a class name can be used, as uou learned earlier.
  • By defining your method arguments to be interface types, you can create generic arguments that apply to any class that might use this interface.
• 180 Consider the interface Trackable, which defines methods with no arguments for track() and quitTracking().
  • You also might have a method for beginTracking(), which has one argument: an object of the Trackable class.
• 180 What class should that argument be ?
  • Any object that implements the Trackable interface rather than a particular class and its subclasses.
  • The solution is to declare the argument as simply Trackable in the interface:
  • 
    public interface Trackable {
        public abstract Trackable beginTracking(Trackable self);
    }
    
    
  • Then in an actual implementation for this method in a class, you can take the generic Trackable argument and cast it to the appropriate object:
  • 
    public class Monitor implements Trackable {
    
    public Trackable beginTracking(Trackable self) {
        Monitor mon = (Monitor) self;
        // ...
        return mon;
    }
    
    

Extending Interfaces

• Top
• 180 As you can do with classes, you can organize interfaces into a hierarchy.
  • When one interface inherits from another interface, that subinterface acquires all the method definitions and constants that its superinterface declared.
• 180 To extend an interface, you use the extends keyword just as you do in a class definition:
  • 
    interface PreciselyTrackable extends Trackable {
        // ...
    }
    
    
  • reserve
• 181 Note that unlike classes, the interface hierarchy has no equivalent of the Object class
  • there is no root superinterface from which all interfaces descend.
  • Interfaces can either exist entirely on their own or inherit from another interface.
• 181 Note also that unlike the class hierarchy, the inheritance hierarchy can have multiple inheritance.
  • For example, a single interface can extend as many classes as it needs to (separated by commas in the extends part of the definition),
    • and the new interface contains a combination of all its parent's methods and constants.
  • In interfaces, the rules for managing method name conflicts are the same as for classes that use multiple interfaces,
    • methods that differ only in return type result in a compiler message.

Creating an Online Storefront (Second Program)

• Top
• 181 To explore all the topics covered up to this point, the Storefront application uses packages, access control, interfaces, and encapsulation.
  • This application manages the items in an online storefront, handling two main tasks:
    • Calculating the sale price of each item, depending on how much of it is presently in stock
    • Sorting items according to sale price
  • The application consists of two classes, Storefront and Item.
  • These classes will be organized as a new package called org.cadenhead.ecommerce.

• Top
• 181 In NetBeans, choose File, New File, indicate that you're creating a new empty Java file, and then click Next.
  • Give it the class name Item and the package name org.cadenhead.ecommerce.
  • Click Finish to start entering the code shown in Listing 6.2

Listing 6.2

• Top
• page 181 - 182
  
  package org.cadenhead.ecommerce;
  
  public class Item implements Comparable {
      private String id;
      private String name;
      private double retail;
      private int quantity;
      private double price;
  
      Item(String idIn, String nameIn, String retailIn, String qIn) {
          id = idIn;
          name = nameIn;
          retail = Double.parseDouble(retailIn);
          quantity = Integer.parseInt(qIn);
  
          if (quantity > 400)
              price = retail * .5D;
          else if (quantity > 200)
              price = retail * .6D;
          else
              price = retail * .7D;
          price = Math.floor( price * 100 + .5 ) / 100;
      }
  
      public int compareTo(Object obj) {
          Item temp = (Item) obj;
          if (this.price < temp.price) {
              return 1;
          } else if (this.price > temp.price) {
              return -1;
          }
          return 0;
      }
  
      public String getId() {
          return id;
      }
  
      public String getName() {
          return name;
      }
  
      public String getRetail() {
          return retail;
      }
  
      public String getQuantity() {
          return quantity;
      }
  
      public String getPrice() {
          return price;
      }
  }
  
  

• Top
• 182 When you save this file, look in the Projects pane of NetBeans.
  • The Item.java source code file has been put in a different place, as shown in Figure 6.3

Figure 6.3 goes here

Explanation

• Top
• 183 NetBeans puts the source code file in the org.cadenhead.ecommerce category.
• 183 The Item class is a support class that represents a product sold by an online store.
  • It contains private instance variables for the product ID code, name, how many are in stock (quantity), and the retail and sale prices.
• 183 Because all the instance variables of this class are private, no other class can set or retrieve their values.
  • Simple accessor methods are created in lines 35 - 53 to provide a way for other programs to retrieve these values.
  • Each method begins with get followed by the capitalized name of the variable,
    • which is a standard convention in Java programming used throughout the Java Class Library.
  • The getPrice() method returns a double containing the value of price.
  • No methods are provided for setting any of these instance variables.
  • That is handled in the constructor method for this class.
• 183 Line 1 establishes that the Item class is part of the org.cadenhead.ecommerce package.
• 183 The Item class implements the Comparable interface (line 3), which makes it easy to sort a class's objects.
  • This interface has only one method, compareTo(Object), which returns an integer.
• 183 The compareTo() method compares two objects of a class:
  • the current object and another object passed as an argument to the method.
  • The value returned by the method defines the natural sorting order for objects of this class:
    • If the current object should be sorted above the other object, return -1.
    • If the current object should be sorted below the other object, return 1.
    • If the two objects are equal, return 0.
  • You determine in the compareTo() method which of an object's instance variables to consider when sorting.
  • Lines 25 - 33 override the compareTo() method for the Item class, sorting on the basis of the price variable.
  • Items are sorted by price from highest to lowest.
• 183 After you have implemented the Comparable interface for an object, two class methods can be called to sort an array or a class holding those objects.
  • You'll see this later, when the Storefront class is created.
• 184 The Item() constructor in lines 10 - 23 takes four String objects as arguments and uses them to set up the id, name, retail, and quantity instance variables.
  • The last two must be converted from strings to numeric using Double.parseDouble() and Integer.parseInt() class methods, respectively.
• 184 The value of the price instance variable depends on how much of that item is presently in stock:
  • If more than 400 are in stock, price is 50 percent of retail (lines 16 - 17)
  • If between 201 and 400 are in stock, price is 60 percent of retail (lines 18 - 19).
  • For everything else, price is 70 percent of retail (lines 20 - 21).
  • reserve
• 184 Line 22 rounds off price so that it contains two or fewer decimal places,
  • turning a value such as $6.9299999999999 into $6.93.
  • The Math.floor() method rounds off decimal numbers to the next-lowest integer, returning them as double values.

Third Program

• Top
• 184 As the next step in the project, you need a class that represents a storefront for these products.
  • Create an empty Java file with the class name Storefront and package name org.cadenhead.ecommerce, and enter the code shown in Listing 6.3

Listing 6.3

• Top
• page 184
  
  package org.cadenhead.ecommerce;
  
  import java.util.*;
  
  public class Storefront {
      private LinkedList catalog = new LinkedList();
  
      public void addItem(String id, String name, String price,
          String quant) {
  
          Item it = new Item(id, name, price, quant);
          catalog.add(it);
      }
  
      public Item getItem(int i) {
          return (Item) catalog.get(i);
      }
  
      public int getSize() {
          return catalog.size();
      }
  
      public void sort() {
          Collections.sort(catalog);
      }
  
      public String getId() {
          return id;
      }
  
      public String getName() {
          return name;
      }
  }
  
  

Explanation

• Top
• 185 Because it belongs to the same package as the Item class, Storefront will be listed with it in the NetBeans Projects pane.
• 185 The Storefront class is used to manage a collection of products in an online store.
  • Each product is an Item object, and they are stored together in a LinkedList instance variable named catalog (line 6).
• 185 The addItem() method in lines 8 - 13 creates a new Item object based on four arguments sent to the method:
  • the ID
  • name
  • price
  • and quantity of the item that is in stock.
  • After the item is created, it is added to the catalog linked list through a call to its add(Object) method with the Item object as an argument.
• 185 The getItem() and getSize() methods provide an interface to the information stored in the private catalog variable.
  • The getSize() method in lines 19 - 21 calls the catalog.size() method, which returns the number of objects contained in catalog.
• 185 Because objects in a linked list are numbered like arrays and other data structures, you can retrieve them using an index number.
  • The getItem() method in lines 15 - 17 calls catalog.get(int) with an index number as an argument, returning the object stored at that location in the linked list.
• 185 The sort() method in lines 23 - 25 is where you benefit from the implementation of the Comparable interface in the Item class.
  • The class method Collections.sort() sorts a linked list and other data structures based on the natural sort order of the objects they contain,
    • calling the object's compareTo() method to determine this order.

• Top
• 185 To finish this project, the GiftShop application is a class that makes use of Item and Storefront objects.
  • This application also belongs to the org.cadenhead.ecommerce package.
  • Create the new Java class GiftShop with the source code shown in Listing 6.4

Listing 6.4

• Top
• page 185-186
  
  package org.cadenhead.ecommerce;
  
  public class GiftShop {
      public static void main(String[] arguments) {
          Storefront store = new Storefront();
          store.addItem("C01", "MUG", "9.99", "150");
          store.addItem("C02", "LG MUG", "12.99", "82");
          store.addItem("C03", "MOUSEPAD", "10.49", "800");
          store.addItem("D01", "T SHIRT", "16.99", "90");
          store.sort();
  
          for (int i = 0; i < store.getSize(); i++) {
              Item show = (Item) store.getItem(i);
              System.out.println("\nItem ID: " + show.getId() +
                  "\nName: " + show.getName() +
                  "\nRetail Price: $" + show.getRetail() +
                  "\nPrice: $" + show.getPrice() +
                  "\nQuantity: " + show.getQuantity());
          }
      }
  }
  
  

Explanation

• Top
• 186 The GiftShop class demonstrates each part of the public interface that the Storefront and Item classes make available.
  • You can do the following:
    • Create an online store
    • Add items to it
    • Sort the items by sale price
    • Loop through a list of items to display information about each one
• 186 The output is shown in Figure 6.4

Figure 6.4 goes here

• Top
• 187 Many implementation details of these classes are hidden from GiftShop and other classes that would use the package.
  • For instance, the programmer who developed GiftShop doesn't need to know that Storefront uses a linked list to hold all the store's product data.
  • If the developer of Storefront later decided to use a different data structure,
    • as long as getSize() and getItem() returned the expected values, GiftShop would continue to work correctly.

Summary

• Top
• 187 Today you learned how to encapsulate an object by using access control modifiers for its variables and methods.
  • You also learned how to use other modifiers such as static, final, and abstract to develop Java classes and class hierarchies.
• 187 To further the effort of developing and using a set of classes,
  • you learned how to group classes into packages.
  • These groupings better organize your programs and help you share classes with many other Java programmers making their code publicly available.
• 187 Finally, you learned how to implement interfaces and inner classes,
  • an extremely helpful Java language feature that models behavior outside of a class hierarchy.

Q & A

• Top
• Q Won't using accessor methods everywhere slow down my Java code ?
• A Not always. As Java compilers improve and can implement better optimizations,
  • they will be able to make accessor methods fast automatically.
  • But if you're concerned about speed, you can always declare accessor methods to be final,
    • and they'll be comparable in speed to direct instance variable accesses under most circumstances.

• Q Based on what I've learned, private abstract methods and final abstract methods and classes don't seem to make sense. Are they legal ?
• A No. They cause compiler errors, as you have guessed.
  • To be useful, abstract methods must be overridden, and abstract classes must be subclassed,
    • but neither of those operations would be legal if they were also private or final.

Quiz - Questions

• Top
• Review today's material by taking this three-question quiz.

1. What packages are automatically imported into your Java classes ?
   1. None
   2. The classes are stored in the folders of your Classpath
   3. The classes in the java.lang package
2. According to the convention for naming packages, what should be the first part of the name of a package you create ?
   1. Your name followed by a period
   2. Your top-level Internet domain followed by a period
   3. The text java followed by a period
3. If you create a subclass and override a public method, what access modifiers can you use with that method ?
   1. public only
   2. public or protected
   3. public, protected, or default access

Answers

• Top | Note A is 1, B is 2, and C is 3

1. C. All other packages must be imported if you want to use short class names
   • such as LinkedList instead of full package and class names such as java.util.LinkedList.
2. B. This convention assumes that all Java package developers will own an Internet domain
   • or have access to one so that the package can be made available for download.
3. A. All public methods must remain public in subclasses.
   • Access control in a subclass can be more public or the same as its subclass, but it can't be more private.

Certification Practice

• Top
• 189 The following question is the kind of thing you could expect to be asked on a Java programming certification test. Answer it without looking at today's material or using the Java compiler to test the code.
• The answer is available on the book's website at www.java21days.com

• Given:
• 
  package org.cadenhead.bureau;
  
  public class Information {
      public int duration = 12;
      protected float rate = 3.15F;
      float average = 0.5F;
  }
  
  and:
  
  package org.cadenhead.bureau;
  
  public class MoreInformation extends Information {
      public int quantity = 8;
  }
  
  and:
  
  package org.cadenhead.bureau.us;
  
  import prg.cadenhead.bureau.*;
  
  public class EvenMoreInformation extends MoreInformation {
      public int quantity = 9;
  
      EvenMoreInformation() {
          super();
          int i1 = duration;
          float i2 = rate;
          float i3 = average;
      }
  }

1. Which instance variables are visible in the EvenMoreInformation() class ?
   1. quantity, duration, rate, and average
   2. quantity, duration, and rate
   3. quantity, duration, and average
   4. quantity, rate, and average

Exercise

• Top
• To extend your knowledge of the subjects covered today, try the following exercises:
  1. Create a modified version of the Storefront project that includes a noDiscount variable for each item.
     • When this variable is true, sell the item at the retail price.
  2. Create a ZipCode class that uses access control to ensure that its zipCode instance variable always has a five-digit value.