Nachdem ich lange vergeblich auf der Suche nach einem Assembler Syntax Highlighter war, habe ich mich entschieden, einen Java Highlighter für diese Zwecke zu “missbrauchen”.

Zunächst werden der Quellcode für das modifizierte JEditorPane und die Library JSoup benötigt.

Die entsprechenden Keywords stehen in der Hashmap des Konstruktors und können beliebig angepasst, vermehrt und gelöscht werden.

assemblerKeywords.put("mov", DEFAULT_KEYWORD);
assemblerKeywords.put("inc", DEFAULT_KEYWORD);
assemblerKeywords.put("lcall", DEFAULT_KEYWORD);

Um dieses modifizierte JEditorPane schließlich auf einen Frame zu packen, kann man sich das Pane mit der Methode getEditPane() holen.

JEditorPane codebox = (JEditorPane) new Syntax().getEditPane();

Das Casten ist notwendig, da die Methode das Pane zunächst nur als JComponent zurück gibt. Es gibt bestimmt bequemere und vor allem sauberere Lösungen, aber einen Syntax Highlighter selbst zu schreiben, überfordert mich als Java-Anfänger dann doch ein wenig ;)

Eine interessante Möglichkeit, um diese lästigen if-else-Klammern ein bisschen zu reduzieren, ist der ternäre Operator. Die allgemeine Form ist: x = BOOL_TEST ? TRUE_FALL : FALSE_FALL

Beispiel:

max = (a > b) ? a : b;

Die ursprüngliche Form mit if-else:

if (a > b) {
	max = a;
}
else {
	max = b;
}

Wenn man einfach mal Lust hat, etwas Kleines zu programmieren, nimmt man gerne einen alten Klassiker. Ich habe mich für Hangman (“Galgenmännchen”) entschieden. Diese Version ist sehr minimalistisch gehalten. Vielleicht füge ich demnächst noch eine GUI hinzu.

Eine Liste mit über 5000 Wörtern, passend für das Spiel:

View.java

public class View {

	public View(){
		Core core = new Core();
		core.newRound();	 
	}
	
	public static void main(String args[]) {
		new View();
	}
}

Core.java

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
 
public class Core {
 
	private List<Word> words = new ArrayList<>();
	private Word round;
	 
	public Core() {
		loadWordList();
	}
	 
