Java

this

Das Schlüsselwort this bezieht sich auf das aktuelle Objekt in einer Methode oder einem Konstruktor.

Parameter

An Methoden können Informationen als Parameter übergeben werden. Parameter fungieren als Variablen innerhalb der Methode.

Parameter werden nach dem Methodennamen innerhalb der Klammern angegeben. Sie können beliebig viele Parameter hinzufügen, trennen Sie sie einfach durch ein Komma.

public class Main {
  static void myMethod(String fname, int age) {
return(fname + " is " + age);
  }

  public static void main(String[] args) {
	 System.out.println(myMethod("Liam", 51));
  }
}

Objekte

In Java wird ein Objekt aus einer Klasse erstellt. Wir haben bereits eine Klasse namens Main erstellt und können diese nun zum Erstellen von Objekten verwenden.

Um ein Objekt von Main zu erstellen, geben Sie den Klassennamen an, gefolgt von dem Objektnamen, und verwenden Sie das Schlüsselwort new

//In Java Swing
JButton button = new JButton();

//eine eine ein Objekt aus einer Klasse konstruieren
Heater hotter = new Heater();

Instanzvariablen/Attribut

Eine nicht statische Variable, die innerhalb der Klasse, aber nicht in der Methode deklariert ist, wird als Instanzvariable bezeichnet. Instanzvariablen sind auf ein bestimmtes Objekt bezogen; sie können auf Klassenvariablen zugreifen.

Referenzvariablen

Mit Referenzvariablen macht man Beziehungen zu einer Variabel

Heater <hotter> = new Heater();

hotter.warmer();

Konstruktor

Ist eine spezielle Methode, die beim aufrufen einer Klasse ausgeführt wird.

public Heater() {
this.min = -15;
this.max = 30;
this.increment = 5;
this.temperature = 15;
}

//Verketteter Konstruktor
public Heater(int min, int max)
{
this.min = min;
this.max = max;
this.increment = 5;
this.temperature = 15;
}

Attribute

Attribute sind Variablen bzw. Klassenattribute die innerhalb einer Klasse sind aber ausserhalb einer Methode ist. Sie sind mit Instanzvariablen gleichzusetzen.

Methoden

Eine Methode ist ein Codeblock, der nur ausgeführt wird, wenn er aufgerufen wird.

Sie können einer Methode Daten, so genannte Parameter, übergeben.

Methoden werden verwendet, um bestimmte Aktionen auszuführen, und sie werden auch als Funktionen bezeichnet.

Warum Methoden verwenden? Um Code wiederzuverwenden: den Code einmal definieren und dann mehrfach verwenden.

//example
public void methode(int vari1, int vari2) {
return vari1 + vari2;
}

//echtes example
public void warmer() {
if ((temperature + increment) <= this.max) {
temperature += increment;
}
}

Methoden kann man folgendermassen aufrufen:

//Aus der Main mit einer Referenzvariablel
hotter.warmer();

//Aus der Class selber
warmer();

Setter und Getter Methoden

Ist ein Programmierkonezpt wie man Methoden in Klassen definiert. Die Methoden können genutzt werden um Daten aufzurufen bzw. zu verändern. Da durch den Zugriffsmodifizierter “private” Methoden oder Variablen nur in der eigenen Klasse existieren kann und somit nicht von aussen zugegriffen werden kann, braucht es eine Methode um dies sicher zu realisieren.

Modifiers

Static

Eine Variable die in allen Objekten den gleichen Wert hat. Ausserdem kann man damit Methoden/Attribute aufrufen ohne ein Objekt zu erstellen bzw. Sie Statischen Variablen/Methoden existieren nach der Initialisierung der Instanzvariablen. Dies ist bei der Main Methode der fall. Ohne den Parameter “Static” kann die Main-Methode nicht ausgeführt werden.

Variablen

Variablen sind Container zum Speichern von Datenwerten.

Initialisierung

Das Initialisieren von Variablen

int myNum;

Deklaration

Eine Deklaration ist eine die Zuweisung eines Wertes bei einer Variable

int myNum = 15;
System.out.println(myNum);

String

String Length

String txt = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
System.out.println("The length of the txt string is: " + txt.length());

Finding a Character in a String

String txt = "Please locate where 'locate' occurs!";
System.out.println(txt.indexOf("locate")); // Outputs 7

String Concatenation

String firstName = "John ";
String lastName = "Doe";
System.out.println(firstName.concat(lastName));

Numbers and Strings

int x = 10;
int y = 20;
int z = x + y;  // z will be 30 (an integer/number)

String x = "10";
String y = "20";
String z = x + y;  // z will be 1020 (a String)

More String Methods

String txt = "Hello World";
System.out.println(txt.toUpperCase());   // Outputs "HELLO WORLD"
System.out.println(txt.toLowerCase());   // Outputs "hello world"

Math.max(x,y)

Die Methode Math.max(_x_,_y_) kann verwendet werden, um den höchsten Wert von x und y zu finden:

Math.max(5, 10);

Math.min(x,y)

Die Methode Math.min(_x_,_y_) kann verwendet werden, um den kleinsten Wert von x und y zu finden:

Math.min(5, 10);

Math.sqrt(x)

Die Methode Math.sqrt(_x_) gibt die Quadratwurzel von x zurück:

Math.sqrt(64);

Math.abs(x)

Die Methode Math.abs(_x_) gibt den absoluten (positiven) Wert von x zurück:

Math.abs(-4.7);

Random Numbers

