Java OOP is a course in object-oriented design and programming with Java 25 LTS, from classes, encapsulation, inheritance and polymorphism to interfaces, records, sealed classes, the SOLID principles, design patterns and unit testing with JUnit. It suits people who already write Java, developers who want maintainable code and computing students.
Many people who can already write Java still put everything into a few large classes. As the system grows it becomes hard to change, hard to test and impossible to reuse. Thinking in objects properly gives each piece of code a clear responsibility, and modern Java adds tools that make good design easier, such as records, sealed classes and pattern matching, which older OOP textbooks do not cover.
This course teaches object-oriented principles in depth on Java 25 LTS and shows how to apply them. It starts with thinking in objects, class design, abstraction, encapsulation, inheritance and polymorphism, then moves on to abstract classes and interfaces, records, sealed classes, pattern matching, composition and generics. It then raises the level to design with the SOLID principles, class diagrams and common design patterns, and uses JUnit 6 unit tests to refactor with confidence. It closes with a capstone that designs and builds a system with OOP from start to finish. (3 days, 6 hours per day, 18 hours in total, Intermediate level.)
Course Details
This course is the 2026 edition that replaces the previous JAVA OOP course. It has been rewritten from scratch for Java 25 LTS. It runs for 3 days, 6 hours per day (18 hours in total, 09:00-16:00), as lectures with labs built on a library system brief that grows throughout the course. Intermediate level. It keeps the original core topics of classes, abstraction, encapsulation, inheritance, polymorphism, final, abstract classes and interfaces, and adds records, sealed classes, pattern matching, composition, the SOLID principles, design patterns and unit testing with JUnit 6. It builds on Basic Java Programming with a deeper focus on object-oriented design. Learners take home a lab guide, source code and Maven projects for every lab.
Section 1: Lab: OOP Concepts and Tool Setup
Section 2: Classes, Objects and Constructors
Section 3: Abstraction and Encapsulation
Section 4: Lab: Inheritance
Section 5: Polymorphism and final
Section 6: Abstract Classes and Interfaces
Section 7: Lab: Records, Sealed Classes and Pattern Matching
Section 8: Composition over Inheritance
Section 9: Generics and Collections in Design
Section 10: Lab: Designing Exceptions Systematically
Section 11: The SOLID Principles and Class Diagrams
Section 12: Creational Design Patterns
Section 13: Lab: Structural and Behavioural Patterns
Section 14: Lab: Unit Testing and Refactoring
Section 15: Workshop: Capstone System Design with OOP
No public rounds are open right now. Join the waiting list and we will contact you first when the next round opens, or ask us on LINE. Or call 02-570-8449 or 088-807-9770
A top-down approach splits work into steps and functions in the order they run, with data often passed through many functions and changeable from many places, which suits small programs. OOP splits a system into objects that combine data and behaviour, each managing its own state with a clear responsibility, so a growing system is easier to change, test and reuse. Java 25 also offers records and sealed classes that make data models more concise.
An abstract class can hold state (fields) and shared code, has constructors, and a subclass can extend only one, so it suits classes that genuinely share a type. An interface defines capabilities a class must provide, holds no object state but can have default, static and private methods, and a class can implement many, so it suits contracts between parts of a system. To restrict which types may extend or implement them, you can make either one sealed.
Overloading means several methods in the same class share a name but take different parameters, and the compiler picks which one to call at compile time. Overriding means a subclass rewrites a method with the same name and parameters as its superclass to change its behaviour, and Java picks the version to run at run time based on the object's actual type, which is the heart of polymorphism. Always add @Override so the compiler can check it.
It suits people who can already write Java and want to program in an object-oriented way properly, developers who want maintainable code, anyone moving on to Spring Boot or Jakarta EE, students, lecturers and tech leads. You should know basic Java such as variables, conditions, loops, methods and ArrayList. If you have not written Java before, take Basic Java Programming first.
You will be able to break a brief into classes with clear responsibilities, apply encapsulation, inheritance and polymorphism in the right places, choose between abstract classes, interfaces, records and sealed classes, design to the SOLID principles, draw class diagrams, use common design patterns and write JUnit 6 unit tests to refactor safely. Participants who complete the training receive a Certificate of Completion with its own number, which can be verified online.
Yes. It can be run in-house for your team, with exercises adapted to your work, such as examples from your organisation's business domain, or a focus on reviewing and refactoring the Java code your team maintains. You can request a quotation from this page, or contact us on LINE @itgenius or by phone on 02-570-8449.
Articles are published in Thai.
Java is still the main language behind many enterprise, banking and backend systems, but the language has changed a great deal in recent years. Many books and examples still teach Java 8 style, with long code and no records, pattern matching or virtual…
Many organisational Java web systems still run on servlets and JSP with Hibernate, and IT teams need to maintain or modernise them. Since Jakarta EE 9, every javax package has become jakarta, and current Hibernate uses annotations with Jakarta Persistence…
Many people want to start programming but get stuck at the first step, because most books are written for readers who already have a background. They open with technical terms and long code to memorise before explaining how a computer actually thinks. Java is…
