Please enable JavaScript.

Coggle requires JavaScript to display documents.

Chapter 4 - Coggle Diagram

- - - - Functional Modelling
        
        The functional model shows the processes that are performed within an object and how the data changes as it moves between methods. It specifies the meaning of the operations of object modelling and the actions of dynamic modelling. The functional model corresponds to the data flow diagram of traditional structured analysis.
        
        State the purpose of each function
        
        Identify constraints
        
        Construct data flow diagrams showing functional dependencies
        
        Specify optimization criteria
        
        Identify all the inputs and outputs
      - Object Modelling
        
        Object modelling develops the static structure of the software system in terms of objects. It identifies the objects, the classes into which the objects can be grouped into and the relationships between the objects. It also identifies the main attributes and operations that characterize each class.
        
        Create user object model diagram
        
        Define user object attributes
        
        Identify the relationships among classes
        
        Define the operations that should be performed on the classes
        
        Identify objects and group into classes
        
        Review glossary
      - Dynamic Modelling
        
        a way of describing how an individual object responds to events, either internal events triggered by other objects, or external events triggered by the outside world”
        
        Identify states of each object
        
        Express each state in terms of object attributes
        
        Construct dynamic model diagram, comprising of state transition diagrams
        
        Validate the state–transition diagrams drawn
        
        Identify events and analyze the applicability of actions
  - - - Class Design principles
        
        (SRP) Single Responsibility Principle
        
        Objects or entities should be open for extension but closed for modification.
        
        (OCP) Open Closed Principle
        
        Objects or entities should be open for extension but closed for modification.
        
        (DIP) Dependency Inversion Principle
        
        Entities must depend on abstractions, not on concretions. It states that the high-level module must not depend on the low-level module, but they should depend on abstractions.
        
        (ISP) Interface Segregation Principle
        
        A client should never be forced to implement an interface that it doesn’t use, or clients shouldn’t be forced to depend on methods they do not use.
        
        (LSP) Liskov Substitution Principle
        
        Objects of subclass type can replace objects of parent class without causing errors.
      - Package Coupling Principles
        
        (SDP) Stable Dependencies Principle
        
        Stability is defined as the amount of changes to be made to a software package when a change is made to the dependent package. The notion of the principle is to support on dependencies in the direction of stability
        
        (SAP) Stable Abstractions Principle
        
        A package is said to be stable when any release to the other packages does not modify it. When there is a situation when all the packages pointing to the stable package, the stable package need to be abstract
        
        (ADP) Acyclic Dependencies Principle
        
        "The dependencies between packages must not form cycles"
      - Package Cohesion principle
        
        (CRP) Common Reuse Principle
        
        A programmer might choose to consume only one reusable component, but changes to the other component necessitate redistribution of the entire package
        
        (CCP) Common Closure Principle
        
        This principle suggests that you should group your classes around the impact of change
        
        (REP) Reuse-Release Equivalence Principle
        
        The REP tells us that classes should be packaged together because they are used together.
  - - - Definition : Encapsulation is defined as the wrapping up of data under a single unit. It is the mechanism that binds together code and the data it manipulates.
      - Access Modifiers
        
        Definition : you can use to define the visibility of classes, methods, and attributes. Each of them specifies a different level of accessibility, and you can only use one modifier per class, method or attribute
        
        Private
        
        This is the most restrictive and most commonly used access modifier. If you use the private modifier with an attribute or method, it can only be accessed within the same class. Subclasses or any other classes within the same or a different package can’t access this attribute or method.
        
        Default
        
        When you don’t provide any access modifier for your attribute or method, you can access it within your class and from all classes within the same package.
        
        Protected
        
        Attributes and methods with the access modifier protected can be accessed within your class, by all classes within the same package, and by all subclasses within the same or other packages.
        
        Public
        
        This is the least restrictive access modifier. Methods and attributes that use the public modifier can be accessed within your current class and by all other classes.
    - - abstract classes
        
        Definition : Data abstraction is the process of hiding certain details and showing only essential information to the user.
        Abstraction can be achieved with either abstract classes or interfaces (which you will learn more about in the next chapter). Keyword : abstract
        
        Abstract class: is a restricted class that cannot be used to create objects (to access it, it must be inherited from another class).
        
        Abstract method: can only be used in an abstract class, and it does not have a body. The body is provided by the subclass (inherited from).
      - Interface
        
        Definition : The interface in Java is a mechanism to achieve abstraction. There can be only abstract methods in the Java interface, not method body. It is used to achieve abstraction and multiple inheritance in Java.
        
        Syntax : interface <interface_name>{ }
        
        Three reasons to use interface
        
        By interface, we can support the functionality of multiple inheritance.
        
        It can be used to achieve loose coupling.
        
        It is used to achieve abstraction.
      - Difference abstract class vs. interface
        
        An abstract class allows you to create functionality that subclasses can implement or override. An interface only allows you to define functionality, not implement it. And whereas a class can extend only one abstract class, it can take advantage of multiple interfaces.
    - - Definition : Inheritance is a mechanism in which one object acquires all the properties and behaviors of a parent object. It is an important part of OOPs (Object Oriented programming system). Keyword : Extends
      - Type : single, multiple, multilevel, hierarchical, and hybrid
      - Terms used in Inheritance
        
        Class: A class is a group of objects which have common properties. It is a template or blueprint from which objects are created.
        
        Sub Class/Child Class: Subclass is a class which inherits the other class. It is also called a derived class, extended class, or child class.
        
        Super Class/Parent Class: Superclass is the class from where a subclass inherits the features. It is also called a base class or a parent class.
        
        Reusability: As the name specifies, reusability is a mechanism which facilitates you to reuse the fields and methods of the existing class when you create a new class. You can use the same fields and methods already defined in the previous class.
      - Example
        
        Class Programmer extends Employee {}
    - - Definition : Polymorphism is the ability of any data to be processed in more than one form
      - Compile Time
        
        Method overriding
        
        is when a method defined in a superclass or interface is re-defined by one of its subclasses, thus modifying/replacing the behavior the superclass provides. The decision to call an implementation or another is dynamically taken at runtime, depending on the object the operation is called from.
        
        Operator overloadding
        
        refers to the ability of a certain language-dependant operator to behave differently based on the type of its operands
        
        Run Time
        
        Virtual functions
        
        is a member function which is declared in the base class using the keyword virtual and is re-defined (Overriden) by the derived class ( the ability to take many forms )