Posted: April 2nd, 2011 | Filed under: Programmieren, Tutorials | Tags: einrichten, Entwicklung, Java, slick, slick2D, Spiele, Tutorial | 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:
Posted: November 3rd, 2010 | Filed under: Programmieren | Tags: Beispiel, Checkbox, Example, JCheckBox, JList, List, ListCellRenderer, ListModel, toString(), Tutorial | 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:
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.
Posted: Januar 22nd, 2009 | Filed under: Programmieren, Tutorials | Tags: Bier, eigene Exception, Exception, Exception Beispiel, Java, Java Exception, Tutorial | 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 liter) throws 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 😉
Posted: Januar 2nd, 2009 | Filed under: Programmieren | Tags: Java, Java Dialog, Java DialogBox, Java MessageBox, Java PopUp, JOptionPane showMessageDialog, MessageBox Tutorial, showMessageDialog, Tutorial | 17 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 - mit Ausrufezeichen
MessageDialog - mit Fragezeichen
MessageDialog - mit Warnkreuz
Hier könnt ihr den Quellcode herunterladen.
Posted: Dezember 29th, 2008 | Filed under: Programmieren | Tags: Beispiel, Java, JFrame JMenuBar, JMenuBar, JMenuBar Beispiel, JMenuBar Example, JScrollPane, MenuBar, Menüleiste, Tutorial | 11 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)
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(400, 300);
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.
Ein Karlsruher Bloggt!
