kramann.info
© Guido Kramann

Login: Passwort:










Informatik3
1 Vom_struct_zur_Klasse
..1.1 Vom_struct_zur_Klasse
..1.2 struct_Programm
..1.3 Klassen_Programm
..1.4 Offene_Fragen
..1.5 Historie
..1.6 Objektabstraktion
..1.7 OO_Kundenverwaltung
..1.8 Objektfaehigkeiten
..1.9 Formatierung
..1.10 Motivation
..1.11 Uebung1
..1.12 Uebung2
2 UML
..2.1 Volumenberechnung
..2.2 UML_Klassendiagramm
..2.3 Konstruktor
..2.4 Statische_Variable
3 Strings
..3.1 Klassenbibliotheken
..3.2 stringUML
..3.3 Uebung3
4 Initialisierungen
4 bluej
5 Zeiger_und_Arrays
..5.1 Zeiger
..5.2 Zeiger_und_Funktion
..5.3 Uebung4
6 Vererbung
..6.1 MesswerteUML
..6.2 MesswerteProgramm
..6.3 VererbungsProgramm
..6.4 Vector
..6.5 Uebung
7 Modifikatoren
..7.1 public_Vererbung
..7.2 protected_Vererbung
8 Listen_und_Templates
..8.1 Containertypen
....8.1.1 ListeUML
....8.1.2 ListeProgramm
..8.2 Templates
....8.2.1 Listentemplate
....8.2.2 STLvectorTemplate
..8.3 Uebung5
..8.4 Uebung6
..8.5 Uebung7
9 Java
..9.1 Uebung
..9.2 GettingStarted
..9.3 Animation
..9.4 Hybrid
..9.5 Threads
10 Delegation
11 LayoutProjekt
12 Fenster
13 Uebung
14 Zwischenprojekt
..14.1 Befehle
..14.2 Planung
..14.3 JNI
..14.4 JNIumsetzen
..14.5 Anwendungsklasse
..14.6 GUI01
..14.7 GUI02
15 Rasterlayout
..15.1 Bilder_Packages
..15.2 interfaces
..15.3 ArrayList
..15.4 clone
..15.5 Uebung
16 Nuetzliches
..16.1 Threads
..16.2 Animation
..16.3 RungeKutta
..16.4 Loesungsansatz
..16.5 Internetprogrammierung
....16.5.1 Codegenerierung
....16.5.2 PHP_Programmierung
....16.5.3 PHP_OOP
....16.5.4 Java
17 Algorithmen
..17.1 RungeKutta
..17.2 Loesungsansatz
..17.3 Evoopt
..17.4 Uebung12
..17.5 Uebung8_2014
..17.6 Ausdruecke
18 Uebung10
19 UML_ALT
..19.1 Flaechenberechnung
..19.2 UML_Flaechenberechnung
..19.3 Implementierung
..19.4 ListeUML
..19.5 ListenImplementierung
..19.6 Anwendung

15.2 Entwicklung und Verwendung eigener Interfaces

15.2 Development and use of own interfaces (EN google-translate)

15.2 Rozwój i wykorzystanie własnych interfejsów (PL google-translate)

rl002_bauteile.zip - Zweite Entwicklungsstufe zu Rasterlayout.

Die einzelnen Bauteile sollen entgegen dem ursprünglichen Konzept durch einzelne Klassen repräsentiert werden.

The individual components are intended to go against the original concept individual classes are represented.

Poszczególne elementy mają być sprzeczne z oryginalną koncepcją poszczególne klasy są reprezentowane.

Die ersten Bauteile werden sein: Widerstand und Bruecke. Dabei stellt Bruecke nur eine Drahtbrücke dar.

The first components will be: resistance and bridge. Bruecke represents only a wire bridge.

Pierwszymi komponentami będą: opór i most. Bruecke reprezentuje tylko most druciany.

Die Grundidee dabei ist, dass alle diese Klassen eine Methode zeichnen(Graphics2D g2d) besitzen, der das Graphics2D-Objekt aus paint(..) von Rasterlayout übergeben wird und die sich dann selber in g2d einzeichnen, indem sie Methoden von g2d benutzen.

