Object-Oriented Design

Start Date: 07/05/2020

Course Type: Common Course

Course Link: https://www.coursera.org/learn/object-oriented-design

About Course

This course takes Java beginners to the next level by covering object-oriented analysis and design. You will discover how to create modular, flexible, and reusable software, by applying object-oriented design principles and guidelines. And, you will be able to communicate these designs in a visual notation known as Unified Modelling Language (UML). You will be challenged in the Capstone Project to apply your knowledge of object-oriented design by evolving and documenting the Java codebase for an Android application with corresponding UML documentation. After completing this course, you will be able to: • Apply the Class Responsibility Collaborator (CRC) technique to analyze and design the object-oriented model for a problem. • Explain and apply object-oriented modeling principles and their purpose (e.g., abstraction, encapsulation, decomposition, generalization). • Explain and apply different types of inheritance • Explain the difference between association, aggregation, and composition dependencies. • Express object-oriented models as Unified Modeling Language (UML) class diagrams. • Translate between UML class diagrams and equivalent Java code. • Apply design guidelines for modularity, separation of concerns, information hiding, and conceptual integrity to create a flexible, reusable, maintainable design. • Explain the tradeoff between cohesion and coupling.

Course Syllabus

Good software design begins before coding. After establishing the initial software requirements, design practices involve two main activities: conceptual design and technical design. In this module, you will realize the importance of design and object-oriented thinking, and learn how to design software using techniques like CRC cards.

Coursera Plus banner featuring three learners and university partner logos

Course Introduction

Object-Oriented Design in Scala This course provides a brief introduction to object-oriented programming, including basic data structures and common patterns used to organize code. We'll work on the design of a simple object-oriented program, which will serve as a starting point for more advanced assignments. You'll learn some programming techniques, and then we'll talk about how to break up large programs into smaller pieces and how to make them execute more efficiently. Please note that the course is intended for advanced learners, those who plan to use Scala as their main language for expressing their ideas. You, the learner, are highly encouraged to join us if you are interested in learning more about object-oriented programming, but if you are new to Scala you may find this course to be more suitable for you. The course also contains two Scala plug-in packs, one for the JVM and one for the JVM platform. JVM is a much faster JVM than the JVM platform for Java programs, and it is also free. Why use JVM? Well, at the end of the course you will also have learned how to use the standard Java libraries, and how the JVM runs Java code (which is the same object-oriented code that is executed in C programs). In addition, the JVM runs Java code, so you get all the benefits of Scala while still receiving all the power and flexibility of Java. Note that the course is intended for advanced learners, those who plan to

Course Tag

Object-Oriented Design Object-Oriented Analysis And Design Unified Modeling Language (UML)

Related Wiki Topic

Article Example
Object-oriented design Some typical input artifacts for object-oriented design are:
Object-oriented design Object-oriented design is a method of design encompassing the process of object-oriented decomposition and a notation for depicting both logical and physical as well as state and dynamic models of the system under design.
Object-oriented operating system An object-oriented operating system is an operating system that uses object oriented design principles.
Object-oriented design An object contains encapsulated data and procedures grouped together to represent an entity. The 'object interface' defines how the object can be interacted with. An object-oriented program is described by the interaction of these objects. Object-oriented design is the discipline of defining the objects and their interactions to solve a problem that was identified and documented during object-oriented analysis.
Object-oriented design Object-oriented design is the process of planning a system of interacting objects for the purpose of solving a software problem. It is one approach to software design.
Object-oriented design The input for object-oriented design is provided by the output of object-oriented analysis. Realize that an output artifact does not need to be completely developed to serve as input of object-oriented design; analysis and design may occur in parallel, and in practice the results of one activity can feed the other in a short feedback cycle through an iterative process. Both analysis and design can be performed incrementally, and the artifacts can be continuously grown instead of completely developed in one shot.
GRASP (object-oriented design) General responsibility assignment software patterns (or principles), abbreviated GRASP, consist of guidelines for assigning responsibility to classes and objects in object-oriented design.
Object-oriented analysis and design Important topics during OOD also include the design of software architectures by applying architectural patterns and design patterns with object-oriented design principles.
Object-oriented design What follows is a description of the class-based subset of object-oriented design, which does not include object prototype-based approaches where objects are not typically obtained by instancing classes but by cloning other (prototype) objects.
Object-oriented operating system The present day operating systems use object-oriented design principles for many components of the system, which includes protection.
Object-oriented design The five basic concepts of object-oriented design are the implementation level features that are built into the programming language. These features are often referred to by these common names:
Identity (object-oriented programming) An identity in object-oriented programming, object-oriented design and object-oriented analysis describes the property of objects that distinguishes them from other objects. This is closely related to the philosophical concept of identity.
GRASP (object-oriented design) Computer scientist Craig Larman states that "the critical design tool for software development is a mind well educated in design principles. It is not UML or any other technology." Thus, GRASP are really a mental toolset, a learning aid to help in the design of object-oriented software.
Layer (object-oriented design) In object-oriented design, a layer is a group of classes that have the same set of link-time module dependencies to other modules. In other words, a layer is a group of reusable components that are reusable in similar circumstances. In programming languages, the layer distinction is often expressed as "import" dependencies between software modules.
Design Patterns Chapter 1 is a discussion of object-oriented design techniques, based on the authors' experience, which they believe would lead to good object-oriented software design, including:
GRASP (object-oriented design) The different patterns and principles used in GRASP are: controller, creator, indirection, information expert, high cohesion, low coupling, polymorphism, protected variations, and pure fabrication. All these patterns answer some software problem, and these problems are common to almost every software development project. These techniques have not been invented to create new ways of working, but to better document and standardize old, tried-and-tested programming principles in object-oriented design.
GRASP (object-oriented design) Creation of objects is one of the most common activities in an object-oriented system. Which class is responsible for creating objects is a fundamental property of the relationship between objects of particular classes.
Object-oriented programming Challenges of object-oriented design are addressed by several methodologies. Most common is known as the design patterns codified by Gamma "et al.". More broadly, the term "design patterns" can be used to refer to any general, repeatable solution to a commonly occurring problem in software design. Some of these commonly occurring problems have implications and solutions particular to object-oriented development.
GRASP (object-oriented design) It is defined as the first object beyond the UI layer that receives and coordinates ("controls") a system operation. The controller should delegate the work that needs to be done to other objects; it coordinates or controls the activity. It should not do much work itself. The GRASP Controller can be thought of as being a part of the application/service layer (assuming that the application has made an explicit distinction between the application/service layer and the domain layer) in an object-oriented system with common layers in an information system logical architecture.
Object-oriented software engineering OOSE was developed by Ivar Jacobson in 1992 while at Objectory AB. It is the first object-oriented design methodology to employ use cases to drive software design. It also uses other design products similar to those used by Object-modeling technique.