 |
|
Das Java-Archivtool jar
Der Java-Compiler erzeugt für jede Klasse eine eigene class Datei. Bei größeren Projekten erhält man so eine Menge von Klassen auf deren Vollständigkeit man bei der Distribution zu achten hat.
Insbesondere beim Übertragen von Java-Code über eine Netzwerkverbindung (z. B. JavaApplets) müssen so viele kurze Übertragungen getätigt werden, deren overhead wesentlich höher ist als bei einer einzigen längeren Verbindung.
Um dies zu verhindern, kann man die class Dateien in ein jar Archiv packen. Dabei handelt es sich im Grunde um ein normales Zip-Archiv, jar bietet aber noch zusätzliche Eigenschaften:
-
jarArchive können signiert werden (siehe AppletSecurity). - In der Konfigurationsdatei
META_INF/MANIFEST.MFkönnen zusätzliche Informationen abgelegt werden, z. B. den Namen der Klasse, die diemainMethode enthält. Eine so gepackte Applikation kann dann einfach mittelsjava -jar Archiv.jargestartet werden.
Sicherheit von Applets
Applets haben nur einen stark eingeschränkten Zugriff auf die Resourcen des Clients, so dürfen Applets z. B.- keine Dateien lesen oder schreiben.
- keine Verbindungen zu anderen Rechnern aufnehmen außer dem, von dem sie geladen wurden.
jarsigner mit einem X.509-Schlüssel signiert werden.
Die Zuweisung von mehr Rechten ist vom Browser abhängig: - Im Mozilla gelten signierte Applets nach Rückfrage beim Benutzer grundsätzlich als vertrauenswürdig.
- Der JDK
appletviewerwertet die Datei~/.java.policyaus, die Rechte nach Zertifikat oder nach Herkunft des Applets erlaubt, also auch unsigniert Applets privilegieren kann. - Der Konqueror verhält sich offenbar wie der
appletviewer.
Unsigniert:
Signiert:
Siehe auch:- http://java.sun.com/j2se/1.4.1/docs/guide/security/
- http://java.sun.com/docs/books/tutorial/security1.2/toolsign/index.html
Der Datentyp Complex
package fft;
class Complex {
private double real;
private double img;
Complex(double real, double imaginary) {
this.real = real;
img = imaginary;
}
public String toString() {
return real + " + " + img + "i" ;
}
/* Complex.add(x, y) */
static Complex add(Complex a, Complex b) {
return new Complex(a.real + b.real, a.img + b.img);
}
/* x.add(y) */
Complex add(Complex other) {
//real = real + other.real;
//img += other.img;
//return this;
return new Complex( real + other.real, img + other.img);
}
static Complex multiply(Complex x, Complex y) {
return new Complex(x.real * y.real - x.img * y.img,
x.real * y.img + x.img * y.real);
}
/* x**n */
static Complex exp(Complex x, int n) {
if (n == 0) {
return new Complex(1,0);
} else {
return Complex.multiply(x, Complex.exp(x, --n));
}
}
/* = cos(2pi/n) + i(sin(2pi/n))
*/
static Complex getRootOfUnity(int n){
return new Complex(Math.cos(2 * Math.PI /n), Math.sin(2 * Math.PI /n));
}
}
-- Christo - 12 Dec 2003
Der Datentyp Matrize
package fft;
class Matrix {
Object[][] data;
Matrix(int rows, int cols) {
data = new Object[rows][cols];
}
void setValue(int row, int column, Object o) {
data[row][column] = o;
}
Object getValue(int row, int column) {
return data[row][column];
}
public String toString() {
String result = "";
for(int i = 0; i < 4; i++) {
result += "|";
for(int j = 0; j < 4; j++) {
result += " (" + data[i][j] + ")";
}
result += "|" + System.getProperty("line.separator");
}
return result;
}
}
-- Christo - 12 Dec 2003
Ein Datentyp für Körper
Matrixmultiplicationen sind nur auf dafür geeigneten Objekten möglich, bspw. auf den Elementen eines Körpers. Dazu definieren wir ein InterfaceEoField ("_element of field_"):
package fft;
/* Abstrakte Klasse Körper, die das Vorhandensein der Grundrechenarten fordert. */
interface EoField {
/* Diese Methoden lassen sich leider nicht static definieren */
public EoField add(EoField other);
public EoField multiply(EoField other);
}
RealNumber
Eine einfache Implementation dieses Interfaces kann so aussehen:
package fft;
class RealNumber implements EoField {
private double value;
public RealNumber(double value) {
this.value = value;
}
public EoField add(EoField other) {
return new RealNumber(value + ((RealNumber) other).value);
}
public EoField multiply(EoField other) {
return new RealNumber(value * ((RealNumber) other).value);
}
public String toString() {
return String.valueOf(value);
}
}
Anpassung von Complex
Damit Complex EoField implementiert, müssen folgende Anpassungen vorgenommen werden:
package fft;
class Complex implements EoField {
...
public EoField add(EoField other) {
return add(this, (Complex) other);
}
public EoField multiply(EoField other) {
return multiply(this, (Complex) other);
}
-- Christo - 12 Dec 2003
Matrixmultiplikation
Für die KlasseMatrix kann nun eine Multiplikation von Matrizen von EoField Objekten definiert werden:
/* a[nxp] * n[pxm] = c[nxm] */
public static Matrix multiply(Matrix left, Matrix right) {
int n = left.getRows();
int m = right.getColumns();
int p = left.getColumns();
Matrix result = new Matrix(n, m);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
// c[i][j] = a[i][0]*b[0][j] + a[i][1] * b[1][j] ...
EoField tmp = (((EoField) left.getValue(i, 0)).multiply((EoField) right.getValue(0, j)));
for (int k = 1; k < p; k++) {
tmp = tmp.add(((EoField) left.getValue(i, k)).multiply((EoField) right.getValue(k, j)));
}
result.setValue(i, j, tmp);
}
}
return result;
}
-- Christo - 12 Dec 2003
Edit | Attach | Print version | History: r1 | Backlinks | View wiki text | Edit wiki text | More topic actions
Copyright © by the contributing authors. All material on this collaboration platform is the property of the contributing authors. Ideas, requests, problems regarding GSI Wiki? Send feedback | Legal notice | Privacy Policy (german)