Java Spieleentwicklung: Einstieg in Slick – Tutorial

Posted: April 2nd, 2011 | Filed under: Programmieren, Tutorials | Tags: , , , , , , | 5 Comments »

Seit einiger Zeit befasse ich mich mit der Java 2D Spiele-Engine Slick (Danke an Tobse). Deswegen habe ich mir gedacht wieso nicht ein Tutorial schreiben. Heraus gekommen ist ein Dokument welches beschreibt wie man Slick einrichtet, wie mein sein erstes Projekt erstellt und wie man ein erstes Spiel entwickelt. Als Beispiel-Spiel habe ich mich für einen Pong-Klon entschieden.

Hier geht’s zum Slick Tutorial:

image


Java Checkbox in JList

Posted: November 3rd, 2010 | Filed under: Programmieren | Tags: , , , , , , , , , | 7 Comments »

Für mein neustes Programm jCalFilter, welches Einträge in einem Kalender im ICS-Format filtern kann, habe ich eine JList gebraucht in der ich Termine auswählen kann. Dafür eignete sich am Besten eine JList die JCheckboxes beinhaltet. Mit diesem kleinen Tutorial möchte ich euch zeugen wie ihr das realisieren könnt.

Das fertige Programm soll so aussehen:

image

Als Datenkapsel verwende ich ein Objekt Person welches lediglich die Informationen Vorname, Name und Alter abspeichert. Des weiteren bietet die Klasse Person noch eine toString()-Methode. In dieser wird der Text zurückgegeben der jeweils in der Liste angezeigt werden soll.

Person.java

public class Person {

  private String name;
  private String vorname;
  private int alter;
 
  public Person(String name, String vorname, int alter){
    this.name = name;
    this.vorname = vorname;
    this.alter = alter;
  }
 
  public String getName() {
    return name;
  }
  public void setName(String name) {
    this.name = name;
  }
  public String getVorname() {
    return vorname;
  }
  public void setVorname(String vorname) {
    this.vorname = vorname;
  }
  public int getAlter() {
    return alter;
  }
  public void setAlter(int alter) {
    this.alter = alter;
  }
 
  @Override
  public String toString() {
    return vorname + " " + name + " (" + alter + ")";
  }
}

 

Nun kommen wir zum eigentlichen Kern der Implementierung. Die Klasse JCheckBoxList erbt einfach von JList. Diese beinhaltet einen ListCellRenderer in dem Formatierungen verändert werden können. Zusätzlich bietet die Klasse JCheckBoxList eine Methode selectAll() und deselectAll() an, um eben alle Häkchen zu setzten oder um die Auswahl aller Häkchen zu entfernen.

JCheckBoxList.java

import java.awt.Component;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;

import javax.swing.JCheckBox;
import javax.swing.JList;
import javax.swing.ListCellRenderer;
import javax.swing.ListSelectionModel;
import javax.swing.UIManager;

public class JCheckBoxList extends JList {

  public JCheckBoxList() {
    setCellRenderer(new CellRenderer());
    addMouseListener(new MouseAdapter() {
      public void mousePressed(MouseEvent e) {
        int index = locationToIndex(e.getPoint());
        if (index != -1) {
          JCheckBox checkbox = (JCheckBox) getModel().getElementAt(
              index);
          checkbox.setSelected(!checkbox.isSelected());
          repaint();
        }
      }
    });
    setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
  }

  protected class CellRenderer implements ListCellRenderer {
    public Component getListCellRendererComponent(JList list, Object value,
        int index, boolean isSelected, boolean cellHasFocus) {
      JCheckBox checkbox = (JCheckBox) value;

      if (isSelected) {
        // checkbox.setBorderPainted(true);
        // checkbox.setForeground(UIManager.getColor("List.selectionForeground"));
        // checkbox.setBackground(UIManager.getColor("List.selectionBackground"));
      } else {
        // checkbox.setBorderPainted(false);
        // checkbox.setForeground(UIManager.getColor("List.foreground"));
        checkbox.setBackground(UIManager.getColor("List.background"));
      }
      return checkbox;
    }
  }

  public void selectAll() {
    int size = this.getModel().getSize();
    for (int i = 0; i < size; i++) {
      JCheckBox checkbox = (JCheckboxWithObject) this.getModel()
          .getElementAt(i);
      checkbox.setSelected(true);
    }
    this.repaint();
  }

