Differences

This shows you the differences between two versions of the page.

--- devops:software_architecture [2022/11/29 20:53] – [Summary] skipidar
+++ devops:software_architecture [2024/01/11 09:09] (current) – skipidar
@@ Line 43: / Line 43: @@
-- Java RMI
+  * Java RMI
-	- 	RMI you can have references to remote objects and invoke their methods
+    * 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
+  * Java RPC
-	- With RPC you can just call remote functions exported into a server,
+    * 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.
-	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"
-	Lost its popularity, REST is the solution of choice.
+        * If you need ACID-compliant transactions, SOAP is the way to go.
-	- SOAP
-		Simple Object Access Protocol
-			- If you need ACID-compliant transactions, SOAP is the way to go.
-			-
 	- CORBA
 		-Common Object Request Broker Architecture
-- REST
+  * 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
-	Representational state transfer
+      * REST allows a greater variety of data formats, whereas SOAP only allows XML.
-	The general consensus among experts these days is that REST is the typically preferred protocol unless there’s a compelling reason to use SOAP
+      * Simple
-		- REST allows a greater variety of data formats, whereas SOAP only allows XML.
+      * uses HTTP layer
-		- SImple
-		- uses HTTP layer
@@ Line 75: / Line 66: @@
-- architecture principles
+  * architecture principles
-	- SOLID
+      * SOLID
-		- Single-responsibiity Principle
+            * Single-responsibiity Principle
-			-
+            * Open-Cosed
-		- Open-Cosed
+            * Liskov substitution principles
-			-
+            * Interface segregation principle
-		- Liskov substitution principles
+               * client should NOT implement interfaces / methods they dont use
-		- Interface segregation principle
+            * Dependency Inversion principle
-			- client should NOT implement interfaces / methods they dont use
-		- Dependency Inversion principle
 			-
 - 4+1 View: https://de.wikipedia.org/wiki/4%2B1_Sichtenmodell
-  * Logical View
+  * 1 Logical View
     * Diagram: https://de.wikipedia.org/wiki/Klassendiagramm
     * Diagram2: https://en.wikipedia.org/wiki/Communication_diagram
@@ Line 95: / Line 84: @@
-  * Development view
+  * 2 Development view
     * Diagram: https://en.wikipedia.org/wiki/Package_diagram
-  * Process view
+  * 3 Process view
     * Diagram: https://en.wikipedia.org/wiki/Activity_diagram
-  * Physical view / deployment view
+  * 4 Physical view / deployment view
     * Diagram: https://en.wikipedia.org/wiki/Deployment_diagram
-  * Scenarios
+  * +1 Scenarios
     * Diagram: https://en.wikipedia.org/wiki/Use_case_diagram
+===== Object-Oriented Programming OOP =====
+=== Polymorphism ===
+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 ===
+<color #22b14c>Binding</color>: association of method definition to the method call.
+<color #22b14c>Static binding</color>: The binding of static, private and final methods. These methods cannot be overridden, type of class is determined at compile time.
+<color #22b14c>Dynamic binding</color>: Determined at run time. Methods are not static, private, nor final.
+<sxh java>
+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
+    }
+}
+</sxh>
+=== Method Overriding ===
+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.
+<sxh java>
+class Dog {
+    public void bark(){
+        System.out.println("dog bark");
+    }
+}
+class Hound extends Dog {
+    public void bark(){
+        System.out.println("hound bark");
+    }
+}
+</sxh>
+=== Method Overloading ===
+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**
+<sxh java>
+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);
+}
+</sxh>
+===== Async programming =====
+Exlained with Python
+by re-implementing "await" with scheduler
+https://www.heise.de/hintergrund/Asynchrones-Programmieren-async-minus-await-7527129.html