006
29.03.2010, 20:14 Uhr
~SagIchDirNicht
Gast
|
| Zitat: |
Gibt es eine Moeglichkeit den Overflow beim Rechnen mit byte-Variablen abzufangen? Bei sowas z. B.:
| C++: |
byte a = (byte) 120;
byte b = (byte) 30;
byte c = (byte) 0;
c = (byte) (a + b);
|
|
Java bietet von Hause aus keine Prüfung auf einen Overflow an, du musst wie meine Vorgänger selber auf einen Overflow prüfen und zwar immer mit einem Nächst höheren Wert. Am besten du nimmst für eine Addition immer einen
Hier ein kleines Beispiel für ganz Zahl Datentypen:
| C++: |
package com.betasystems.data.adapter;
import java.math.BigInteger;
public class Overflow {
/**
* Exception wird geworfen sobald ein Overflow auftritt
*
* @author Yves
*
*/
public static class OverlowException extends Exception {
public OverlowException() {
super();
// TODO Auto-generated constructor stub
}
public OverlowException(String message, Throwable cause) {
super(message, cause);
// TODO Auto-generated constructor stub
}
public OverlowException(String message) {
super(message);
// TODO Auto-generated constructor stub
}
public OverlowException(Throwable cause) {
super(cause);
// TODO Auto-generated constructor stub
}
}
/**
* Prüfe für die Typen Byte,Short,Integer und
* Long ob sich die Zahlen a und b ohne einen Overlow addieren lassen
*
* @param a
* Zahl vom Typ Byte,Short,Integer oder Long
* @param b
* Zahl vom Typ Byte,Short,Integer oder Long
* @return
* true kein Overlow trat auf
*/
public static boolean canAdd(Number a, Number b) {
BigInteger maxValue = null;
if (a instanceof Byte || b instanceof Byte) {
maxValue = BigInteger.valueOf(Byte.MAX_VALUE);
}
if (a instanceof Short || b instanceof Short) {
maxValue = BigInteger.valueOf(Short.MAX_VALUE);
}
if (a instanceof Integer || b instanceof Integer) {
maxValue = BigInteger.valueOf(Integer.MAX_VALUE);
}
if (a instanceof Long || b instanceof Long) {
maxValue = BigInteger.valueOf(Long.MAX_VALUE);
}
if (maxValue == null)
throw new IllegalArgumentException("Invalid Type");
BigInteger aL = BigInteger.valueOf(a.longValue());
BigInteger ab = BigInteger.valueOf(b.longValue());
return aL.add(ab).compareTo(maxValue) <= 0;
}
/**
* Wirft eine OverlowException sobald ein Overflow auftritt
* @param a
* Zahl vom Typ Byte,Short,Integer oder Long
* @param b
* Zahl vom Typ Byte,Short,Integer oder Long
* @throws OverlowException
*/
public static void checkOverflow(Number a, Number b)
throws OverlowException {
if (!canAdd(a, b)) {
throw new OverlowException("a overflow occured");
}
}
public static void main(String[] args) {
byte a = (byte) 120;
byte b = (byte) 30;
byte c = (byte) 0;
try {
checkOverflow(a, b);
} catch (OverlowException e) {
System.out.println(e.getMessage());
}
c = (byte) (a + b); // Da du ja weißt das Byte und Byte
//für Byte zu groß wird nutze doch einfach einen Integer
int result = (int) a+b // wäre angebrachter, verwende immer einen nächsthören
// Datentyp für die Ergebnis Variable
}
}
|
Du solltest Wissen, dass der Datentyp Byte in Java immer 8 Bit groß ist und signed ist.
Das 8 Bit wird für das Vorzeichen verwendet, es also sind nur 7 Bit für die Speicherung der Zahl übrig. Das sagt ein Byte kann Maximal die Werte von -128 bis 127 anehmen.
Daherführt Byte und Byte im schlechtesten Fall zu einem Overflow. Also verwender einfach einen höheren Datentyp als Byte:
| C++: |
byte a = (byte) 120;
byte b = (byte) 30;
int c = 0;
c = (int) a + b;
|
Gruß, ich hoffe ich konnte Helfen  |
da weis ich gar nicht, ob die Bitoperationen von C/C++ da überhaupt funktionieren... 
