Add mehr Übungen

CheckstyleConfig2.xml

@@ -0,0 +1,55 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE module PUBLIC "-//Puppy Crawl//DTD Check Configuration 1.3//EN" "http://www.puppycrawl.com/dtds/configuration_1_3.dtd">
+
+<!--
+    This configuration file was written by the eclipse-cs plugin configuration editor
+-->
+<!--
+    Checkstyle-Configuration: ASB-Konventionen
+    Description: none
+-->
+<module name="Checker">
+  <module name="TreeWalker">
+    <module name="ConstantName"/>
+    <module name="LocalFinalVariableName"/>
+    <module name="LocalVariableName"/>
+    <module name="MemberName"/>
+    <module name="MethodName"/>
+    <module name="PackageName">
+      <property name="format" value="^[a-z0-9]+(\.[a-zA-Z0-9_][a-zA-Z0-9_]*)*$"/>
+    </module>
+    <module name="ParameterName"/>
+    <module name="StaticVariableName"/>
+    <module name="TypeName"/>
+    <module name="AvoidNestedBlocks">
+      <property name="allowInSwitchCase" value="true"/>
+    </module>
+    <module name="LeftCurly">
+      <property name="option" value="eol"/>
+    </module>
+    <module name="RightCurly">
+      <property name="option" value="same"/>
+    </module>
+    <module name="HiddenField">
+      <property name="ignoreConstructorParameter" value="true"/>
+      <property name="ignoreSetter" value="true"/>
+    </module>
+    <module name="InnerAssignment"/>
+    <module name="MissingSwitchDefault"/>
+    <module name="SimplifyBooleanExpression"/>
+    <module name="SimplifyBooleanReturn"/>
+    <module name="StringLiteralEquality"/>
+    <module name="VisibilityModifier">
+      <property name="protectedAllowed" value="true"/>
+    </module>
+    <module name="Indentation"/>
+    <module name="NeedBraces"/>
+  </module>
+  <module name="FileTabCharacter">
+    <property name="eachLine" value="true"/>
+  </module>
+  <module name="RegexpMultiline">
+    <property name="format"  value="System\s*.\s*exit\s*\(\s*[-|+]?\s*\d+\s*\)\s*;"/>
+    <property name="message" value="Die Verwendung von System.exit ist nicht gestattet."/>
+</module>
+</module>

bin/gui/counter/zipper.jardesc

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="WINDOWS-1252" standalone="no"?>
+<jardesc>
+    <jar path="C:/Users/Alex/Desktop/FH Übungen/Benutzeroberflächen/Abgabeübungen/Beispiel.zip"/>
+    <options buildIfNeeded="true" compress="true" descriptionLocation="/Graphische_Benutzeroberflächen/src/gui/counter/zipper.jardesc" exportErrors="true" exportWarnings="true" includeDirectoryEntries="false" overwrite="false" saveDescription="true" storeRefactorings="false" useSourceFolders="false"/>
+    <storedRefactorings deprecationInfo="true" structuralOnly="false"/>
+    <selectedProjects/>
+    <selectedElements exportClassFiles="false" exportJavaFiles="true" exportOutputFolder="false">
+        <file path="/Graphische_Benutzeroberflächen/checkstyle.properties"/>
+        <javaElement handleIdentifier="=Graphische_Benutzeroberflächen/src"/>
+    </selectedElements>
+</jardesc>

checkstyle.properties

@@ -0,0 +1,2 @@
+LeftCurly=nlow
+RightCurly=same

src/Main/CommandoZentrale.java

@@ -0,0 +1,56 @@
+package Main;
+
+import java.awt.SystemColor;
+
+import org.newdawn.slick.AppGameContainer;
+import org.newdawn.slick.BasicGame;
+import org.newdawn.slick.GameContainer;
+import org.newdawn.slick.Graphics;
+import org.newdawn.slick.SlickException;
+
+public class CommandoZentrale extends BasicGame {
+
+	public CommandoZentrale(String title) {
+		super(title);
+		// TODO Auto-generated constructor stub
+	}
+
+	@Override
+	public void render(GameContainer container, Graphics g)
+			throws SlickException {
+		// TODO Auto-generated method stub
+		g.setDrawMode(org.newdawn.slick.Graphics.MODE_ALPHA_MAP);
+		
+	}
+
+	@Override
+	public void init(GameContainer container) throws SlickException {
+		// TODO Auto-generated method stub
+
+	}
+
+	@Override
+	public void update(GameContainer container, int delta)
+			throws SlickException {
+		// TODO Auto-generated method stub
+
+	}
+
+	public static void main(String[] args) throws SlickException {
+		// TODO Auto-generated method stub
+       
+            final AppGameContainer app = new AppGameContainer(new CommandoZentrale("DesktopHumunculus"));
+            app.setDisplayMode(app.getScreenWidth(), app.getScreenHeight(), true);// 
+            app.setTargetFrameRate(60);// Flüssige FPS von 60
+            app.setVSync(true);// VSinc um Renderprobleme bei schneller
+                               // Objektbewegung zu verhindern
+            //app.getTime();
+            //app.hasFocus();
+           
+            app.setShowFPS(true);
+            app.start();
+      
+           
+        
+	}
+}

src/gui/center/CenterFrame.java

