OBJECT 1 ORIENTED PROGRAMMING

Transcription

1 OBJET ORIENTED PROGRAMMING hapter SYS-ED/ OMPUTER EDUATION TEHNIQUES, IN.

2 Objectives You will learn: Features/facilities of creating a class in Java. Defining class and its members. Scope and lifetime. Managing inheritance in Java. Overriding method. Super object. loning objects. Writing abstract classes and methods. SYS-ED \OMPUTER EDUATION TEHNIQUES, IN. (JAVA PRG - ADV -.) h : Page i

3 lass reation There are two primary components which make up the implementation of a class the class declaration class body The class declaration declares the name of the class along with other attributes. The class body follows the class declaration and is embedded within curly braces { and. The class body contains declarations for all instance variables and class variables. Instance and class variables collectively are referred to as member variables for the class. The class body also contains declarations and implementations for all instance methods and class methods for the class. Declarations and class methods collectively known as methods. A class may contain one or more constructors that provide for the initialization of an object created from the class. A class's state is represented by its member variables which are declared in the body of the class. Typically, a class's variables are defined before its methods are declared. classdeclaration { member variable declarations method declarations To declare variables that are members of a class, the declarations must be within the class body, but not within the body of a method. Variables declared within the body of a method are local to that method. Objects have behavior that is implemented by its methods. Other objects can ask an object to perform something by invoking its methods. In Java, a class's methods are defined in the body of the class for which the method implements some behavior. Typically, a class's methods are defined after its variables in the class body. Member variables and methods are known collectively as members. When declaring a member of a Java class, access specifiers can be used for allowing or disallowing other objects of other types access to that member. A Java class can contain two different types of members: instance members class members SYS-ED \OMPUTER EDUATION TEHNIQUES, IN. (JAVA PRG - ADV -.) h : Page

4 lass Declaration lass Declaration omponents omponent public abstract final class NameOflass extends Super Explanation A class can be used only by other classes in the same package; this is the default. The public modifier declares that the class can be used by any class regardless of its package. Declares that the class cannot be instantiated. Declares that the class cannot be subclassed. lass keyword indicates to the compiler that this is a class declaration and that the name of the class is NameOflass. Extends clause identifies Super as the superclass of the class, thereby inserting the class within the class hierarchy. SYS-ED \OMPUTER EDUATION TEHNIQUES, IN. (JAVA PRG - ADV -.) h : Page

5 lass onstructors All Java classes have constructors that are used to initialize a new object of that type. A constructor has the same name as the class. The name of the Stack class's constructor is Stack, the name of the Rectangle class's constructor is Rectangle, and the name of the Thread class's constructor is Thread. Stack defines a single constructor: public Stack() { items = new Vector(0); Java supports name overloading for constructors so that a class can have any number of constructors, all of which have the same name. public Stack(int initialsize) { items = new Vector(initialSize); This is another constructor that could be defined by Stack. This particular constructor sets the initial size of the stack according to its parameter: Both constructors share the same name, Stack, but they have different parameter lists. The compiler differentiates these constructors based on the number of parameters in the list and their types. Typically, a constructor uses its arguments to initialize the new object's state. When creating an object, choose the constructor whose arguments best reflect how to initialize the new object. Based on the number and type of the arguments that you pass into the constructor, the compiler can determine which constructor to use. The compiler knows that when writing the following code, it should use the constructor that requires a single integer argument: new Stack(0); Similarly, when writing the following code, the compiler chooses the no-argument constructor or the default constructor: new Stack(); SYS-ED \OMPUTER EDUATION TEHNIQUES, IN. (JAVA PRG - ADV -.) h : Page

6 The default constructor is automatically provided by the runtime system for any class that contains no constructors. The default provided by the runtime system doesn't do anything. Therefore, in order to perform some initialization, it will be necessary to write some constructors for the class class AnimationThread extends Thread { int framespersecond; int numimages; Image[] images; AnimationThread(int fps, int num) { super("animationthread"); this.framespersecond = fps; this.numimages = num; this.images = new Image[numImages]; for (int i = 0; i <= numimages; i++) {... // Load all the images The constructor for the subclass of Thread performs animation, sets up some default values, such as the frame speed and the number of images, and then loads the images. The body of a constructor is similar to the body of a method; it contains local variable declarations, loops, and other statements. There is one line in the AnimationThread constructor that wouldn't be part of a method in the second line: super("animationthread"); This line invokes a constructor provided by the superclass of AnimationThread - Thread. This particular Thread constructor takes a String that sets the name of Thread. SYS-ED \OMPUTER EDUATION TEHNIQUES, IN. (JAVA PRG - ADV -.) h : Page

7 Often a constructor will need to take advantage of initialization code written in a class's superclass. Indeed, some classes must call their superclass constructor in order for the object to work properly. If present, the superclass constructor must be the first statement in the subclass's constructor. An object should perform the higher-level initialization first. It is possible to specify what other objects can create instances of a class by using an access specifier in the constructors' declaration. Access Specifier private protected public no specifier gives package access Instance reation by a lass No other class can instantiate the class. The class may contain public class methods (sometimes called factory methods), and those methods can construct an object and return it, but no other classes can. Only subclasses of the class and classes in the same package can create instances of it. Any class can create an instance of your class. Only classes within the same package as your class can construct an instance of it. Only classes within the same package as a class can construct an instance of it. SYS-ED \OMPUTER EDUATION TEHNIQUES, IN. (JAVA PRG - ADV -.) h : Page

8 Member Variable Declaration Stack uses the following line of code to define its single member variable: private Vector items; The member variable declared is named items, and its data type is Vector. The private keyword identifies items as a private member. This means that only code within the Stack class can access it. This will not declare some other type of variable such as a local variable. This is because the declaration appears within the class body, but outside of any methods or constructors. Member variable declarations can be more complex. In addition to type, name, and access level, other attributes can be declared including whether the variable is a class or instance variable and whether it's a constant. omponents of a member variable declaration include: omponent accesslevel static final transient volatile type Explanation ontrols which other classes have access to a member variable by using one of four access levels: public, protected, package, and private. Access to methods is controlled in the same way. Declares that this is a class variable rather than an instance variable. Static is also used to declare class methods. Indicates that the value of this member cannot change. There will be a compile-time error if a program ever tries to change a final variable. By convention, the name of constant values are spelled in uppercase letters. The transient marker is not fully specified by the Java Language Specification. It is used in object serialization to mark member variables that should not be serialized. The volatile keyword is used to prevent the compiler from performing certain optimizations on a member. A member variable must have a type. Primitive type names such as int, float, or boolean can be used. A member variable's name can be any Java identifier; which by convention begins with a lowercase letter. More than one member variable can not be declared with the same name in the same class, but a subclass can hide a member variable of the same name in its superclass. SYS-ED \OMPUTER EDUATION TEHNIQUES, IN. (JAVA PRG - ADV -.) h : Page 6

9 Method Declaration - Details A method's declaration provides information about the method to the compiler, runtime system, and other classes and objects. Included is not only the name of the method, but also such information as the return type of the method, the number and type of the arguments required by the method, and which other classes and objects can call the method. Most method attributes can be declared implicitly. The only required elements of a method declaration are the method's name, its return type, and a pair of parentheses ( ). Elements of a Method Declaration Elements accesslevel static abstract final native synchronized returntype methodname (paramlist) [throws exceptions] Returning a Value from a Method Explanation ontrol of which other classes have access to a method is done using one of four access levels: public, protected, package, and private. Declares this method as a class method rather than an instance method. Has no implementation and must be a member of an abstract class. an not be overridden by subclasses. Methods implemented in a language other than Java are called native methods and are declared using the native keyword. Library of functions written in another language can be used from Java. oncurrently running threads often invoke methods that operate on the same data. These methods can be declared synchronized to ensure that the threads access information in a thread-safe manner. Java requires that a method declare the data type of the value that it returns. If your method does not return a value, use the keyword void for the return type. A method name can be any legal Java identifier. Information can be passed into a method through its arguments. If a method throws any checked exceptions, the method declaration must indicate the type of those exceptions. A method's return type is declared in its method declaration. Within the body of the method, the return operator is used for returning the value. SYS-ED \OMPUTER EDUATION TEHNIQUES, IN. (JAVA PRG - ADV -.) h : Page 7

10 Any method that is not declared void must contain a return statement. The Stack class declares the isempty method, which returns a boolean: 6 public boolean isempty() { if (items.size() == 0) return true; else return false; The data type of the return value must match the method's return type; an Object type can not be returned from a method declared to return an integer. The isempty method returns either the boolean value true or false, depending on the outcome of a test. A compiler error results if a method is written in which the return value doesn't match the return type. The isempty method returns a primitive type. Methods also can return a reference type public synchronized Object pop() { int len = items.size(); Object obj = null; if (len == 0) throw new EmptyStackException(); obj = items.elementat(len - ); items.removeelementat(len - ); return obj; Stack declares the pop method that returns the Object reference type. When a method returns an object such as pop does, the class of the returned object must be either a subclass of or the exact class of the return type. SYS-ED \OMPUTER EDUATION TEHNIQUES, IN. (JAVA PRG - ADV -.) h : Page 8

11 6 Method Body Within an object's method body, the standard approach is to refer directly to the object's member variables. However, sometimes it will be necessary to disambiguate the member variable name if one of the arguments to the method has the same name. 6 7 class HSBolor { int hue, saturation, brightness; HSBolor (int hue, int saturation, int brightness) { this.hue = hue; this.saturation = saturation; this.brightness = brightness; The constructor for the HSBolor class initializes some of an object's member variables according to the arguments passed into the constructor. Each argument to the constructor has the same name as the object's member variable whose initial value the argument contains. The this keyword is used for removing ambiguity regarding the argument and member variables. Argument names take precedence and hide member variables with the same name. In order to refer to the member variable it must be done through the current object explicitly by using the this keyword. Some programmers prefer to use the this keyword when referring to a member variable of the object whose method the reference appears. This will serve to explicitly qualify the intent of the code explicit and reduces error based on name sharing. The this keyword can also be used for calling one of the current object's methods. This will only be necessary if there is some ambiguity in the method name and is often used to make the intent of the code more clear. If a method hides one of its superclass's member variables, it can refer to the hidden variable through the use of the super keyword. Similarly, if a method overrides one of its superclass's methods, another method can invoke the overridden method through the use of the super keyword. SYS-ED \OMPUTER EDUATION TEHNIQUES, IN. (JAVA PRG - ADV -.) h : Page 9

12 lass 6 class ASillylass { boolean avariable; void amethod() { avariable = true; Subclass The sublass hides avariable and overrides amethod class ASillierlass extends ASillylass { boolean avariable; void amethod() { avariable = false; super.amethod(); System.out.println(aVariable); System.out.println(super.aVariable);. amethod sets avariable; this is variable which has been declared in ASillierlass that hides the one declared in ASillylass to false.. amethod invokes its overridden method with this statement: super.amethod(); SYS-ED \OMPUTER EDUATION TEHNIQUES, IN. (JAVA PRG - ADV -.) h : Page 0

13 7 Local Variables Within the body of the method, it is possible to declare more variables for use within that method. Variables of this type are local variables and live only while control remains within the method Object findobjectinarray(object o, Object[] arrayofobjects) { int i; // local variable for (i = 0; i < arrayofobjects.length; i++) { if (arrayofobjects[i] == o) return o; return null; This method declares a local variable i that it uses to iterate over the elements of its array argument. After this method returns, i no longer exists. SYS-ED \OMPUTER EDUATION TEHNIQUES, IN. (JAVA PRG - ADV -.) h : Page

14 8 Inheritance - Managing The extends clause declares that a class is a subclass of another. Java does not support multiple class inheritance. Only one class can be specified for a superclass for a class. Even though the extends clause can be omitted from a class declaration, the class will still have a superclass. A subclass is a class that extends another class. A subclass inherits state and behavior from all of its ancestors. The term superclass refers to a class's direct ancestor as well as to all of its ascendant classes. A subclass inherits variables and methods from its superclass and all of its ancestors. The subclass can use these members as is, or it can hide the member variables or override the methods. A subclass inherits all of the members in its superclass that are accessible to that subclass unless the subclass explicitly hides a member variable or overrides a method. onstructors are not members and are not inherited by subclasses. The following rules apply to inheritance by a subclass: 8. Members Inherited by a Subclass Subclasses inherit those superclass members declared as public or protected. Subclasses inherit those superclass members declared with no access specifier as long as the subclass is in the same package as the superclass. Subclasses don't inherit a superclass's member if the subclass declares a member with the same name. - In the case of member variables, the member variable in the subclass hides the one in the superclass. - In the case of methods, the method in the subclass overrides the one in the superclass. reating a subclass can be performed by including the extends clause in a class declaration. However, other provisions will have to be made in the code when subclassing a class. Typically this will be overriding methods or providing implementations for abstract methods. SYS-ED \OMPUTER EDUATION TEHNIQUES, IN. (JAVA PRG - ADV -.) h : Page

15 9 Member Variables - Hiding Member variables defined in the subclass, hide member variables that have the same name in the superclass. Although extremely useful, it can be a source of errors. When naming member variables, care needs to be taken in order to hide only those member variables that are intended to be hidden. A feature of Java member variables is that a class can access a hidden member variable through its superclass. 6 class Super { Number anumber; class Subbie extends Super { Float anumber; The anumber variable in Subbie hides anumber in Super. Super's anumber can be accessed from Subbie with super.anumber. super is a Java language keyword that allows a method to refer to hidden variables and overridden methods of the superclass. The ability of a subclass to override a method in its superclass allows a class to inherit from a superclass whose behavior is "close enough" and then supplement or modify the behavior of that superclass. SYS-ED \OMPUTER EDUATION TEHNIQUES, IN. (JAVA PRG - ADV -.) h : Page

16 0 Overriding Methods The ability of a subclass to override a method in its superclass allows a class to inherit from a superclass whose behavior is "close enough" and then override methods as needed. All classes are descendants of the Object class. Object contains the tostring method, which returns a String object containing the name of the object's class and its hash code. Most, if not all, classes will want to override this method and print out something meaningful for that class. The return type, method name, and number and type of the parameters for the overriding method must match those in the overridden method. The overriding method can have a different throws clause as long as it doesn't declare any types not declared by the throws clause in the overridden method. The access specifier for the overriding method can allow more access than the overridden method, but not less. A protected method in the superclass can be made public, but not private. SYS-ED \OMPUTER EDUATION TEHNIQUES, IN. (JAVA PRG - ADV -.) h : Page

17 Overridden Method - alling There will be times when there will be a requirement not to completely override a method. Additional functionality can be added by calling the overridden method using the super keyword. super.overriddenmethodname();. Methods a Subclass annot Override A subclass cannot override methods that are declared final in the superclass. If there is an attempt to override a final method, the compiler displays an error message similar to the following and refuses to compile the program: FinalTest.java:7: Final methods can't be overridden. Method void iamfinal() is final in class lasswithfinalmethod. void iamfinal() { ^ error A subclass cannot override methods that are declared static in the superclass. A subclass cannot override a class method. A subclass can hide a static method in the superclass by declaring a static method in the subclass with the same signature as the static method in the superclass.. Methods a Subclass Must Override A subclass must override methods that are declared abstract in the superclass, or the subclass itself must be abstract. SYS-ED \OMPUTER EDUATION TEHNIQUES, IN. (JAVA PRG - ADV -.) h : Page

18 Object Descendent The object class sits at the top of the class hierarchy tree in the Java platform. Every class in the Java system is a descendent, direct or indirect, of the Object class. This class defines the basic state and behavior that all objects must have, such as the: ability to compare oneself to another object. convert to a string. wait on a condition variable. notify other objects that a condition variable has changed. return the class of the object. There are times when a class will want to override the following Object methods: clone equals/hashode finalize tostring The equals/hashode are listed together as they must be overridden together. A class cannot override these Object methods: getlass notify notifyall wait SYS-ED \OMPUTER EDUATION TEHNIQUES, IN. (JAVA PRG - ADV -.) h : Page 6

19 clone Method The clone method is used for creating an object from an existing object. To create a clone: aloneableobject.clone(); An object's implementation of this method checks to see if the object on which clone was invoked implements the loneable interface, and throws a lonenotsupportedexception if it does not. The Object itself does not implement loneable, so subclasses of Object that don't explicitly implement the interface are not cloneable. If the object on which clone was invoked does implement the loneable interface, Object's implementation of the clone method creates an object of the same type as the original object and initializes the new object's member variables to have the same values as the original object's corresponding member variables. A simple way to make a class cloneable then, is to add implements loneable to a class's declaration. For some classes the default behavior of Object's clone method will work just fine. Other classes need to override clone to get correct behavior public class Stack implements loneable { private Vector items; // code for Stack's methods and constructor not shown protected Object clone() { try { Stack s = (Stack)super.clone(); // clone the stack s.items = (Vector)items.clone(); // clone the vector return s; // return the clone catch (lonenotsupportedexception e) { // this shouldn't happen because Stack is loneable throw new InternalError(); The Stack class contains a member variable that refers to a Vector. If Stack relies on Object's implementation of clone, then the original stack and its clone will refer to the same vector. hanging one stack will result in a change in an other. This is not a desirable behavior. SYS-ED \OMPUTER EDUATION TEHNIQUES, IN. (JAVA PRG - ADV -.) h : Page 7

20 The implementation for Stack's clone method is straightforward; it calls super.clone, which Stack inherits from Object and which creates and initializes an instance of the correct type. The original stack and its clone now refer to the same vector. The method then clones the vector. lone should never use new to create the clone and should not call constructors. Rather, the method should call super.clone, which creates an object of the correct type and allows the hierarchy of superclasses to perform the copying necessary to get a proper clone. SYS-ED \OMPUTER EDUATION TEHNIQUES, IN. (JAVA PRG - ADV -.) h : Page 8

21 The equals and hashode methods must be overridden together. The equals and hashode Methods The equals method compares two objects for equality and returns true if they are equal. The equals method provided in the Object class uses the identity function to determine whether objects are equal. When the objects being compared are the exact same object the method returns true. However, for some classes, two distinct objects of that type might be considered equal if they contain the same information. This code tests two Integers, one and anotherone, for equality. Integer one = new Integer(), anotherone = new Integer(); if (one.equals(anotherone)) System.out.println("objects are equal"); This program displays objects are equal even though one and anotherone reference two distinct objects. They are considered equal because the objects compared contain the same integer value. lasses should only override the equals method if the identity function is not appropriate for a class. If equals is overriden, then override hashode as well. The value returned by hashode is an int that maps an object into a bucket in a hash table. An object must always produce the same hash code. However, objects can share hash codes. Writing a hashing function is easy; always return the same hash code for the same object. Writing an efficient hashing function, one that provides a sufficient distribution of objects over the buckets, is difficult. Even so, the hashing function for some classes is straightforward. A hash code for an Integer object is its integer value. SYS-ED \OMPUTER EDUATION TEHNIQUES, IN. (JAVA PRG - ADV -.) h : Page 9

22 Final lasses and Methods - Writing lasses can be declared as final; this means that a class cannot be subclassed. The reasons for doing this would be: increasing system security by preventing system subversion. sound object-oriented design.. Security One mechanism that hackers use to subvert systems is to create a subclass of a class and then substitute their class for the original. The subclass looks like the original class; but does different things, possibly causing damage or getting into private information. To prevent this from occurring, a class can be declared as final and thereby prevent any subclasses from being created. The String class in the java.lang package is a final class for just this reason. This class is vital to the operation of the compiler and the interpreter must guarantee that whenever a method or object uses a String it gets exactly a java.lang.string and not some other string. This will ensure that all strings have no inconsistent, undesirable, or unpredictable properties.. Design A class can be designed as final for object-oriented design reasons. To specify that a class is final, use the keyword final before the class keyword in the class declaration. final class hessalgorithm {... This declaration will declare (perfect) hessalgorithm class as final. SYS-ED \OMPUTER EDUATION TEHNIQUES, IN. (JAVA PRG - ADV -.) h : Page 0

23 6 Final Methods The final keyword can be used in a method declaration to indicate to the compiler that the method cannot be overridden by subclasses. The Object class does this; some of its methods are final and some are not. It might be necessary to make a method final if it has an implementation that should not be changed and which is critical to the consistent state of the object. This code will serve to make the nextmove method final; instead of Algorithm class final class hessalgorithm {... final void nextmove(hesspiece piecemoved, BoardLocation newlocation) { SYS-ED \OMPUTER EDUATION TEHNIQUES, IN. (JAVA PRG - ADV -.) h : Page

24 7 Abstract lasses and Methods - Writing Sometimes there will be classes that have been defined which represent an abstract concept; these classes should not be instantiated. In object-oriented programming, there will be models for abstract concepts which will not be able to create an instance of it. For example, the Number class in the java.lang package represents the abstract concept of numbers. It makes sense to model numbers in a program, but it doesn't make sense to create a generic number object. Instead, the Number class makes sense only as a superclass to classes like Integer and Float, both of which implement specific kinds of numbers. A class such as Number, which represents an abstract concept and should not be instantiated, is called an abstract class. An abstract class is a class that can only be subclassed - it cannot be instantiated. To declare a class is an abstract class, use the keyword abstract before the class keyword in the class declaration: abstract class Number {... When an attempt is made to instantiate an abstract class, the compiler displays an error. SYS-ED \OMPUTER EDUATION TEHNIQUES, IN. (JAVA PRG - ADV -.) h : Page

25 8 Abstract Methods An abstract class may contain abstract methods; abstract methods are classes which have no implementation. An abstract class can define a complete programming interface, thereby providing its subclasses with the method declarations for all of the methods necessary to implement that programming interface. The abstract class can leave some or all of the implementation details of those methods up to its subclasses. 8. Abstract lass with an Abstract Method An object-oriented drawing application can be used for drawing circles, rectangles, lines, Bezier curves, and so on. Each of these graphic objects share certain states such as position, bounding box and behavior such as move, resize, and draw. An efficient use of these similarities would be to declare and inherit them from the same parent object - GraphicObject. In addition to the similarities, these graphic objects also have substantial differences; for example drawing a circle is quite different from drawing a rectangle. The graphics objects cannot share these types of states or behavior. On the other hand, all GraphicObjects must know how to draw themselves; they differ in how they are drawn. This is a situation which lends itself to the creation of an abstract superclass. The steps for implementing a superclass would be:. Declare an abstract class, GraphicObject, to provide member variables and methods that are wholly shared by all subclasses, such as the current position and the moveto method.. GraphicObject is to declare abstract methods for methods, such as draw, which will need to be implemented by all subclasses, but be implemented in entirely different ways. Having no default implementation in the superclass is reasonable. The GraphicObject class would be as follows: abstract class GraphicObject { int x, y;... void moveto(int newx, int newy) {... abstract void draw(); SYS-ED \OMPUTER EDUATION TEHNIQUES, IN. (JAVA PRG - ADV -.) h : Page

26 Each non-abstract subclass of GraphicObject, such as ircle and Rectangle, would have to provide an implementation for the draw method class ircle extends GraphicObject { void draw() {... class Rectangle extends GraphicObject { void draw() {... SYS-ED \OMPUTER EDUATION TEHNIQUES, IN. (JAVA PRG - ADV -.) h : Page

27 9 Interface An interface defines a protocol of behavior that can be implemented by any class anywhere in the class hierarchy. It defines a set of methods but does not implement them. A class that implements the interface agrees to implement all the methods defined in the interface, thereby agreeing to certain behavior. An interface is a named collection of method definitions without implementations. An interface can also declare constants. Since an interface is a list of unimplemented abstract methods, a fundamental question is how an interface differs from an abstract class. The differences are: An interface cannot implement any methods, whereas an abstract class can. A class can implement many interfaces but can have only one superclass. An interface is not part of the class hierarchy; unrelated classes can implement the same interface. SYS-ED \OMPUTER EDUATION TEHNIQUES, IN. (JAVA PRG - ADV -.) h : Page

28 9. Interface Example Functional Specification A class needs to be defined for watching stock prices coming over a data feed. This class will allow other classes to register to be notified when the value of a particular stock changes. The StockMonitor class would implement a method that lets other objects register for notification. ode 6 public class StockMonitor { public void watchstock(stockwatcher watcher, String tickersymbol, double delta) {... The first argument to this method is a StockWatcher object. StockWatcher is the name of an interface. That interface declares one method: valuehanged. An object that wants to be notified of stock changes must be an instance of a class that implements this interface and thus implements the valuehanged method. The other two arguments provide the symbol of the stock to watch and the amount of change that the watcher considers interesting enough to be notified of. When the StockMonitor class detects an interesting change, it calls the valuehanged method of the watcher. The watchstock method ensures, through the data type of its first argument, that all registered objects implement the valuehanged method. It makes sense to use an interface data type because it matters only that registrants implement a particular method. An interface definition has two components: 9. Interface Definition interface declaration interface body The interface declaration declares various attributes about the interface, such as its name and whether it extends other interfaces. The interface body contains the constant and the method declarations for that interface. SYS-ED \OMPUTER EDUATION TEHNIQUES, IN. (JAVA PRG - ADV -.) h : Page 6

29 The StockWatcher interface and the structure of an interface definition would be implemented as: 6 7 public interface StockWatcher { final String sunticker = "SUNW"; final String oracleticker = "ORL"; final String ciscoticker = "SO"; void valuehanged(string tickersymbol, double newvalue); This interface defines three constants, which are the ticker symbols of watchable stocks. This interface also declares, but does not implement, the valuehanged method. lasses that implement this interface provide the implementation for that method. Two elements are required in an interface declaration: interface keyword name of the interface The public access specifier indicates that the interface can be used by any class in any package. If an interface is not specified as public, the interface will be accessible only to classes that are defined in the same package as the interface. An interface declaration can have one other component; a list of superinterfaces. An interface can extend other interfaces, such as a class can extend or subclass another class. However, whereas a class can extend only one other class, an interface can extend any number of interfaces. The list of superinterfaces is a comma-separated list of all the interfaces extended by the new interface. The interface body contains method declarations for all the methods included in the interface. A method declaration within an interface is followed by a semicolon (;) because an interface does not provide implementations for the methods declared within it. All methods declared in an interface are implicitly public and abstract. SYS-ED \OMPUTER EDUATION TEHNIQUES, IN. (JAVA PRG - ADV -.) h : Page 7

30 9. Interface Implementation An interface defines a protocol of behavior. A class that implements an interface adheres to the protocol defined by that interface. To declare a class that implements an interface, include an implements clause in the class declaration. A class can implement more than one interface, so the implements keyword is followed by a comma-separated list of the interfaces implemented by the class public class StockApplet extends Applet implements StockWatcher {... public void valuehanged(string tickersymbol, double newvalue) { if (tickersymbol.equals(sunticker)) {... else if (tickersymbol.equals(oracleticker)) {... else if (tickersymbol.equals(ciscoticker)) {... An applet which implements the StockWatcher interface. This class refers to each constant defined in StockWatcher,sunTicker, oracle-ticker, imple name. lasses that implement an interface inherit the constants defined within that interface. So those classes can use simple names to refer to the constants. Any other class can use an interfaces constants with a qualified name: StockWatcher.sunTicker SYS-ED \OMPUTER EDUATION TEHNIQUES, IN. (JAVA PRG - ADV -.) h : Page 8

31 0 Packages To make classes easier to find and use, avoid naming conflicts, and control access, programmers bundle groups of related classes and interfaces into packages. A package is a collection of related classes and interfaces providing access protection and namespace management. The classes and interfaces that are part of the Java platform are members of various packages that bundle classes by function: fundamental classes are in java.lang. classes for reading and writing (input and output) are in java.io lasses and interfaces can be placed in packages. 0. lasses - Placing in a Package onsider a group of classes which has been written to represent a collection of graphic objects, such as circles, rectangles, lines, and points. An interface can be written, Draggable, that classes implement if they have the capability of being dragged with the mouse by the user: //in the Graphic.java file public abstract class Graphic {... //in the ircle.java file public class ircle extends Graphic implements Draggable {... //in the Rectangle.java file public class Rectangle extends Graphic implements Draggable {... //in the Draggable.java file public interface Draggable {... SYS-ED \OMPUTER EDUATION TEHNIQUES, IN. (JAVA PRG - ADV -.) h : Page 9

32 These classes should be bundled and the interface placed in a package for several reasons: It will be easier to determine that these classes and interfaces are related. Programmers will know where to find classes and interfaces that provide graphics-related functions. Names of classes won t conflict with class names in other packages, because the package creates a new namespace. lasses within the package can be allowed to have unrestricted access to one another; yet still restrict access for classes outside the package. SYS-ED \OMPUTER EDUATION TEHNIQUES, IN. (JAVA PRG - ADV -.) h : Page 0

33 0. Package reation A package is created by putting a class or an interface in it. This is done by placing a package statement at the top of the source file in which the class or the interface is defined. package graphics; public class ircle extends Graphic implements Draggable {... This code appears in the source file ircle.java and puts the ircle class in the graphics package. The ircle class is a public member of the graphics package. A package statement must be included at the top of every source file that defines a class or an interface that is to be a member of the graphics package. The following statement would be included in Rectangle.java: package graphics; public class Rectangle extends Graphic implements Draggable {... The scope of the package statement is the entire source file, so all classes and interfaces defined in ircle.java and Rectangle.java are also members of the graphics package. If multiple classes are placed in a single source file, only one may be public, and it must share the name of the source files base name. Only public package members are accessible from outside the package. If a package statement is not used, the class or interface ends up in the default package, which is a package that has no name. In general, the default package is only for small or temporary applications or when the development is just beginning. Otherwise, classes and interfaces belong in named packages. SYS-ED \OMPUTER EDUATION TEHNIQUES, IN. (JAVA PRG - ADV -.) h : Page

34 0. Package Naming With programmers writing classes and interfaces using the Java programming language, there is a high likelihood that two programmers will use the same name for two different classes. ompanies use their reversed Internet domain name in their package names: com.company.package Some companies elect to drop the first element com. Name collisions that occur within a single company need to be handled by convention within that company. One approach for doing this would be to include the region or the project name after the company name e.g. com.company.region.package. SYS-ED \OMPUTER EDUATION TEHNIQUES, IN. (JAVA PRG - ADV -.) h : Page

35 0. Package Members Only public package members are accessible outside the package in which they are defined. To use a public package member from outside its package, one or more of the following steps must be taken: Refer to the member by its long (qualified) name. Import the package member. Import the members entire package. Each is appropriate for different situations. A package members simple name can be used when the code that is being written is in the same package as that member or if the members package has been imported. However, if a member from a different package is to be used and that package has not been imported, the members qualified name must be used; this name will include the package name. This qualified name for the Rectangle class declared in the graphics package example would be: graphics.rectangle This long name could be used for creating an instance of graphics.rectangle: graphics.rectangle myrect = new graphics.rectangle(); The use of long names will be satisfactory for a single use. However, it would quickly become annoying if graphics.rectangle had to be written again and again. The code would become very messy and difficult to read. In such cases, the member would need to be imported instead. To import a specific member into the current file, put an import statement at the beginning of the file before any class or interface definitions but after the package statement. SYS-ED \OMPUTER EDUATION TEHNIQUES, IN. (JAVA PRG - ADV -.) h : Page

36 import graphics.ircle; ircle class can now be referred to by its simple name: ircle myircle = new ircle(); This approach works well when only a few members from the graphics package are being used. If many classes and interfaces from a package are being used, then the entire package can be imported. To import all the classes and interfaces contained in a particular package, use the import statement with the asterisk (*) wildcard character: import graphics.*; Any class or interface in the graphics package can now be referred to by its short name: ircle myircle = new ircle(); Rectangle myrectangle = new Rectangle(); The asterisk in the import statement can be used only to specify all the classes within a package. It cannot be used to match a subset of the classes in a package. import graphics.a*; // does not work The code does not match all the classes in the graphics package that begin with A. SYS-ED \OMPUTER EDUATION TEHNIQUES, IN. (JAVA PRG - ADV -.) h : Page