Lecture 9 Enhanced Class Design

1
Lecture 9Enhanced Class Design

• Instructors
• Fu-Chiung Cheng
• (???)
• Associate Professor
• Computer Science Engineering
• Tatung Institute of Technology

1
2
Outline

• abstract classes
• formal Java interfaces
• packages

1
3
Abstract Classes

• An abstract class cannot be instantiated
• It is used in a class hierarchy to organize
  common features at appropriate levels
• An abstract method has no implementation, just a
  name and signature
• An abstract class often contains abstract methods
• Any class that contains an abstract method is by
  definition abstract

2
4
Abstract Classes

• The modifier abstract is used to define abstract
  classes and methods
• The children of the abstract class are expected
  to define implementations for the abstract
  methods in ways appropriate for them
• If a child class does not define all abstract
  methods of the parent, then the child is also
  abstract
• An abstract class is often too generic to be of
  use by itself

3
5
Abstract Classes

• See Dinner.java

4
6
public class Dinner public static void main
(String args) Pepperoni slice new
Pepperoni() System.out.println
(slice.slogan()) // method main //
class Dinner abstract class Food abstract
public String slogan() // class Food class
Pepperoni extends Food public String
slogan() return "Great for pizza!"
// method slogan // class Pepperoni
7
Abstract Classes

• See Printer.java

5
8
public class Printer public static void main
(String args) byte logo_data 41,
42, 49, 44 Text_File report new
Text_File ("Sand Reconner", 66,
"One two three") Image_File logo new
Image_File ("Number 1", 45,
logo_data) Print_Logger daily new
Print_Logger() daily.log(report)
daily.log(logo) // method main // class
Printer
9
abstract class File protected String id
protected int size public File (String
file_id, int file_size) id file_id
size file_size // constructor File
public String name() return id //
method name abstract public String
print() // class File
10
class Text_File extends File protected
String text public Text_File (String id, int
size, String file_contents) super(id,
size) text file_contents //
constructor Text_File public String print()
return text // method print //
class Text_File
11
class Binary_File extends File protected
byte data public Binary_File (String id,
int size, byte file_data) super(id,
size) data file_data //
constructor Binary_File public String print()
return "" // method print //
class Binary_File
12
class Image_File extends Binary_File public
Image_File (String id, int size, byte
file_data) super(id, size, file_data)
// constructor Image_File public String
print() return new String (data)
// method print // class Image_File class
Print_Logger public void log (File file)
System.out.println (file.name() " "
file.print()) // method log // class
Print_Logger
13
Abstract Classes

• An abstract method cannot be declared as final,
  because it must be overridden in a child class
• An abstract method cannot be declared as static,
  because it cannot be invoked without an
  implementation
• Abstract classes are placeholders that help
  organize information and provide a base for
  polymorphic references

6
14
Interfaces

• A Java interface is a collection of constants and
  abstract methods
• Interface the set of service methods provided
  by an object
• That is, the set of methods that can be invoked
  through an object define the way the rest of the
  system interacts, or interfaces, with that object
• The Java language has an interface construct that
  formalizes this concept

7
15
Interfaces

• A class that implements an interface must provide
  implementations for all of the methods defined in
  the interface
• This relationship is specified in the header of
  the class
• class class-name implements interface-name
• ...
• See Soap_Box.java

8
16
public class Soap_Box public static void
main (String args) Kant immanual new
Kant() System.out.println
(immanual.pontificate()) // method main
// class Soap_Box interface Philosopher
String pontificate() // class
Philosopher class Kant implements Philosopher
public String pontificate() return
"Follow the Categorical Imperitive!" //
method pontificate // class Kant
17
Interfaces

• An interface can be implemented by multiple
  classes
• Each implementing class can provide their own
  unique version of the method definitions
• An interface is not a class, and cannot be used
  to instantiate an object
• An interface is not part of the class hierarchy
• A class can be derived from a base class and
  implement one or more interfaces

9
18
Interfaces

• Unlike interface methods, interface constants
  require nothing special of the implementing class
  
• Constants in an interface can be used in the
  implementing class as if they were declared
  locally
• This feature provides a convenient technique for
  distributing common constant values among
  multiple classes

10
19
Interfaces

• An interface can be derived from another
  interface, using the extends reserved word
• The child interface inherits the constants and
  abstract methods of the parent
• Note that the interface hierarchy and the class
  hierarchy are distinct
• A class that implements the child interface must
  define all methods in both the parent and child