@@ -0,0 +1,125 @@
+package gui.center;
+
+import java.awt.Frame;
+import java.awt.Toolkit;
+import java.awt.event.WindowEvent;
+import java.awt.event.WindowListener;
+
+import javax.swing.JFrame;
+
+public class CenterFrame extends JFrame implements WindowListener
+{
+
+    public CenterFrame()
+    {
+        super("CenterFrame");
+        this.setVisible(true);
+        // this.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
+    }
+
+    public void setIntoCenter()
+    {
+        this.setLocation(Toolkit.getDefaultToolkit().getScreenSize().width / 2, Toolkit.getDefaultToolkit().getScreenSize().height / 2);
+
+        System.out.println("Bildschirmdimensionen: " + Toolkit.getDefaultToolkit().getScreenSize().height + " x " + Toolkit.getDefaultToolkit().getScreenSize().width);
+
+    }
+
+    public static void setAllIntoCenter()
+    {
+        /*
+         * ablauf vorzähler perfekt um über datenstrukturen drüber zu laufen
+         * for(Frame currentFrame : Frame.getFrames()) { if(currentFrame
+         * instanceof CenterFrame) {
+         * ((CenterFrame)currentFrame).setIntoCenter(); } }
+         */
+
+        final Frame[] a = Frame.getFrames();
+        for (int i = 0; i < Frame.getFrames().length; i++)
+        {
+            if (a[i] instanceof CenterFrame)
+            {
+                ((CenterFrame) a[i]).setIntoCenter();
+            }
+        }
+
+    }
+
+    public static void setAllVisible(final boolean visibility)
+    {
+        // TODO Auto-generated method stub
+
+        for (final Frame currentFrame : Frame.getFrames())
+        {
+            if (currentFrame instanceof CenterFrame)
+            {
+                ((CenterFrame) currentFrame).setVisible(visibility);
+            }
+        }
+
+    }
+
+    public static void main(final String args[])
+    {
+        final CenterFrame cf1 = new CenterFrame();
+        cf1.setTitle("cf1");
+        cf1.addWindowListener(cf1);
+
+        final CenterFrame cf2 = new CenterFrame();
+        cf2.setTitle("cf2");
+        cf2.addWindowListener(cf2);
+
+        new ControlFrame();
+
+    }
+
+    @Override
+    public void windowActivated(final WindowEvent e)
+    {
+        // TODO Auto-generated method stub
+        System.out.println("Activated " + this.getTitle());
+    }
+
+    @Override
+    public void windowClosed(final WindowEvent e)
+    {
+        // TODO Auto-generated method stub
+        System.out.println("Closed " + this.getTitle());
+    }
+
+    @Override
+    public void windowClosing(final WindowEvent e)
+    {
+        // TODO Auto-generated method stub
+        System.out.println("Closing " + this.getTitle());
+    }
+
+    @Override
+    public void windowDeactivated(final WindowEvent e)
+    {
+        // TODO Auto-generated method stub
+        System.out.println("Deactivated " + this.getTitle());
+    }
+
+    @Override
+    public void windowDeiconified(final WindowEvent e)
+    {
+        // TODO Auto-generated method stub
+        System.out.println("Deiconified " + this.getTitle());
+    }
+
+    @Override
+    public void windowIconified(final WindowEvent e)
+    {
+        // TODO Auto-generated method stub
+        System.out.println("Iconified " + this.getTitle());
+    }
+
+    @Override
+    public void windowOpened(final WindowEvent e)
+    {
+        // TODO Auto-generated method stub
+        System.out.println("Opened " + this.getTitle());
+    }
+
+}

src/gui/center/ControlFrame.java

@@ -0,0 +1,75 @@
+package gui.center;
+
+import java.awt.GridLayout;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+import javax.swing.JButton;
+import javax.swing.JFrame;
+
+public class ControlFrame extends JFrame
+{
+
+    ControlFrame()
+    {
+        super("ControlFrame");
+        this.setLayout(new GridLayout(3, 0));
+        this.setVisible(true);
+        final JButton centerButton = new JButton("Zentrieren");
+        centerButton.setName("control");
+        this.add(centerButton);
+        final JButton hideButton = new JButton("Verstecken");
+        hideButton.setName("hide");
+        this.add(hideButton);
+        final JButton showButton = new JButton("Zeigen");
+        showButton.setName("show");
+        this.add(showButton);
+
+        final Listener klick = new Listener();
+        final HideListener hider = new HideListener();
+        final ShowListener shower = new ShowListener();
+
+        centerButton.addActionListener(klick);
+        hideButton.addActionListener(hider);
+        showButton.addActionListener(shower);
+        this.pack();
+
+    }
+
+    class Listener implements ActionListener
+    {
+
+        @Override
+        public void actionPerformed(final ActionEvent e)
+        {
+            // TODO Auto-generated method stub
+            CenterFrame.setAllIntoCenter();
+        }
+
+    }
+
+    class HideListener implements ActionListener
+    {
+
+        @Override
+        public void actionPerformed(final ActionEvent e)
+        {
+            // TODO Auto-generated method stub
+            CenterFrame.setAllVisible(false);
+        }
+
+    }
+
+    class ShowListener implements ActionListener
+    {
+
+        @Override
+        public void actionPerformed(final ActionEvent e)
+        {
+            // TODO Auto-generated method stub
+            CenterFrame.setAllVisible(true);
+        }
+
+    }
+
+}

src/gui/counter/Decrementer.java

@@ -0,0 +1,6 @@
+package gui.counter;
+
+public class Decrementer 
+{
+
+}

