Programmieren lernen mit Java

Typname	Größe	Wrapper-Klasse	Wertebereich	Beschreibung
boolean	un-definiert	java.lang.Boolean	true / false	Boolescher Wahrheitswert, Boolescher Typ
char	16 bit	java.lang.Character	0 ... 65.535 (z. B. 'A')	Unicode-Zeichen (UTF-16)
byte	8 bit	java.lang.Byte	-128 ... 127	Zweierkomplement-Wert
short	16 bit	java.lang.Short	-32.768 ... 32.767	Zweierkomplement-Wert
int	32 bit	java.lang.Integer	-2.147.483.648 ... 2.147.483.647	Zweierkomplement-Wert
long	64 bit	java.lang.Long	-263 bis 263-1, ab Java 8 auch 0 bis 264 -1	Zweierkomplement-Wert
float	32 bit	java.lang.Float	+/-1,4E-45 ... +/-3,4E+38	32-bit IEEE 754, es wird empfohlen, diesen Wert nicht für Programme zu verwenden, die sehr genau rechnen müssen.
double	64 bit	java.lang.Double	+/-4,9E-324 ... +/-1,7E+308	64-bit IEEE 754, doppelte Genauigkeit

Anwendung:

//erzeugt eine Variable, die 32bit Integerzahlen aufnehmen kann

 int meineZahl;
 
//Variable, die ein einzelnes Zeichen akzeptiert

 char meinZeichen;
 
// Achtung! das folgende ist kein Primitive, 
// das ist ein Objekt, das aus der String Klasse gebaut wird:

 String zeichenkette1 = new String("Text aus mehr als einem Zeichen");

Reservierte Schlüsselwörter

abstract	continue	for	new	switch
assert	default	goto†	package	synchronized
boolean	do	if	private	this
break	double	implements	protected	throw
byte	else	import	public	throws
case	enum	instanceof	return	transient
catch	extends	int	short	try
char	final	interface	static	void
class	finally	long	strictfp	volatile
const†	float	native	super	while

Beispiel1: ein Taschenrechner

 //Taschnrechner
//1.) lese die Nutzereingabe mit der Scanner Methode, damit wir sie in Einzelteile zerlegen können
  java.util.Scanner userInput = new java.util.Scanner(System.in);
  System.out.println("Give us a valid formula... ");

//Eine valide Formel besteht aus der Angabe der Rechenmethode (add, sub, div oder mult) und zwei Zahlen, 
//auf die sie angewendet werden soll
//hier lesen wir diese genau 3 Elemente in ein Array, beginnend bei 0
  

  int i=0;
  String[]  input = new String[3];
 while (i < 3){ 
     input[i] = userInput.next(); 
     i++;
  }
  userInput.close();
  
 System.out.println("Gewählte Rechenmethode: " + input[0]);
 double zahl1 = 1;
 double zahl2 = 1;
 
 if (input[0].contentEquals("add")){ 
	 zahl1 = Double.parseDouble(input[1]);
	 zahl2 = Double.parseDouble(input[2]);
	 double summe = zahl1 + zahl2;
	 
	 System.out.println("Ergebnis: " + summe);
 }
  

 
 

Klassen arbeiten zusammen

Das Package beginner.t3 fasst mehrere Klassendateien zusammen, sodass später eine zusammenhängende JAR Datei aus ihnen gebaut werden kann.
Die Klasse begin ist dazu gedacht, später als Main Klasse den Startpunkt des Programms bereitzustellen.

package beginner.t3;

import java.io.IOException;

public class begin {

	public static void main(String[] args) throws IOException {
	 //one method to bring them all
		
	 java.util.Scanner userInput = new java.util.Scanner(System.in);
	 System.out.println("Give us a filename ");
	 String fileName = new String(userInput.next());
	
	 userInput.close();
		  
	 FileRW files = new FileRW();
		
	 String fileContent = new String(files.fileReader(fileName));
		
	  System.out.println(fileContent + "%n----%n");        
        
        files.writeString2File("/home/zettberlin/text2.txt", fileContent);
        
        files.append2log(" # file written again\n");
	}

}

Die Klasse FileRW muss im gleichen Ordner liegen und dem gleichen Package angehören, dann lässt sich aus ihr das oben in begin verwendete Objekt files bilden, mit dem man auf ihre(teils noch sehr unfertigen) Methoden zugreifen kann.

package beginner.t3;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.*;

public class FileRW {
	
	public StringBuilder fileReader(String filename) throws IOException {
		//read text from a file
	       StringBuilder sb = new StringBuilder();

	        try (BufferedReader br = Files.newBufferedReader(Paths.get(filename))) {

	            // read line by line
	            String line;
	            while ((line = br.readLine()) != null) {
	                sb.append(line).append("\n");
	            }

	        } catch (IOException e) {
	            System.err.format("IOException: %s%n", e);
	        }

	        System.out.println(sb);	
	        
	        return sb;
	        
		
	}
	
	public void writeString2File (String targetFile, String content) throws IOException {
		
		
		System.out.println(targetFile + content);
		
	}
	
	public void append2log (String content) throws IOException {
		
		String logFile = new String("/home/zettberlin/java_begin.log");
		
		File file = new File(logFile);
		FileWriter fAppender = new FileWriter(file, true);
		BufferedWriter bWriter = new BufferedWriter(fAppender);
		bWriter.write(content);
		bWriter.close();
		
		
	}

}

Zweidimensionale Arrays

  String[][] zweiDimensionen = {{"erster", "zwei", "drei"}, {"subEins", "zweisub", "null"}};
        
  System.out.println(zweiDimensionen[0][0]);
             
   int[][] sample = {{1, 2, 3}, {4, 5, 6}};
  
  System.out.println(sample[0][2]);

Mehr Beispiele:

• Rechnen in Schleife
• Eingaben in Schleifen
• Streams und Scanner
• Eigene Klassen benutzen
• Nutzerkonten
• Collections

Für Nachfragen per Email stehe ich gern zur Verfügung: zettberlinlinuxuse.de