Module 1 Project - Source Code and Submission Guide (Java 17)

• Download the starter and set your base package.
• Implement the required interfaces and classes using encapsulation and access control.
• Test and run with JUnit 5; submit a ZIP with README.md and passing tests.

What this project is

You’ll build a small, testable Java 17 app that demonstrates packages, interfaces, encapsulation, and access control (Module 1 core skills). You’ll also practice directory structure, basic testing, and a minimal CLI (or `main`) entry point.

Project goals (why this matters)

• Encapsulation: expose behavior, not fields.
• Interfaces: program to contracts, enable multiple implementations.
• Packages: clear module boundaries; avoid cyclic dependencies.
• Access control: prefer private/package-private; keep APIs small.
• Tests: prove correctness with a few focused JUnit 5 tests.

 
project/
  README.md
  pom.xml (or build.gradle)
  src/
    main/
      java/
        com/yourname/oop/module1/
          App.java
          model/
          service/
          repo/
    test/
      java/
        com/yourname/oop/module1/
          AppTest.java

Set your base package: com.yourname.oop.module1 (replace yourname)

1. Domain model (minimal but real):
   • model/Student (id, name, email) - fields private, validate in constructor/setters.
   • model/Course (code, title).
   • model/Enrollment (studentId, courseCode, status).
2. Repository contract and impl:

   • 
     // repo/Repository.java
     package com.yourname.oop.module1.repo;
     import java.util.*;
     
     public interface Repository<T, ID> {
         T save(T entity);
         Optional<T> findById(ID id);
         List<T> findAll();
         boolean deleteById(ID id);
     }
                     

   • 
     // repo/InMemoryRepository.java
     package com.yourname.oop.module1.repo;
     import java.util.*;
     import java.util.concurrent.ConcurrentHashMap;
     
     public class InMemoryRepository<T, ID> implements Repository<T, ID> {
         private final Map<ID, T> store = new ConcurrentHashMap<>();
         private final java.util.function.Function<T, ID> idExtractor;
     
         public InMemoryRepository(java.util.function.Function<T, ID> idExtractor) {
             this.idExtractor = Objects.requireNonNull(idExtractor);
         }
     
         @Override public T save(T entity) {
             ID id = idExtractor.apply(entity);
             if (id == null) throw new IllegalArgumentException("Entity id cannot be null");
             store.put(id, entity);
             return entity;
         }
         @Override public Optional<T> findById(ID id) { return Optional.ofNullable(store.get(id)); }
         @Override public List<T> findAll() { return new ArrayList<>(store.values()); }
         @Override public boolean deleteById(ID id) { return store.remove(id) != null; }
     }
                     

3. Service layer (business logic):
   • service/EnrollmentService that uses repositories to enroll a student, list enrollments, drop course, etc.
   • Enforce simple rules (e.g., no duplicate enrollment).
4. Entry point (App.java): minimal CLI / demo that:
   • creates repos, seeds 1–2 students and courses, enrolls, prints results.
   • No fancy I/O needed; System.out.println is fine.

// App.java
package com.yourname.oop.module1;

import com.yourname.oop.module1.model.*;
import com.yourname.oop.module1.repo.*;
import java.util.*;

public class App {
    public static void main(String[] args) {
        Repository<Student, String> students =
            new InMemoryRepository<>(Student::id);
        Repository<Course, String> courses =
            new InMemoryRepository<>(Course::code);

        students.save(new Student("s-1", "Ava", "ava@example.com"));
        courses.save(new Course("CS101", "Intro to CS"));

        System.out.println("Students: " + students.findAll().size());
        System.out.println("Courses: " + courses.findAll().size());
    }
}

// model/Student.java
package com.yourname.oop.module1.model;
import java.util.Objects;

public final class Student {
    private final String id;
    private String name;
    private String email;

    public Student(String id, String name, String email) {
        this.id = Objects.requireNonNull(id);
        setName(name);
        setEmail(email);
    }
    public String id() { return id; }
    public String name() { return name; }
    public String email() { return email; }

    public void setName(String name) {
        if (name == null || name.isBlank()) throw new IllegalArgumentException("name");
        this.name = name.trim();
    }
    public void setEmail(String email) {
        if (email == null || !email.contains("@")) throw new IllegalArgumentException("email");
        this.email = email.trim();
    }
}

Tests (JUnit 5)

// AppTest.java
package com.yourname.oop.module1;

import com.yourname.oop.module1.model.Student;
import com.yourname.oop.module1.repo.*;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

public class AppTest {
    @Test
    void canSaveAndFindStudent() {
        Repository<Student, String> students = new InMemoryRepository<>(Student::id);
        Student s = new Student("s-1", "Ava", "ava@example.com");
        students.save(s);
        assertTrue(students.findById("s-1").isPresent());
    }
}

• Maven: mvn -q -DskipTests=false test && mvn -q -DskipTests package
• Gradle: ./gradlew test build

• Public fields in model: make fields private, expose behavior/getters.
• Leaky repos: don’t return internal mutable collections; return copies.
• God classes: keep App thin; move rules to services.
• Package soup: stay under com.yourname.oop.module1.* with clear subpackages.
• No tests: add at least 2–3 targeted tests per layer.

• ✅ README.md (how to build/run; your design notes)
• ✅ Source under com/yourname/oop/module1/...
• ✅ JUnit tests passing (include command/output in README)
• ✅ ZIP name: module1-project-yourname.zip

1. Why define a Repository<T,ID> interface?
2. Where should validation live-constructor, setters, or service?
3. When is package-private preferable to public?

1. To program to a contract, enable multiple impls (e.g., in-memory vs DB).
2. Validate invariants in constructors/setters; cross-entity rules in services.
3. When the API is internal to a package and you don’t want to expose it publicly.

• Previous: Module 1 - Access Control
• Next: Module 1 - Interfaces and Packages
• Related: Glossary - Encapsulation, Interface, Package