src/gui/counter/Incrementer.java

@@ -0,0 +1,6 @@
+package gui.counter;
+
+public class Incrementer
+{
+
+}

src/gui/counter/zipper.jardesc

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="WINDOWS-1252" standalone="no"?>
+<jardesc>
+    <jar path="C:/Users/Alex/Desktop/FH Übungen/Benutzeroberflächen/Abgabeübungen/Beispiel.zip"/>
+    <options buildIfNeeded="true" compress="true" descriptionLocation="/Graphische_Benutzeroberflächen/src/gui/counter/zipper.jardesc" exportErrors="true" exportWarnings="true" includeDirectoryEntries="false" overwrite="false" saveDescription="true" storeRefactorings="false" useSourceFolders="false"/>
+    <storedRefactorings deprecationInfo="true" structuralOnly="false"/>
+    <selectedProjects/>
+    <selectedElements exportClassFiles="false" exportJavaFiles="true" exportOutputFolder="false">
+        <file path="/Graphische_Benutzeroberflächen/checkstyle.properties"/>
+        <javaElement handleIdentifier="=Graphische_Benutzeroberflächen/src"/>
+    </selectedElements>
+</jardesc>

src/gui/dialog/Dialogtest.java

@@ -0,0 +1,47 @@
+package gui.dialog;
+
+import java.awt.GridLayout;
+
+import javax.swing.JButton;
+import javax.swing.JFrame;
+
+public class Dialogtest extends JFrame
+{
+    Dialogtest()
+    {
+
+        final JFrame frame = new JFrame();
+        frame.setLayout(new GridLayout(4, 0));
+
+        final JButton diaModAb = new JButton();
+        diaModAb.setText("Dialog: Modal und JFrame Abhängig!");
+        frame.add(diaModAb);
+
+        final JButton diaNModAb = new JButton();
+        diaNModAb.setText("Dialog: Nicht Modal und JFrame Abhängig!");
+        frame.add(diaNModAb);
+
+        final JButton diaModNab = new JButton();
+        diaModNab.setText("Dialog: Modal und nicht JFrame Abhängig!");
+        frame.add(diaModNab);
+
+        final JButton diaNModNab = new JButton();
+        diaNModNab.setText("Dialog: Nicht Modal und Nicht JFrame Abhängig!");
+        frame.add(diaNModNab);
+
+        // *Sollte JDialog als JFrame ersatz dienen, da ähnliche methoden
+        // beinhaltet?
+        frame.pack();
+        frame.setVisible(true);
+    }
+
+    /**
+     * @param args
+     */
+    public static void main(final String[] args)
+    {
+        // TODO Auto-generated method stub
+        new Dialogtest();
+    }
+
+}

src/gui/measuring/AlarmListener.java

@@ -0,0 +1,25 @@
+package gui.measuring;
+
+public class AlarmListener implements MeasuringListener
+{
+    private double unterGrenze;
+
+    private double oberGrenze;
+
+    public AlarmListener(double unterGrenze, double oberGrenze)
+    {
+
+        unterGrenze = this.unterGrenze;
+        oberGrenze = this.oberGrenze;
+    }
+
+    @Override
+    public void valueMeasured(final double value, final int iD)
+    {
+        // TODO Auto-generated method stub
+        if ((value > this.oberGrenze) || (value < this.unterGrenze))
+        {
+            System.out.println("Warnung: Messgerät " + iD + " Messwert ist außerhalb des Intervalls!");
+        }
+    }
+}

src/gui/measuring/Main.java

@@ -0,0 +1,24 @@
+package gui.measuring;
+
+public class Main
+{
+
+    /**
+     * @param args
+     */
+    public static void main(final String[] args)
+    {
+        // TODO Auto-generated method stub
+        final AlarmListener alarm1 = new AlarmListener(0, 20.0);
+        final AlarmListener alarm2 = new AlarmListener(10.0, 30.0);
+        final MeasuringCenter center = new MeasuringCenter();
+
+        center.addMeasuringListener(alarm1);
+        center.addMeasuringListener(alarm2);
+
+        final MeasuringDevice device1 = new MeasuringDevice(center, 1);
+        device1.measure(13.5);
+
+    }
+
+}

src/gui/measuring/MeasuringCenter.java

@@ -0,0 +1,27 @@
+package gui.measuring;
+
+import java.util.ArrayList;
+
+public class MeasuringCenter
+{
+
+    private ArrayList<MeasuringListener> listenerList = new ArrayList<MeasuringListener>();
+
+    public MeasuringCenter()
+    {
+
+    }
+
+    public void addMeasuringListener(final MeasuringListener listener)
+    {
+        this.listenerList.add(listener);
+    }
+
+    public void reportMeasuredValues(final double messWert, final int deviceId)
+    {
+        for (final MeasuringListener i : this.listenerList)
+        {
+            i.valueMeasured(messWert, deviceId);
+        }
+    }
+}

src/gui/measuring/MeasuringDevice.java

@@ -0,0 +1,19 @@
+package gui.measuring;
+
+public class MeasuringDevice
+{
+    private MeasuringCenter mc;
+
+    private int deviceId;
+
+    MeasuringDevice(final MeasuringCenter ms, final int deviceId)
+    {
+        this.mc = ms;
+        this.deviceId = deviceId;
+    }
+
+    public void measure(final double wert)
+    {
+        this.mc.reportMeasuredValues(wert, this.deviceId);
+    }
+}

