You are here: GSI Wiki>Java Web>DiaShow4 (2003-12-12, christo)EditAttach
Start presentation

Slide 1: 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:

  • jar Archive können signiert werden (siehe AppletSecurity).
  • In der Konfigurationsdatei META_INF/MANIFEST.MF können zusätzliche Informationen abgelegt werden, z. B. den Namen der Klasse, die die main Methode enthält. Eine so gepackte Applikation kann dann einfach mittels java -jar Archiv.jar gestartet werden.

-- ChristopherHuhn - 02 Dec 2003

Slide 2: 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.

Applets können jedoch mit dem Tool 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 appletviewer wertet die Datei ~/.java.policy aus, 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:

-- ChristopherHuhn - 01 Dec 2003

Slide 3: 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));
        }
        
}

-- ChristopherHuhn - 12 Dec 2003

Slide 4: 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;
        }
}

-- ChristopherHuhn - 12 Dec 2003

Slide 5: 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 Interface EoField ("_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);
        
}

Slide 6: 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);
        }
}

Slide 7: 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);
        }

-- ChristopherHuhn - 12 Dec 2003

Slide 8: Matrixmultiplikation

Für die Klasse Matrix 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;
}

-- ChristopherHuhn - 12 Dec 2003

-- ChristopherHuhn - 12 Dec 2003
Topic revision: r1 - 2003-12-12, christo
 
This site is powered by FoswikiCopyright © 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
Imprint (in German)
Privacy Policy (in German)