Create 15A. UML Modeling Language

Week 7: Enum, Generic Type, Streams, write to file, class diagram/15A. UML Modeling Language

@@ -0,0 +1,241 @@
+UML (Unified Model Language)
+to document object-oriented programs
+
+It can be used to graphically depict the BASIC STRUCTURES of object-oriented programming, such as CLASSES and their INHERITANCE relationships. 
+These diagrams are usually referred to as CLASS DIAGRAMS.
+
+
+
+
+
+
+
+
+Class
+In UML, a class is represented by a frame consisting of 3 parts. 
+At the top is the class NAME, 
+in the middle are the class ATTRIBUTES, and 
+at the bottom are the class METHODS.
+
+ATTRIBUTES are presented in the form
+name: type
+
+
+A + or - is written in front of the attribute depending on whether the attribute is 'public' or 'private'. 
+The sign for a 'protected' attribute is (usually) #.
+
+So for example a protected, double type attribute balance would be marked:
+#balance: double
+
+...and a private Student type attribute tutor:
+-tutor: Student
+
+
+
+
+
+METHODS are represented in a similar form, but also the PARAMS of the methods are announced in the diagram. 
+The 'method type' is reported after the parameter list.
+
+So, for example, the set method 'setName' could be marked as follows:
++setName(name: String): void
+
+
+
+
+=================================================
+
+
+ 
+
+Let's look at the class 'Exercise' as an example:
+
+class Exercise {
+    // PRIVATE ATTRIBUTES
+    private String correctAnswer;
+    private String exerciseDescription;
+    private double points;
+
+    // CONSTRUCTOR
+    public Exercise(String correctAnswer, String exerciseDescription, double points) {
+        this.correctAnswer = correctAnswer;
+        this.exerciseDescription = exerciseDescription;
+        this.points = points;
+    }
+
+    public String getExerciseDescription() {
+        return exerciseDescription;
+    }
+
+    public double getPoints() {
+        return points;
+    }
+
+    public void setPoints(double points) {
+        this.points = points;
+    }
+    
+    public void checkAnswer(String answer) {
+        if (answer.equals(correctAnswer)) {
+            points = 10;
+        }
+    }
+}
+ 
+
+The UML diagram drawn from the class would look like this:
+https://ville.utu.fi/APP/connector/0/219/source/9c79f234-86e5-43c5-821a-eaee0895bdeb.png
+
+
+Exercise
+-correctAnswer: String
+-exercise Description: String
+-points: double
+
++Exercise (correctAnswer: String, exercise Description: String, points: double)
++getExerciseDescription(): String
++getPoints(): String
++setPoints(points: double): void
++checkAnswer(answer: string): void
+
+
+
+
+
+
+
+====================================
+
+
+Modeling Class Hierarchies
+
+Inheritance is marked with an ARROW that STARTS FROM the INHERITING CLASS. 
+The head of the arrow is a triangle. 
+If, for example, we have a class 'Teacher' that inherits from the class 'Person', the diagram could look like this:
+https://ville.utu.fi/APP/connector/0/227/source/bf884576-16f4-4ef0-a9e5-a4e69cf1faa3.png
+
+
+
+Person
++email: String
+-name: String
++Person(email: String, name: String)
++getName(): String
++setName(): String
+
+^
+-
+|
+|
+|
+|
+|
+
+Teacher
+-teachingSubject: String
++Teacher(email: String, name: String, teachingSubject: String)
++getTeaching Subject(): String
+
+
+
+
+
+
+
+
+Interface classes are marked by writing the word <interface> above the class name. 
+The implementation of the 'interface' is marked with an arrow similar to inheritance.
+
+For example, the 'interface' class 'Priced' and its implementing class 'Product':
+
+ 
+
+interface Priced {
+    double getPrice();
+    void setPrice(double price);
+}
+
+
+class Product implements Priced {
+    
+    private String name;
+    private double price;
+    private String code;
+    
+    public Product(String name, double price, String code) {
+        this.name = name;
+        this.price = price;
+        this.code = code;
+    }
+
+    @Override
+    public double getPrice() {
+        return price;
+    }
+
+    @Override
+    public void setPrice(double price) {
+        this.price = price;
+    }
+}
+ 
+
+...could be represented with a diagram like this:
+https://ville.utu.fi/APP/connector/0/234/source/9b1af723-9438-4cb5-96bc-d20e586f2239.png
+
+
+
+<interface>
+Priced
+-getPrice(): double
++setPrice(price: double): void
+
+
+^
+-
+|
+|
+|
+|
+|
+
+
+Product
+-code: String
+-name: String
+-price: double
++Product(code: String, name: String, price: double)
++getPrice(): double
++setPrice(price: double): void
+
+
+
+
+
+
+
+
+
+
+
+
+====================================
+
+
+
+
+More Information on Class Diagrams
+
+There is plenty of additional information about UML and class diagrams on the internet.
+
+Diagrams can be drawn with almost any drawing program. 
+A good free environment for drawing diagrams is DIA, for example:
+http://dia-installer.de/
+
+The online draw.io is also well suited for drawing UML diagrams:
+https://app.diagrams.net/
+
+There are also various plugins for Eclipse and other editors 
+that can automatically generate a UML diagram from your code (or even code from a UML diagram).
+
+