src/gui/measuring/MeasuringListener.java

@@ -0,0 +1,8 @@
+package gui.measuring;
+
+public interface MeasuringListener
+{
+
+    public void valueMeasured(double value, int newValue);
+
+}

src/gui/plusminus/MinusHandler.java

@@ -0,0 +1,28 @@
+package gui.plusminus;
+
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+
+
+public class MinusHandler implements ActionListener
+{
+    private PlusMinus pM;
+    
+    MinusHandler(PlusMinus pM)
+    {
+        this.pM = pM;
+    }
+        
+    
+
+    @Override
+    public void actionPerformed(ActionEvent e)
+    {
+            // TODO Auto-generated method stub
+        pM.decrement();
+    }
+}
+    
+    
+

src/gui/plusminus/PlusHandler.java

@@ -0,0 +1,25 @@
+package gui.plusminus;
+
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+
+
+public class PlusHandler implements ActionListener
+{
+    private PlusMinus pM;
+    
+    PlusHandler(PlusMinus pM)
+    {
+        this.pM = pM;
+    }
+    
+    
+    @Override
+    public void actionPerformed(ActionEvent e)
+    {
+            // TODO Auto-generated method stub
+        pM.increment();
+    }
+    
+}

src/gui/plusminus/PlusMinus.java

@@ -0,0 +1,101 @@
+package gui.plusminus;
+
+import java.awt.GridLayout;
+
+import javax.swing.ImageIcon;
+import javax.swing.JButton;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+
+public class PlusMinus extends JFrame
+{
+
+    private ImageIcon icon = new ImageIcon("src/gui/plusminus/icon.jpg");
+
+    /*
+     * URL plusIconURL = IconPluMinusURLs.class.getResource("icons/up.png) Icon
+     * plusIcon = new ImageIcon(plusIconURL);
+     */
+
+    private JLabel label = new JLabel();
+
+    private int min, max, positiverWert, value;
+
+    private JButton minus = new JButton("-", this.icon);
+
+    private JButton plus = new JButton("+", this.icon);
+
+    public PlusMinus(final int min, final int max, final int positiverWert)
+    {
+        super("PlusMinus");
+
+        this.min = min;
+        this.max = max;
+        this.positiverWert = positiverWert;
+        this.value = min;
+
+        this.setLayout(new GridLayout(3, 0));
+
+        this.plus.setName("plus");
+        this.plus.setToolTipText("Erhöhen der Zahl");
+        this.add(this.plus);
+        this.plus.addActionListener(new PlusHandler(this));
+
+        this.label.setName("label");
+        this.label.setText("" + this.value);
+        this.add(this.label);
+
+        this.minus.setName("minus");
+        this.minus.setToolTipText("Verringern der Zahl");
+        this.add(this.minus);
+        this.minus.addActionListener(new MinusHandler(this));
+
+        this.checkButtons();
+        this.pack();
+        this.setVisible(true);
+
+    }
+
+    public void checkButtons()
+    {
+        if ((this.value + this.positiverWert) > this.max)
+        {
+            this.plus.setEnabled(false);
+        }
+        else
+        {
+            this.plus.setEnabled(true);
+        }
+
+        if ((this.value - this.positiverWert) < this.min)
+        {
+            this.minus.setEnabled(false);
+        }
+        else
+        {
+            this.minus.setEnabled(true);
+        }
+    }
+
+    public void decrement()
+    {
+        // TODO Auto-generated method stub
+        this.value = this.value - this.positiverWert;
+        this.checkButtons();
+        this.label.setText("" + this.value);
+    }
+
+    public void increment()
+    {
+        this.value = this.value + this.positiverWert;
+        this.checkButtons();
+        this.label.setText("" + this.value);
+    }
+
+    public static void main(final String[] args)
+    {
+        // TODO Auto-generated method stub
+        new PlusMinus(-10, 10, 1);
+
+    }
+}

src/package1/Patient.java

@@ -0,0 +1,71 @@
+package package1;
+
+public class Patient
+{
+    private String name;
+
+    private int alter;
+
+    private Patient vorgaenger = null;
+
+    static private int folgeNummer = 1;
+
+    private int warteNummer;
+
+    Patient(final String name, final int alter)
+    {
+        this.name = name;
+        this.alter = alter;
+        this.warteNummer = Patient.folgeNummer;
+        Patient.folgeNummer++;
+
+    }
+
+    Patient(final String name, final int alter, final Patient vorgaenger)
+    {
+        this.name = name;
+        this.alter = alter;
+        this.warteNummer = Patient.folgeNummer;
+        Patient.folgeNummer++;
+    }
+
+    public boolean istErster()
+    {
+        if (this.vorgaenger == null)
+        {
+            return true;
+        }
+        else
+        {
+            return false;
+        }
+    }
+
+    public int altersDifferenz(final Patient t)
+    {
+        if (this.alter > t.alter)
+        {
+            return this.alter - t.alter;
+        }
+        else
+        {
+            return t.alter - this.alter;
+            // return static int Math.abs(this.alter-t.alter);
+        }
+    }
+
+    @Override
+    public String toString()
+    {
+        String s = new String("name: " + this.name + " warteNr: " + this.warteNummer + "\n ");
+
+        if (this.vorgaenger != null)
+        {
+            s += new String(" Vorgaenger: ");
+            s += this.vorgaenger.toString();
+        }
+        return s;
+
+    }
+
+}

