Lecture 1-8

OO Paradigm's 4 fundamental concepts

Abstraction, Polymorphism, Inheritance, Encapsulation (A-PIE)

Abstraction (Updated Definition)

the ability of separating the interface from implementation

Abstraction Advantages

Simplifies complex systems by hiding unnecessary details (increases readability, reusability, testability, and maintainability)

Inheritance pt.1 (two way ability)

Inheritance is two way ability: ability to extend parent class capabilities by creating a child class that gets all parent capabilities and possibly defines more

Inheritance pt.2 (two way ability)

the ability of factoring out the common capabilities of a group of classes (children) into a parent class

parent class is called?

superclass

child class is called?

subclass

Mother class of Java

Object class

Keyword in Java to denote Inheritance

extends

Inheritance relationship

asymmetric relationship, child inherits from parent, parent doesn't inherit from child

Subclass can have..?

additional methods/instance fields

Method overriding

re-implementing an inherited method in the subclass

Inheritance in UML

ClassA inherits from ClassB

What members of superclass would be inherited by subclass?

All visible members

Can you declare same instance variables of superclass in subclass?

Yes, BUT DONT DO IT.

How to invoke superclass constructor?

use super(); as first statement of subclass constructor

How to invoke superclass method?

use super keyword (good programming practice even if optional)

Multiple Inheritance (have 2+ direct superclasses)

NOT SUPPORTED IN JAVA; increases complexity of programming

Implementation Artifact

Source code and Read

Implementation Goals

to implement, test and integrate classes

Big Bang Integration Strategy

WORST IMPLEMENTATION STRATEGY

OOP Implementation Strategy

implement a class, test it, integrate into software, test again (integration testing)

Prototype

simple version of the software that served as mockups

Implementation: Two phenomena

needs to cope with non-stop change and increasing complexity (OOD is most effective)

Testing

systematic attempts to find defects (breaking code deliberately)

Testing criteria

compare behavior with what was promised in functional spec; any violation from functional spec is considered a defect.

Types of Testing

UNIT, integration, smoke, regression, stress, user acceptance, alpha/beta

Unit Testing

make sure all units (methods/objects/packages) of the software individually works fine

Expected Value vs. Actual Value

value of variable we expect to get vs what we get after executing code (TWO VALUES SHD BE EQUAL IN WORKING CODE)

JUnit5 Framework

organizes testcases OUTSIDE of source code (helps with neatness)

JavaFX

framework written in Java for creating graphical user interface (GUI) in java applications (desktop & web)

Why is JavaFx better than Swing?

JavaFX has richer libraries/widgets, GUI can be created faster, more efficient applications, more readable, better support for MVC, easier to integrate sound and video

Goals of Design

Identify the classes, responsibilities (interface), relationships between classes

Technical-spec

artifact from design phase; official description of software components written by software designers for developers

technical-spec ingredients

repeat problem statement, block diagram of software architecture, UML diagrams showing classes/relationships, UI mockups

identifying classes from functional-spec

look for nouns, don't be too specific or too general

identifying responsibilities

look for verbs, every responsibility belongs to only one class,

CRC

class-responsibilities-collaborations, technique to refine classes/responsibilities, find a class for each responsibility, find class' relationships

crc card (NOT PART OF TECHNICAL-SPEC)

describes one class- contains name of class, responsibilities of class, and it's dependencies/collaborators

Golden Rule of Design

every class should have a single purpose.

Quality of Class' Interface (5 Cs)

Cohesion, Completeness, Convenience, Clarity, Consistency

Cohesion

a class is cohesive if it has a single purpose

Completeness

class' interface should support all responsibilities it was intended to and NOTHING LESS

Convenience

class' interface should be easy to use

Clarity

there should be no confusion in class's interface (should be clear and readable)

Consistency

operations in a class should be consistent

Benefits of 5 Cs

higher readability, maintainability, reusability, and testability.

