- Design Patterns aus GOF

- MVC

- API: HAL, HATEOAS, REST

1. HATEOAS -

1. architecture pattern

Hypermedia As The Engine Of The Aookication State

	
- REST
	GET - safe, idempotent
	PUT 
	POST - Idempotent
	DELETE - Idempotent
	PATCH
	
	

See https://stackify.com/soap-vs-rest/

	

* Java RMI
  * RMI you can have references to remote objects and invoke their methods
	RMI stands out when the need to develop something more complex than a pure client-server architecture arises

* Java RPC
  * With RPC you can just call remote functions exported into a server,In Java, when you talk about RPC, you are talking about SOAP and Web Services.
  * Lost its popularity, REST is the solution of choice.
  * SOAP - "Simple Object Access Protocol"
      * If you need ACID-compliant transactions, SOAP is the way to go.		
- CORBA
	-Common Object Request Broker Architecture

	
* REST - Representational state transfer. The general consensus among experts these days is that REST is the typically preferred protocol unless there’s a compelling reason to use SOAP
    * REST allows a greater variety of data formats, whereas SOAP only allows XML.
    * Simple
    * uses HTTP layer

	



* architecture principles 
    * SOLID
          * Single-responsibiity Principle
          * Open-Cosed
          * Liskov substitution principles 
          * Interface segregation principle
             * client should NOT implement interfaces / methods they dont use
          * Dependency Inversion principle
		- 
	

- 4+1 View: https://de.wikipedia.org/wiki/4%2B1_Sichtenmodell

• 1 Logical View
  • Diagram: https://de.wikipedia.org/wiki/Klassendiagramm
  • Diagram2: https://en.wikipedia.org/wiki/Communication_diagram
  • Diagram3: https://en.wikipedia.org/wiki/Sequence_diagram

• 2 Development view
  • Diagram: https://en.wikipedia.org/wiki/Package_diagram

• 3 Process view
  • Diagram: https://en.wikipedia.org/wiki/Activity_diagram

• 4 Physical view / deployment view
  • Diagram: https://en.wikipedia.org/wiki/Deployment_diagram

• +1 Scenarios
  • Diagram: https://en.wikipedia.org/wiki/Use_case_diagram

Polymorphism in Java has two types:

Runtime polymorphism (dynamic binding) and Compile time polymorphism (static binding).

Method overriding is an example of dynamic polymorphism, while method overloading is an example of static polymorphism.

Binding: association of method definition to the method call.

Static binding: The binding of static, private and final methods. These methods cannot be overridden, type of class is determined at compile time.

Dynamic binding: Determined at run time. Methods are not static, private, nor final.

class Dog {
    public void bark(){
        System.out.println("dog bark");
    }
}
class Hound extends Dog {
    public void bark(){
        System.out.println("hound bark");
    }
}



public class OverridingTest1 {
    public static void main(String [] args){
        Dog dog = new Dog(); // var of type dog resolves method bark at runtime
        dog.bark(); // dog bark
    }
}

public class OverridingTest2 {
    public static void main(String [] args){
        Dog dog = new Hound(); // use Hound, where method bark is overridden
        dog.bark(); // hound bark. var of type dog resolves method bark at runtime
    }
}

Method overriding is an example of dynamic polymorphism.

Method overriding, in object-oriented programming, is a language feature that allows a subclass or child class to provide a specific implementation of a method that is already provided by one of its superclasses or parent classes.

class Dog {
    public void bark(){
        System.out.println("dog bark");
    }
}
class Hound extends Dog {
    public void bark(){
        System.out.println("hound bark");
    }
}

Method overloading is an example of static polymorphism.

Method overloading in java is a feature that allows a class to have more than one method with the same name, but with different parameters

public void Square ( int number ) 
{
    int square = number * number;
    System.out.printIn(“Method with Integer Argument Called:“+square);
}

public void Square(double number)
{
    double square = number * number; 
    System.out.printIn(“Method with double Argument Called:“+square);
}

public void Square(long number)
{ 
    long square = number * number;
    System.out.printIn(“Method with long Argument Called:“+square);
}

Exlained with Python

by re-implementing “await” with scheduler

https://www.heise.de/hintergrund/Asynchrones-Programmieren-async-minus-await-7527129.html