  public void deselectAll() {
    int size = this.getModel().getSize();
    for (int i = 0; i < size; i++) {
      JCheckBox checkbox = (JCheckboxWithObject) this.getModel()
          .getElementAt(i);
      checkbox.setSelected(false);
    }
    this.repaint();
  }
}

 

Um die Verbindung zwischen einer Person und der Checkbox herzustellen habe ich das Objekt JCheckboxWithObject erstellt. Diese Klasse erbt von JCheckBox aber beinhaltet zusätzlich noch ein Objekt vom Typ Object in dem man irgendein Objekt ablegen kann. In unserem Fall ein Objekt vom Typ Person. Die Checkbox wird, im Konstruktor und der Setter-Methode, nun mit dem Rückgabestring der toString()-Methode des jeweiligen Objektes(Person) beschriftet.

JCheckboxWithObject.java

import javax.swing.JCheckBox;

public class JCheckboxWithObject extends JCheckBox{
 
  private Object object;
 
  public JCheckboxWithObject (Object object){
    this.object = object;
    this.setText(object.toString());
  }
 
  public Object getObject() {
    return object;
  }

  public void setObject(Object object) {
    this.object = object;
    this.setText(object.toString());
  }
}

 

Nun kann die Datenstruktur wie folgt angewendet werden. Das Ergebnis seht ihr ja oben.

Main.java

import javax.swing.DefaultListModel;
import javax.swing.JFrame;
import javax.swing.SwingUtilities;
import javax.swing.UIManager;

public class Main {

  {
    // Set Look & Feel
    try {
      UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
    } catch (Exception e) {
      e.printStackTrace();
    }
  }

  public static void main(String[] args) {
    SwingUtilities.invokeLater(new Runnable() {
      public void run() {
        // Fenster
        JFrame frame = new JFrame();

        // Checkboxliste
        DefaultListModel personenListModel = new DefaultListModel();
        JCheckBoxList list = new JCheckBoxList();
        list.setModel(personenListModel);

        // Daten hinzufügen
        Person hans = new Person("Wurst", "Hans", 24);
        Person peter = new Person("Müller", "Peter", 36);
        Person klaus = new Person("Wagner", "Klaus", 29);
        JCheckboxWithObject hansCheckbox = new JCheckboxWithObject(hans);
        JCheckboxWithObject peterCheckbox = new JCheckboxWithObject(
            peter);
        JCheckboxWithObject klausCheckbox = new JCheckboxWithObject(
            klaus);

        personenListModel.addElement(hansCheckbox);
        personenListModel.addElement(peterCheckbox);
        personenListModel.addElement(klausCheckbox);

        frame.getContentPane().add(list);
        frame.setVisible(true);
        frame.setTitle("JCheckbox in JList");
        frame.setSize(200, 200);
      }
    });
  }
}

Download

Hier könnt ihr euch denn ganzen Quellcode herunterladen.


Java Exceptions Beispiel & Tutorial / Bier trinken

Posted: Januar 22nd, 2009 | Filed under: Programmieren, Tutorials | Tags: , , , , , , | No Comments »

Da Exceptions ein unverzichtbares Thema bezüglich Fehlererkennung und Fehlerbehandlung in Java ist zeige ich euch heute ein kleine und lustige Beispiel-Applikation.

Die Mannschaft eines Fussballvereins betritt nach dem Training die hauseigene Vereinskneipe. Alle sind in Feierstimmung und bestellen sich reichlich Bier :D. Der Wirt schenkt fleißig aus und den Fussballern schmeckts. Doch Plötzlich trifft ein schreckliges Ereignis ein. Das 10 Liter Bierfass ist leer. 🙁

Was das ganze jetzt mit Java zu tun hat? Im Prinzip nichteinmal so wenig. Desswegen habe ich diesen Anwendungsfall auch genommen um euch Java Exceptions zu veranschaulichen.

Beim Ausführen eines Java-Programms können Fehler auftreten, die zum Übersetzungszeitpunkt des Quelltextes nicht absehbar waren. Solche Fehler werden „Laufzeitfehler“ genannt. Tritt ein Laufzeitfehler auf, liegt eine Ausnahmesituation vor, es wird daher eine Ausnahme (Exception) ausgelöst (entweder durch die Java-Laufzeitumgebung oder durch eine entsprechende Codierung des Programmieres). Exceptions sind durch eine Klassenhierarchie in Java abgebildet.