Relationship Between Classes

6 relationships - dependency, aggregation, composition, inheritance, interface implementation

Dependency (uses relationship)

ClassA depends on ClassB is ClassA USES ClassB (asymmetrical relationship- only works one way); classB is mentioned in classA

Is imported by unused class a dependency?

YES, because Java compiler looks for it when compiling the code.

Is importing a library in a class a dependency?

If it's a Java library then NO, any other libraries YES.

Golden Rule of Design #2

Minimize dependency between the classes so that we can be less concerned about how changes in ClassB will affect ClassA (easier maintenance)

Aggregation (has-a-relationship)

ClassA aggregates ClassB if ClassA has ClassB in its INSTANCE VARIABLES; implemented through instance variables

Multiplicity of Aggregation

how many instances of ClassB is required in classA; written as x(# of ClassA's instances):z(# of classBs instances)

precise multiplicity

use a range for number of instances of ClassB; x:y..z

(# of classA instances):(min # of classB instances)..(max # of classB instances)

difference between aggregation and dependency

aggregation is a subset (type) of dependency

Composition

ClassA composes ClassB if ClassA has ClassB in its instance variables AND ClassB CANNOT exist independently

Showing relationships between Classes using UML diagrams

use connectors, each of the 6 relationships has a specific connector

Diamond for both aggregation/composition is at the end of of the..?

aggregator/composer class

Sequence Diagram

shows interaction between OBJECTS during RUNTIME- show single method behavior (single complex use case)

Preferred way to write object in sequence diagram

Rectangle, underlined font for object, name is ( : ClassName); other ways are just objectName and objectName : ClassName

State Diagram

shows how different states of an OBJECT change its behavior during RUNTIME; for SPECIFIC OBJECTS that have high impact on system behavior

Entity

any individual thing that exists in this universe

Cyberspace

virtual universe; electronic model of the real universe

Paradigm

a method for modeling and representing ENTITIES and their INTERACTIONS

Object Oriented Paradigm

models entities of the real universe with objects

Object

entity in the cyberspace that has a state, behavior, and identity

State of an Object

the set of the values of the attributes at any moment

Behavior of an Object

set of the operations (services/methods) that an object can do (or give)

Identity of an Object

unique name given to the object by the JVM (helps distinguish objects with same states and behaviors)

Abstraction

removing the details to have a generic concept/blueprint of it

Class

an abstraction of similar objects

Class Members

instance variables (attributes), methods (behavior), and nested classes

Access Modifiers

public (no restrictions, global visibility), protected (only visible in same package), default (same package), private (most restricted, only in same class)

API (of a single class or library)

whatever can be seen by other classes

Interface

whatever can be seen by other classes from a SINGLE CLASS

UML (Unified Modeling Language)

A tool for diagramming a set of object classes has class name, instance variables, and methods

JavaDoc Tags

@author
@param
@return,
we can also add new tags

javadoc utility

creates HTML pages for classes takes first sentence of comments into summary table (so first sentence should be rlly descriptive)

Problem Statement

non-technical document from client that clearly describes the problem with 3 major parts problem, vision, domain

Software Development Lifecycle (SDLC)

(1) Planning (2) Analysis (3) Design (4) Implementation (5) Testing (6) Delivery (7) Maintenance

The sequence of these phases is the SDLC

Planning Phase

allocating resources (time, team, money), creating project plan

Artifact

The output of a phase (document, source code, diagrams, etc.)

Analysis Phase

transform problem statement to a precise description of the tasks that the software is going to do

Functional-spec

Artifact from Analysis Phase official description of requirements demanded by client

Components of Functional-spec

Problem in more detail, describe what required features are (NOT HOW), describe use-cases, has software mockup

Use Case

description of the steps that provides ONE BENEFIT (feature) of your software (system) to the client; in analysis phase

Use case Variants

use cases should predict bad scenarios too; bad scenarios are variants/alternatives