	public void loadWordList() {
		String line = "";
		try {
			File file = new File(this.getClass().getClassLoader()
			.getResource("words.txt").getFile());
			@SuppressWarnings("resource")
			BufferedReader in = new BufferedReader(new FileReader(file));
			while ((line = in.readLine()) != null) {
				words.add(new Word(line));
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	 
	public void newRound() {
		round = words.get(new Random().nextInt(words.size()));
		while (!round.checkIfFinished()) {
			System.out.println(String.valueOf(round.getToSolve()));
			round.guessChar(readChar());
			if (round.getGuessCounter()>8) {
				break;
			}
			try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		if (round.checkIfFinished()) {
			System.out.println("Gewonnen!");
		} else {
			System.out.println("Verloren!");
			System.out.println("Das gesuchte Wort lautete: " + String.valueOf(round.getWord()));
		}
	}
	 
	public char readChar() {
		BufferedReader read = new BufferedReader(new InputStreamReader(
		System.in));
		String input = new String();
		try {
			input = read.readLine();
		} catch (java.io.IOException e) {
			System.out.println(e);
		}
		char back = input.charAt(0);
		return back;
	}
}

Word.java

public class Word {
 
	private char[] word;
	private int size;
	private int guessCounter = 0;
	 
	private char[] toSolve;
	 
	public Word(String word) {
		this.word = word.toUpperCase().toCharArray();
		size = this.word.length;
		toSolve = new char[size];
		for (int i = 0; i < toSolve.length; i++) {
			toSolve[i] = '_';
		}
	}
	 
	public char[] getWord() {
		return word;
	}
	 
	public int getSize() {
		return size;
	}
	 
	public char[] getToSolve() {
		return toSolve;
	}
	 
	public int getGuessCounter() {
		return guessCounter;
	}
	 
	public boolean guessChar(char c){
		boolean guess = false;
		c = Character.toUpperCase(c);
		for (int i=0; i<word.length; i++) {
			if (c==word[i]) {
				toSolve[i] = c;
				guess = true;
			}
		}
		if (guess) {
			System.out.println("Der Buchstabe " + c + " war dabei!");
		} else {
			guessCounter++;
			System.out.println("Der Buchstabe " + c + " war nicht dabei!");
		}
		return guess;
	}
	 
	public boolean checkIfFinished(){
		boolean finished = true;
		for (int i = 0; i < toSolve.length; i++) {
			if (toSolve[i]== '_') {
				finished = false;
			}
		}
		return finished;
	} 
}

Der Zahlenrechner ist ein kleines Programm, dass ich nach 3 Monaten Einarbeitung in Java schreiben wollte, es aber nie fertiggestellt habe. Es kann Zahlen zwischen den Systemen 2 bis 32 in jeweils ein anderes umrechnen. Heute habe ich mich endlich an die Fertigstellung gemacht und veröffentliche hier den Quellcode.

Model.java

public class Model {
 
	final char[] ziffern = { '0', '1', '2', '3', '4', '5', '6', '7',
	'8', '9', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k',
	'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x',
	'y', 'z' };
	 
	public int zuDezimal(String eingabe, int system) {
		char[] zahl = eingabe.toLowerCase().toCharArray();
		int ergebnis = 0;
		int counter = 0;
		for (int i = zahl.length - 1; i >= 0; i--) {
			ergebnis += (int) (holeZahlenWert(zahl[i]) * Math.pow(system, counter));
			counter++;
		}
		return ergebnis;
	}
	 
	public int holeZahlenWert(char ziffer) {
		for (int i = 0; i < ziffern.length; i++) {
			if (ziffer==ziffern[i]) {
				return i;
			}		 
		}
		return 0;
	}
	 
	public char gibZahlenZeichen(int zahl) {
		return ziffern[zahl];	 
	}
	 
	public String rechne(int zahl, int zielsystem) {
		String ergebnis = "";
		boolean weiter = true;
		while (weiter) {
			ergebnis = gibZahlenZeichen(zahl%zielsystem) + ergebnis;
			zahl = (int)zahl/zielsystem;
			if(zahl==0) {
				break;
			}
		}
		return ergebnis.toUpperCase();
	} 
}

View.java

import java.awt.Container;
import java.awt.Insets;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
 
import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.JFrame;
import javax.swing.JTextField;
 
public class View {
 
	JTextField input = new JTextField();
	JTextField output = new JTextField();
	JButton button = new JButton("Umrechnen");
	JComboBox startsystem = new JComboBox();
	JComboBox zielsystem = new JComboBox();
	 
	public View() {
		JFrame frame = new JFrame("Zahlenrechner");
		Container cp = frame.getContentPane();
		cp.setLayout(null);
		cp.setFocusable(true);
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		frame.setSize(280, 140);
		input.setBounds(10, 10, 130, 25);
		cp.add(input);
		output.setBounds(10, 40, 130, 25);
		cp.add(output);
		startsystem.setBounds(150, 10, 100, 25);
		cp.add(startsystem);
		zielsystem.setBounds(150, 40, 100, 25);
		cp.add(zielsystem);
		fillLists();
		button.setMargin(new Insets(5, 5, 5, 5));
		button.setBounds(10, 70, 130, 25);
		button.addActionListener(new ActionListener() {
		
			@Override
			public void actionPerformed(ActionEvent arg0) {
				int start = 2+startsystem.getSelectedIndex();
				int ziel = 2+zielsystem.getSelectedIndex();
				String in = input.getText();
				Model m = new Model();
				output.setText(m.rechne(m.zuDezimal(in, start), ziel));
			}
		});
		cp.add(button);
		frame.setVisible(true);
	}
	 
	public void fillLists(){
		String[] namen = {"2 (binär)", "3", "4", "5", "6", "7",
		"8 (oktal)", "9", "10 (dezimal)", "11",
		"12", "13", "14", "15", "16 (hexadezimal)",
		"17", "18", "19", "20", "21", "22", "23",
		"24", "25", "26", "27", "28", "29", "30",
		"31", "32", "33", "34", "35", "36"};
		for (int i = 0; i < namen.length; i++) {
			startsystem.addItem(namen[i]);
			zielsystem.addItem(namen[i]);
		}
	}
	 
	public static void main(String[] args) {
		new View();
	} 
}