Basis-Typen

Einstieg
Wertebereich
Scala Basis-Typen vs. Java primitive Typen
Literale
Wertetypen

Einstieg

In Scala gibt es keine primitive Datentypen. Alle Typen sind Objekte. In Scala gibt es jedoch Objekttypen, die den primitiven Datentypen in Java zugeordnet werden können. Eine Sonderstellung unter den Basis-Typen stellt der Typ String dar, der auch in Java ein Objekt ist.

Nachfolgend eine Auflistung der Basis Typen in Scala:

• String
• Int
• Long
• Short
• Byte
• Float
• Double
• Char
• Boolean

Die Typen Int, Long, Short, Byte und Char werden als integrale Typen bezeichnet. Die integralen Typen und die Typen Float und Double werden als numerische Typen bezeichnet.

Wertebereich

Der Wertebereich der Basis Typen entspricht dem der entsprechenden primitiven Typen in Java. Die bei numerischen Typen angegebene Bytezahl entspricht dem darzustellenden Wertebereich. Da die Basistypen vollwertige Objekte sind, benötigen diese eine größere Anzahl Bytes um diese im Speicher abzulegen.

Wertebereich der numerischen Basistypen

Basistyp	Bytes	Wertebereich
Byte	1	-128	(-27)	bis	127	(27-1)
Char	2	0		bis	128	(27)
Short	2	-215		bis	215-1
Int	4	-231		bis	231-1
Long	8	-263		bis	263-1
Float	4	±3.4028235E38
Double	8	±1.7976931348623157E308

Wertebereich von String und Boolean

Ein Boolean kann die Werte true oder false annehmen. Ein String ist eine beliebig lange Sequenz von Elementen des Typs Char .

Scala Basis-Typen vs. Java primitive Typen

Da Scala vollwertige Objekte anstatt der primitiven Typen in Java verwendet, lässt vermuten, dass ein Scala Programm langsamer abläuft als ein Java Programm. Dies ist in der Regel nicht der Fall. Scala greift, wo möglich, auf primitive Typen in den Klassen zurück, sodass der Objekt-Overhead sich nicht wesentlich auf die Ausführungsgeschwindigkeit eines Scala Programmes auswirkt. Scala Programme sind in der Ablaufgeschwindigkeit vergleichbar zu entsprechenden Java Programmen.

Durchgeführte Geschwindigkeitsmessungen des Autors anhand von Berechnungsprogrammen zeigen, dass Scala Programme oft nur unwesentlich langsamer sind und zum Teil auch schneller als die entsprechenden Java Programme. Diese Beobachtung deckt sich mit Angaben anderer Quellen zu Scala.

Literale

Literale sind vordefinierte Konstanten für Basistypen. Literale können überall dort im Quelltext verwendet werden, wo Konstanten-Variablen im Quelltext eingesetzt werden können.

Boolean Literale

Der Datentyp Boolean kennt genau zwei Literale:

• true
• false

welche den Wahrheitswerten wahr und falsch entsprechen.

Char (Character) Literale

Ein Char Literal ist ein einzelnes, druckbares Unicode Zeichen oder eine Escape Sequenz in einfachen Anführungszeichen. Für Unicode Zeichen im Bereich von 0 bis 255 ist auch eine Angabe in oktal Form möglich. Nachfolgend einige Beispiele für Char Literale:

'A'	Das Zeichen A
'\u0042'	Das Zeichen B als Unicode Escape Sequenz
'\141'	Das Zeichen a als Oktal Escape Sequenz<
'\n'	Der Zeilenumbruch

Gleitkomma Literale

Double Literale

Ein Double Literal besteht aus einer Reihe von Zahlen und mindestens einem der folgenden Elemente:

• Einem Dezimalpunkt (.)
• Dem Exponentialzeichen E oder e mit zusätzlicher Angabe des Exponenten zur Basis 10
• Die Angabe von D oder d zur Kennzeichnung des Double Literals

Nachfolgend einige Beispiele für Double Literale:

123.45
.123
123E0
123d
123D
123.45E0d          
          

Ein Literal in der Form 123. sollte man nicht mehr verwenden. Nach aktuellem Stand (23. November 2011), wird ein Literal, dass auf einem Punkt endet in der Version 2.10 von Scala als deprecated gekennzeichnet und wird mit der Version 2.11 sogar nicht mehr al Double Literal erkannt.