src/uebungen1/DemoKlasse.java

@@ -0,0 +1,47 @@
+package uebungen1;
+
+public class DemoKlasse
+{
+
+    private int wert;
+
+    DemoKlasse()
+    {
+        this.wert = 0;
+    }
+
+    public int getWert()
+    {
+        return this.wert;
+    }
+
+    public void setWert(final int wert)
+    {
+        this.wert = wert;
+    }
+
+    public DemoKlasse addieren(final DemoKlasse obj)
+    {
+        final DemoKlasse neuesObjekt = new DemoKlasse();
+
+        neuesObjekt.wert = this.wert + obj.wert;
+        return neuesObjekt;
+    }
+
+    /**
+     * @param args
+     */
+    public static void main(final String[] args)
+    {
+        // TODO Auto-generated method stub
+        DemoKlasse a1 = new DemoKlasse();
+        final DemoKlasse a2 = new DemoKlasse();
+
+        a1.setWert(5);
+        a2.setWert(6);
+
+        a1 = a1.addieren(a2);
+        System.out.println("" + a1.getWert());
+
+    }
+}

src/uebungen1/Gruppe.java

@@ -0,0 +1,32 @@
+package uebungen1;
+
+import java.util.ArrayList;
+
+class Gruppe 
+{
+
+
+    public Gruppe() 
+    {
+        ArrayList<Mensch> mensch;
+    }
+    void addGruppenmitglied (Mensch member) 
+    {
+        
+    }
+}
+
+interface Mensch 
+{
+    
+}
+
+class Mann implements Mensch 
+{
+    
+}
+
+class Frau implements Mensch 
+{
+    
+}

src/uebungen1/binarstellen.java

@@ -0,0 +1,42 @@
+package uebungen1;
+
+import utilities.TastaturEingabe;
+
+public class binarstellen
+{
+
+    /**
+     * @param args
+     */
+
+    public static void main(final String[] args)
+    {
+        // TODO Auto-generated method stub
+        int n;
+
+        for (int i = 0; i <= 10; i++)
+        {
+            n = TastaturEingabe.readInt("Geben Sie die nächste Zahl ein: ");
+
+            if (n == 6)
+            {
+                break;
+            }
+
+            if ((n % 3) == 0)
+            {
+                continue;
+            }
+
+            if (n < 8)
+            {
+                System.out.println("" + (n * n));
+            }
+            else
+            {
+                System.out.println("" + n);
+            }
+        }
+    }
+
+}

src/uebungen7/GeomObjekt.java

@@ -0,0 +1,29 @@
+package uebungen7;
+
+public abstract class GeomObjekt
+{
+
+    protected int x, y;
+
+    GeomObjekt()
+    {
+        this.x = 0;
+        this.y = 0;
+    }
+
+    /**
+     * @param args
+     */
+
+    public void print()
+    {
+
+    }
+
+    public static void main(final String[] args)
+    {
+        // TODO Auto-generated method stub
+
+    }
+
+}

src/uebungen7/Kreis.java

@@ -0,0 +1,23 @@
+package uebungen7;
+
+public class Kreis extends GeomObjekt
+{
+
+    private int d;
+
+    public Kreis()
+    {
+        // TODO Auto-generated constructor stub
+        this.d = 0;
+    }
+
+    /**
+     * @param args
+     */
+    @Override
+    public void print()
+    {
+        System.out.println("Kreis");
+    }
+
+}

src/uebungen7/Rechteck.java

@@ -0,0 +1,18 @@
+package uebungen7;
+
+public class Rechteck extends GeomObjekt
+{
+    private int l, b;
+
+    Rechteck()
+    {
+        this.l = 0;
+        this.b = 0;
+    }
+
+    @Override
+    public void print()
+    {
+        System.out.println("Rechteck");
+    }
+}

src/utilities/Datum.java

@@ -0,0 +1,80 @@
+package utilities;
+
+import java.util.GregorianCalendar;
+
+public class Datum
+{
+   private int tag, monat, jahr;
+
+   // aktuelles Datum (d.h., heute) erzeugen
+   public Datum()
+   {
+      GregorianCalendar gc = new GregorianCalendar();
+      tag = gc.get(GregorianCalendar.DAY_OF_MONTH);
+      // In der Klasse GregorianCalendar werden die Monate von 0 bis 11
+      // durchnummeriert; daher muessen wir den Wert 1 addieren.
+      monat = gc.get(GregorianCalendar.MONTH) + 1;
+      jahr = gc.get(GregorianCalendar.YEAR);
+   }
+
+   public Datum(int t, int m, int j)
+   {
+      tag = t;
+      monat = m;
+      jahr = j;
+   }
+
+   public String toString()
+   {
+      return tag + "." + monat + "." + jahr;
+   }
+
+   public boolean equals(Object obj)
+   {
+      if (obj instanceof Datum)
+      {
+         Datum d = (Datum)obj;
+
+         return jahr == d.jahr
+             && monat == d.monat
+             && tag == d.tag;
+      }
+      else
+         return false;
+   }
+
+   public boolean frueherAls(Datum d)
+   {
+      if(jahr < d.jahr)
+         return true;
+      if(jahr == d.jahr)
+      {
+         if(monat < d.monat)
+            return true;
+         if(monat == d.monat)
+            return tag < d.tag;
+      }
+      return false;
+   }
+
+   public boolean vor(Datum d)
+   {
+      return frueherAls(d);
+   }
+
+   public boolean nach(Datum d)
+   {
+      return !vor(d) && !equals(d);
+   }
+
+
+   public static void main(String[] args)
+   {
+      Datum d = new Datum();
+      System.out.println(d);
+      Datum e = new Datum(6, 4, 2002);
+      System.out.println(e);
+      System.out.println(d.vor(e));
+      System.out.println(d.nach(e));
+   }
+}