The basic idea is that all these classes draw a method (Graphics2D g2d) which passes the Graphics2D object out of paint (..) from raster layout and who then draw themselves in g2d using methods from g2d.

Podstawową ideą jest to, że wszystkie te klasy rysują metodę (Graphics2D g2d) która mija obiekt Graphics2D z farby (..) z układu rastrowego i którzy następnie narysują się w g2d używając metod z g2d.

Ein Codefragment könnte so aussehen:

A snippet might look like this:

Fragment może wyglądać tak:

    protected void zeichneBeschriftung(Graphics2D g2d, Color farbe,
                                       int xraster, int yraster)
    {
        g2d.setColor(farbe);
        g2d.setFont(Style.FONT_BESCHRIFTUNG);
        g2d.drawString(
                        beschriftung,
                        Style.XOFF_BESCHRIFTUNG + 
                        (int)Math.round( (double)xraster*Style.rastermass ),
                        Style.YOFF_BESCHRIFTUNG + 
                        (int)Math.round( (double)yraster*Style.rastermass  )                        
                    );
    }

Code 15.2-1: So kann ein Objekt "sich selber" zeichnen.

Interfaces (Schnittstellen)

Interfaces

Interfejsy

Später sollen alle sich selber zeichnenden Objekte in einer Container-Klasse vom Typ ArrayList abgelegt werden. Dies bietet den Vorteil, dass ein einer Schleife alle gesammelten Objekte durchgegangen und jeweils die Methode "zeichnen()" aufgerufen werden kann. Dies setzt voraus, dass alle diese Objekte die Methode zeichnen() besitzen und ArrayList das weiss. Dies kann gewährleistet werden, indem für alle Bauteil-Klassen eine gemeinsame Schnittstelle hier: "BauteilInterface" vereinbart wird.

Later, all self-drawing objects in a container class of Type ArrayList. This offers the advantage of being a one-lo can be called. This assumes that all these objects are the meth draw () and ArrayList knows this. This can be guarante by having a common interface for all component classes here: componentInterface is agreed.

Później wszystkie samoprzylepne obiekty w klasie kontenera Wpisz ArrayList. Daje to tę zaletę, że jest jedną pęt można nazwać. Zakłada się, że wszystkie te obiekty są meto draw () i ArrayList o tym wiedzą. To może być zagwarantowa dzięki wspólnemu interfejsowi dla wszystkich klas komponentów tutaj: componentInterface jest uzgodniony.

Damit ausserdem redundante Methoden und Attribute nicht in jedem Bauteilobjekt implementiert werden müssen, wird in die Vererbungshierarchie noch eine allgemeine Klasse Bauteil zwischengeschoben. In UML dargestellt, ergibt. Interfaces werden mit dem Zusatz <<interface >> dargestellt.

In addition, redundant methods and attributes are not included in every component object must be implemented in the inheritance hierarchy one more general class component interposed. Shown in UML, yields. Interfaces are with the additi

Ponadto nadmiarowe metody i atrybuty nie są uwzględniane w każdym obiekcie składowym muszą być jeszcze raz wdrożone w hierarchii dziedziczenia wstawiony komponent klasy ogólnej. Pokazane w UML, plony. Interfejsy są z dodatki

Abstrakte Methoden und Klassen

Abstract methods and classes

Streszczenie metod i zajęć

Abstrakte Methoden werden in UML kursiv dargestellt und in Java mit dem Schlüsselwort abstract versehen. Abtrakte Methode werden an der Stelle wo sie erscheinen nicht implementiert. D.h. nur der Methodenkopf erscheint dort. In einer erbenden, bzw. implementierenden Klasse müssen sie dann noch implementiert werden, damit sie aufgerufen werden können.

Abstract methods are shown in italics in UML and provided with the keyword abstract in Java. Abract methods are not implemented at the point where they appear. That only the method head appears ther In an inheriting or implementing class, they then have to be implemented, so that they can be called.

Metody abstrakcyjne są zaznaczone kursywą w języku UML i opatrzone słowem kluczowym abstract w języku Java. Metody Abrakt nie są wdrażane w miejscu, w którym się pojawiają. że pojawia się tam tylko głowa metod W klasie dziedziczącej lub implementującej muszą one zostać wdrożone, aby można było ich nazwać.

