Lecture #1: Course Overview

This course (originally “Conception Logicielle à Objets”) introduces object-oriented design and programming, using Java as the working language. The concepts taught are general — they apply to other object-oriented languages in the “C family” (C++, C#, etc.) — but Java is used throughout for examples and lab work because it is a clean, fully object-oriented language for learning these ideas.

Schedule

This edition runs as 12 hours of lectures and 12 hours of lab work, aimed at students who already know C and standard data structures — the goal is a solid working grasp of Java specifically, not a from-scratch introduction to programming or to data structures. See the session-by-session schedule for how the material maps onto that time.

What the Course Covers

Basic OOP concepts. The starting point is the vocabulary and mental model of object orientation: objects, classes, messages (method calls), and class hierarchies built through inheritance. The goal is to see how grouping data (attributes) and behavior (methods) into classes, and factoring shared behavior into parent classes, leads to code that is shorter, more reusable, and easier to extend — for instance, adding a new subclass without having to touch code that already works with the parent class.

Java specifics. Once the general ideas are in place, the course looks at how Java implements them concretely: syntax, class and object declarations, and the language features and conventions specific to Java as opposed to the abstract OOP model.

References and object identity. The part of Java that trips up C programmers the most: object variables hold references (not values), assignment creates aliases, method calls pass the reference by value, == compares identity rather than content, and every class needs a deliberate equals/hashCode/toString if it’s going to behave correctly in comparisons, printouts, and hash-based collections.

Advanced concepts. This module goes deeper into abstraction (abstract classes and methods that defer implementation to subclasses) and subtyping (how an object of a subclass can stand in for an object of its supertype, and what guarantees that relationship provides). These ideas underpin polymorphism — the ability to write code that works uniformly over many different object types.

Exceptions. Java’s structured mechanism for signaling and handling error conditions. This covers how to raise, propagate, and catch exceptions, and how to design error handling that keeps code robust without cluttering the main logic.

Collections. An introduction to the java.util library: lists, sets, maps, and the utility classes built around them. Collections are a natural showcase for polymorphism — the same add/remove/iterate operations work regardless of the underlying structure (linked list, resizable array, etc.).

Packages and encapsulation. How Java organizes code into packages and controls visibility (public, private, protected, package-private) to enforce clean boundaries between components and hide implementation details.

Files and object serialization. How to persist objects to disk and read them back, using Java’s serialization mechanism to convert live objects into a storable/transmittable form and reverse the process.

Objects and graphical interfaces. A look at how GUI toolkits are themselves a strong illustration of object-oriented design: windows, buttons, and menu items are objects, and user interaction (clicks, events) is handled through the same polymorphic, message-passing style introduced earlier in the course.

Resources

For reference material, consult the course wiki on the Polytech Lille portal (under the Software Engineering specialty’s course documents), and install a Java SE Development Kit (JDK), version 8 or later, from Oracle’s or an OpenJDK distribution’s official site.

Course originally authored by B. Carré, Polytech Lille. This document is an independent English-language overview covering the same topics, not a translation.