Programming with Objects

Transcription

1 Programming with Objects Writing your own Classes As this topic is covered in great detail in Chapter 4 of the book, I will just review the main concepts here. We have already briefly encountered a user-defined class called MyMath. However, a much more powerful way of using classes is to use a class definition as a template for many instances of that class. Historically, classes arose from the need to treat complex data as units, rather than disconnected variables. Consider a program that needs to store and use complex numbers like 3+ 2i. A complex number has a real and an imaginary part, both of which could be stored as variables of type double, as follows: double n1real= 3.0; double n1imag= 2.0; But it would be much more convenient to use only one variable to store a complex number, like so: Complex n1= new Complex(3.0,2.0); Fortunately, we can now easily do that, by defining our own complex-number class: public class Complex { double realpart; double imagpart; public Complex(double realparam, double imagparam) { realpart = realparam; imagpart = imagparam; public double getrealpart() { return realpart; public double getimagpart() { return imagpart; public String tostring() { return realpart+"+"+imagpart+"i"; Now we can simply use objects of type Complex whenever we need a complex number.

2 But classes can do even more. For complex numbers, one often needs to compute the 2 2 absolute value of the number, which is defined as x = a + bi = a + b. Now one could write an algorithm for that every time one needs this function. It would be much better from a programming point of view though if one could ``teach'' the Complex class how to compute this function. Fortunately, Java allows just that. We also we include a second constructor for a Complex object. This is how to extend the class: public class Complex { double realpart; double imagpart; public Complex(double realparam, double imagparam) { realpart = realparam; imagpart = imagparam; public Complex( ) { realpart = 0.0; imagpart = 0.0; etc. as above public double abs() { return Math.sqrt(realPart * realpart + imagpart * imagpart); Note that the abs()-method does not need any parameters since it is a member of the Complex-class and can access all the member variables of this class. Other possible methods for this class include a function that squares a complex number using the formula : public Complex sqr() { return new Complex(realPart*realPartimagPart*imagPart,2*realPart*imagPart); or a function that adds a complex number to another complex number. Note that the addmethod has only one complex number as a parameter, since one of the summands is the current object: public Complex add(complex other) { return new Complex(realPart+other.getRealPart(),imagPart+other.getImagPart());

3 Figure 2 gives the complete class diagram with the methods described above and a few more additional methods. The diagram is not in the UML standard but should be easily convertible into it. Please note the return types, number and types of parameters. Methods like square or square root have no parameter, since they need only one argument (the current object). Methods like add have one parameter, which is the object that is added (in this case) to the current object. Also note that the constructor is (usually) not mentioned in the class diagram, and that this class has no main method. Figure 2: The Class Diagram for the Complex class. This is how one could use these methods from another program: public class TestComplex { public static void main (String[] args) { Complex x1 = new Complex(3,4); // 3+4i Complex x2 = new Complex(5,6); // 5+6i System.out.println(x1.abs()); //prints 5.0 System.out.println(x1.sqr()); //prints i System.out.println(x1.add(x2)); // prints i if (x1.equals(x2)) System.out.println("\"X1 is equal to X2\" "); else System.out.println("\"X1 is NOT equal to X2\" "); // prints "X1 is NOT equal to X2"

4 The tostring-method Whenever an object is used in a string context (e.g., by ``adding'' it to a string, as in System.out.println("Value is: "+obj), a method with the definition public String tostring() is called in that object. If no such method is defined in the object, the compiler takes the tostring method of another object 4, which usually does not print meaningful results. Therefore, the tostring() method should always be implemented in any self-defined object. Visibility and Encapsulation Visibility means the accessibility of variables and methods from methods in other classes. The book has all necessary information on that. Important points are: 1. visibility is marked for each variable or methods by the keywords public or private. No marker means ``visible inside the package'', or, if no packages are used, is equivalent to public visibility. 2. methods that are used by other classes must be public 3. all other methods should be private 4. variables should always be private, they should never be accessed from other classes Important: Since variables should always be private, one must write access methods for every variable that does need to be accessed from the outside. For example, in order to access a variable private String foo from the outside of a class, one should write methods public String getfoo() and public void setfoo(string newfoo). The purpose of this is that one can control accesses to the variable. For example, since an outside class could not overwrite a class's variables without going through the setmethods for those variables, a class can control the value of its variables. That would not be possible if the variables were public (=accessible from other classes). Static methods and variables Static methods Static methods were introduced earlier. They are marked by the keyword static. A static method has no access to class member variables, but can be called ``in the class'' rather than in an instance. That is, in order to call a static method inside a class, no instance of that class has to be created. Static and member methods can be mixed inside a class definition. From static methods, one can only call other static methods or create instances of classes.

5 The main method must be static. In particular, that means that without using objects, all methods in a program must be static. Static variables Static variables are created independently from object instances. This is a somewhat illogical concept, since at least in theory a class ``does not exist in memory'' until it is instantiated. Nevertheless, the ``class object'' itself can store variables. If a class containing a static variable is instantiated, all instances access the same static variable--it is shared among instances. From a static method, only static variables can be accessed. That means, for example, that class variables (=variables declared outside any method) that are used from the mainfunction must be static themselves. Static variables should be avoided except in those cases where they are absolutely necessary. It is better to create a new (dummy) class and instantiate it once than to make static variables, except in trivial programs. Note: The book uses get- and set-methods even when implementing member methods of a different object of the same class. As an example, look at the add-method in the Rational-class. This is not necessary, as member methods of a class can access even private variables in another object of the same class. I have no idea why the book does this, unless you want to allow access to those variables for objects of a different class. As an example, consider the following modification of the Complex class and the TestComplex program, where in the add method, we just access the variables of the other object in the same class (the difference has been bolded) public class TestComplex1 { public static void main (String[] args) { Complex1 x1 = new Complex1(3,4); // 3+4i Complex1 x2 = new Complex1(5,6); // 5+6i System.out.println(x1.abs()); //prints 5.0 System.out.println(x1.sqr()); //prints i System.out.println(x1.add(x2)); // prints i

6 if (x1.equals(x2)) System.out.println("\"X1 is equal to X2\" "); else System.out.println("\"X1 is NOT equal to X2\""); public class Complex1 { double realpart; double imagpart; public Complex1(double realparam, double imagparam) { realpart = realparam; imagpart = imagparam; public Complex1( ) { realpart = 0.0; imagpart = 0.0; public double getrealpart() { return realpart;

7 public double getimagpart() { return imagpart; public String tostring() { return realpart+"+"+imagpart+"i"; public double abs() { return Math.sqrt(realPart * realpart + imagpart * imagpart); public Complex1 add(complex1 other) { return new Complex1(realPart+other.realPart, imagpart+other.imagpart); public Complex1 sqr() { return new Complex1(realPart*realPart-imagPart*imagPart, 2*realPart*imagPart);