Algoritmiek

Algoritmiek
Primitieve Types, Casting,
Polymorphism, Interfaces.
Hoorcollege 13 - Ma. 27 nov. 2006
L.M. Bosveld-de Smet
Java’s data typen

Primitive types

boolean

Numerieke typen




integer types: byte, short, int, long
floating-point types: float, double
character type: char
Reference types

String, Integer, Account, NewEmployee, ….
Integer Types

Java ’s integer types:
Type
byte
short
int
long
Size
8
16
32
64
bits
bits
bits
bits
Smallest Value
–128
–32,768
–2,147,483,648
–263
Largest Value
127
32,767
2,147,483,647
263–1
Integer Classes

Byte, Short, Integer, Long


java.lang package.
Elke class bevat constanten:

MIN_VALUE en MAX_VALUE

Bijvoorbeeld:


Byte.MIN_VALUE is –128
Byte.MAX_VALUE is 127.
Methode parse…

Methoden om String om te zetten naar getal:




Byte.parseByte
Integer.parseInt
Long.parseLong
Short.parseShort
Floating-Point Types


float
double
Type
float
double
Smallest
Size Positive Value Largest Value Precision
32 bits
64 bits
1.40  10–45
4.94  10–324
3.40  1038
1.79  10308
6 digits
15 digits
Speciale Waarden

java.lang package:


Constanten:




Float en Double.
POSITIVE_INFINITY
NEGATIVE_INFINITY
NaN
Methode:

isNaN
char Type

Voor willekeurige karakters


char ch;
Toekenningen




ch
ch
ch
ch
=
=
=
=
'a';
'A';
'0';
' ';
//
//
//
//
Lowercase a
Uppercase A
Zero
Space
ASCII Character Set

ASCII (American Standard Code for
Information Interchange)



128 characters
Spatie (character 32) gaat vooraf aan de cijfers
(48–57).
Hoofdletters (65–90) komen voor de kleine letters
(97–122).
ASCII Character Set

Control characters



eerste 32 karakters en laatste karakter, del
Niet op scherm toonbaar, niet te printen
Printing characters

Karakters die geen control characters of spatie zijn
Java: Unicode Character Set
Relatie tussen ASCII, Latin1 en Unicode:
Escape Sequences

Te gebruiken in character en String literals:
Naam
Escape Sequence
Backspace
Form feed
Line feed
Carriage return
Horizontal tab
Backslash
Single quote
Double quote
Octal escape
\b
\f
\n
\r
\t
\\
\'
\"
\0–\377
Operaties met karakters

Berekeningen: getalswaarden
int i = 'a';
char ch = 65;
ch++;

// i is nu 97
// ch is nu 'A'
// ch i now 'B'
Vergelijkingen: getalswaarden
if ('a' <= ch && ch <= 'z')
…
Operaties met karakters

‘controlling expression’ in een switch
statement:
switch (letter) {
case 'a': case 'e': case 'i': case 'o': case 'u':
System.out.println("Vowel");
break;
case 'y':
System.out.println("Possible vowel");
break;
default:
System.out.println("Consonant");
break;
}
Operaties met karakters

als ‘loop counter’:
for (char ch = 'A'; ch <= 'Z'; ch++)
…

Nadelen:


'a' * 'b' / 'c‘ wordt geaccepteerd
bugs die ontstaan door per ongeluk gebruik van
karakter voor getal worden niet ontdekt door Java
compiler.
characters versus Strings

ISBN-nummer zonder streepjes
for (int i = 0; i < isbn.length(); i++) {
char ch = isbn.charAt(i);
if (ch != '-')
System.out.print(ch);
}
Character Class

Character class (java.lang package)

Methoden om karakters te testen of om te zetten:










Character.isDigit('a')  false
Character.isISOControl('a')  false
Character.isISOControl('\n')  true
Character.isLetter('a')  true
Character.isLetterOrDigit(' ')  false
Character.isLowerCase('A')  false
Character.isUpperCase('A')  true
Character.isWhitespace('\n')  true
Character.toLowerCase('A')  'a‘
Character.toUpperCase('A')  'A'
Type Conversie

Mengen van verschillende typen in een
operatie


Impliciete conversie: automatische conversie
Expliciete conversie: conversies toegestaan aan
programmeur
Impliciete conversie