src/utilities/FormatierteAusgabe.java

@@ -0,0 +1,154 @@
+package utilities;
+
+/**
+ * Klasse zur formatierten Ausgabe einfacher Datentypen
+ */
+
+public class FormatierteAusgabe
+{
+   private static int zehn_hoch(int potenz)
+   {  int erg=1;
+      for (int i=0;i<potenz;i++)
+         erg=10*erg;
+      return erg;
+   }
+
+/**
+*  Formatierte Ausgabe ganzer Zahlen.
+*  Es wird ausser der auszugebenden Zahl auch die Ausgabebreite
+*  angegeben.
+*  Die Zahl wird rechtsbündig in der angegebenen Breite ausgegeben.
+*  Bei negativen Zahlen kommt das Minuszeichen unmittelbar vor
+*  der ersten Ziffer.
+*  Ist die Zahl zu groß, wird sie unformatiert ausgegeben,
+*  eingeleitet durch "|"
+*  @param zahl auszugebende Zahl
+*  @param breite Ausgabebreite (Anzahl auszugebender Zeichen)
+*  @param fuell Füllzeichen
+*/
+   public static String format(int zahl,int breite,char fuell)
+   {  boolean neg=false;
+      String erg="";
+      int lbreite=breite;
+      if (zahl<0)
+      {  neg=true;
+         zahl=-zahl;
+         lbreite--;
+      }
+      if (zahl>=zehn_hoch(lbreite))
+      {  erg="|"+zahl;
+         return erg;
+      }
+      for (int i=lbreite-1;i>0;i--)
+         if (zahl<zehn_hoch(i))
+            erg+=fuell; //System.out.print(" ");
+         else
+            break;
+      if (neg)
+         erg+="-";
+      return erg+zahl;
+   }
+
+/**
+*  Formatierte Ausgabe ganzer long-Zahlen.
+*  Es wird ausser der auszugebenden Zahl auch die Ausgabebreite
+*  angegeben.
+*  Die Zahl wird rechtsbündig in der angegebenen Breite ausgegeben.
+*  Bei negativen Zahlen kommt das Minuszeichen unmittelbar vor
+*  der ersten Ziffer.
+*  Ist die Zahl zu groß, wird sie unformatiert ausgegeben,
+*  eingeleitet durch "|"
+*  @param zahl auszugebende Zahl
+*  @param breite Ausgabebreite (Anzahl auszugebender Zeichen)
+*  @param fuell Füllzeichen
+*/
+   public static String format(long zahl,int breite,char fuell)
+   {  boolean neg=false;
+      String erg="";
+      int lbreite=breite;
+      if (zahl<0)
+      {  neg=true;
+         zahl=-zahl;
+         lbreite--;
+      }
+      if (zahl>=zehn_hoch(lbreite))
+      {  erg="|"+zahl;
+         return erg;
+      }
+      for (int i=lbreite-1;i>0;i--)
+         if (zahl<zehn_hoch(i))
+            erg+=fuell;
+         else
+            break;
+      if (neg)
+         erg+="-";
+      return erg+zahl;
+   }
+
+/**
+*  Formatierte Ausgabe ganzer int-Zahlen.
+*  Es wird außer der auszugebenden Zahl auch die Ausgabebreite
+*  angegeben.
+*  Die Zahl wird rechtsbündig in der angegebenen Breite ausgegeben.
+*  Bei negativen Zahlen kommt das Minuszeichen unmittelbar vor
+*  der ersten Ziffer.
+*  Ist die Zahl zu groß, wird sie unformatiert ausgegeben,
+*  eingeleitet durch "|"
+*  @param zahl auszugebende Zahl
+*  @param breite Ausgabebreite (Anzahl auszugebender Zeichen)
+*/
+   public static void ausgabeInt(int zahl,int breite)
+   {  System.out.print(format(zahl,breite,' ')); }
+
+/**
+*  Formatierte Ausgabe eines Strings.
+*  Es wird ausser dem auszugebenden String auch die Ausgabebreite
+*  angegeben.
+*  Der String wird rechtsbündig ausgegeben und links mit einem
+*  angebbaren Zeichen aufgefüllt.
+*  @param s auszugebender String
+*  @param breite Ausgabebreite (Anzahl auszugebender Zeichen)
+*  @param fuell Füllzeichen
+*/
+   public static String format(String s,int breite,char fuell)
+   {  int lg=s.length(),i;
+      String erg=new String();
+      if (s.length()>breite)
+         return s.substring(s.length()-breite);
+      for (i=0;i<breite-lg;i++)
+         erg+=fuell;
+      erg+=s;
+      return erg;
+   }
+
+
+
+   final static long EINS = 1L;
+
+   /**
+   *  gibt eine long-Zahl als Binärzahl aus.
+   *  nach jeweils 4 Bitstellen wird ein Zwischenraum ausgegeben;
+   *  die Anzahl der ausgegebenen Bit ist angebbar
+   *  @param zahl auszugebende long-Zahl
+   *  @param breite Stellenanzahl für Binärzahl
+   */
+   public static void binaer(long zahl, int breite)
+   {
+      for (int i = breite-1; i>=0; i--)
+      {  if ((zahl & (EINS<<i)) != 0)   //  Bitstelle berechnen
+            System.out.print('1');
+         else
+            System.out.print('0');
+         if (i%4 == 0)
+            System.out.print(' ');      // Zwischenraum
+      }
+      System.out.flush();
+   }
+
+   public static void binaerAusgabe(long zahl, int breite)
+   {
+      binaer(zahl, breite);
+   }
+
+
+}

