Kursus · MitmekeelneAlgajaÕppeteekonna Backend Engineering 1. etapp

Java and Object-Oriented Programming Foundation

Build a strong programming foundation with Java and learn how real software is designed using object-oriented principles.

11 moodulit
140 õppetundi
16 nädalat
Mitmekeelne

Fumu igas õppetunnisKüsi Fumult mis tahes õppetunnis. Ta selgitab materjali selle õppetunni põhjal, kus sa parasjagu oled.
Kinnitatud tunnistus sinu profiililLäbi kõik õppetunnid ja saad PDF-tunnistuse koos lingiga, millega igaüks saab seda kontrollida.

Kursuse ülevaade

Kursusest

Learn Java with a Strong Engineering Foundation

Learning Java is not just about memorizing syntax or getting code to compile.

Strong software engineers learn how to break problems into smaller responsibilities, model software clearly, reason about trade-offs, and write code that remains understandable as applications grow.

Java & Object-Oriented Programming Foundation is designed to help you build that foundation from the beginning.

Across 11 modules and more than 100 lessons, you will progress from Java fundamentals to object-oriented design, practical software modeling, refactoring, and increasingly realistic programming problems.

The goal is not only to teach you what code to write, but to help you understand why a solution is designed that way.

Who Is This Course For?

This course is suitable for:

Beginners starting their programming journey
Developers moving to Java from another programming language
Learners who want to strengthen their Java and OOP fundamentals
Anyone preparing to move into Java backend development and Spring Boot

No previous Java or object-oriented programming experience is required.

The course begins with the fundamentals and gradually introduces stronger programming and software-design concepts.

Go Beyond Java Syntax

Knowing Java syntax is important, but syntax alone does not make someone a strong developer.

Throughout the course, you will also learn how to reason about software.

You will explore questions such as:

How should a larger problem be divided into smaller responsibilities?
Which object should own a particular behavior or piece of state?
When does an abstraction make a design better?
When is a simpler solution the better choice?
How can code remain understandable as an application grows?
How do you recognize unnecessary complexity?

Object-oriented programming is taught in the same way.

Instead of simply memorizing concepts such as encapsulation, inheritance, polymorphism, and abstraction, you will learn:

Why these concepts exist
What problems they help solve
Where they are useful
What trade-offs they introduce
When they should not be used

The focus is on developing judgment, not memorizing patterns.

Learn by Building and Reasoning

The course progresses step by step.

You will begin with small programming problems and gradually work toward applications involving multiple classes, objects, relationships, abstractions, and collaborating components.

Throughout the course, you will work with:

Practical coding exercises, with worked solutions for every one
Predict-the-result challenges
Knowledge checks
Software-design questions
Refactoring exercises
Review lessons with implementation challenges for modules 1–8
Hands-on projects you build yourself first, then compare with a reference solution
A larger final project, built stage by stage with JUnit tests in a Maven project under Git, with a self-graded assessment

You will learn to evaluate more than whether your code works.

You will also learn to ask:

Is this code clear?

Are the responsibilities in the right place?

Will this design be easy to change?

Am I introducing complexity that I do not need?

That shift in thinking is where programming starts to become software engineering.

What You Will Learn

You will build a foundation in:

Programming logic and problem solving
Variables, types, expressions, and control flow
Methods, arrays, and recursion
Classes, objects, constructors, and object state
Encapsulation, invariants, and immutability
Object relationships, composition, and delegation
Inheritance, method overriding, and runtime polymorphism
Abstract classes, interfaces, and dependency design
Generics and the collections framework: List, Set, Map, queues, and deques
Algorithms and Big-O: sorting, searching, heaps, hashing, and trees
Lambdas, method references, streams, and collectors
Optional, the modern date and time API, and records
Concurrency basics, executors, CompletableFuture, and virtual threads
Enums, exceptions, validation, and reliable error handling
Files, paths, and file-based persistence
Packages, equality contracts, clean APIs, and refactoring
Unit testing with JUnit 5, a Maven project, the IntelliJ IDEA debugger, and Git basics
A final project that brings it all together in one application

The emphasis throughout the course is on understanding the reasoning behind these concepts rather than copying patterns mechanically.

Learn in English — Translate with AI When You Need It

The course is written in English, using the terminology you will encounter in professional Java documentation, APIs, technical articles, codebases, and engineering teams.

Java keywords, APIs, class names, method names, and technical terminology remain consistent with industry usage.

If English is not your preferred learning language, Tarkev's AI-assisted translation allows you to translate lesson content into a supported language while you learn.

