Post on 12-Jan-2016
transcript
Java Classes
Using Java ClassesIntroduction to UML
Java and object-orientation
Java is an object-oriented language a Java program consists of one or more
classes, each of which contain attributes and methods
Java programs create and use instances of these classes called objects
we can use UML (Unified Modelling language) to design and document our object-oriented designs
UML class diagrams can easily be translated into Java code
Why classes?
convenient way of packaging together related data and functionality
this is called encapsulation
Example - Spike
Spike's data colour of body
and features position (x and y
coordinates) height
Spike's functionality
construct a new Spike object and initialise its data
draw move to a given position get its current position (x or y coordinate) change its height to a given value
Java classes
in Java we use the following terms: attributes for the data methods for the functionality
attributes are usually private other objects can't read or change them
public methods are used to interact with the object
typically methods could: read an attribute set (change) an attribute do something (eg paint) using attribute values
Why classes?
once we have defined a class we can create one or more instances (objects) of that class class is the blueprint object is the actual
instance each object has its own
data can be different to that
of other objects of the same class
methods are used to interact with individual objects
How to create and use objects
declare a variable of the desired class Spike spike1;
create objects of that class using the constructor and the keyword new spike1 = new Spike();
use the name of the object to call its methods spike1.moveTo(50, 100); spike1.drawSpike();
Other classes you’ve seen
Console readString(), readInt()…. methods
System.out print() and println() methods
You also used the String class Take a look at your first Java project again.
UML class diagrams
UML – Universal Modelling Language
standard notation for designing and documenting object-oriented systems
a UML class diagram is a box with 3 compartments top: class name middle: attributes bottom: methods
Spike
startXstartYheightwidthbodyColourfeaturesColour
SpikedrawSpikemoveTogetXgetYsetHeight
More detailed class diagrams
attribute visibility+ for public- for private
type of attribute, return type of methodafter :
type and name of method parameters in brackets after
method name
Spike
-startX:int-startY:int-height:int-width:int-bodyColour:Color-featuresColour:Color
+Spike(x:int,y:int,h:int,body:Color)+drawSpike(g:Graphics):void+moveTo(x:int,y:int):void+getX():int+getY():int+setHeight(newHeight:int):int
Using classes very often in Object-Oriented programming we
will use classes written by someone else part of Java language in libraries, like Console written by our colleagues (Spike)
(hopefully) these classes will be well designed, tested and documented
we can use them with confidence this is called software reuse
allows rapid building of robust systems now we will go through another example of
using a library (someone else's) class
DayCloneable
Day
-day:int-month:int-year:int
+Day()+Day(yyyy:int,m:int,d:int)+advance(n:int):void+getDay():int+getMonth():int+getYear():int+weekday():int+daysBetween(b:Day):int+toString():String+clone():Object-isValid():boolean-toJulian():int-fromJulian(j:int):void
part of corejava library encapsulates all information
about a date private attributes:
day month year
all integers why not have a dayOfWeek
attribute?
Day methodsCloneable
Day
-day:int-month:int-year:int
+Day()+Day(yyyy:int,m:int,d:int)+advance(n:int):void+getDay():int+getMonth():int+getYear():int+weekday():int+daysBetween(b:Day):int+toString():String+clone():Object-isValid():boolean-toJulian():int-fromJulian(j:int):void
what do you think the other methods do? hint: it is good programming
practice to give methods meaningful names!
can refer to documentation for more information hopefully the class developer
wrote meaningful comments!!
Constructors
all classes have a constructor method that is called when an object is first created
all constructors must have the same name as the class and are public
constructors never have a return type Java provides a default constructor
creates space in memory for the object and all its attributes
classes can provide their own version(s) to do any initialisation steps required which methods are the Day constructors and
what do you think they do?
Day classCloneable
Day
-day:int-month:int-year:int
+Day()+Day(yyyy:int,m:int,d:int)+advance(n:int):void+getDay():int+getMonth():int+getYear():int+weekday():int+daysBetween(b:Day):int+toString():String+clone():Object-isValid():boolean-toJulian():int-fromJulian(j:int):void
two constructor methods: public Day()
creates a Day object with today’s date
public Day(int yyyy, int m, int d) creates a Day object with given
date
get- methods
often need a method to return the value of a private attribute way of reading the attribute without changing it
conventional to use a get- method method getX( ) returns the attribute X
public so other classes can use it return type is the same type as the attribute Day has three get- methods
what do you think they do?
set- methods
set- methods are used to change the value of given attribute give write- access to a private attribute
method setX(type a) sets the value of attribute X to the new value a
public so other classes can use it parameter type is the same type as the attribute
return type is usually void Day does not have any set- methods
why do you think this is?
toString() method
all Java classes have a default toString() method
returns a String containing information about the object
the default is name of class @ hash code of the object for example Day@1a16869
many classes override this method to return something more meaningful in this case Day[2004,9,22] name of class, then year, month, day in
square brackets
DayCloneable
Day
-day:int-month:int-year:int
+Day()+Day(yyyy:int,m:int,d:int)+advance(n:int):void+getDay():int+getMonth():int+getYear():int+weekday():int+daysBetween(b:Day):int+toString():String+clone():Object-isValid():boolean-toJulian():int-fromJulian(j:int):void
other methods of interest: advance(int n) advances the
date by n days not as easy as it looks – have to
consider end of months and years
int weekday() returns the day of the week 0 for Sunday to 6 for Saturday
int daysBetween(Day b) calculates and returns the
number of days between 2 Day objects
Information hiding
the logic within these methods is quite complicated
fortunately we don't need to know how they are implemented
as long as we know what they do, we can confidently use them without knowing how they do it
in OO terms this is called information hiding
Using the Day class we'd now like to write a program that
uses some of the features of the Day class
before we write our program we need to think about what it will do
Scenario - a small application program is required which can ask the user for a number and tell them
what date it will be in that many day's time
How can we do this?
could create a Day object it encapsulates all the information about a date
what date should we represent? today's date use default constructor
how can we get input from the user? use Console.readInt() method
how can we advance the date? use the Day object's advance() method luckily we don't need to write it ourselves!!!
How can we do this?
how can we output the results? use the Day object's toString() method, and
print the returned String to the console how should we structure the program?
put code in one class DayInterface.java
small, so put all code in main() method import corejava.* to access Console and Day
classes
DayInterface.javaimport corejava.*;public class DayInterface{ public static void main(String[] args) { Day theDate; int amount; theDate = new Day(); amount = Console.readInt("How many days from now? "); theDate.advance(amount); System.out.println(amount + " days from today is " +
theDate.toString()); }}
Output
How many days from now? 250250 days from today is
Day[2005,7,26]
Summary
have looked at classes why we use them - encapsulation what they are made of (attributes and methods) how we can document them with UML class
diagrams how we can use library classes in our own
programs information hiding – we don't need to know how they
work!
tutorial design some class diagrams write some more applications using other
people's classes