src/utilities/TastaturEingabe.java

@@ -0,0 +1,203 @@
+package utilities;
+
+import java.io.*;
+
+public class TastaturEingabe
+{
+   static BufferedReader eing =
+      new BufferedReader(new InputStreamReader (System.in));
+
+   public static double readDouble (String prompt)
+   {
+      while (true)
+      {
+         System.out.print(prompt);
+         try
+         {
+            String zeile = eing.readLine();
+            return Double.parseDouble(zeile);
+         }
+         catch (NumberFormatException e)
+         {
+            System.out.println ("Bitte eine Zahl eingeben (ggf. mit Dezimalpunkt).");
+         }
+         catch (IOException e)
+         {
+            e.printStackTrace();
+            System.exit(1);
+         }
+      }
+   }
+
+   public static int readInt (String prompt)
+   {
+      while (true)
+      {
+         System.out.print(prompt);
+         try
+         {
+            String zeile = eing.readLine();
+            return Integer.parseInt(zeile);
+         }
+         catch (NumberFormatException e)
+         {
+            System.out.println ("Bitte eine ganze Zahl eingeben.");
+         }
+         catch (IOException e)
+         {
+            e.printStackTrace();
+            System.exit(1);
+         }
+      }
+   }
+
+   public static long readLong (String prompt)
+   {
+      while (true)
+      {
+         System.out.print(prompt);
+         try
+         {
+            String zeile = eing.readLine();
+            return Long.parseLong(zeile);
+         }
+         catch (NumberFormatException e)
+         {
+            System.out.println ("Bitte eine ganze Zahl eingeben.");
+         }
+         catch (IOException e)
+         {
+            e.printStackTrace();
+            System.exit(1);
+         }
+      }
+   }
+
+   public static boolean readBoolean (String prompt)
+   {
+      while (true)
+      {
+         System.out.print(prompt);
+         try
+         {
+            String e = eing.readLine();
+            if (e.equals("j") || e.equals("J"))
+               return true;
+            if (e.equals("n") || e.equals("N"))
+               return false;
+            throw new IllegalArgumentException();
+         }
+         catch (IllegalArgumentException e)
+         {
+            System.out.println ("Bitte J oder N eingeben.");
+         }
+         catch (IOException e)
+         {
+            e.printStackTrace();
+            System.exit(1);
+         }
+      }
+   }
+
+   public static String readString (String prompt)
+   {
+      while (true)
+      {
+         System.out.print(prompt);
+         try
+         {
+            return eing.readLine();
+         }
+         catch (IOException e)
+         {
+            e.printStackTrace();
+            System.exit(1);
+         }
+      }
+   }
+
+   public static char readChar (String prompt)
+   {
+      while (true)
+      {
+         System.out.print(prompt);
+         try
+         {
+            String s = eing.readLine();
+            if (s.length() == 0)
+               throw new IllegalArgumentException();
+            return s.charAt(0);
+         }
+         catch (IllegalArgumentException e)
+         {
+            System.out.println ("Bitte ein Zeichen eingeben.");
+         }
+         catch (IOException e)
+         {
+            e.printStackTrace();
+            System.exit(1);
+         }
+      }
+   }
+
+
+   /**
+    *  wartet auf <Return>
+    *  @param b true: Meldung "Weiter ..." wird ausgegeben
+    */
+   public static void warte(boolean b)
+   {
+      String s;
+      if (b)
+      {
+         System.out.print("....... Weiter mit <Return>");
+         System.out.flush();
+      }
+      s = readString("");
+   }
+
+   /**
+    *  wartet auf <Return>
+    *  Meldung "....... Weiter mit <Return>" wird immer ausgegeben
+    */
+   public static void warte()
+   {
+      warte(true);
+   }
+
+   public static Datum readDatum (String prompt)
+   {
+      while (true)
+      {
+         System.out.print(prompt);
+         try
+         {
+            String zeile = eing.readLine();
+            if (zeile.length()!=10) throw new NumberFormatException();
+            int tag = Integer.parseInt(zeile.substring(0,2));
+            char trenn = zeile.charAt(2);
+            if (trenn!='.' & trenn!='/') throw new NumberFormatException();
+            int monat = Integer.parseInt(zeile.substring(3,5));
+            trenn = zeile.charAt(5);
+            if (trenn!='.' & trenn!='/') throw new NumberFormatException();
+            int jahr = Integer.parseInt(zeile.substring(6,10));
+            Datum einDatum = new Datum (tag, monat, jahr);
+            return einDatum;
+         }
+         catch (NumberFormatException e)
+         {
+            System.out.println ("Bitte eine Datum in der Form tt.mm.jjjj eingeben.");
+         }
+         catch (IllegalArgumentException e)
+         {
+            System.out.println ("Fehler in Datum: " + e.getMessage());
+         }
+         catch (IOException e)
+         {
+            e.printStackTrace();
+            System.exit(1);
+         }
+      }
+   }
+
+}

