Class. Chapter 6: Data Abstraction. Example. Class

Transcription

1 Chapter 6: Data Abstraction In Java, there are three types of data values primitives arrays objects actually, arrays are a special type of object Class In Java, objects are used to represent data values Just as 3 is a primitive value of type int, every object must have a type These types are called classes Class A class defines a type of object, including its data: the information that is used to represent the object the operations (methods) that can be performed on the data After the type is defined, objects of that type can be defined and used An individual value of a class is called an object, or an instance of the class Example Suppose we want to represent planets in Java We can define a class Planet, with data: diameter, mass, distance from the sun, orbital period, rotational period, location,... methods: setdiameter, setmass, etc. getdiameter, getmass, etc. move Instances of Planet might include earth, mars, venus, saturn

2 Objects and Methods Different objects have different methods for manipulating their data The specific methods are determined based on what makes sense for that type of object For example, with strings: length, concatenation, comparison, substring String: A standard class String is a standard Java class Remember, values from a class are called objects, so "hello" is an object from the class String, or an instance of the class The class String has instance methods that operate on an instance of the class For example: length(), concat(), compareto(), charat() Methods Each type of object supports a specified set of methods There are two types of methods in a class instance methods class methods Instance Methods Instance methods are called for a specific object and have direct access to that object s data without having to pass the object as a parameter String s = "abc"; s.length(); The object is implicitly passed as a parameter to the method. We use the object's name followed by a '.', followed by the method name

3 String Instance Methods boolean equals( Object anobject ) compares this String with another object not the same as '==' See StringCompare.java int length() Number of characters in this String char charat( int index ) The character at position index in this String index ranges from 0 to length() - 1 IndexOutOfBoundsException String Instance Methods 2 int compareto(string str) Returns an integer value, based on lexicographic order int indexof(int ch) Index of where the first occurrance of ch occurs in this string or -1 if not present int indexof(string str) Index of the first character of a matching substring str or -1 if not present String Instance Methods 3 String concat(string str) Concatenates this string instance with str and returns the result String tolowercase() Returns a copy of this string, but converted to all lower case String touppercase() Returns a copy of this string, but converted to all upper case Class Methods These methods are part of the class definition, but don't operate on a specific instance of the class Class methods are indicated by the keyword static We have written class methods up to now Class methods provide some type of operation related to the objects provided by the class Math.random() Math.sqrt()

4 String.valueOf() static String valueof( type prim ) returns the String representation of the value of prim valueof is an overloaded function valueof( char c ) valueof( char[] data ) valueof( int i ) valueof( double d ) String.valueOf() static String valueof( type prim ) We don't need an instance of String to call this method Instead, we use the class name: String s; int value = 1234; s = String.valueOf( value ); System.out.println( s.length() ); StringTest.java // StringTest.java - demo some String methods public class StringTest { public static void main(string[] args) { String str1 = "abcd", str2 = "abcd", str3; System.out.println(str1.equals(str2)); System.out.println(str1.length()); System.out.println(str1.charAt(1)); System.out.println(str1.compareTo("aBcE")); System.out.println(str1.compareTo("aBcC")); System.out.println(str1.compareTo("aBcD")); System.out.println(str1.indexOf('D')); System.out.println(str1.indexOf("Bc")); System.out.println(str1.indexOf("zz")); // parts cut out here StringTest.java // StringTest.java - demo some String methods public class StringTest { public static void main(string[] args) { String str1 = "abcd", str2 = "abcd", str3; // parts cut out here System.out.println(str1.concat("efg")); str3 = str1.tolowercase(); System.out.println(str3); str3 = str1.touppercase(); System.out.println(str3); System.out.println(str1); str3 = String.valueOf(123); System.out.println(str3.equals("123"));

