The object-oriented programming paradigm is currently one of the most important paradigms in the programming world. Based on this idea, the course aims for students to learn how to design and program within this paradigm, using a modern language employed in real environments.
The course will emphasize the software design phase, and assumes that students already have sufficient knowledge and command of the imperative and procedural paradigm to understand the imperative functioning of a new programming language.
Given that most software projects are developed by teams of programmers, the course also aims to provide students with the necessary skills to face these work environments.
Titular Professors
Professors
Knowledge of imperative programming and basic algorithmic.
It is recommended to have taken: 50A11 Programming Methodology and Technology
- The student knows the object-oriented paradigm and all its characteristics.
- The student knows a real and current object-oriented language.
- The student develops programming projects using the tools and practices typical of a real development environment.
- The student designs software based on specific specifications.
- The student correctly uses GRASP software design patterns.
- The student works in a team.
The detailed contents of the course are (*):
- Knowledge of the object?oriented paradigm.
- Class or Prototype
- Object or Instance
- Message, Method or Operation
- Encapsulation and Abstraction
- Inheritance
- Polymorphism
- Interface
- Knowledge of a real object?oriented language.
- Introduction to Java.
- Main characteristics of Java
- Introduction to the language
- Instance / class / local / parameter variables
- Primitive data types vs references
- Arrays
- Operators
- Exception handling
- Introduction to OO
- Class declaration
- Visibility (private / protected / package / public)
- Method declaration, Constructors and Parameter passing
- The “this” reference
- Instantiation and use of objects
- Static and Final
- Enumerations
- Inheritance in Java
- Interfaces
- Class hierarchy in Java
- The Object class
- Multiple inheritance
- Method overriding
- Polymorphism
- The “super” reference
- Subclass constructors
- Abstract methods and classes
- Numbers, Characters and Strings
- Introduction to Generics
- Packages
- Basic I/O
- Collections
- AWT / Swing
- Concurrency
- Use of a real development environment.
- Diagram modelling tool
- IntelliJ IDEA as the development environment
- Git as a Version Control System
- Jira as a project manager
- Ability to design software from given specifications.
- UML
- Class / Object / Message
- Encapsulation and Abstraction
- Encapsulation vs Visibility
- Relationships between classes
- Inheritance
- Polymorphism
- Use of software design patterns.
- GRASP guidelines
- Layered Architecture
- Model–View–Controller pattern
- Responsibility-driven design
- Object-Orientation and Databases
- DAO design pattern
- Teamwork in a software development project.
- Communication tools
- Version Control systems
- Project management tools
The course contents are distributed throughout the academic year; the order of delivery does not correspond to the order of the list above. Concepts are introduced and reinforced progressively. Topics on analysis, design, implementation and patterns will be seen iteratively throughout the course while introducing different data structures.
The course is oriented so that the student takes an active role in their own learning. The teaching methodology is designed so that the course is dynamic and participatory. Lectures are combined with exercise sessions and in?class activities, as well as guided practical work with the course instructors.
The course contents are planned to be delivered at three levels. First, a theoretical introduction to the concept is given. Next, the software design concepts related to this topic are introduced. Finally, the implementation of these concepts in a programming language is explained.
The teaching methodology of the course is clearly divided into two semesters.
In the first semester, students acquire the foundations of the object?oriented paradigm and programming in Java. The teaching approach in this semester is based on lectures in which instructors introduce the concepts, work through example exercises, and guide students in the analysis and design of solutions to the proposed problems. Student learning is complemented with formative assessment through continuous?assessment exercises.
In the second semester, the course focuses on project-based learning. The knowledge acquired during the first semester is consolidated by carrying out an almost real software development project.
The course is organized into two independent semesters, both of which are mandatory to pass the course. Assessment combines individual exercises with a heavily weighted project in each semester. The first semester includes formative exercises and a project divided into phases that must be passed individually for the project to be considered valid, with the possibility that the exercise grades count only if they are favorable to the student. The second semester also includes individual exercises and a group project that is graded based on the work completed, the mentor’s evaluation, and peer assessment.
[1] C.S.Horstman and G.Cornell, Core Java 2, Vol I. Fundamentos, Septima edición, Prentice Hall, 2006.
[2] K.Arnold, JGosling and D.Holmes, The Java programming language, Boston : Addison-Wesley, 2000
[3] M.Fowler, UML Distilled Third Edition. A brief guide to the standard object modeling language, Addison-Wesley, 2003.
[4] R.Miles and K.Hamilton, Learning UML 2.0, O'Reilly Media Inc, 2006.
[5] C.Larman, Applying UML and patterns : an introduction to object-oriented analysis and design, Prentice Hall PTR, 1998
[6] E.Gamma, R.Helm, R.Johnson and J.Vlissides, Design patterns: elements of reusable object-oriented software, Addison-Wesley Longman Publishing Co., 1995
[7] J.Cooper, Java Design Patterns, Addison Wesley, 2000
[8] D.Lea, Concurrent programming in Java: design principles and patterns, Addison-Wesley, 2000
[9] M.Fowler, Refactoring: Improving the Design of Existing Code, Addison-Wesley Professional, 2018
[10] R.Martin, Clean Code: A Handbook of Agile Software Craftsmanship, Pearson, 2008
[11] K.Sierra and B.Bates, Head First Java, O'Reilly Media, 2005
[12] E.Freeman, B.Bates, K.Sierra and E.Robson, Head First Design Patterns: A Brain-Friendly Guide, O'Reilly Media, 2004