Operanden van verschillende typen


‘numeric promotion’
Assignments met data van verschillende typen

Rechts krijgt type van links, mits links ‘wijder’ is
Short s; int i;
i = s; // toegestaan
int i; float f;
i = f; // niet toegestaan

Argument en parameter van verschillende typen


Type van argument wordt type van parameter, mits
parameter ‘wijder’ is
Conversie naar String
‘Breedte’ van primitieve typen

Numerieke typen:
Casting

Type conversie op bevel van programmeur
int i;
float f;
…
i = (int) f;

// Cast f naar int type
Casting van floating-point number naar
integer type: truncatie
f = 45.6;
i = (int) f; // i is 45

Algemene vorm van een ‘cast’:
( type-name ) expression
Kerneigenschappen van O-O design





Abstraction: abstractie
Encapsulation: inkapseling
Inheritance: overerving
Polymorphism: veelvormigheid
Interface
Klassen hierarchie
zoogdieren
carnivoren
katten
honden
herbivoren
…
…
Type conversie


Objecten van een bepaald class type worden
behandeld als objecten van een ander class
type
Beperkingen:



hond ≠ herbivoor
kat ≠ hond
carnivoor ≠ hond
Assignment restricties
c
type Carnivoor
k
carnivoren
X
katten
honden
…
type Kat
h
type Hond
X
…
eetVlees
…
…
type Carnivoor
Assignment restricties
c
type Carnivoor
k
carnivoren
…
miauwt
eetVlees
katten
honden
…
type Kat
h
type Hond
X
…
type Kat
Assignment restricties
c
type Carnivoor
k
carnivoren
X
katten
honden
…
type Kat
h
type Hond
…
blaft
eetVlees
…
type Hond
Assignment “up”, beperkte
toepassing van methodes
c
Carnivoor c = new Kat ();
type Carnivoor
…
miauwt
c.miauwt(); // niet OK
eetVlees
…
type Kat
Casting en Anonieme verwijzing
c
type Carnivoor
…
miauwt
((Kat)c).miauwt(); // is OK
eetVlees
type Kat
…
type Kat
Polymorphism



Specifieke methode-aanroep op verschillende
momenten leidt tot verschillend gedrag
Selectie van code tijdens run-time
Dynamische binding
Interfaces



Plaatsen van beperkingen op verzameling
klassen
Klassen die een interface ‘implementeren’
vertonen een bepaald gedrag, en erven alle
in de interface gedefinieerde constanten
Voorbeeld:
abstracte
public interface Example {
public void doSomething();
}
methode
Stappenplan voor interface

Schrijf interface

Vorm:
public interface <interface name> {
<abstract method headings>;
<constant declarations>;
}


Voeg implements <interface name> toe aan alle klassen
die haar implementeren, en controleer of deze klassen volledige
definities bevatten van de in de interface genoemde methoden
gebruik “casting” om zeker te zijn dat alle aanroepen van
interface-methoden worden toegepast op type <interface
name> referenties.
Voorbeeld 1: interface Payable
/* Payable.java
Authors: Koffman & Wolz
* the Payable interface.
*/
public interface Payable {
public double calcWeeklyPay();
}
NewCompany class
public void computePayroll () {
System.out.println ("ID" + "\t" + "pay");
for (int i = 0; i < employees.length; i++) {
// calculate weekly pay
double weekPay;
NewEmployee emp = employees[i];
if (emp instanceof HourlyEmployee)
weekPay = ((HourlyEmployee) emp).calcWeeklyPay();
else if (emp instanceof SalaryEmployee)
weekPay = ((SalaryEmployee) emp).calcWeeklyPay();
else
weekPay = 0.0;
// add the weekly pay amount to employee's total pay
emp.updateTotalPay (weekPay);
// add the weekly pay amount to the payroll
payroll += weekPay;
// display ID and pay
System.out.println (emp.getSocial() +
"\t" + weekPay);
}
}
NewCompany class
public void computePayroll () {
System.out.println ("ID" + "\t" + "pay");
for (int i = 0; i < employees.length; i++) {
// calculate weekly pay
double weekPay;
NewEmployee emp = employees[i];
if (emp instanceof Payable)
weekPay = ((Payable) emp).calcWeeklyPay();
else
weekPay = 0.0;
// add the weekly pay amount to employee's total pay
emp.updateTotalPay (weekPay);
// add the weekly pay amount to the payroll
payroll += weekPay;
// display ID and pay
System.out.println (emp.getSocial() +
"\t" + weekPay);
}
}
HourlyEmployee
public class HourlyEmployee extends NewEmployee
implements Payable {
…
public double calcWeeklyPay() {
return hours * rate;
}
…
}
SalaryEmployee
public class SalaryEmployee extends NewEmployee
implements Payable {
…
public double calcWeeklyPay() {
if (annualSalary > 0)
return annualSalary / 52;
else
return 0;
}
…
}
TestNewCompany
Voorbeeld 2: Comparable interface
public interface Comparable {
public int compareTo (Object obj);
}