5 String Literals String literals are instances of String Therefore, we can invoke instance methods on them "abc".length() "hello".charat( 1 ); String is unusual Because strings are so common, Java provides some special syntax for the class String special support for concatenation special support for String literals String is the only class that is treated specially String Concatenation The '+' operator is overloaded to support String concatenation "hello " + "world" is equivalent to "hello ".concat( "world" ); String Literals String literals are supported String s = "hello"; is equivalent to char[] temp={ h, e, l, l, o ; String s = new String(temp); Instance methods are operations on objects

6 Strings are immutable Instances of class String are immutable Once its value is assigned, it cannot be changed We can create a new string, but we can't change the one we have. One implication of this is that when we pass a String to a method String s = "hello"; somemethod( s ); StringBuffer StringBuffer is another standard Java class for representing strings It has instance methods that allow you to change the value of a StringBuffer object These are called mutator methods insert(), reverse(), replace(), setcharat(), deletecharat(),... we know that its value will be unchanged when the method returns s will have the value "hello" when somemethod returns StringBufferTest.java // StringBufferTest.java - demo StringBuffer methods public class StringBufferTest { public static void main(string[] args) { StringBuffer sbuf1 = new StringBuffer(); StringBuffer sbuf2 = new StringBuffer("abcd"); StringBuffer sbuf3 = new StringBuffer(30); System.out.println(sbuf1.length()); System.out.println(sbuf2.length()); System.out.println(sbuf3.length()); System.out.println(sbuf1.capacity()); System.out.println(sbuf2.capacity()); System.out.println(sbuf3.capacity()); System.out.println(sbuf2.charAt(1)); // parts cut out here StringBufferTest.java // StringBufferTest.java - demo StringBuffer methods public class StringBufferTest { public static void main(string[] args) { sbuf2.setcharat(2,'z'); System.out.println(sbuf2); sbuf2.append("xyz"); System.out.println(sbuf2); sbuf2.append('?'); sbuf2.insert(4, "---"); sbuf2.insert(2, '+'); System.out.println(sbuf2); sbuf2.reverse(); System.out.println(sbuf2); System.out.println("sbuf2 capacity " + sbuf2.capacity()); System.out.println("sbuf2 length " + sbuf2.length());

7 Object Declarations When you declare an object, you are really creating a reference Similar to array declaration and allocation StringBuffer sbuf1 = new StringBuffer(); StringBuffer sbuf2 = new StringBuffer("abcd"); StringBuffer sbuf3 = new StringBuffer(30); Can also do this with separate statements StringBuffer sbuf1; sbuf1 = new StringBuffer(); Elements of a Simple Class As discussed earlier, a class describes the data values that make up an object along with the operations that can be applied to the object The data values are stored in instance variables, which are also known as fields or data members. The operations are described by instance methods, which are sometimes called procedure members. Example: Counter We often want to count things, why not create an abstraction for doing it? Advantage: you can reuse it in different places in the program, or even in other programs Data: Current value of the counter (initially zero) Operations: Reset, Increment, Decrement, Get the current value CounterTest.java class CounterTest { public static void main( String[] args ) { Counter countthis = new Counter(); Counter countthat = new Counter(); countthis.increment(); countthis.increment(); countthat.increment(); System.out.println("countThis: " + countthis.get() ); System.out.println("countThat: " + countthat.get() );

8 class Counter { int value; Counter.java Objects in Memory void reset() { value = 0; void increment() { value++; void decrement() { value--; int get() { return value; No main() method value is an instance variable Instance methods no static keyword CountThis CountThat Local variables in main() Counter objects value 2 value 1 Class Counter reset() increment() decrement() get() Important Details Each Counter object has its own copy of the member variables In this case, the integer variable called value When the methods are called, the call is of the form <objectname>.<methodname>() The object itself is an implicit parameter to the method, so that any references to the data access that object s copy of the instance variables Abstract Data Type Counter is an example of an Abstract Data Type (ADT) an abstraction representing a particular type of data Classes allow us to implement ADTs The data and methods combine to implement the functionality we desire or expect for this type of data The implementation details are hidden from the user The implementation is all in one place The type can be used in many different places in the program or in many programs

9 Package In general, each class is in a separate file The name of the file should match the class name (with.java at the end) All classes in the same directory are part of the same package Whether or not a method is in the same class or package as the data or method it is accessing affects what it can see and do. Data Hiding It is desirable to hide the inner details of a class (ADT) from the users of the class We want to be able to determine the correctness of our class without having to examine the entire program that it is used in For example, with our Counter class, we want to ensure that the value doesn't change by more than 1. Data Hiding Accessing instance variables from outside the class violates the data hiding principle class CounterTest2 { public static void main( String[] args ) { Counter c = new Counter(); c.value = 150; System.out.println( "c.value = " + c.get() ); A Better Counter Class Use the private and public access specifiers to control access to instance variables and methods class Counter { private int value; public void reset() { value = 0; public void increment() { value++; public void decrement() { value--; public int get() { return value;

10 Public/Private/Default private methods/fields cannot be accessed from outside of the class public methods/fields can be accessed from anywhere default (no specifier) methods/fields have package access they can be accessed from other classes in the same package if you don't specify a package (see section 12.11), all classes in the same directory are part of the same default, un-named package Constructing Objects We create or construct objects with the new operator StringBuffer sb = new StringBuffer(); Counter countthis = new Counter(); This allocates memory for the object and initializes the object Constructing Objects An object is initialized by calling its constructor A constructor is a special method in a class It has the same name as the class No return type is specified Implicit return type is instance of class It is automatically called when an object of that type is created Constructors are usually used to set data in the object to an initial value Constructors can take parameters Constructing Objects If the class definition does not include a constructor, then Java uses a default, noargument constructor This initializes all instance variables booleans to false other primitives to 0 everything else to null

11 Counter: Another Look This class does not have a defined constructor The default, no-argument constructor initializes the value field to 0 It is invoked when new Counter() is executed class Counter { private int value; public void reset() { value = 0; public void increment() { value++; public void decrement() { value--; public int get() { return value; Adding Constructors to Counter Want to create a Counter with an initial value class Counter { private int value; public Counter() { value = 0; public Counter( int v ) { value = v; public void reset() { value = 0; public void increment() { value++; public void decrement() { value--; public int get() { return value; Using Constructors Create two counters using our constructors class CounterTest3 { public static void main( String[] args ) { Counter countthis = new Counter(10); Counter countthat = new Counter(); countthis.increment(); countthis.increment(); countthat.increment(); System.out.println("countThis: " + countthis.get() ); System.out.println("countThat: " + countthat.get() ); Constructor Error Java provides the default, no-argument constructor only if there are no constructors defined in the class. If we had only provided this constructor public Counter( int v ) { value = v; Then creating a Counter with Counter countthat = new Counter(); would be a syntax error, because there is no constructor that takes 0 arguments.

12 Another Example Complex Numbers, with real and imaginary parts public class Complex { private double real; private double imaginary; public Complex() { real = 0; imaginary = 0; public Complex(double r, double i) { real = r; imaginary = i; Another Example Make some complex numbers Complex a = new Complex(); Complex b = new Complex( 3.7, 5.1 ); Complex c = new Complex( 3, 0 ); public double getreal() { return real; public double getimaginary() { return imaginary; import java.util.random; A Dice Example import tio.*; Testing the Dice class Dice { private int die1, die2; private Random roller; Dice(int seed) { roller = new Random(seed); void roll() { die1 = roller.nextint(6) + 1; die2 = roller.nextint(6) + 1; int gettotal() { return die1 + die2; public String tostring() { return die1 + ", " + die2; class DiceTest { public static void main(string[] args) { System.out.println("Enter the seed."); Dice dice = new Dice(Console.in.readInt()); System.out.println("How many times should I roll?"); int count = Console.in.readInt(); while(count > 0) { dice.roll(); System.out.println("You rolled " + dice); System.out.println("The total is " + dice.gettotal()); count--;

13 A Person Class Testing the Person Class class Person { private String name; private int age; private char gender; public Person( String n, int a, char g ) { name = n; age = a; gender = g; public String getname() { return name; public int getage() { return age; public char getgender() {return gender; class PersonTest { public static void main( String[] args ) { Person bill = new Person( "Bill", 25, 'M' ); Person amy = new Person( "Amy", 33, 'F' ); printperson( bill ); printperson( amy ); static void printperson( Person p ) { System.out.println( "Name: " + p.getname() ); System.out.println( "Age: " + p.getage() ); System.out.println( "Gender: " + p.getgender() ); tostring() You can use System.out.println() to display any object However, the default behavior is not very useful You can write your own tostring() method for your classes public String tostring() By providing every class with a tostring() method, we can use System.out.println() to print ANY object value class Person { private String name; private int age; private char gender; Person.toString() public Person( String n, int a, char g ) { name = n; age = a; gender = g; public String tostring() { return "Name: " + name + "\nage: " + age + "\ngender: " + gender;

14 Using tostring() class PersonTest2 { public static void main( String[] args ) { Person bill = new Person( "Bill", 25, 'M' ); Person amy = new Person( "Amy", 33, 'F' ); System.out.println( bill ); System.out.println( amy ); Static Methods and Variables Remember, a static (or class) method is one that is not associated with an object Static methods are invoked using the class name Math.random() String.valueOf() Similarly, a static or class variable is one that is independent of the objects of the class Static Variables Class variables are associated with the class rather than with a particular instance of the class As with static methods, public static variables are accessed using the class name followed by the variable name Math.PI A static variable is created once, when the class is first encountered by Java. How Many Counters? Add a static variable to keep track of the number of Counter objects class Counter { private int value; private static int howmany = 0; public Counter() { value = 0; howmany++; public Counter( int v ) { value = v; howmany++; public void reset() { value = 0; public void increment() { value++; public void decrement() { value--; public int get() { return value; public static int howmany() { return howmany;

15 How Many Counters? Class Variables in Memory class CounterTest4 { public static void main( String[] args ) { Counter countthis = new Counter(10); Counter countthat = new Counter(); countthis.increment(); countthis.increment(); countthat.increment(); System.out.println("countThis: " + countthis.get() ); System.out.println("countThat: " + countthat.get() ); System.out.println("How Many: " + Counter.howMany() ); CountThis CountThat Local variables in main() Counter objects value 12 value 1 Class Counter 2 howmany reset() increment() decrement() get() howmany() Let's put it all together Write a class Clock that represents a 24 hour clock Midnight = 0 This class should have a constructor that takes three parameters: hour, minute, and second Include the following instance methods: add( Clock c ) add c to a Clock instance For example, add 1:00:00 to 9:30:00 tostring() - format c as "HH:MM:SS" Let's put it all together Access instance variables should be accessible only from the class instance methods should be accessible from everywhere

16 Class Constants It is generally a bad idea for instance or class variables to be public It is better to provide accessor and mutator methods This allows us to guarantee certain conditions about the data However, there is one type of class data that is commonly made public: Constants Immutable variables with special values Class Constants and Final Examples Math.PI Integer.MAXINT Constants generally written in UPPER CASE Defined with the keyword final public static final double PI = ; Any attempt to modify the value of a constant will result in an error. Why Use Constants? Constants are only defined once Some numbers, such as pi, are frequently used Constants allow us to name a value This makes the code more clear Which is easier to understand? 12 or MONTHSPERYEAR Clock constants Let's add some class constants to the Clock class SECONDSPERMINUTE MINUTESPERHOUR HOURSPERDAY

17 Calling Methods There are three ways to call a method, depending on whether or not the method is in the same class whether the method is an instance method or a class method Calling Methods in the Same Class If a method is in the same class as the calling method, just use the method name a = foo( b ); Instance Instance Instance Class Class Class Class cannot call Instance Why not? Calling Methods in Another Class From another class: To call an instance method, you must use the name of an instance of the class String s = "abc"; int a = s.length(); To call a class method, you must use the name of the class double r = Math.random(); Calling Methods Let's add a method tick() to our clock class Advance the time 1 second Call another method in Clock to implement this method.

18 Accessing Another Object's Private Variables An instance method operating on one object can access another object's private fields Remember, private limits variable access to methods in the class The add() method of Clock does this Clock when = new Clock( 15, 30, 0 ); Clock howlong = new Clock( 1, 0, 0 ); when.add( howlong ); Implementation details are hidden from other classes, but not from objects in the same class Passing Objects to Methods As with Arrays, objects are references So, when we pass an object to a method, we can change its value class PassingReferences { public static void main(string[] args) { StringBuffer sbuf = new StringBuffer("testing"); System.out.println("sbuf is now " + sbuf); modify(sbuf); System.out.println("sbuf is now " + sbuf); static void modify(stringbuffer sb) { sb.append(", 1 2 3"); Object state before sb.append() Object state after sb.append() Variables in main() Variables in modify(sbuf) Variables in main() Variables in modify(sbuf) sbuf sb sbuf sb testing testing, StringBuffer object StringBuffer object

19 Passing Objects to Methods But, you can't change the value of the reference Object state before new class ModifyParameters { public static void main(string[] args) { StringBuffer sbuf = new StringBuffer("testing"); System.out.println("sbuf is now " + sbuf); modify(sbuf); System.out.println("sbuf is now " + sbuf); static void modify(stringbuffer sb) { sb = new StringBuffer("doesn't work"); sbuf Variables in main() Variables in modify(sbuf) sb testing StringBuffer object Object state after new Variables in main() Variables in modify(sbuf) sbuf sb testing, StringBuffer object doesn't work StringBuffer object Accessing Another Object's Private Variables An instance method operating on one object can access another object's private fields Remember, private limits variable access to methods in the class Implementation details are hidden from other classes, but not from objects in the same class Let's create an add() method in Clock Clock when = new Clock( 15, 30, 0 ); Clock howlong = new Clock( 1, 0, 0 ); when.add( howlong );

20 Calling Methods There are three ways to call a method, depending on whether or not the method is in the same class whether the method is an instance method or a class method Calling Methods in the Same Class If a method is in the same class as the calling method, just use the method name a = foo( b ); Instance Instance Instance Class Class Class Class cannot call Instance Why not? Calling Methods in Another Class From another class: To call an instance method, you must use the name of an instance of the class String s = "abc"; int a = s.length(); To call a class method, you must use the name of the class double r = Math.random(); Calling Methods Let's add a method tick() to our clock class Advance the time 1 second Call another method in Clock to implement this method.

21 Scope: Local Variables We have discussed the scope of local variables (ones defined in methods) already A variable's scope extends from the line it is declared until the end of the block it is contained in A formal parameter's scope is the entire method A variable declared in the for loop control has a scope that extends to the end of the for loop This means that variables can't be used before they are declared, or after the end of their scope Scope: Instance and Class Variables The scope rules for instance and class variables are different The scope of instance and class variables is the entire class regardless of where they are declared They can be referred to from any method in the class This means that you can refer to an instance or class variable before you declare it Example: Clock class class Clock { private int hour; private int minute; private int second; public Clock( int h, int m, int s ) { hour = h % HOURSPERDAY; minute = m % MINUTESPERHOUR; second = s % SECONDSPERMINUTE; public Clock() {... public void add( Clock c ) {... public void tick() {... public String tostring() {... Hidden Variables Local variables hide or eclipse instance and class variables with the same name References to that name will refer to the local variable public static final int HOURSPERDAY = 24; public static final int MINUTESPERHOUR = 60; public static final int SECONDSPERMINUTE = 60;

22 Hidden Class Variables Access hidden class variables using the class name //Scope2.java: class versus local scope class Scope2 { public static void main(string[] args) { int x = 2; System.out.println("local x = " + x); System.out.println("class variable x = " + Scope2.x); static int x = 1; Hidden Instance Variables Last time one of the sample question asked us to write a class Point class Point { private int x; private int y; public Point( int x1, int y1 ) { x = x1; y = y1; public String tostring() { return ( x + ", " + y ); Hidden Instance Variables Notice that we named the Constructor's parameters x1 and y1 instead of the more intuitive x and y class Point { private int x; private int y; public Point( int x, int y ) { x = x; // which x is which? y = y; //?... The Keyword this Java provides the keyword this to allow us to refer to an object's hidden instance variables this is a reference to the implicit object class Point { private int x; private int y; public Point( int x, int y ) { this.x = x; this.y = y;...

23 Arrays of Objects Point[] parray = new Point[5]; Just as we can have arrays of primitive types, we can also have arrays of objects Recall that When we declare an array we have to use new to create the storage for the array When we create an object we have to use new to create the storage for the object So, when we create an array of objects we have to use new twice; once for the array and once for the objects. parray The array for (int i = 0; i < parray.length; i++) { parray[i] = new Point(i, i+1); parray x y The array 3 4 x y x y The Point objects x y x y A Deck of Cards The book has an example where a deck of cards is represented as a 52 element array. Each element is an object of type Card //Deck.java - a deck of playing cards class Deck { Card[] deck; Deck() { deck = new Card[52]; for (int i = 0; i < deck.length; i++) deck[i] = new Card(new Suit(i / ), new Pips(i % ));

24 Shuffle the Deck Deck.toString() void shuffle() { for (int i = 0; i < deck.length; i++){ int k = (int)(math.random() * 52); Card t = deck[i]; deck[i] = deck[k]; deck[k] = t; The book has an error The highlighted line is a correction public String tostring() { String t = ""; for (int i = 0; i < 52; i++) if ( (i + 1) % 5 == 0) t = t + deck[i] + "\n"; else t = t + deck[i]; return t; The book has an error The highlighted line is a correction Testing the Deck //CardTest.java testing the shuffling method. public class CardTest { public static void main(string argv[]) { Deck deck = new Deck(); System.out.println("\nNew Shuffle\n" + deck); deck.shuffle(); System.out.println("\nNew Shuffle\n" + deck); deck.shuffle(); System.out.println("\nNew Shuffle\n" + deck);