Klassen, die mindestens eine Methode abstrakte Methode besitzen sind so genannte abstrakte Klassen und müssen in Java dann auch mit diesem Zusatz im Kopf der Klasse ausgezeichnet werden, also public abstract class MeineKlasse.

Classes that have at least one method abstract method are so-called abstract classes and must be in Java then also with this addition in the head of the Class, ie public abstract class MeineKlasse.

Klasy, które mają co najmniej jedną metodę abstrakcyjną, są tzw Klasy abstrakcyjne i musi być w Javie, a następnie z tym dodatkiem w głowie Klasa, czyli publiczna klasa abstrakcyjna MeineKlasse.

In unserem Beispiel werden fast alle Methoden, die in BauteilInterface vereinbart werden bereits in der Klasse Bauteil implementiert. Jedoch die Methode zeichnen(..) wird erst in den von Bauteil erbenden Klassen implementiert, weil die Implementierung von zeichnen(..) stark von dem jeweils zu zeichnenden Bauteil abhängt.

In our example, almost all the methods that are agreed in BauteilInterface already implemented in the class component. However, the method will draw (. implemented only in the component inheriting classes because of the implementation of drawing (..) strongly depends on the component to be drawn.

W naszym przykładzie prawie wszystkie metody są uzgodnione w BauteilInterface już zaimplementowane w komponencie klasy. Jednak metoda będzie rysować (. implementowane tylko w komponencie dziedziczącym klasy z powodu implementacji rysunku (..) silnie zależy od rysowanego komponentu.

Dagegen sind setRotation(..) und setTranslation(..) für alle Bauteile gleich und werden deshalb in der gemeinsamen Oberklasse Bauteil schon implementiert.

In contrast, setRotation (..) and setTranslation (..) are the same for all components and are therefore already implemented in the common upper class component.

Natomiast setRotation (..) i setTranslation (..) są takie same dla wszystkich składników i są zatem już wdrożone we wspólnym elemencie klasy wyższej.

In UML ergibt sich deshalb folgende Implementierungs- bzw. Vererbungsstruktur: (Implementierung: Pfeil wie bei Vererbung, aber gestrichelt.)

UML therefore has the following implementation or inheritance structure: (Implementation: arrow as in inheritance, but dashed.)

UML ma zatem następującą implementację lub strukturę dziedziczenia: (Wdrażanie: strzałka jak w dziedziczeniu, ale przerywana.)

Vererbungs- bzw. Implementierungsstruktur der Bauteil-Klassen.

Bild 15.2-1: Vererbungs- bzw. Implementierungsstruktur der Bauteil-Klassen.

Im folgenden sind die entsprechenden Java-Implementierungen dargestellt.

The following shows the corresponding Java implementations.

Poniżej przedstawiono odpowiednie implementacje Java.

package bauteile;

import java.awt.Graphics2D;

public interface BauteilInterface
{
    public abstract void zeichnen(Graphics2D g2d);
    public abstract void setRotation(int rotation);
    public abstract void setTranslation(int xpos, int ypos);
}

Code 15.2-2: Quelltext zu BauteilInterface.java

package bauteile;

import java.awt.Graphics2D;
import java.awt.Color;

import konstanten.Style;

public abstract class Bauteil implements BauteilInterface
{
    protected String beschriftung = "";
    protected int xpos=0,ypos=0,rotation=0;

    //wird erst in den erbenden Klassen implementiert:
    public abstract void zeichnen(Graphics2D g2d); 

    public void setBeschriftung(String beschriftung)
    {
        this.beschriftung = beschriftung;
    }

    public void setRotation(int rotation)
    {
        this.rotation = rotation;
    }

    public void setTranslation(int xpos, int ypos)
    {
        this.xpos = xpos;
        this.ypos = ypos;
    }

    protected void setTransformation(Graphics2D g2d)
    {
         g2d.translate(Style.xoff + (int)Math.round( (double)xpos*Style.rastermass ),
                       Style.yoff + (int)Math.round( (double)ypos*Style.rastermass ));      
         g2d.rotate(0.5*Math.PI*(double)rotation);           
    }

    protected void unsetTransformation(Graphics2D g2d)
    {
         g2d.rotate(-0.5*Math.PI*(double)rotation);           
         g2d.translate(-Style.xoff - (int)Math.round( (double)xpos*Style.rastermass ),
                       -Style.yoff - (int)Math.round( (double)ypos*Style.rastermass ));      
    }

    protected void zeichnePad(Graphics2D g2d, Color farbe, int xraster, int yraster)
    {
        g2d.setColor(farbe);
        g2d.fillOval(
                        (int)Math.round( (double)xraster*Style.rastermass -0.5*Style.bohrung*Style.rastermass ),
                        (int)Math.round( (double)yraster*Style.rastermass -0.5*Style.bohrung*Style.rastermass ),                        
                        (int)Math.round( Style.bohrung*Style.rastermass ),
                        (int)Math.round( Style.bohrung*Style.rastermass )
                    );
    }

    protected void zeichneLinie(Graphics2D g2d, Color farbe, int xraster1, int yraster1,
                                                             int xraster2, int yraster2)
    {
        g2d.setColor(farbe);
        g2d.drawLine(
                        (int)Math.round( (double)xraster1*Style.rastermass ),
                        (int)Math.round( (double)yraster1*Style.rastermass ),                        
                        (int)Math.round( (double)xraster2*Style.rastermass ),
                        (int)Math.round( (double)yraster2*Style.rastermass )                        
                    );
    }

    protected void zeichneBox(Graphics2D g2d, Color farbe, int xraster1, int xraster2,
                                                           int yraster)
    {
        g2d.setColor(farbe);
        g2d.fillRect(
                        (int)Math.round( (double)xraster1*Style.rastermass ),
                        (int)Math.round( (double)yraster*Style.rastermass  -0.6*Style.rastermass),                        
                        (int)Math.round( (double)(xraster2-xraster1)*Style.rastermass ),                        
                        (int)Math.round( 1.2*Style.rastermass )
                    );

        g2d.setColor(Color.BLACK);
        g2d.drawRect(
                        (int)Math.round( (double)xraster1*Style.rastermass ),
                        (int)Math.round( (double)yraster*Style.rastermass  -0.6*Style.rastermass),                        
                        (int)Math.round( (double)(xraster2-xraster1)*Style.rastermass ),                        
                        (int)Math.round( 1.2*Style.rastermass )
                    );
    }


    protected void zeichneBeschriftung(Graphics2D g2d, Color farbe,
                                       int xraster, int yraster)
    {
        g2d.setColor(farbe);
        g2d.setFont(Style.FONT_BESCHRIFTUNG);
        g2d.drawString(
                        beschriftung,
                        Style.XOFF_BESCHRIFTUNG + 
                        (int)Math.round( (double)xraster*Style.rastermass ),
                        Style.YOFF_BESCHRIFTUNG + 
                        (int)Math.round( (double)yraster*Style.rastermass  )                        
                    );
    }

}

Code 15.2-3: Quelltext zu Bauteil.java

Die Methoden zeichnePad(..), zeichneLinie(..), zeichneBox(..) und zeichneBeschriftung(..) sind Hilfsmethoden, die von der Methode zeichnen(..) der erbenden Klassen aufgerufen werden (g2d wird hier weitergereicht), um gwisse Grundelemente, wie eine Linie zwischen zwei Rasterpunkten, eine Beschriftung usw. zu zeichnen.

The methods DrawPad (..), DrawLine (..), DrawBox (..) and drawLabel (..) are helper methods that are drawn by the method (..) of the inheriting classes (g2d is passed on here) to basic elements, such as draw a line between two grid points, a label, and so on.

Metody DrawPad (..), DrawLine (..), DrawBox (..) i drawLabel (..) są metodami pomocniczymi, które są rysowane metodą (...) dziedziczenia klas (g2d jest tutaj przekazywane) do podstawowych elementów, takich jak narysuj linię między dwoma punktami siatki, etykietą i tak dalej.

Bestimmte Konstanten sind in der Klasse Style als statische public-Attribute vermerkt, um sie in jeder Klasse leicht benutzen zu können und sie an zentraler Stelle anpassen zu können. So kann es ja leicht sein, dass der obere linke Rasterpunkt in einem anderen Rasterhintergrundbild etwas anders liegt und die Rasterabstände anders sind. Es wäre sehr Fehler anfällig, unübersichtlch und schwer zu merken, müßte man diese Parameter an verschiedenen Stellen im Programm bei Bedarf nachziehen. Statt dessen sind sie in konstanten.Style als xoff, yoff und rastermass neben weiteren Konstanten gespeichert.

Certain constants are in the class Style as static public attributes in order to use them easily in each class and to make them more central To be able to adjust the position. So it can be easy, that the upper left grid poi something different in another raster background image and the grid spacing are different. It would be very prone to error, unflattering a hard to remember, one would have to put these parameters at different places in the Tighten program if necessary. Instead they are in constant sty stored as xoff, yoff and raster measure next to other constants.

Niektóre stałe są w stylu klasowym jako statyczne atrybuty publiczne w celu łatwego ich użycia w każdej klasie i uczynienia ich bardziej centralnymi Aby móc dostosować pozycję. Więc może być łatwo, że górny lewy punkt siat coś innego w innym rastrowym obrazie tła i odstępach siatki są różne. Byłoby bardzo podatne na błędy, niepochlebne trudne do zapamiętania, należałoby umieścić te parametry w różnych miejscach w W razie potrzeby dokręć program. Zamiast tego są w stałym sty przechowywane jako xoff, yoff i raster mierzą obok innych stałych.

Durch die Vorarbeit, die im Interface BauteilInterface und in der Basisklasse Bauteil geleistet wurde, fällt nun die Implementierung von Widerstand kurz aus. Dies ist auch gut, da damit gerechnet werden muss, dass neben Widerstand eine Vielzahl weiterer Bauteile realisiert werden muss. Es wäre mühsam, wenn man sich in die elementaren Grundgrafikelemente, wie eine Linie zwischen zwei Rasterpunkten ziehen, jedesmal neu hineindenken müßte. So muss man lediglich sagen, wieviele Rasterpunkte z.B. eine Linie lang ist, bzw. um wieviele Rasterpunkte in x- und y-Richtung eine Beschriftung versetzt ist.

Through the preliminary work, in the interface component interface and in the base class component was done, the implementation of resistance is now short. This is also good, since it must be expected that in addition to resistance one Variety of other components must be realized. It would be cumbersome to look at elementary basic graphics such as draw a line between two halftone dots, each time re-thinking. So you just have to say how many halftone dots, e.g. a line is lon or by how many grid points in the x and y direction a label is offset.

Poprzez wstępne prace, w interfejsie komponentu interfejsu oraz w komponencie klasy bazowej zostało zrobione, wdrożenie oporu jest teraz krótkie. Jest to również dobre, ponieważ należy się spodziewać, że oprócz oporu jeden Musi być realizowana różnorodność innych komponentów. Byłoby kłopotliwe, gdyby spojrzeć na elementarną grafikę podstawową, taką jak narysuj linię pomiędzy dwiema półtonowymi kropkami, za każdym razem przemyślaną. Musisz tylko powiedzieć, ile punktów rastrowych, np. linia jest dług lub o ile punktów siatki w kierunku X i Y etykieta jest przesunięta.

Da zudem die Transformationen die hier möglich sind engumgrenzt sind, werden sie mit einfachen Integer-Parametern kodiert: xpos,ypos,rotation. Dabei ist bei xpos und ypos eine Einheit ein Schritt im Rastermass. Als Rotation sind die Werte 0,1,2 und 3 möglich, was Drehungen um 0, 90, 180 und 270 Grad entspricht.

In addition, since the transformations that are possible here are closely bounded, will be encode them with simple integer parameters: xpos, ypos, rotation. At xpos and ypos, a unit is a step in the grid. As rotation the values ​​0,1,2 and 3 are possible, which rotations around 0, 90, 180 and 270 degrees corresponds.

Ponadto, ponieważ transformacje, które są tutaj możliwe, są ściśle ograniczone, będą zakodować je za pomocą prostych parametrów całkowitych: xpos, ypos, rotacja. W xpos i ypos jednostka jest krokiem w siatce. Jako obrót możliwe są wartości 0,1,2 i 3, które obracają się wokół 0, 90, 180 i Odpowiada 270 stopni.

Mit den weiteren Hilfsmethoden setTransformation(..) und ansetTransformation(..) läßt sich die notwendige Transformation für das aktuelle Bauteil setzen, bzw. rückgängig machen, bevor das nächste Bauteil mit seiner eigenen Transformation (Lage auf dem Raster und Drehung) gezeichnet wird.

With the further auxiliary methods setTransformation (..) and ansetTransformation (..) can be the necessary transformation for the current component set, or undo, before the next component with his own transformation (position on the grid and rotation) is drawn.

Z dalszymi metodami pomocniczymi setTransformation (..) i ansetTransformation (..) może być konieczną transformacją dla bieżącego komponentu ustawić lub cofnąć przed następnym komponentem transformacja własna (pozycja na siatce i rotacja) jest narysowana.

package bauteile;

import java.awt.Graphics2D;
import java.awt.Color;
import java.awt.BasicStroke;

import konstanten.Style;



public class Widerstand extends Bauteil implements BauteilInterface
{
    public void zeichnen(Graphics2D g2d)
    {
        setTransformation(g2d);

         g2d.setStroke(new BasicStroke(
                                       2.0f,                  // Liniendicke
                                       BasicStroke.CAP_ROUND, // Form des Linienendes
                                       BasicStroke.JOIN_ROUND // Verbindung von Polygonlinien
                                      )   
                      ); 

        zeichnePad(g2d, Color.BLACK, 0, 0);
        zeichnePad(g2d, Color.BLACK, 4, 0);
        
        zeichneLinie(g2d, Color.BLACK, 0, 0, 1, 0);
        zeichneLinie(g2d, Color.BLACK, 3, 0, 4, 0);

        zeichneBox(g2d, Style.FARBE_BAUTEIL, 1, 3, 0);
        
        zeichneBeschriftung(g2d, Color.BLUE, 1, 0);

        unsetTransformation(g2d);
    }
}

Code 15.2-4: Quelltext Widerstand.java

In der paint-Methode von Rasterlayout können nun testweise Bauteile dargestellt werden, bzw. können sich selber zeichnen:

In the paint method of raster layout, test components can now be displayed or you can draw yourself:

W metodzie malowania układu rastrowego można teraz wyświetlać komponenty testowe lub możesz narysować siebie:

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.util.*;

import hilfsklassen.Bilder;

import bauteile.*;

public class Rasterlayout extends Canvas
{
     private Image rasterbild = null;

     private Widerstand r1,r2,r3;

     public Rasterlayout()
     {
         rasterbild = Bilder.holeBild("raster.png");

         JFrame frame = new JFrame();
         frame.setBounds(10,10,900,700);
         frame.getContentPane().add(this);
         frame.setVisible(true); 

         r1 = new Widerstand();
         r1.setTranslation(8,1);         
         r1.setRotation(0);         
         r1.setBeschriftung("100");

         r2 = new Widerstand();
         r2.setTranslation(16,1);         
         r2.setRotation(0);         

         r3 = new Widerstand();
         r3.setTranslation(16,1);         
         r3.setRotation(1);         
         r3.setBeschriftung("2k2");
     }

     public void paint(Graphics g)
     {         
         if(rasterbild!=null)
         {
             g.drawImage(rasterbild,0,0,Color.WHITE,this); 
         }

         Graphics2D g2d = (Graphics2D)g;

         r1.zeichnen(g2d);         
         r2.zeichnen(g2d);         
         r3.zeichnen(g2d);         
     }

     public static void main(String[] args)
     {
         Rasterlayout rasterlayout = new Rasterlayout();
     }
}

Code 15.2-5: Quelltext von Rasterlayout.java

Darstellung nach Start des Programms.

Bild 15.2-2: Darstellung nach Start des Programms.