This can help you understand difficult explanations in a language that feels more comfortable while keeping you connected to the original English technical terminology.

You learn from the same course and can use translation whenever it helps.

Build the Foundation for Java Backend Development

This course intentionally focuses on Java and software-engineering fundamentals before introducing frameworks.

Frameworks such as Spring Boot become much easier to understand when you already know the language and the design principles underneath them.

By developing these fundamentals first, you will be better prepared to understand concepts such as:

Dependency injection
Application architecture
Service boundaries
Domain modeling
Data access
API development
Testing
Backend application design

After completing this course, you will have the foundation needed to continue into Java backend development and Spring Boot.

By the End of the Course

After completing the course, you should be able to:

Build Java programs independently
Read and understand existing Java code
Break larger problems into smaller responsibilities
Model problems using classes and objects
Use encapsulation, inheritance, interfaces, and composition intentionally
Organize Java applications more clearly
Reason about maintainability and code quality
Refactor unnecessarily complicated code
Make better design decisions as applications grow
Approach Java backend development with stronger fundamentals

Most importantly, you should begin thinking about code not only as something that needs to work, but as software that other people—including your future self—need to understand, change, and maintain.

Learn Java. Understand the reasoning behind the code. Start building software like an engineer.

Õppekava

11 moodulit · 140 õppetundi · 28 tasuta eelvaadet

1Programming and Java Fundamentals25 õppetundi20 eelvaadetYou learn how Java programs are built and run, set up OpenJDK 21 and IntelliJ IDEA, and write console programs with variables, `String` values, input, conditions and loops. These building blocks are what module 2 organizes into methods and arrays.

1.1 Introduction to ProgrammingVideo ja lugemine · 38 minEelvaade
1.2 How a Computer Executes a ProgramVideo ja lugemine · 33 minEelvaade
1.3 Introduction to JavaVideo ja lugemine · 33 minEelvaade
1.4 JDK, JRE, JVM, and BytecodeLugemine · 8 minEelvaade
1.5 Setting Up the Java Development EnvironmentVideo ja lugemine · 34 minEelvaade
1.6 Creating Your First Java ProjectVideo ja lugemine · 26 minEelvaade
1.7 Understanding the First Java ProgramLugemine · 10 minEelvaade
1.8 Java Syntax and Coding ConventionsLugemine · 12 minEelvaade
Selles moodulis on veel 17 õppetundi

2Methods, Arrays, and Program Structure11 õppetundi3 eelvaadetYou learn to split programs into methods with parameters and return values, store and process data in arrays, and solve problems with recursion. Module 3 builds on methods to model programs as classes and objects.

2.1 Introduction to MethodsVideo ja lugemine · 32 minEelvaade
2.2 Parameters, Arguments, and Return ValuesLugemine · 9 minEelvaade
2.3 Scope, Static Methods, and Method OverloadingLugemine
2.4 Introduction to ArraysLugemine
2.5 Traversing and Working with ArraysLugemine
2.6 Two-Dimensional and Multidimensional ArraysLugemine
2.7 The Arrays Utility Class and Common Array OperationsLugemine
2.8 Introduction to RecursionVideo ja lugemine · 35 minEelvaade
Selles moodulis on veel 3 õppetundi

3Object-Oriented Programming Foundations14 õppetundi2 eelvaadetYou learn to design classes that keep objects valid: constructors, encapsulation, `static` members, equality, composition, immutability and packages, ending with a course enrollment project. Module 4 extends these classes into type hierarchies with inheritance, interfaces and polymorphism.

3.1 Introduction to Object-Oriented DesignVideo ja lugemine · 30 minEelvaade
3.2 Classes, Objects, Fields, and MethodsLugemine · 8 minEelvaade
3.3 Constructors and Valid Object CreationLugemine
3.4 The `this` Keyword and Method OverloadingLugemine
3.5 Encapsulation, Access Control, and Object InvariantsLugemine
3.6 Static and Instance MembersLugemine
3.7 Object References, `null`, Identity, Equality, and `toString()`Lugemine
3.8 Composition and Object RelationshipsVideo ja lugemine · 26 min
Selles moodulis on veel 6 õppetundi

4Inheritance, Interfaces, and Polymorphism11 õppetundi3 eelvaadetYou learn to build type hierarchies with `extends`, abstract classes and interfaces, use runtime polymorphism, and choose composition when inheritance does not fit. Module 5 uses these parent types and interfaces in generics and the collections framework.