String class implements Comparable interface
String class heeft een compareTo () method.
Method call
resultaat
verklaring
“this”.compareTo(“that”)
positief
negatief
zero
“this”
“that”.compareTo(“this”)
“same”.compareTo(“same”)
“that”
“same”
is groter dan “that”
is kleiner dan “this”
is gelijk aan “same”
Probleem: sorteren van Comparable
objecten


Sorteren van objecten van willekeurig type
Sorteren van integers, String objecten,
NewEmployee objecten, etc.
IntArray class

IntArray class

Zoeken naar een bepaalde waarde in de array





voor elk array element, doe het volgende:
als het huidige element overéénkomt met de gezochte waarde
geef de index van het huidige element terug.
geef -1 terug.
Sorteren van de waarden in de array


voor elke index, vanaf 0 tot aan de laatste index, doe het
volgende:
vind de positie (posMin) van het kleinste element in de subarray
startend bij het element behorende bij de huidige index (<array
name>[fill])

verwissel het kleinste element met het element behorende bij
index fill.
TestIntArray output
Generieke selectionSort

Class method van class Sorts
public class Sorts {
// postcondition: elements in array x are in increasing order
public static void selectionSort (Comparable[] x) {
int posMin;
// index of next smallest element
Comparable temp;
// temporary variable for exchange
for (int fill = 0; fill < x.length - 1; fill++) {
/* invariant:
* the elements in x[0] through x[fill-1] are in their
* proper place and fill < x.length is true
*/
// find index of smallest element in subarray
// starting at element x[fill].
posMin = findPosMin (x, fill);
// exchange elements with indices fill and posMin
if (posMin != fill) {
temp = x[fill];
x[fill] = x[posMin];
x[posMin] = temp;
}
}
}
findPosMin(): helper method
// postcondition: returns the position of the smallest
//
element in array x from x[fill] to the end.
private static int findPosMin (Comparable[] x, int fill) {
// assume smallest element is at position fill
int posMinSoFar = fill;
// remember any smaller value found in the array
for (int i = fill + 1; i < x.length; i++) {
if (x[i].compareTo (x[posMinSoFar]) < 0)
posMinSoFar = i;
}
// posMinSoFar is index of smallest element
return posMinSoFar;
}
}
Toepassen selectionSort op array met
String objecten
public interface Comparable {
public int compareTo(Object obj);
}
public class TestStringSort {
public static void main (String[] args) {
public class String extends …
String names = new String[5];
implements Comparable {
…
…
//sort the array names
public int compareTo(Object obj) {
Sorts.selectionSort(names);
String s = (String) obj;
…
…
}
}
…
public class Sorts {
public static void selectionSort(Comparable[]x) {
}
…
}
Toepassen selectionSort op array met
NewEmployee objecten
public class NewCompany {
public interface Comparable {
private NewEmployee[] employees;
public int compareTo(Object obj);
…
}
//sorts employees by social security number
public void sortEmployees {
Sorts.selectionSort(employees);
public class TestNewCompany {
}
public static void main (String[] args) {
implements Comparable {
…
NewCompany myCompany = NewCompany(3);
…
}
…
public int compareTo (Object obj) {
//sort employees by social security number
NewEmployee emp = (NewEmployee) obj;
myCompany.sortEmployees();
return this.socSecNum.compareTo
…
(emp.socSecNum);
}
public class Sorts {
}
public class NewEmployee
public static void selectionSort(Comparable[]x) {
…
…
}
}
TestNewCompany met sorteren