1 / 57

The complete Circle class

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; } }. Using the Circle class.

wiesner
Télécharger la présentation

The complete Circle class

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  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

More Related