The complete Circle class

1. The complete Circle class public class Circle { public double x,y; // center coordinates public double r; // radius // the methods public double circumference() { return 2*3.14*r; } public double area() { return 3.14*r*r; } }

2. Using the Circle class public class TestCircle { public static void main(String args[]) { Circle c; c = new Circle(); c.x = 2.0; c.y = 2.0; c.r = 5.5; System.out.println(c.area()); } }

3. The this keyword • this refers to the current object • In the Circle class, the following definitions for area() are equivalent: public double area() { return 3.14 * r * r; } public double area() { return 3.14 * this.r * this.r; } • Using the keyword clarifies that you are referring to a variable inside an object

4. Constructors • A constructor is a special type of method • has the same name as the class • It is called when an object is created • new Circle(); // “calls” the Circle() method • If no constructor is defined, a default constructor that does nothing is implemented

5. A constructor for the Circle class public class Circle { public double x,y; // center coordinates public double r; // radius public Circle() { // sets default values for x, y, and r this.x = 0.0; this.y = 0.0; this.r = 1.0; } ... }

6. A constructor with parameters public class Circle { … public Circle(double x, double y, double z) { this.x = x; this.y = y; this.r = z; // using this is now a necessity } ... }

7. Using the different constructors Circle c, d; c = new Circle(); // radius of circle has been set to 1.0 System.out.println(c.area()); d = new Circle(1.0,1.0,5.0); // radius of circle has been set to 5.0 System.out.println(d.area());

8. Method Overloading • In Java, it is possible to have several method definitions under the same name • but the signatures should be different • Signature: • the name of the method • the number of parameters • the types of the parameters

9. Syntax Summary • Constructor without a parameter public classname() { *body of the constructor }

10. Syntax Summary • Overloading constructors public classname(type variable-name) { *body of constructor } public classname( type variable-name, type variable-name) { *body of constructor }

11. Encapsulation • A key OO concept: “Information Hiding” • Key points • The user of an object should have access only to those methods (or data) that are essential • Unnecessary implementation details should be hidden from the user • In Java, use public and private

12. Access Modifiers • public • a public variable/method is available for use outside the class it is defined in • private • a private variable/method may be used only within the class it is defined in

13. The Circle class Revisited public class Circle { private double x,y; // center coordinates private double r; // radius // ... } // when using the Circle class ... Circle c; c.r = 1.0; // this statement is not allowed

14. Outside accessto private data • No direct access • Define (public) set and get methods instead or initialize the data through constructors • Why? • If you change your mind about the names and even the types of these private data, the code using the class need not be changed

15. Set and Get Methods • Variables/attributes in a class are often not declared public • Instead: • define use a (public) set method to assign a value to a variable • define a get method to retrieve that value • Consistent with encapsulation

16. Set and Get Methods for Radius public class Circle { // ... private double r; // radius // … public void setRadius(double r) { this.r = r; } public double getRadius() { return this.r; } // ... }

17. Inheritance

18. Subclasses and Inheritance • Inheritance: • programming language feature that allows for the implicit definition of variables/methods for a class through an existing class • In Java, use the extends keyword public class B extends A { … } • objects of subclass B now have access* to variables and methods defined in A

19. The EnhancedCircle class public class EnhancedCircle extends Circle { // as if area(), circumference(), setRadius() and getRadius() // automatically defined; x,y,r are also present (but are private // to the the Circle class) private int color; public void setColor(int c) { color = c; } public void draw() { … } public double diameter() { return getRadius()*2; } }

20. Using a Subclass EnhancedCircle c; c = new EnhancedCircle(); // Circle() constructor // implicitly invoked c.setColor(5); c.setRadius(6.6); System.out.println(c.area()); System.out.println(c.diameter()); c.draw();

21. Applets and Inheritance • Java Applets that we write extend the Applet class (defined in package java.applet) • Methods such as add() (for adding visual components) are actually methods available in the Applet class • init(), action(), and paint() are also available but can be overridden

22. Class Hierarchy • Subclass relationship forms a hierarchy • Example: TextField class • TextField extends TextComponent which extends Component which extends Object • Object is the topmost class in Java • Exercise (use javap): • determine where the methods setText(), getText(), hide(), and show() are defined

23. Method Overriding • A method (with a given signature) may be overridden in a subclass • Suppose class B extends A • let void operate() be a method defined in A • void operate() may be defined in B • objects of class A use A’s operate() • objects of class B use B’s operate()

24. Dynamic Binding • Let A be a superclass of subclasses B and C • A variable of class A may refer to instances of A, B, and C • Java facilitates the calling of the appropriate method at run time • Example • A v; … v.operate();

25. Constructors and Superclasses • Suppose B extends A • new B() calls B’s constructor • how about A’s constructor ? • Rule • the constructor of a superclass is always invoked before the statements in the subclass’ constructor are executed

26. super() • Used to call a superclass’ constructor • Implicitly included when not indicated If B extends A, the following are equivalent: public B() { public B() { // body of constructor super(); } // body of constructor }

27. Calling a particular Constructor • Use super with parameters if a particular constructor should be called • Example: public class BlueButton extends Button { public BlueButton(String s) { super(s); // without this, super() is called (label-less) setBackground(Color.blue); } … }

28. Default Constructors • When no constructors are defined • a default constructor with no parameters is implicitly included • If at least one constructor is defined, with or without parameters • a default constructor will not apply

29. Syntax Summary • Extends and Super public class subclass extends superclass { public subclassconstructor(...) { super(...); *body of constructor } ... }

30. Abstract Classes and Interfaces

31. “Incomplete” Classes • Objects vs “concepts” • Example: Circle and Shape • circles are shapes (Circle extends Shape) • shapes (such as circle) have area and circumference • how are area() and circumference() defined at the level of Shape? • Shape has incomplete definitions

32. The Shape class • One option • make area() and circumference() methods that do nothing (perhaps return 0.0) • Circle could extend shape and then override these methods • problems ? • Another option available in Java • abstract class

33. Abstract Class • Same as class • but it is possible to omit method bodies • syntax: • abstract before class (and method headers) • semicolon at the end of the method headers • Rules • may declare variables of abstract classes • instantiation not possible (new will not work) • subclasses must override incomplete methods

34. The Shape class public abstract class Shape { private int color; public void setColor(int c) { color = c; } public abstract double circumference(); public abstract double area(); }

35. The Circle class public class Circle extends Shape { private double r; … // the compiler will complain if the ff methods are not defined public double circumference() { return 2*3.14*r; } public double area() { return 3.14*r*r; } }

36. Using Shape and Circle Circle c; Shape s; c = new Circle(); // ok s = new Shape(); // not allowed -- Shape is abstract s = new Circle(); // ok because Circle is a // subclass of Shape

37. Another Example:Function Plotter • Define an abstract class FunctionPlotter that plots a mathematical function f() • a method plot() plots a function f() by evaluating f() on some x values • make f() an abstract method, i.e.,public abstract double f(double x); • Next, define classes that extend FunctionPlotter and complete the definition of f()

38. Function Plotter, continued • LinePlotter defines f() as follows: public double f(double x) { return x; } • SquarePlotter defines f() as follows: public double f(double x) { return x*x; } Note: LinePlotter, SquarePlotter (and Circle, in the previous example) are called concrete classes

39. Why Use Abstract Classes? • More robust code • no need to use “new” on anything it shouldn’t be used on • Enforces discipline • Abstract classes cannot be instantiated; they are meant to be extended • Anyone who extends an abstract class is now forced to define the incomplete parts

40. Interface • None of the methods have bodies • Instance variables not allowed • Syntax • interface not class • no need to put abstract before method headers • implements not extends on the complete (concrete) class

41. Rules on Interfaces • May declare variables whose type is an interface • objects that are instances of classes that implement the interface may be referred to by such variables • Instantiation not possible • Implementing class must define all methods

42. Example public interface Switch { public void turnOn(); public void turnOff(); public boolean isOn(); } public class Computer implements Switch { // must define turnOn(), turnOff(), and isOn() in this class ... }

43. Notes on Interfaces • Interface variables can be declared • e.g., Switch s; • Interfaces cannot be instantiated • Interface variables may refer to objects of classes that implement the interface • e.g., s = new Computer(); • A class may implement several interfaces

44. Multiple Inheritance • Other OO languages such as C++ allow several superclasses for a given class • not possible in Java • Implementation problems • common members in superclasses • In Java • use interfaces • it is possible to implement several interfaces with no “conflicts”

45. Anonymous Classes • Feature available in JDK 1.1 or higher versions of Java • Useful when • Only one object of the concrete class needs to be created • It is not too important to have a name for the concrete class

46. Back to FunctionPlotter Example • Without anonymous classes, the LinePlotter class would look like this public class LinePlotter extends FunctionPlotter { public double f(double x) { return x; } } • And then, in some main program … LinePlotter lp = new LinePlotter(); lp.plot();

47. Using Anonymous Classes FunctionPlotter lp = new FunctionPlotter() { public double f(double x) { return x; } } lp.plot(); // no need to explicitly define a LinePlotter class

48. Syntax Summary • Anonymous classes abstractclassorinterface var = new abstractclassorinterface() { // complete the definitions of abstract // methods here }

49. The Java Event Models

50. Event-Driven Programming in Java • Specifying actions for events performed on the GUI • most common example: clicking on a button • The Java Event Models • JDK 1.0.2 (deprecated) • JDK 1.1 and the new event model