src/utilities/Uhrzeit.java

@@ -0,0 +1,139 @@
+package utilities;
+
+class Uhrzeit implements Comparable
+{
+   private int std;      // 0 bis 23
+   private int min, sek; // 0 bis 59
+   private int zone;     // Zeitzone in Werten von -11 bis +12
+
+   private static int stdNormal;
+   private static int minNormal;
+
+   static void setzeNormalzeit (int std, int min)
+   {
+      stdNormal = std;
+      minNormal = min;
+   }
+
+   Uhrzeit ()
+   {
+      std = stdNormal;
+      min = minNormal;
+      // weitere Angaben nicht nötig (Standardvorbelegung)
+   }
+
+   Uhrzeit (int std, int min)
+   {
+      setzeStdMin (std, min);
+   }
+
+   Uhrzeit (int std, int min, int sek)
+   {
+      setzeUhrzeit (std, min, sek);
+   }
+
+   Uhrzeit (int std, int min, int sek, int zone)
+   {
+      setzeUhrzeit (std, min, sek, zone);
+   }
+
+   private void setzeStdMin (int std, int min)
+   {
+      if (min<0)
+         throw new IllegalArgumentException
+                   ("Minuten müssen >= 0 sein.");
+      else
+         while (min>=60)
+            min = min - 60;
+      this.min = min;
+      if (std<0)
+         throw new IllegalArgumentException
+                   ("Stunden müssen >= 0 sein.");
+      else
+         while (std>=24)
+            std = std - 24;
+      this.std = std;
+   }
+
+   void setzeUhrzeit (int std, int min)
+   {
+      setzeStdMin (std, min);
+      this.sek = 0;
+   }
+
+   void setzeUhrzeit (int std, int min, int sek)
+   {
+      setzeStdMin (std, min);
+      if (sek<0 | sek>59)
+         throw new IllegalArgumentException
+            ("Sekunden müssen zwischen 0 und 59 liegen.");
+      this.sek = sek;
+      zone = 1;
+   }
+
+   void setzeUhrzeit (int std, int min, int sek, int zone)
+   {
+      setzeStdMin (std, min);
+      if (sek<0 | sek>59)
+         throw new IllegalArgumentException
+            ("Sekunden müssen zwischen 0 und 59 liegen.");
+      this.sek = sek;
+      if (zone<-11 | zone>12)
+         throw new IllegalArgumentException
+            ("Zeitzone muss zwischen -11 und +12 liegen.");
+      this.zone = zone;
+   }
+
+   String differenz(Uhrzeit bis)
+   {
+      int dStd = bis.std + bis.zone - std - zone;
+      int dMin = bis.min - min;
+      if (dMin < 0)
+      {
+         dMin = dMin + 60;
+         dStd--;
+      }
+      int dSek = bis.sek - sek;
+      if (dSek < 0)
+      {
+         dSek = dSek + 60;
+         dMin--;
+      }
+      return dStd + " Std " + dMin + " Min " + dSek + " Sek";
+   }
+
+   public String toString ()
+   {
+      String zeit = ((std<10)?"0"+std:""+std) + ":";
+      zeit = zeit + ((min<10)?"0"+min:""+min) + ":";
+      zeit = zeit + ((sek<10)?"0"+sek:""+sek) + " GMT";
+      zeit = zeit + ((zone<0)?"-":"+") + Math.abs(zone);
+      return zeit;
+   }
+
+   public boolean equals(Object einObject)
+   {
+      Uhrzeit eineZeit = (Uhrzeit)einObject;
+      return this.std - this.zone == eineZeit.std - eineZeit.zone
+           & this.min == eineZeit.min;
+   }
+
+   public int compareTo(Object einObject)
+   {
+      Uhrzeit z = (Uhrzeit)einObject;
+      return
+         (((this.std-this.zone)*60)+this.min)*60+this.sek
+        -((((z.std-z.zone)*60)+z.min)*60+z.sek);
+   }
+
+   int gibStunde ()
+   {
+      return std;
+   }
+
+   int gibMinute()
+   {
+      return min;
+   }
+
+}

src/Übungen/Aufgaben.java

@@ -0,0 +1,48 @@
+package Übungen;
+
+import java.io.IOException;
+
+public class Aufgaben {
+
+	/**
+	 * @param args
+	 * @throws IOException 
+	 */
+	public static void main(String[] args) throws IOException {
+		// TODO Auto-generated method stub
+		int n , complexity;
+		
+		n = System.in.read();
+		int count=0;
+		for (int i=0; i < n; i++)
+			for (int j=0; j < n; j++)
+			count++;
+		
+		//complexity = count;
+		System.out.println("Count: "+count);
+		count=0;		
+		for (int i=n; i > 0; i--)
+			for (int j=i; j < n; j++)
+			count++;
+		
+		System.out.println("Count: "+count);
+		count=0;
+		
+		for (int i=1; i <= n/2; i++)
+			for (int j=1; j < n * n; j++)
+			count++;
+		
+		System.out.println("Count: "+count);
+		count=0;
+		int i = n;
+		do
+		{ count++;
+		i= i/3;
+		}
+		while (i > 0);
+		
+		System.out.println("Count: "+count);
+		
+	}
+
+}