Math.random()` gibt eine Zufallszahl zwischen 0,0 (einschließlich) und 1,0 (ausschließlich) zurück:

Math.random();

Um eine bessere Kontrolle über die Zufallszahl zu erhalten, wenn Sie beispielsweise nur eine Zufallszahl zwischen 0 und 100 wünschen, können Sie die folgende Formel verwenden:

int randomNum = (int)(Math.random() * 101);  // 0 to 100

Arrays

Arrays werden verwendet, um mehrere Werte in einer einzigen Variablen zu speichern, anstatt separate Variablen für jeden Wert zu deklarieren.

Um ein Array zu deklarieren, definieren Sie den Variablentyp mit eckigen Klammern:

String[] cars = {"Volvo", "BMW", "Ford", "Mazda"};

Sie können auf ein Array-Element zugreifen, indem Sie sich auf die Indexnummer beziehen.

Diese Anweisung greift auf den Wert des ersten Elements in cars zu:

String[] cars = {"Volvo", "BMW", "Ford", "Mazda"};
System.out.println(cars[0]);
// Outputs Volvo

Um den Wert eines bestimmten Elements zu ändern, geben Sie die Indexnummer an:

String[] cars = {"Volvo", "BMW", "Ford", "Mazda"};
cars[0] = "Opel";
System.out.println(cars[0]);
// Now outputs Opel instead of Volvo

Um herauszufinden, wie viele Elemente ein Array hat, verwenden Sie die Eigenschaft length:

String[] cars = {"Volvo", "BMW", "Ford", "Mazda"};
System.out.println(cars.length);
// Outputs 4

Ein mehrdimensionales Array ist ein Array von Arrays.

Um ein zweidimensionales Array zu erstellen, fügen Sie jedes Array in einen eigenen Satz geschweifter Klammern ein:

int[][] myNumbers = { {1, 2, 3, 4}, {5, 6, 7} };
int x = myNumbers[1][2];
System.out.println(x);
// Outputs 7

Operatoren

Comparison Operators

Logical Operators

Assignment Operators

Escape sequences/character

Da Zeichenketten in Anführungszeichen geschrieben werden müssen, wird Java diese Zeichenkette falsch verstehen und einen Fehler erzeugen:

//falsch
String txt = "We are the so-called "Vikings" from the north.";
//richtig
String txt = "We are the so-called \"Vikings\" from the north.";

Ein und Ausgabe Routinen

Ausgabe von Text/Zahlen/Variablen

//Text
System.out.println("Hello World!");
//Zahlen
System.out.println(50000);
System.out.println(1+1);
//Variablen
System.out.println("Hello" + name);

Die Klasse Scanner wird zum Abrufen von Benutzereingaben verwendet und befindet sich im Paket java.util.

Um die Scanner-Klasse zu verwenden, erstellen Sie ein Objekt der Klasse und verwenden eine der verfügbaren Methoden, die in der Dokumentation der Scanner-Klasse zu finden sind. In unserem Beispiel werden wir die Methode nextLine() verwenden, die zum Lesen von Strings verwendet wird:

Scanner myObj = new Scanner(System.in);  // Create a Scanner object
System.out.println("Enter username");

String userName = myObj.nextLine();  // Read user input
System.out.println("Username is: " + userName);  // Output user input

IF, Else, Switch, For, For-Each

if (condition1) {
  // block of code to be executed if condition1 is true
} else if (condition2) {
  // block of code to be executed if the condition1 is false and condition2 is true
} else {
  // block of code to be executed if the condition1 is false and condition2 is false
}

switch(expression) {
  case x:
// code block
break;
  case y:
// code block
break;
  default:
// code block
}

while (condition) {
  // code block to be executed
}

for (statement 1; statement 2; statement 3) {
  // code block to be executed
}

for (type variableName : arrayName) {
  // code block to be executed
}

Break & Continue

continue

Die continue-Anweisung unterbricht eine Iteration (in der Schleife), wenn eine bestimmte Bedingung eintritt, und fährt mit der nächsten Iteration in der Schleife fort.

for (int i = 0; i < 10; i++) {
  if (i == 4) {
continue;
  }
  System.out.println(i);
}

break

Die Break Anweisung kann man Verwenden um aus einer Schleife herauszuspringen.

for (int i = 0; i < 10; i++) {
  if (i == 4) {
break;
  }
  System.out.println(i);
}

Scope

Method Scope

Variablen, die direkt innerhalb einer Methode deklariert werden, stehen überall in der Methode nach der Codezeile, in der sie deklariert wurden, zur Verfügung:

Example

public class Main {
  public static void main(String[] args) {

// Code here CANNOT use x

int x = 100;

// Code here can use x
System.out.println(x);
  

Block Scope

Ein Code-Block bezieht sich auf den gesamten Code zwischen geschweiften Klammern {}.

Auf Variablen, die innerhalb von Codeblöcken deklariert werden, kann nur durch den Code zwischen den geschweiften Klammern zugegriffen werden, der auf die Zeile folgt, in der die Variable deklariert wurde:

Example

public class Main {
  public static void main(String[] args) {

// Code here CANNOT use x

{ // This is a block

  // Code here CANNOT use x

  int x = 100;

  // Code here CAN use x
  System.out.println(x);

} // The block ends here

  // Code here CANNOT use x

  }
}

Recursion

Rekursion ist die Technik, eine Funktion dazu zu bringen, sich selbst aufzurufen. Mit dieser Technik lassen sich komplizierte Probleme in einfache, leichter zu lösende Probleme aufteilen.

Rekursion kann etwas schwierig zu verstehen sein. Der beste Weg, um herauszufinden, wie sie funktioniert, ist, mit ihr zu experimentieren.

public class Main {
  public static void main(String[] args) {
int result = sum(10);
System.out.println(result);
  }
  
  public static int sum(int k) {
if (k > 0) {
  return k + sum(k - 1);
} else {
  return 0;
	}
}	  

Package

Mit Package kann man Bibliotheken zusammenbauen und diese in ein neues Programm einzubinden.

Bsp.:

package <Paketname>;

Import

Mit Import können gewisse Funktionen einem Java Programm hinzugefügt werden.

import javax.swing.*;
import java.awt.*;

Main

Eine Main-Klasse beinhaltet eine Mainfunktion. Diese wird gebraucht, um ein Programm zu starten. Die Mainfunktion ist eine static-Funktion mit einem String-Array als Parameter. Es kann mehrere Main-Funktionen geben.

public class Main {
public static void main(String[] args) {
	test test_lernen = new test();
}
}

Class

package org.example;

public class test {
public test() {
		  ///Some Code...
}
}

Extends

Das Schlüsselwort extends erweitert eine Klasse (zeigt an, dass eine Klasse von einer anderen Klasse geerbt wird).

In Java ist es möglich, Attribute und Methoden von einer Klasse an eine andere zu vererben. Wir unterteilen das “Vererbungskonzept” in zwei Kategorien:

• Unterklasse (child) - die Klasse, die von einer anderen Klasse erbt
• Oberklasse (parent) - die Klasse, von der geerbt wird

public class test extends [JFrame] {
		public test() {
		  ///Some Code...
}
}

Implements

Um eine Klasse zu deklarieren, die eine Schnittstelle implementiert, fügen Sie eine implements-Klausel in die Klassendeklaration ein.

public class test extends [JFrame] implements [ActionListener] {
		public test() {
		  ///Some Code...
}
}

Setablels

this.setTitle()

Setzt den Fenstertitel

this.setTitle("Zero");

this.setSize()

Bestimmt die Grösse des Fensters.

this.setSize(width,height);

this.setResizable()

Bestimmt ob man das Fenster Vergrössern darf.

this.setResizable(bool);

setVisible()

Bestimmt ob das Window sichtbar ist.

setVisible(bool);

setDefaultCloseOperation

setDefaultCloseOperation(EXIT_ON_CLOSE);

JPanel

JPanel ist ein allgemeiner, leichter Container, in dem weitere Objekte platziert werden können.

JPanel keyPanel = new JPanel();

//Layout Setzen
keyPanel.setLayout(new GridLayout(3, 4, 20, 20));

Definieren von Objekten (JButton, JTextField, JTextArea, JLabel)

//Eine Implementierung eines "Push"-Knopfes.
JButton Button1 = new JButton("Button1");
JButton Button2 = new JButton("Button2");
//Ein Textfeld ist ein einfaches Textsteuerelement, das es dem Benutzer ermöglicht, eine kleine Menge Text einzugeben.
JTextField TextField = new JTextField("Enter Value");
//Ein JTextArea ist ein mehrzeiliger Bereich, der einfachen Text anzeigt.
JTextArea TextArea = new JTextArea();
//Ein Anzeigebereich für eine kurze Textzeichenfolge oder ein Bild oder beides. Ein Etikett reagiert nicht auf Eingabeereignisse. Folglich kann es den Tastaturfokus nicht erhalten.
JLabel Label = new JLabel("Hallo Welt!");

Layout Manager

GridLayout

GridLayout Grid = new GridLayout(rows, cols);
getContentPane().setLayout(Grid);
getContentPane().add(Button1);
getContentPane().add(Button2);

BorderLayout

getContentPane().setLayout(new BorderLayout(20, 20));
getContentPane().add(ButtonON, BorderLayout.NORTH);

FlowLayout

getContentPane().setLayout(new FlowLayout());
getContentPane().add(Label, FlowLayout.LEFT);

Event-Listener

• ActionEvent für Ereignisse, welche GUI-Elemente, wie Knöpfe etc. betreffen (Klicken des Knopfes)

//anonyme Klasse implementiert

Button2.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
ObjectSwing.setText("Text2");
}
});

Button1.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
ObjectSwing.setText("Text1");
}
});

//innere Klasse implementiert

Button1.addActionListener(new ButtonListener())

class ButtonListener implements ActionListener {
	@Override
	public void actionPerformed(ActionEvent e) {
ObjectSwing.setText("Text1");
}
}

//direkt in Klasse implementiert

Button1.addActionListener(this)

@Override
	public void actionPerformed(ActionEvent e) {
ObjectSwing.setText("Text1");
}

• MouseEvent für Ereignisse, welche die Maus betreffen (Verschieben, Klick etc.)

class ClickMeListener extends MouseAdapter {
	public void mouseEntered(MouseEvent e) {
		clickMe.setLabel("Don't click me!");
	}

	public void mouseExited(MouseEvent e) {
		clickMe.setLabel("Click me!");
	}
}

JButton clickMe = new JButton("Click me!");
clickMe.addMouseListener(new ClickMeListener());

• WindowEvent für Ereignisse, welche ein Fenster betreffen (Öffnen, Schliessen etc.)

C#

Variablen Datentypen

Ein Datentyp legt die Größe und den Typ der Variablenwerte fest.

Eine Variable wird zuerst mit dem gewünschten Datentyp “Initialisiert” und dann einen Namen gegeben:

int myNum = 5;   // Integer (whole number)
double myDoubleNum = 5.99D;  // Floating point number
char myLetter = 'D'; // Character
bool myBool = true;  // Boolean
string myText = "Hello"; // String

In C# gibt es einige Datentypen eine Kleine Übersicht gibt es hier was die.

Type casting

Typ-Casting bedeutet, dass Sie einen Wert eines Datentyps einem anderen Typ zuweisen.

In C# gibt es zwei Arten von Casting:

Implizites Casting (automatisch) - Konvertierung eines kleineren Typs in einen größeren Typ char -> int -> long -> float -> double

Explizites Casting (manuell) - Konvertierung eines größeren Typs in einen Typ kleinerer Größe double -> float -> long -> int -> char

int myInt = 10;
double myDouble = 5.25;
bool myBool = true;

Console.WriteLine(Convert.ToString(myInt));// convert int to string
Console.WriteLine(Convert.ToDouble(myInt));// convert int to double
Console.WriteLine(Convert.ToInt32(myDouble));  // convert double to int
Console.WriteLine(Convert.ToString(myBool));   // convert bool to string

Arithmetic Operators

Assignment Operators

Comparison Operators

Logical Operators

Math.Max(x,y)

Die Methode Math.Max(_x_,_y_) kann verwendet werden, um den höchsten Wert von x und y zu finden:

Example

Math.Max(5, 10);

Math.Min(x,y)

Die Methode Math.Min(_x_,_y_) kann verwendet werden, um den kleinsten Wert von x und y zu finden:

Example

Math.Min(5, 10);

Math.Sqrt(x)

Die Methode Math.Sqrt(_x_) gibt die Quadratwurzel von x zurück:

Example

Math.Sqrt(64);

Math.Abs(x)

Die Methode Math.Abs(_x_) gibt den absoluten (positiven) Wert von x zurück:

Example

Math.Abs(-4.7);

Math.Round()

Math.Round() rundet eine Zahl auf die nächste ganze Zahl:

Example

Math.Round(9.99);

IF, Else, Switch, For, For-Each

If-Else Statement:

int x = 10;

if (x > 5) {
Console.WriteLine("x is greater than 5");
} else {
Console.WriteLine("x is less than or equal to 5");
}

Switch Statement:

int month = 3;

switch (month)
{
case 1:
Console.WriteLine("January");
break;
case 2:
Console.WriteLine("February");
break;
case 3:
Console.WriteLine("March");
break;
default:
Console.WriteLine("Not a valid month");
break;
}

For Loop:

for (int i = 0; i < 5; i++){
Console.WriteLine("Iteration: " + i);
}

Foreach Loop:

int[] numbers = { 1, 2, 3, 4, 5 };

foreach (int number in numbers) {
Console.WriteLine("Number: " + number);
}

While Loop:

int i = 0;

while (i < 5)
{
Console.WriteLine("Iteration: " + i);
i++;
}

C# Break and Continue

C# Break

Die break-Anweisung kann auch verwendet werden, um aus einer Schleife herauszuspringen.

int i = 0;
while (i < 10)
{
  Console.WriteLine(i);
  i++;
  if (i == 4)
  {
break;
  }
}

C# Continue

Die continue-Anweisung bricht eine Iteration (in der Schleife) ab, wenn eine bestimmte Bedingung eintritt, und fährt mit der nächsten Iteration in der Schleife fort.

int i = 0;
while (i < 10)
{
  if (i == 4)
  {
i++;
continue;
  }
  Console.WriteLine(i);
  i++;
}

Bool

In der Programmierung benötigt man sehr oft einen Datentyp, der nur einen von zwei Werten haben kann, wie z. B.:

JA / NEIN
EIN / AUS
WAHR / FALSCH

Dafür gibt es in C# den Datentyp bool, der die Werte true oder false annehmen kann.

bool isCSharpFun = true;
bool isFishTasty = false;
Console.WriteLine(isCSharpFun);   // Outputs True
Console.WriteLine(isFishTasty);   // Outputs False

Special Characters

Da Zeichenketten in Anführungszeichen geschrieben werden müssen, wird C# diese Zeichenkette falsch verstehen und einen Fehler erzeugen:

//falsch
string txt = "We are the so-called "Vikings" from the north.";
//richtig
string txt = "We are the so-called \"Vikings\" from the north.";

Die Lösung, um dieses Problem zu vermeiden, ist die Verwendung des Backslash-Escape-Zeichens.

Das Escape-Zeichen “Backslash” (\) verwandelt Sonderzeichen in Zeichenfolgen:

Escape Sequenzen

Andere nützliche Escape-Zeichen in C# sind:

Strings

String Length

Eine Zeichenkette in C# ist eigentlich ein Objekt, das Eigenschaften und Methoden enthält, die bestimmte Operationen mit Zeichenketten durchführen können. Die Länge einer Zeichenkette kann zum Beispiel mit der Eigenschaft Length ermittelt werden:

string txt = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
Console.WriteLine("The length of the txt string is: " + txt.Length);

Other Methods

string txt = "Hello World";
Console.WriteLine(txt.ToUpper());   // Outputs "HELLO WORLD"
Console.WriteLine(txt.ToLower());   // Outputs "hello world"

Access Strings

Sie können auf die Zeichen in einer Zeichenkette zugreifen, indem Sie sich auf die Indexnummer in eckigen Klammern [] beziehen.

Dieses Beispiel gibt das erste Zeichen in myString aus:

string myString = "Hello";
Console.WriteLine(myString[0]);  // Outputs "H"

Dieses Beispiel gibt das zweite Zeichen (1) in myString aus:

string myString = "Hello";
Console.WriteLine(myString[1]);  // Outputs "e"

Sie können auch die Indexposition eines bestimmten Zeichens in einer Zeichenkette ermitteln, indem Sie die Methode IndexOf() verwenden:

string myString = "Hello";
Console.WriteLine(myString.IndexOf("e"));  // Outputs "1"

Eine weitere nützliche Methode ist Substring(), die die Zeichen aus einer Zeichenkette ab der angegebenen Zeichenposition/dem angegebenen Index extrahiert und eine neue Zeichenkette zurückgibt. Diese Methode wird oft zusammen mit IndexOf() verwendet, um die spezifische Zeichenposition zu ermitteln:

// Full name
string name = "John Doe";

// Location of the letter D
int charPos = name.IndexOf("D");

// Get last name
string lastName = name.Substring(charPos);

// Print the result
Console.WriteLine(lastName);

String Interpolation

Eine weitere Möglichkeit der String-Verkettung ist die String-Interpolation, bei der die Werte von Variablen durch Platzhalter in einem String ersetzt werden. Beachten Sie, dass Sie sich nicht um Leerzeichen kümmern müssen, wie bei der Konkatenation:

string firstName = "John";
string lastName = "Doe";
string name = $"My full name is: {firstName} {lastName}";
Console.WriteLine(name);

String Concatenation

Der Operator + kann zwischen Zeichenketten verwendet werden, um sie zu kombinieren. Dies wird als Verkettung bezeichnet:

string firstName = "John ";
string lastName = "Doe";
string name = firstName + lastName;
Console.WriteLine(name);

Sie können auch die Methode string.Concat() verwenden, um zwei Zeichenketten zu verketten:

string firstName = "John ";
string lastName = "Doe";
string name = string.Concat(firstName, lastName);
Console.WriteLine(name);

Adding Numbers and Strings

Wenn Sie zwei Zahlen addieren, ist das Ergebnis eine Zahl:

int x = 10;
int y = 20;
int z = x + y;  // z will be 30 (an integer/number)

Wenn Sie zwei Zeichenfolgen addieren, ist das Ergebnis eine Verkettung von Zeichenfolgen:

string x = "10";
string y = "20";
string z = x + y;  // z will be 1020 (a string)

Arrays

Arrays werden verwendet, um mehrere Werte in einer einzigen Variablen zu speichern, anstatt für jeden Wert eine eigene Variable zu deklarieren.

Um ein Array zu deklarieren, definieren Sie den Variablentyp mit eckigen Klammern:

string[] cars;

string[] cars = {"Volvo", "BMW", "Ford", "Mazda"};

int[] myNum = {10, 20, 30, 40};

Access the Elements of an Array

Sie greifen auf ein Array-Element zu, indem Sie sich auf die Indexnummer beziehen.

Diese Anweisung greift auf den Wert des ersten Elements in cars zu:

string[] cars = {"Volvo", "BMW", "Ford", "Mazda"};
Console.WriteLine(cars[0]);
// Outputs Volvo

Change an Array Element

string[] cars = {"Volvo", "BMW", "Ford", "Mazda"};
cars[0] = "Opel";
Console.WriteLine(cars[0]);
// Now outputs Opel instead of Volvo

Array Length

string[] cars = {"Volvo", "BMW", "Ford", "Mazda"};
Console.WriteLine(cars.Length);
// Outputs 4

Loop Through Arrays

string[] cars = {"Volvo", "BMW", "Ford", "Mazda"};
foreach (string i in cars) 
{
  Console.WriteLine(i);
}

Sort an Array

// Sort a string
string[] cars = {"Volvo", "BMW", "Ford", "Mazda"};
Array.Sort(cars);
foreach (string i in cars)
{
  Console.WriteLine(i);
}

// Sort an int
int[] myNumbers = {5, 1, 8, 9};
Array.Sort(myNumbers);
foreach (int i in myNumbers)
{
  Console.WriteLine(i);
}

System.Linq Namespace

Weitere nützliche Array-Methoden, wie Min, Max und Sum, finden Sie im System.Linq-Namensraum:

using System;
using System.Linq;

namespace MyApplication
{
  class Program
  {
static void Main(string[] args)
{
  int[] myNumbers = {5, 1, 8, 9};
  Console.WriteLine(myNumbers.Max());  // returns the largest value
  Console.WriteLine(myNumbers.Min());  // returns the smallest value
  Console.WriteLine(myNumbers.Sum());  // returns the sum of elements
}
  }
}

Exception handling

try…catch

Bei der Ausführung von C#-Code können verschiedene Fehler auftreten: Codierungsfehler des Programmierers, Fehler aufgrund falscher Eingaben, oder andere unvorhersehbare Dinge.

Wenn ein Fehler auftritt, wird C# normalerweise anhalten und eine Fehlermeldung erzeugen. Der technische Begriff dafür ist: C# wirft eine Exception (wirft einen Fehler).

try
{
  //  Block of code to try
}
catch (Exception e)
{
  //  Block of code to handle errors
}

Enum’s

Eine Enum ist eine spezielle “Klasse”, die eine Gruppe von Konstanten (unveränderliche/nur lesbare Variablen) darstellt. Mann kann sich Enums wie Constrains in SQL vorstellen.

enum Months
{
  January,// 0
  February,   // 1
  March,  // 2
  April,  // 3
  May,// 4
  June,   // 5
  July// 6
}

static void Main(string[] args)
{
  int myNum = (int) Months.April;
  Console.WriteLine(myNum);
}

OPP

Bei der prozeduralen Programmierung geht es darum, Prozeduren oder Methoden zu schreiben, die Operationen an den Daten durchführen, während es bei der objektorientierten Programmierung darum geht, Objekte zu erstellen, die sowohl Daten als auch Methoden enthalten.

Die objektorientierte Programmierung hat mehrere Vorteile gegenüber der prozeduralen Programmierung:

OOP ist schneller und einfacher in der Ausführung OOP bietet eine klare Struktur für die Programme OOP hilft, den C#-Code DRY “Don’t Repeat Yourself” zu halten, und macht den Code einfacher zu pflegen, zu ändern und zu debuggen OOP ermöglicht es, vollständige wiederverwendbare Anwendungen mit weniger Code und kürzerer Entwicklungszeit zu erstellen

Was sind Klassen und Objekte

Klasse

Um eine Klasse zu erstellen, verwenden Sie das Schlüsselwort class:

class Car
{
  string color = "red";
}

Objekt

Ein Objekt wird aus einer Klasse erstellt. Wir haben bereits die Klasse Car erstellt und können diese nun zum Erstellen von Objekten verwenden.

Um ein Objekt von Car zu erstellen, geben Sie den Klassennamen an, gefolgt vom Objektnamen, und verwenden Sie das Schlüsselwort new:

class Car
{
  string color = "red";

  static void Main(string[] args)
  {
Car myObj = new Car();
Console.WriteLine(myObj.color);
  }
}

Konstruktor

Ein Konstruktor ist eine spezielle Methode, die zur Initialisierung von Objekten verwendet wird. Der Vorteil eines Konstruktors ist, dass er aufgerufen wird, wenn ein Objekt einer Klasse erstellt wird. Er kann verwendet werden, um Anfangswerte für Felder festzulegen:

// Create a Car class
class Car
{
  public string model;  // Create a field

  // Create a class constructor for the Car class
  public Car()
  {
model = "Mustang"; // Set the initial value for model
  }

  static void Main(string[] args)
  {
Car Ford = new Car();  // Create an object of the Car Class (this will call the constructor)
Console.WriteLine(Ford.model);  // Print the value of model
  }
}

// Outputs "Mustang"

Public/Private

Warum Zugriffsmodifikatoren wie Private/Public?

Kontrolle der Sichtbarkeit von Klassenmitgliedern (die Sicherheitsstufe jeder einzelnen Klasse und jedes Klassenmitglieds).

Um eine “Verkapselung” zu erreichen, d.h. um sicherzustellen, dass “sensible” Daten vor den Benutzern verborgen werden. Dies geschieht, indem Felder als privat deklariert werden.

Default

Standardmäßig sind alle Mitglieder einer Klasse privat, wenn Sie keinen Zugriffsmodifikator angeben.

Die Verschiedenen Modifikatoren

Es gibt vier unterschiedliche Zugriffsmodifikatoren in C#. Hier ist ein überblick inklusive deren Bedeutung/Auswirkung in C#:

Properties und Encapsulation

Der Sinn der Kapselung besteht darin, sicherzustellen, dass “sensible” Daten vor den Benutzern verborgen werden. Um dies zu erreichen, müssen Sie:

Felder/Variablen als privat deklarieren öffentliche Get- und Set-Methoden über Eigenschaften bereitstellen, um auf den Wert eines privaten Feldes zuzugreifen und ihn zu aktualisieren

class Person
{
  private string name;
  private int age;

  public string Name
  {
get { return name; }
set { name = value; }
  }

  public int Age
  {
get { return age; }
set { age = value; }
  }
}

class Program
{
  static void Main(string[] args)
  {
Person person = new Person();
person.Name = "Jane Doe";
person.Age = 32;
Console.WriteLine("Person: Name = " + person.Name + ", Age = " + person.Age); // Output: Person: Name = Jane Doe, Age = 32
	}
}

Abstraction

Unter Datenabstraktion versteht man den Prozess, bestimmte Details zu verbergen und dem Benutzer nur die wesentlichen Informationen zu zeigen. Abstraktion kann entweder durch abstrakte Klassen oder durch Schnittstellen erreicht werden.

Das Schlüsselwort abstract wird für Klassen und Methoden verwendet:

Abstrakte Klasse: ist eine eingeschränkte Klasse, die nicht zur Erstellung von Objekten verwendet werden kann (um auf sie zuzugreifen, muss sie von einer anderen Klasse geerbt werden).

Abstrakte Methode: kann nur in einer abstrakten Klasse verwendet werden und hat keinen Körper. Der Rumpf wird von der abgeleiteten Klasse bereitgestellt (geerbt von).

Eine abstrakte Klasse kann sowohl abstrakte als auch reguläre Methoden haben:

abstract class Animal
{
  public abstract void animalSound();
  public void sleep()
  {
Console.WriteLine("Zzz");
  }
}

Um auf die abstrakte Klasse zugreifen zu können, muss sie von einer anderen Klasse geerbt werden. Konvertieren wir die Klasse Animal, die wir im Kapitel Polymorphismus verwendet haben, in eine abstrakte Klasse.

// Abstract class
abstract class Animal
{
  // Abstract method (does not have a body)
  public abstract void animalSound();
  // Regular method
  public void sleep()
  {
Console.WriteLine("Zzz");
  }
}

// Derived class (inherit from Animal)
class Pig : Animal
{
  public override void animalSound()
  {
// The body of animalSound() is provided here
Console.WriteLine("The pig says: wee wee");
  }
}

class Program
{
  static void Main(string[] args)
  {
Pig myPig = new Pig(); // Create a Pig object
myPig.animalSound();  // Call the abstract method
myPig.sleep();  // Call the regular method
  }
}

Interface

Eine Schnittstelle ist eine völlig “abstrakte Klasse”, die nur abstrakte Methoden und Eigenschaften (mit leeren Körpern) enthalten kann.

Standardmäßig sind, Mitglieder eines Interface abstract und public.

Um auf die Methoden der Interface zugreifen zu können, muss das Interface von einer anderen Klasse “implementiert” (quasi geerbt) werden. Um eine Schnittstelle zu implementieren, verwenden Sie das Symbol : (genau wie bei der Vererbung). Der Methodenkörper der Schnittstelle wird von der Klasse “implement” bereitgestellt. Beachten Sie, dass Sie bei der Implementierung einer Schnittstelle nicht das Schlüsselwort override verwenden müssen:

// Interface
interface IAnimal
{
  void animalSound(); // interface method (does not have a body)
}

// Pig "implements" the IAnimal interface
class Pig : IAnimal
{
  public void animalSound()
  {
// The body of animalSound() is provided here
Console.WriteLine("The pig says: wee wee");
  }
}

class Program
{
  static void Main(string[] args)
  {
Pig myPig = new Pig();  // Create a Pig object
myPig.animalSound();
  }
}

Inheritance

In C# ist es möglich, Felder und Methoden von einer Klasse an eine andere zu vererben. Wir unterteilen das “Vererbungskonzept” in zwei Kategorien:

Abgeleitete Klasse (child) - die Klasse, die von einer anderen Klasse erbt Basisklasse (parent) - die Klasse, von der geerbt wird

Um von einer Klasse zu erben, verwenden Sie das Symbol : .

class Vehicle  // base class (parent) 
{
  public string brand = "Ford";  // Vehicle field
  public void honk() // Vehicle method 
  {
Console.WriteLine("Tuut, tuut!");
  }
}

class Car : Vehicle  // derived class (child)
{
  public string modelName = "Mustang";  // Car field
}

class Program
{
  static void Main(string[] args)
  {
// Create a myCar object
Car myCar = new Car();

// Call the honk() method (From the Vehicle class) on the myCar object
myCar.honk();

// Display the value of the brand field (from the Vehicle class) and the value of the modelName from the Car class
Console.WriteLine(myCar.brand + " " + myCar.modelName);
  }
}

Polymorphism

Polymorphismus bedeutet “viele Formen”, und er tritt auf, wenn wir viele Klassen haben, die durch Vererbung miteinander verbunden sind.

Stellen Sie sich zum Beispiel eine Basisklasse namens Animal vor, die eine Methode namens animalSound() hat. Abgeleitete Klassen von Animals könnten Schweine, Katzen, Hunde, Vögel sein - und sie haben auch ihre eigene Implementierung eines Tiergeräusches (das Schwein grunzt, die Katze miaut usw.):

class Animal  // Base class (parent) 
{
  public virtual void animalSound() 
  {
Console.WriteLine("The animal makes a sound");
  }
}

class Pig : Animal  // Derived class (child) 
{
  public override void animalSound() 
  {
Console.WriteLine("The pig says: wee wee");
  }
}

class Dog : Animal  // Derived class (child) 
{
  public override void animalSound() 
  {
Console.WriteLine("The dog says: bow wow");
  }
}

class Program 
{
  static void Main(string[] args) 
  {
Animal myAnimal = new Animal();  // Create a Animal object
Animal myPig = new Pig();  // Create a Pig object
Animal myDog = new Dog();  // Create a Dog object

myAnimal.animalSound();
myPig.animalSound();
myDog.animalSound();
  }
}

Variable Convert.* methods

In C# können Sie Datentypen mithilfe von Typkonvertierungsfunktionen konvertieren, z. B. Convert.ToInt32, Int32.Parse oder int.TryParse.

Hier sind einige Beispiele:

string booleanAsString = "true";
bool booleanValue = Convert.ToBoolean(booleanAsString);

string byteAsString = "255";
byte byteValue = Convert.ToByte(byteAsString);

string charAsString = "A";
char charValue = Convert.ToChar(charAsString);

string dateAsString = "01/01/2000";
DateTime dateValue = Convert.ToDateTime(dateAsString);

string decimalAsString = "42.0";
decimal decimalValue = Convert.ToDecimal(decimalAsString);

string doubleAsString = "3.14";
double doubleValue = Convert.ToDouble(doubleAsString);

string intAsString = "42";
int intValue = Convert.ToInt32(intAsString);

string stringValue = Convert.ToString(42);

WPF

Setables

ResizeMode="NoResize"
Title="MainWindow" Height="300" Width="300"
Background="Aquamarine"
Loaded="Window_Loaded"

Components

TextBlock

Diese Komponente zeigt Text an.

<TextBlock Text="Hello, world!" />

Label

Es kann verwendet werden, um einen beschreibenden Text für andere Steuerelemente bereitzustellen oder um Text als Teil einer Benutzeroberfläche anzuzeigen.

<Label Content="Name: " />

Image

Diese Komponente zeigt ein Bild an.

<Image Source="image.png" />

Checkbox

Eine “Checkbox” in WPF ist ein Steuerelement, das es dem Benutzer ermöglicht, eine binäre Option auszuwählen, entweder “angekreuzt” oder “nicht angekreuzt”.

<CheckBox  Content="Subscribe to newsletter" Click="ButtonBase_OnClick" />

Um Zu checken welche ComboBox gedrückt wurde kann man diesen Code verwenden:

private void ButtonBase_OnClick(object sender, RoutedEventArgs e)  
{  
CheckBox subscribeCheckBox = (CheckBox)sender;  
if (subscribeCheckBox.IsChecked.Value)  
{  
MessageBox.Show("You have subscribed to the newsletter", "Subscription Status");  
}  
else  
{  
MessageBox.Show("You have unsubscribed from the newsletter", "Subscription Status");  
}  
}

ComboBox

Eine ComboBox in WPF ist ein Steuerelement, mit dem der Benutzer ein Element aus einer Dropdown-Liste von Optionen auswählen kann.

<ComboBox x:Name="ExampleComboBox" Width="100" SelectedIndex="0" SelectionChanged="ExampleComboBox_SelectionChanged">
  <ComboBoxItem>Option 1</ComboBoxItem>
  <ComboBoxItem>Option 2</ComboBoxItem>
  <ComboBoxItem>Option 3</ComboBoxItem>
</ComboBox>

Um Zu checken welche ComboBox gedrückt wurde kann man diesen Code verwenden:

ComboBoxItem selectedItem = ExampleComboBox.SelectedItem as ComboBoxItem;  

MessageBox.Show("Selected option: " + selectedItem.Content, "Selection Changed");

Radio Button

Ein RadioButton in WPF ist ein Steuerelement, das es dem Benutzer ermöglicht, eine einzelne Option aus einer Gruppe von sich gegenseitig ausschließenden Optionen auszuwählen.

<Label Content="Gender: " />
<StackPanel Margin="30">
<RadioButton x:Name="Male" Content="Male" GroupName="Gender" IsChecked="True" />
<RadioButton x:Name="Female" Content="Female" GroupName="Gender" />
<RadioButton x:Name="NonBinary" Content="Non-Binary" GroupName="Gender" />
</StackPanel>
<Button Content="Submit" HorizontalAlignment="Left" Height="30" Margin="30,30,0,0" Width="75" Click="Button_Click"/>

Um Zu checken welcher Button gedrückt wurde kann man diesen Code verwenden:

private void Button_Click(object sender, RoutedEventArgs e) {
string selectedGender = "";
if (Male.IsChecked == true)
{
selectedGender = "Male";
}
else if (Female.IsChecked == true)
{
selectedGender = "Female";
}
else if (NonBinary.IsChecked == true)
{
selectedGender = "Non-Binary";
}
MessageBox.Show("Selected Gender: " + selectedGender);  
}

ListBox

Eine Schaltfläche in WPF ist ein Steuerelement, mit dem der Benutzer durch Anklicken eine Aktion auslösen kann, z. B. das Absenden eines Formulars oder das Auslösen eines Befehls.

<ListBox x:Name="ExampleListBox" SelectionMode="Multiple"   HorizontalAlignment="Left" VerticalAlignment="Top" Margin="10,10,0,0"  Width="100">  
<ListBoxItem>Item 1</ListBoxItem>  
<ListBoxItem>Item 2</ListBoxItem>  
<ListBoxItem>Item 3</ListBoxItem>  
</ListBox>  

<TextBlock x:Name="SelectedItemsTextBlock" HorizontalAlignment="Left"  VerticalAlignment="Top" Margin="120,10,0,0" Text="Selected Items:" />  

<ListBox x:Name="SelectedItemsListBox" HorizontalAlignment="Left"   VerticalAlignment="Top" Margin="120,30,0,0" Width="150" ItemsSource="{Binding ElementName=ExampleListBox,  Path=SelectedItems}"/>

<Button x:Name="ShowSelectedItemsButton" Content="Show Selected Items"  HorizontalAlignment="Left"  VerticalAlignment="Top"Margin="10,100,0,0"   Width="150"  Click="ShowSelectedItemsButton_Click"/>

Um die Selektierten Objekte anzuzeigen kann man diese Methode implementieren:

private void ShowSelectedItemsButton_Click(object sender, RoutedEventArgs e) {  
string selectedItems = "";  
foreach (var item in ExampleListBox.SelectedItems)  
{  
selectedItems += ((System.Windows.Controls.ListBoxItem)item).Content.ToString() + "\n";  
}  
MessageBox.Show(selectedItems, "Selected Items");  
}

TreeView

Der TreeView in WPF ist eine hierarchische Ansicht, die es ermöglicht, Daten in einer Baumstruktur anzuzeigen.

<TreeView x:Name="ExampleTreeView">  
<TreeViewItem Header="Parent Node 1">  
<TreeViewItem Header="Child Node 1.1" />  
<TreeViewItem Header="Child Node 1.2" />  
</TreeViewItem>  
<TreeViewItem Header="Parent Node 2">  
<TreeViewItem Header="Child Node 2.1" />  
<TreeViewItem Header="Child Node 2.2" />  
</TreeViewItem>  
</TreeView>

ScrollViewer

Diese Komponente bietet Bildlauffunktionen für ihren Inhalt.

<ScrollViewer>
  <StackPanel>
<!-- Content goes here -->
  </StackPanel>
</ScrollViewer>

Button

Eine Schaltfläche in WPF ist ein Steuerelement, mit dem der Benutzer durch Anklicken eine Aktion auslösen kann, z. B. das Absenden eines Formulars oder das Auslösen eines Befehls.

<Button x:Name="ExampleButton" Content="Click Me" Height="30" Width="100" Click="ExampleButton_Click"/>

Layout Managers

StackPanel

Dieser Layout-Manager stapelt seine Kinder entweder horizontal oder vertikal, je nach seiner Eigenschaft “Ausrichtung”.

<StackPanel Orientation="Vertical">
  <Button Content="Button 1" />
  <Button Content="Button 2" />
  <Button Content="Button 3" />
</StackPanel>

WrapPanel

Dieser Layout-Manager ordnet seine Kinder in einem Fließlayout an und springt in die nächste Zeile, wenn in der aktuellen Zeile kein Platz mehr ist.

<WrapPanel>
  <Button Content="Button 1" Width="100" Height="100"/>
  <Button Content="Button 2" Width="100" Height="100"/>
  <Button Content="Button 3" Width="100" Height="100"/>
</WrapPanel>

Grid

Dieser Layout-Manager unterteilt den verfügbaren Platz in Zeilen und Spalten und ermöglicht die Positionierung seiner Kinder anhand von Zeilen- und Spaltenindizes.

<Grid>
  <Grid.RowDefinitions>
<RowDefinition Height="Auto"/>
<RowDefinition Height="*"/>
  </Grid.RowDefinitions>
  <Grid.ColumnDefinitions>
<ColumnDefinition Width="*"/>
<ColumnDefinition Width="Auto"/>
  </Grid.ColumnDefinitions>

  <Button Grid.Row="0" Grid.Column="0" Content="Button 1"/>
  <Button Grid.Row="1" Grid.Column="1" Content="Button 2"/>
</Grid>

DockPanel

Dieser Layout-Manager positioniert seine Kinder an den Rändern (oben, unten, links, rechts) oder füllt den verbleibenden Platz (LastChildFill).

<DockPanel LastChildFill="True">
  <Button DockPanel.Dock="Top" Content="Button 1"/>
  <Button DockPanel.Dock="Left" Content="Button 2"/>
  <Button Content="Button 3"/>
</DockPanel>

Open new Windows & Close old

Pizza pizza = new Pizza();

this.Close();  
pizza.Show();