Float Literale

Für Float Literale gelten zunächst die gleichen Regeln wie für Double Literale mit der Erweiterung, dass bei einem Float Literal ein "f" oder ein "F" am Ende des Literals angegeben werden muss. Da ein Float Literal ein "f" oder "F" am Ende aufweisen muss, ist bei einem Float der Dezimalpunkt optional.

Beispiele für Float Literale sind:

123.45f
.123F
123.f
123F
123E0f          
          

Ganzzahl Literale

Int Literale

In Scala unterscheiden wir wie in Java je nach Schreibweise 3 unterschiedliche Typen von Int Literalen:

• Dezimale Int Literale
• Hexadezimale Int Literale
• Oktale Int Literale

Ein dezimaler Int Literal besteht aus den Ziffern 0 bis 9 und dem Minuszeichen "-" für negative Werte. In der Dezimalschreibweise darf ein Int Literal nicht mit "0" oder "-0" beginnen (siehe Oktalschreibweise / Hexadezimalschreibweise). Nachfolgend einige Beispiele für Int Literale in Dezimalschreibweise:

256
748
-4656
-43573          
          

In der Oktalschreibweise beginnt ein Int Literal mit "0" oder "-0"- In dieser Schreibweise sind ein führendes Minuszeichen "-" und die Ziffern 0 bis 7 zur Bildung des Literals erlaubt. Nachfolgend einige Beispiele für Int Literale in Oktalschreibweise:

0123
-0653
333
4563          
          

Um ein Int Literal in Hexadezimal anzugeben, muss das Literal mit "0x" oder "0X", mit einem optionalen "-" für negative Werte, eingeleitet werden. Im Anschluss folgt der Wert des Literales in hexadezimaler Schreibweise, wo zusätzlich zu den Ziffern 0 bis 9 noch die Buchstaben A bis F bzw. a bis f zur Bildung des Literals herangezogen werden können. Nachfolgend einige Beispiele für Int Literale in hexadezimaler Schreibweise.

0x123
0xff          
-0x00ff
-0X54ab
0xabcdef
          

Long Literale

Für Long Literale gelten dieselben Regeln wie für Int Literale. Dies gilt auch für die Angabe in Oktal- bzw. Hexadezimalschreibweise.

Die Unterscheidung zu anderen Ganzzahl Literalen erfolgt durch die Endung des Literals mit dem Buchstaben "l" oder "L". Nachfolgend einige Beispiele für Long Literale:

123l
123L
0x235L
0324l    
0xffL      
          

Byte und Short Literale

Für Byte Literale gelten im Grunde dieselben dieselben Bedingungen wie für Int Literale. Voraussetzung ist jedoch, dass Sie einen Wert im Wertebereich des Basistypen darstellen und einer entsprechenden Variable zugewiesen werden. Nachfolgend einige Beispiele für Byte und Short Literale:

val value1 : Short = 123
val value2 : Byte = 123
val value3 : Byte = 0xf
val value4 : Short = 012
          

String Literale

Ein String Literal ist eine Sequenz von Char - Zeichen in doppelten Anführungszeichen. Beispiel für String Literale sind:

• "Ich"
• "123"
• "test"

Das Anführungszeichen, der Backslash bzw. ein beliebiges Unicodezeichen können in einem String durch einen Backslash maskiert werden.

Müssen in einem String Literal eine Vielzahl von (direkt eingebaren) Zeichen maskiert werden, kann ein String Literal in dreifachen, doppelten Anführungszeichen gesetzt werden. Dies führt dazu, dass der Backslash nicht zur Maskierung herangezogen wird und auch alle anderen Zeichen wie angegeben behandelt werden.

Ein Beispiel für einen derartigen String Literal ist: """\"1'\""" welches der Zeichenkette \"1'\ entspricht.

Wertetypen

Scala kennt 9 Wertetypen:

• Int
• Long
• Short
• Byte
• Float
• Double
• Char
• Boolean
• Unit

Wertetypen sind in Scala vom Typ AnyVal abgeleitet. Wertetypen können in Scala nicht als Basisklasse für eigene Erweiterungen verwendet werden. Weiter ist es nicht möglich, eigene Klassen von AnyVal abzuleiten. Alle Klassen, die nicht zu den Wertetypen gehören, sind Referenztypen und haben die gemeinsame Basisklasse AnyRef.

---