11
20
public class Printer2 public static void
main (String args) byte logo_data
41, 42, 49, 44 Text_File report new
Text_File ("Sand Reconner", 66, "One
two three") Image_File logo new
Image_File ("Number 1", 45,
logo_data) Print_Logger daily new
Print_Logger() daily.log (report)
daily.log (logo) // method main // class
Printer2
21
class File protected String id protected
int size public File (String file_id, int
file_size) id file_id size
file_size // constructor File public
String name() return id // method
name // class File class Text_File extends File
implements Printable protected String text
public Text_File (String id, int size, String
file_contents) super(id, size)
text file_contents // constructor
Text_File public String print() return
text // method print // class Text_File
22
class Binary_File extends File protected
byte data public Binary_File (String id,
int size, byte file_data) super(id,
size) data file_data //
constructor Binary_File // class
Binary_File class Image_File extends Binary_File
implements Printable public Image_File
(String id, int size, byte file_data)
super(id, size, file_data) // constructor
Image_File public String print() return
new String (data) // method print //
class Image_File
23
interface Printable public String name()
public String print() // interface
Printable class Print_Logger public void
log (Printable file) System.out.println
(file.name() " " file.print()) //
method log // class Print_Logger
24
Interfaces vs. abstract classes

• Note the similarities between interfaces and
  abstract classes
• Both define abstract methods that are given
  definitions by a particular class
• Both can be used as generic type names for
  references
• However, a class can implement multiple
  interfaces, but can only be derived from one class

13
25
Interfaces

• A class that implements multiple interfaces
  specifies all of them in its header, separated by
  commas
• The ability to implement multiple interfaces
  provides many of the features of multiple
  inheritance, the ability to derive one class from
  two or more parents
• Java does not support multiple inheritance
• See Readable_Files.java

14
26
class Readable_Files implements File_Protection,
Printable private File files private
int permissions Readable_Files (File
file_list, int permissions_list) files
file_list permissions
permissions_list // constructor
Readable_Files public String name() return
"Readable files" // method name public
String print() String printable_list
"" for (int index 0 index lt
files.length index) if
(permissionsindex READ)
printable_list printable_list " "
filesindex.name()
return printable_list // class
Readable_Files
27
Packages

• A Java package is a collection of classes
• The classes in a package may or may not be
  related by inheritance
• A package is used to group similar and
  interdependent classes together
• The Java API is composed of multiple packages
• The import statement is used to assert that a
  particular program will use classes from a
  particular package

15
28
Packages

• A programmer can define a package and add classes
  to it
• The package statement is used to specify that all
  classes defined in a file belong to a particular
  package
• The syntax of the package statement is
• package package-name
• It must be located at the top of a file, and
  there can be only one package statement per file

16
29
Packages

• The classes must be organized in the directory
  structure such that they can be found when
  referenced by an import statement
• There is a CLASSPATH environment variable on each
  computer system that determines where to look for
  classes when referenced
• See Simple_IO_Test.java

17
30
package Simple_IO // Writer.java in Simple_IO
public class Writer public static void
write (int value) System.out.print(value)
// method public static void write_line
(String line) System.out.println(line)
// method // class Reader
31
package Simple_IO // Reader.java in
Simple_IO import java.io. public class Reader
public static int read () throws IOException
BufferedReader stdin new BufferedReader
(new InputStreamReader (System.in))
String value stdin.readLine() return
Integer.parseInt(value) // method
public static String read_line () throws
IOException BufferedReader stdin new
BufferedReader (new InputStreamReader
(System.in)) return stdin.readLine()
// method // class Reader
32
import java.io.IOException import
Simple_IO. class Simple_IO_Test public
static void main (String args) throws
IOException int value Reader.read()
String line Reader.read_line()
Writer.write (value) Writer.write_line
(line) // method main // class
Simple_IO_Test
33
Packages

• The import statement specifies particular
  classes, or an entire package of classes, that
  can be used in that program
• Import statements are not necessary a class can
  always be referenced by its fully qualified name
  in-line
• See Simple_IO_Test2.java
• If two classes from two packages have the same
  name and are used in the same program, they must
  be referenced by their fully qualified name

18
34
class Simple_IO_Test2 public static void
main (String args) throws
java.io.IOException int value
Simple_IO.Reader.read() String line
Simple_IO.Reader.read_line()
Simple_IO.Writer.write (value)
Simple_IO.Writer.write_line (line) //
method main // class Simple_IO_Test2
35
Packages

• As a rule of thumb, if you will use only one
  class from a package, import that class
  specifically
• See Simple_IO_Test3.java
• If two or more classes will be used, use the
  wildcard character in the import statement to
  provide access to all classes in the package

19
36
import Simple_IO.Writer class Simple_IO_Test3
public static void main (String args)
throws java.io.IOException int value
Simple_IO.Reader.read() String line
Simple_IO.Reader.read_line() Writer.write
(value) Writer.write_line (line)
// method main // class Simple_IO_Test3
37
Conclusion

• Abstract classes represent generic concepts in a
  class
• hierarchy
• Abstract classes polymorphism.
• An abstract class can intermix abstract methods
  and
• non-abstract method
• Interfaces have constants and abstract methods
  (public).
• Interfaces multiple inheritance
• Abstract classes and interfaces encapsulation
  or
• information hiding
• A package is used to group similar or
  interdependent
• classes together