Zuerst erstellen wir uns eine Klasse Bier die durch die Methode trinken den Biervorrat (double vorratInLiter) je nach Menge dezimiert. Reicht der Vorrat jedoch nicht aus soll eine Fehlermeldung, also eine Exception, geworfen werden. Anfangs sollen 5 Liter Bier im Fass vorhanden sein.

Zusätzlich erstellen wir uns eine eigene Exception Klasse mit dem Namen BierProbleme. Diese Exception Klasse erzeugt lediglich die Fehlermeldung „Bier ist leer! Bitte neues Kaufen!!! Rothaus schmeckt am Besten!„.

Desswegen müssen wir nun wenn wir die Methode „trinken“ aufrufen eine eventuell auftretende Fehlermeldung durch eine Try Catch Block abfangen.

Hier der Quellcode des Programmes. Ich habe versucht es so einfach wie möglich zu halten. 😀

Bier.java

package Kneipe;

public class Bier {
     
     double vorratInLiter = 5;     
     
     public Bier(){

     }
     
     public void trinken(double literthrows BierProbleme{
          if (vorratInLiter >= liter){
               // Alles Prima, Bier wird getrunken und vom Vorrat abgezogen
               vorratInLiter = vorratInLiter - liter;
               System.out.println("Es wurden " + liter + " getrunken.");
               System.out.println("Neuer Vorrat: " + vorratInLiter);
          }else{
               // Biervorrat reicht nicht mehr aus, Fehlermeldung wird geworfen
               throw new BierProbleme();
          }
     }
     
     public static void main(String[] args) {
          Bier bier = new Bier();
          try {
               // Fussballmannschaft betritt die Kneipe und trinkt bier
               bier.trinken(0.33);
               bier.trinken(0.5);
               bier.trinken(0.5);
               bier.trinken(0.5);
               bier.trinken(0.33);
               bier.trinken(0.2);
               bier.trinken(1);
               bier.trinken(0.5);
               bier.trinken(0.5);
               bier.trinken(0.33);
               bier.trinken(0.33);
               bier.trinken(0.2);          
               
          
          // Fehler wird abgefangen
          catch (BierProbleme e) {
               e.printStackTrace();
               // Es wird neues Bier nachgekauft! (10 Liter)
               bier.vorratInLiter = bier.vorratInLiter + 10;
               System.out.println();
               System.out.println("Es wurde Bier eingekauft! Neuer Vorrat: " + bier.vorratInLiter + " Liter.");
          }
     }
}

BierProbleme.java

package Kneipe;

public class BierProbleme extends Exception{
     public BierProbleme() {
          super("Bier ist leer! Bitte neues Kaufen!!! Rothaus schmeckt am Besten!");
     }
}

Viel Spaß beim trinken 😉


Java MessageDialog / Messagebox

Posted: Januar 2nd, 2009 | Filed under: Programmieren | Tags: , , , , , , , , | 5 Comments »

Wenn man Grafische Benutzer Oberflächen kurz GUIs in Java realisieren braucht man oft sogenannte MessageBoxen, Popupfenster oder um in der Java Sprache zu bleiben MessageDialoge. Diese können durch eine einfache Zeile umgesetzt werden.  Der MessageDialog kann in 5 verschiedenen Arten mit Hilfe der Klasse JOptionPane dargestellt werden.

  • ohne Icon (JOptionPane.PLAIN_MESSAGE)
  • mit Ausrufezeichen (JOptionPane.CANCEL_OPTION)
  • mit Fragezeichen (JOptionPane.QUESTION_MESSAGE)
  • mit Warnkreuz (JOptionPane.ERROR_MESSAGE)
  • mit Infozeichen (JOptionPane.INFORMATION_MESSAGE)
import javax.swing.JOptionPane;

public class MessageDialog {
     public static void main(String[] args) {
          JOptionPane.showMessageDialog(null,"Kein Icon","Titel", JOptionPane.PLAIN_MESSAGE);
          JOptionPane.showMessageDialog(null,"Infozeichen","Titel", JOptionPane.INFORMATION_MESSAGE);
          JOptionPane.showMessageDialog(null,"Fragezeichen","Titel", JOptionPane.QUESTION_MESSAGE);
          JOptionPane.showMessageDialog(null,"Ausrufezeichen","Titel", JOptionPane.CANCEL_OPTION);
          JOptionPane.showMessageDialog(null,"Kreiz","Titel", JOptionPane.ERROR_MESSAGE);
     }
}
MessageDialog - Ohne Icon

MessageDialog - Ohne Icon

MessageDialog - mit Ausrufezeichen

MessageDialog - mit Ausrufezeichen

MessageDialog - mit Fragezeichen

MessageDialog - mit Fragezeichen

MessageDialog - mit Warnkreuz

MessageDialog - mit Warnkreuz

Hier könnt ihr den Quellcode herunterladen.


Java JMenuBar Beispiel / Tutorial

Posted: Dezember 29th, 2008 | Filed under: Programmieren | Tags: , , , , , , , , , | 10 Comments »

Hallo Leute, heute wollte ich euch zeigen wie man eine Menüleiste in Java realisiert.
Dazu erstellen wir ein JFrame und fügen diesem eine JMenuBar hinzu. Die JMenuBar gibt das Rahmenwerk für das jeweilige JMenu. Ein JMenu repräsentiert ein Navigationspunkt. Um Menüunterpunkte zu erzeugen fügen wir unserem JMenu ein JMenuItem hinzu. So einfach geht’s.

JMenuBar -> JMenu (z.B.: Hilfe) -> JMenuItem (z.B.: Über)

JMenuBarBeispiel Screenshot

Am Besten ihr schaut euch den folgenden Quellcode an.

import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;

public class JMenuBarBeispiel implements ActionListener {
     
     JFrame applikation;
     Container container;
     
     // Menüleiste
     JMenuBar menueLeiste;
     
     // Menüleiste Elemente
     JMenu datei;
     JMenu hilfe;
     
     // Datei
     JMenuItem oeffnen;
     JMenuItem beenden;
     
     // Hilfe
     JMenuItem faq;
     JMenuItem about;

     // Textfeld
     JTextArea textarea;
     
     public JMenuBarBeispiel() {
          applikation = new JFrame("JMenuBar Beispiel");
          container = applikation.getContentPane();
          
          // Menüleiste erzeugen
          menueLeiste = new JMenuBar();
          
          // Menüelemente erzeugen
          datei = new JMenu("Datei");
          hilfe = new JMenu("Hilfe");
          
          // Untermenüelemente erzeugen
          oeffnen = new JMenuItem("öffnen");
          oeffnen.addActionListener(this);
          beenden = new JMenuItem("beenden");
          beenden.addActionListener(this);
          faq = new JMenuItem("F.A.Q.");
          faq.addActionListener(this);
          about = new JMenuItem("Über");
          about.addActionListener(this);
          
          // Menüelemente hinzufügen
          menueLeiste.add(datei);
          menueLeiste.add(hilfe);
          
          // Untermenüelemente hinzufügen
          datei.add(oeffnen);
          datei.add(beenden);
          hilfe.add(faq);
          hilfe.add(about);

          // Textfeld erzeugen
          textarea = new JTextArea();          
          
          applikation.add(menueLeiste, BorderLayout.NORTH);
          applikation.add(new JScrollPane(textarea), BorderLayout.CENTER);

          applikation.setSize(400300);
          applikation.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
          applikation.setVisible(true);
     }
     
     public void actionPerformed(ActionEvent object) {
          if (object.getSource() == oeffnen){
               System.out.println("öffnen wurde angeklickt");
          }
          if (object.getSource() == beenden){
               System.out.println("beenden wurde angeklickt");
          }
          if (object.getSource() == faq){
               System.out.println("faq wurde angeklickt");
          }
          if (object.getSource() == about){
               System.out.println("über wurde angeklickt");
          }
     }
     
     public static void main(String[] args) {
          new JMenuBarBeispiel();
     }
}

Hier könnt ihr den Quellcode als Textdatei herunterladen.
Viel Spaß beim weiteren Programmieren. Ihr könnt mein Programm natürlich auch gerne als Vorlage verwenden.