Course Detail
Course Detail
Course Description
| Course | Code | Semester | T+P (Hour) | Credit | ECTS |
|---|---|---|---|---|---|
| OBJECT-ORIENTED PROGRAMMING | - | Spring Semester | 3+2 | 4 | 6 |
| Course Program |
| Prerequisites Courses | |
| Recommended Elective Courses |
| Language of Course | English |
| Course Level | Short Cycle (Associate's Degree) |
| Course Type | Elective |
| Course Coordinator | Assist.Prof. Ali DEMİR |
| Name of Lecturer(s) | |
| Assistant(s) | |
| Aim | This course aims to provide students with a deep and comprehensive understanding of Object-Oriented Programming (OOP) principles and their practical application using Java. Students will master the four pillars of OOP—Encapsulation, Inheritance, Polymorphism, and Abstraction—and learn to apply advanced concepts including design patterns (Creational, Structural, Behavioral), SOLID principles, and composition over inheritance. The course also equips students with modern software development skills such as unit testing (JUnit), UML modeling, build automation (Maven/Gradle), and collaborative Git workflows. By the end of the course, students will be able to architect robust, maintainable, and scalable Java applications. |
| Course Content | This course contains; Introduction to Object-Oriented Programming; four pillars of OOP (Encapsulation, Abstraction, Inheritance, Polymorphism); Java syntax, compilation, and execution; development environment setup (JDK and IDE); first Java program ("HelloWorld"); Java program structure (class, main method),Encapsulation and data hiding; access modifiers (private, protected, public, default); getter and setter methods; data validation in setters; immutable objects and final fields; class and external access rules; wrapper classes,Inheritance and "is-a" relationship; extends keyword; super() for parent constructor calls; constructor chaining; method overriding and @Override annotation; role of access modifiers in inheritance; final classes and final methods; common pitfalls and best practices,Polymorphism; compile-time vs. runtime polymorphism; abstract classes and abstract methods; upcasting and downcasting; Liskov Substitution Principle (LSP); polymorphic behavior in collections; real-world examples,Creational Design Patterns; interfaces and the importance of abstraction; Factory Method pattern; Abstract Factory pattern; Singleton pattern (eager and lazy initialization); relationship with Open/Closed Principle; coding examples and implementations,Composition and "has-a" relationship; Inheritance vs Composition comparison; advantages of composition (loose coupling, flexibility, testability); dangers of deep inheritance hierarchies; the pitfall of inheriting just for code reuse (fragile base class, yo-yo problem); design guidelines (favor composition over inheritance); composition with dependency injection; refactoring example,Structural Design Patterns; Adapter pattern (bridging incompatible interfaces); Decorator pattern (adding behavior dynamically); Composite pattern (part-whole hierarchies); purpose, benefits, and Java implementations of each pattern; pattern comparison,Midterm Exam,Behavioral Design Patterns; Strategy pattern (making algorithms interchangeable); Observer pattern (publish-subscribe mechanism); Command pattern (encapsulating requests as objects); participants, use cases, and code examples for each pattern; pattern comparison (Strategy, Observer, Command),SOLID Principles Deep Dive; S — Single Responsibility Principle; O — Open/Closed Principle; L — Liskov Substitution Principle; I — Interface Segregation Principle; D — Dependency Inversion Principle; code smells and before/after refactoring examples for each principle; interactions between principles and practical application tips,Unit Testing and Test-Driven Development (TDD); mocking dependencies with Mockito; test case design and test coverage; integration of tests into continuous integration; example test implementations,Project Planning and Architecture Review; UML modeling (Use Case, Class, and Package Diagrams); build automation (Maven vs Gradle); standard directory structure and Maven lifecycle; code documentation and Javadoc standards; collaborative Git workflow (feature branching, Pull Request, CI/CD); project submission criteria and evaluation,comprehensive review of OOP principles and design patterns; application of SOLID principles in projects; common mistakes and best practices;,Advanced Java topics, Other OOP languages. |
| Course Learning Outcomes | Teaching Methods | Assessment Methods |
| Teaching Methods: | |
| Assessment Methods: |
Course Outline
| Order | Subjects | Preliminary Work |
|---|---|---|
| 1 | Introduction to Object-Oriented Programming; four pillars of OOP (Encapsulation, Abstraction, Inheritance, Polymorphism); Java syntax, compilation, and execution; development environment setup (JDK and IDE); first Java program ("HelloWorld"); Java program structure (class, main method) | |
| 2 | Encapsulation and data hiding; access modifiers (private, protected, public, default); getter and setter methods; data validation in setters; immutable objects and final fields; class and external access rules; wrapper classes | |
| 3 | Inheritance and "is-a" relationship; extends keyword; super() for parent constructor calls; constructor chaining; method overriding and @Override annotation; role of access modifiers in inheritance; final classes and final methods; common pitfalls and best practices | |
| 4 | Polymorphism; compile-time vs. runtime polymorphism; abstract classes and abstract methods; upcasting and downcasting; Liskov Substitution Principle (LSP); polymorphic behavior in collections; real-world examples | |
| 5 | Creational Design Patterns; interfaces and the importance of abstraction; Factory Method pattern; Abstract Factory pattern; Singleton pattern (eager and lazy initialization); relationship with Open/Closed Principle; coding examples and implementations | |
| 6 | Composition and "has-a" relationship; Inheritance vs Composition comparison; advantages of composition (loose coupling, flexibility, testability); dangers of deep inheritance hierarchies; the pitfall of inheriting just for code reuse (fragile base class, yo-yo problem); design guidelines (favor composition over inheritance); composition with dependency injection; refactoring example | |
| 7 | Structural Design Patterns; Adapter pattern (bridging incompatible interfaces); Decorator pattern (adding behavior dynamically); Composite pattern (part-whole hierarchies); purpose, benefits, and Java implementations of each pattern; pattern comparison | |
| 8 | Midterm Exam | |
| 9 | Behavioral Design Patterns; Strategy pattern (making algorithms interchangeable); Observer pattern (publish-subscribe mechanism); Command pattern (encapsulating requests as objects); participants, use cases, and code examples for each pattern; pattern comparison (Strategy, Observer, Command) | |
| 10 | SOLID Principles Deep Dive; S — Single Responsibility Principle; O — Open/Closed Principle; L — Liskov Substitution Principle; I — Interface Segregation Principle; D — Dependency Inversion Principle; code smells and before/after refactoring examples for each principle; interactions between principles and practical application tips | |
| 11 | Unit Testing and Test-Driven Development (TDD); mocking dependencies with Mockito; test case design and test coverage; integration of tests into continuous integration; example test implementations | |
| 12 | Project Planning and Architecture Review; UML modeling (Use Case, Class, and Package Diagrams); build automation (Maven vs Gradle); standard directory structure and Maven lifecycle; code documentation and Javadoc standards; collaborative Git workflow (feature branching, Pull Request, CI/CD); project submission criteria and evaluation | |
| 13 | comprehensive review of OOP principles and design patterns; application of SOLID principles in projects; common mistakes and best practices; | |
| 14 | Advanced Java topics, Other OOP languages |
| Resources |
Course Contribution to Program Qualifications
| Course Contribution to Program Qualifications | |||||||
| No | Program Qualification | Contribution Level | |||||
| 1 | 2 | 3 | 4 | 5 | |||
Assessment Methods
| Contribution Level | Absolute Evaluation | |
| Rate of Midterm Exam to Success | 40 | |
| Rate of Final Exam to Success | 60 | |
| Total | 100 | |
| ECTS / Workload Table | ||||||
| Activities | Number of | Duration(Hour) | Total Workload(Hour) | |||
| Course Hours | 0 | 0 | 0 | |||
| Guided Problem Solving | 0 | 0 | 0 | |||
| Resolution of Homework Problems and Submission as a Report | 0 | 0 | 0 | |||
| Term Project | 0 | 0 | 0 | |||
| Presentation of Project / Seminar | 0 | 0 | 0 | |||
| Quiz | 0 | 0 | 0 | |||
| Midterm Exam | 0 | 0 | 0 | |||
| General Exam | 0 | 0 | 0 | |||
| Performance Task, Maintenance Plan | 0 | 0 | 0 | |||
| Total Workload(Hour) | 0 | |||||
| Dersin AKTS Kredisi = Toplam İş Yükü (Saat)/30*=(0/30) | 0 | |||||
| ECTS of the course: 30 hours of work is counted as 1 ECTS credit. | ||||||
Detail Informations of the Course
Course Description
| Course | Code | Semester | T+P (Hour) | Credit | ECTS |
|---|---|---|---|---|---|
| OBJECT-ORIENTED PROGRAMMING | - | Spring Semester | 3+2 | 4 | 6 |
| Course Program |
| Prerequisites Courses | |
| Recommended Elective Courses |
| Language of Course | English |
| Course Level | Short Cycle (Associate's Degree) |
| Course Type | Elective |
| Course Coordinator | Assist.Prof. Ali DEMİR |
| Name of Lecturer(s) | |
| Assistant(s) | |
| Aim | This course aims to provide students with a deep and comprehensive understanding of Object-Oriented Programming (OOP) principles and their practical application using Java. Students will master the four pillars of OOP—Encapsulation, Inheritance, Polymorphism, and Abstraction—and learn to apply advanced concepts including design patterns (Creational, Structural, Behavioral), SOLID principles, and composition over inheritance. The course also equips students with modern software development skills such as unit testing (JUnit), UML modeling, build automation (Maven/Gradle), and collaborative Git workflows. By the end of the course, students will be able to architect robust, maintainable, and scalable Java applications. |
| Course Content | This course contains; Introduction to Object-Oriented Programming; four pillars of OOP (Encapsulation, Abstraction, Inheritance, Polymorphism); Java syntax, compilation, and execution; development environment setup (JDK and IDE); first Java program ("HelloWorld"); Java program structure (class, main method),Encapsulation and data hiding; access modifiers (private, protected, public, default); getter and setter methods; data validation in setters; immutable objects and final fields; class and external access rules; wrapper classes,Inheritance and "is-a" relationship; extends keyword; super() for parent constructor calls; constructor chaining; method overriding and @Override annotation; role of access modifiers in inheritance; final classes and final methods; common pitfalls and best practices,Polymorphism; compile-time vs. runtime polymorphism; abstract classes and abstract methods; upcasting and downcasting; Liskov Substitution Principle (LSP); polymorphic behavior in collections; real-world examples,Creational Design Patterns; interfaces and the importance of abstraction; Factory Method pattern; Abstract Factory pattern; Singleton pattern (eager and lazy initialization); relationship with Open/Closed Principle; coding examples and implementations,Composition and "has-a" relationship; Inheritance vs Composition comparison; advantages of composition (loose coupling, flexibility, testability); dangers of deep inheritance hierarchies; the pitfall of inheriting just for code reuse (fragile base class, yo-yo problem); design guidelines (favor composition over inheritance); composition with dependency injection; refactoring example,Structural Design Patterns; Adapter pattern (bridging incompatible interfaces); Decorator pattern (adding behavior dynamically); Composite pattern (part-whole hierarchies); purpose, benefits, and Java implementations of each pattern; pattern comparison,Midterm Exam,Behavioral Design Patterns; Strategy pattern (making algorithms interchangeable); Observer pattern (publish-subscribe mechanism); Command pattern (encapsulating requests as objects); participants, use cases, and code examples for each pattern; pattern comparison (Strategy, Observer, Command),SOLID Principles Deep Dive; S — Single Responsibility Principle; O — Open/Closed Principle; L — Liskov Substitution Principle; I — Interface Segregation Principle; D — Dependency Inversion Principle; code smells and before/after refactoring examples for each principle; interactions between principles and practical application tips,Unit Testing and Test-Driven Development (TDD); mocking dependencies with Mockito; test case design and test coverage; integration of tests into continuous integration; example test implementations,Project Planning and Architecture Review; UML modeling (Use Case, Class, and Package Diagrams); build automation (Maven vs Gradle); standard directory structure and Maven lifecycle; code documentation and Javadoc standards; collaborative Git workflow (feature branching, Pull Request, CI/CD); project submission criteria and evaluation,comprehensive review of OOP principles and design patterns; application of SOLID principles in projects; common mistakes and best practices;,Advanced Java topics, Other OOP languages. |
| Course Learning Outcomes | Teaching Methods | Assessment Methods |
| Teaching Methods: | |
| Assessment Methods: |
Course Outline
| Order | Subjects | Preliminary Work |
|---|---|---|
| 1 | Introduction to Object-Oriented Programming; four pillars of OOP (Encapsulation, Abstraction, Inheritance, Polymorphism); Java syntax, compilation, and execution; development environment setup (JDK and IDE); first Java program ("HelloWorld"); Java program structure (class, main method) | |
| 2 | Encapsulation and data hiding; access modifiers (private, protected, public, default); getter and setter methods; data validation in setters; immutable objects and final fields; class and external access rules; wrapper classes | |
| 3 | Inheritance and "is-a" relationship; extends keyword; super() for parent constructor calls; constructor chaining; method overriding and @Override annotation; role of access modifiers in inheritance; final classes and final methods; common pitfalls and best practices | |
| 4 | Polymorphism; compile-time vs. runtime polymorphism; abstract classes and abstract methods; upcasting and downcasting; Liskov Substitution Principle (LSP); polymorphic behavior in collections; real-world examples | |
| 5 | Creational Design Patterns; interfaces and the importance of abstraction; Factory Method pattern; Abstract Factory pattern; Singleton pattern (eager and lazy initialization); relationship with Open/Closed Principle; coding examples and implementations | |
| 6 | Composition and "has-a" relationship; Inheritance vs Composition comparison; advantages of composition (loose coupling, flexibility, testability); dangers of deep inheritance hierarchies; the pitfall of inheriting just for code reuse (fragile base class, yo-yo problem); design guidelines (favor composition over inheritance); composition with dependency injection; refactoring example | |
| 7 | Structural Design Patterns; Adapter pattern (bridging incompatible interfaces); Decorator pattern (adding behavior dynamically); Composite pattern (part-whole hierarchies); purpose, benefits, and Java implementations of each pattern; pattern comparison | |
| 8 | Midterm Exam | |
| 9 | Behavioral Design Patterns; Strategy pattern (making algorithms interchangeable); Observer pattern (publish-subscribe mechanism); Command pattern (encapsulating requests as objects); participants, use cases, and code examples for each pattern; pattern comparison (Strategy, Observer, Command) | |
| 10 | SOLID Principles Deep Dive; S — Single Responsibility Principle; O — Open/Closed Principle; L — Liskov Substitution Principle; I — Interface Segregation Principle; D — Dependency Inversion Principle; code smells and before/after refactoring examples for each principle; interactions between principles and practical application tips | |
| 11 | Unit Testing and Test-Driven Development (TDD); mocking dependencies with Mockito; test case design and test coverage; integration of tests into continuous integration; example test implementations | |
| 12 | Project Planning and Architecture Review; UML modeling (Use Case, Class, and Package Diagrams); build automation (Maven vs Gradle); standard directory structure and Maven lifecycle; code documentation and Javadoc standards; collaborative Git workflow (feature branching, Pull Request, CI/CD); project submission criteria and evaluation | |
| 13 | comprehensive review of OOP principles and design patterns; application of SOLID principles in projects; common mistakes and best practices; | |
| 14 | Advanced Java topics, Other OOP languages |
| Resources |
Course Contribution to Program Qualifications
| Course Contribution to Program Qualifications | |||||||
| No | Program Qualification | Contribution Level | |||||
| 1 | 2 | 3 | 4 | 5 | |||
Assessment Methods
| Contribution Level | Absolute Evaluation | |
| Rate of Midterm Exam to Success | 40 | |
| Rate of Final Exam to Success | 60 | |
| Total | 100 | |
