[Java Practical Project for Beginners] Object-Oriented Thinking Training - 3 Mini-Project Practices

📌 Before vs After Taking the Course - Here's How You'll Change!

🔸 "It was difficult to translate requirements into code"

→ You will be able to divide functions and design classes directly.

🔸 "Object-oriented design feels overwhelming"

→ Enables writing code structured with OOP thinking

🔸 "I lacked hands-on project experience"

→ Improve your practical skills by completing 3 mini projects

🔸 "I was just learning with my eyes only"

→ Analysis → Design → Implementation → Testing You will directly perform the entire process

💡 A very special lecture for those who are struggling with application implementation

A common story I heard from students while teaching nearly 1,000 students in boot camps

"I understand the concept, but I can't implement it"

"I understand Java syntax now, but when asked to build something with Java, I don't know where to start"

"I finished Java and moved on to Spring, but I can't get my hands on the practice exercises"

"I typed out all the code from the learning materials from start to finish, but I'm so scared of the project"

At that time, the story I told my students was as follows.

"Don't try to learn with just your eyes, learn with your fingers and your mind"

"When typing code, think for yourself as you type"

"Build your foundation first. Then practice over and over again for application."

By thinking for yourself in this way, building the fundamentals of language and technology, and practicing repeatedly for application, you'll find yourself surrounded by the excitement of "What should I create next?"

What's the best way to feel this kind of excitement?

⭐ Even for very small applications, it's about thinking and contemplating on your own while building everything from start to finish by yourself.

⭐ If you don't know what to build or how to build it, take this course.

I will help you feel not only your application implementation skills but also exciting anticipation rather than fear about your projects.

In Mini Project Java Part 1, we create a console application using Java and some external libraries, along with the Google Tasks API.

"Why would we create console-based applications when they're useless anyway?" you might think. ^^;

Of course, I also fully empathize with this statement, though not 100 percent.

However, while console-based applications may be somewhat inconvenient, I think they play a very important role in building a solid foundation in Java fundamentals.

"Surely we're not just going to build console-based applications and call it a day, right?" If that's what you're thinking?

No, that's not right. In the Java Mini Project Part 3, we also implement the UI (JavaFX). ^^;

"Isn't JavaFX a technology that's not really used in practice? But why are we learning it??" If you're thinking this?

⭐ To survive well in the field as a good Java developer for a long time, it's important to implement UI and understand both perspectives of client and server backend without distinction.

If you can understand the client-side perspective, wouldn't you be able to create better server-side applications? ^^;

You'll find it fun once you give it a try. ^^

⭐ Course Structure

• We will carry out a total of 3 mini projects:

  1. Stream API Multiplication Table Application

  2. Todo List Management App (1): Requirements-Based Design, Implementation and Testing

  3. Todo List Management App (2): Google Tasks API Integration

• Each project is based on requirement documents
  where students first attempt design → implementation → testing on their own,
  then compare with Kevin's implementation version to learn better structure and thinking approaches.

📶 Implementation Skills Power-Up Stage Guide

✅ 100% Power Up

• I implement all the features myself first, then compare with the lecture.

  • You'll naturally think "I have no idea how to do this, how can I not look it up?" but whether you search the internet or ask Chat GPT, anyway try to implement all the features yourself.

• You can feel the greatest growth and sense of accomplishment.

  
  

✅ 80% Power Up

• Implement as much as you can on your own to the best of your ability,

  When you get stuck, refer to the lecture content and try applying it.

✅ 50% Power Up

• I watch the lectures first and learn by following along with the code.

  
  

• Then, in the next empty project, try coding it yourself again.

❌ 0% Power Up

• I just watch the lectures with my eyes.

• This means you shouldn't do it this way. ^^;

  • Even the smallest project requires a repeated and accumulated process of thinking for yourself while typing code.

  • Only then can the knowledge that you make your own gradually accumulate through that process.

✨ What you'll gain from this course

• Intuition for Java Object-Oriented Code

• Design → Implementation → Testing complete workflow experience

• Build coding confidence through small and diverse project practice

• Before learning Spring, a solid foundation to strengthen your Java skills

  
  

• Java is becoming fun

After this course, you will be able to practice implementing various types of applications through the following sequel series.

• Java Part 1(Open)

• Java Part 2(Open)

• Java Part 3(Opening Soon)

• Spring MVC Edition(Planned)

• Testing Edition (Planned)

• Spring Rest Docs Edition (Planned)

• Spring Security Edition (Planned)

• Spring WebFlux Edition (Planned)

• 
  

Section 1: Creating a Multiplication Table Application Using Stream API

In Section 1, we'll create a very simple application that can get your brain and fingers warmed up.

"What? Isn't a multiplication table program too simple?" you might think. A multiplication table program is one of the fundamental problems that regularly appears when solving algorithm problems.

However, you need to think from the perspective of creating a single well-functioning application, and since you need to implement it using Java's Stream API, the multiplication table program can approach you in a refreshingly different way. ^^

✅ Project Goals

1. You can understand the concepts of lambda expressions and functional interfaces in Java.

2. Understand the characteristics and basic usage of Stream API.

3. You can understand the importance of code readability.

4. You can separate method logic by functionality through method extraction (Extract).

5. You can understand the concept of separation of concerns using classes.

   
   

Section 2: Creating a Todo List Management Application (1)

In Section 2, we'll create an application for managing to-do tasks.

Task management applications are well known by the name TodoList, and it's one of the most commonly used topics when getting started with web programming.

You might think of it as a simple feature that registers tasks and marks registered tasks as complete, but I believe there are quite a few people who would hesitate when asked to actually implement this simple feature themselves.

Moreover, if you consider the application's code quality, code readability, and even unit test cases, it's not something you can take lightly. ^^;

In the course, you won't just learn to create applications that simply run, but you'll be able to learn quite important things as follows.

✅ What you'll learn in Section 2

1. You can understand how to express the rough requirements of an application to be developed in the form of classes and methods and what advantages this approach offers.

2. You can understand how to first express your thought process in code to implement a specific feature, and then concretely implement that feature.

3. You can understand how to complete unit test code step by step.

4. You can understand how to separate domain logic with applied domain rules from service code and why this separation is beneficial.

5. You can understand the basics of the D.I.P (Dependency Inversion Principle) design principle used in domain-driven development.

   
   

✅ Project Goals

• You can understand how to build the basic structure of an application using the framework of classes and methods.

• You can implement simple task registration logic using task data.

• Understand Layered Architecture.

• Java's Map can be used like an in-memory data store.

• Understand the differences between Anemic Domain Model and Rich Domain Model.

• Understand the basic concepts of the D.I.P (Dependency Inversion Principle) design principle and the reasons for applying this principle.

  
  

Section 3: Creating a Todo List Management Application (2)

In Section 3, we will upgrade the to-do management application created in Section 2 to enable sustainable management of to-do data using Google Tasks API technology.

Of course, we could create a to-do management application using the Google Tasks API from the beginning, but I thought this wouldn't be desirable because it would require cramming too much knowledge into our heads while implementing the application.

Anyway, if you've built the task management application well in Section 2, you can focus on learning the following content in Section 3.

✅ What you'll learn in Section 2

1. You can understand the common procedures for using services provided by Google (Google Tasks, Google Drive, Google Calendar, etc.).

2. Authentication process for using services provided by Google can be understood from a big picture perspective.

3. You can understand the reasons and advantages of writing test cases for the purpose of learning specific technologies.

4. You can understand the reasons why preprocessing and postprocessing are necessary in the testing process and apply them to test cases.

5. D.I.P (Dependency Inversion Principle) design principle is applied to enable flexible changes to data access technologies in the data layer.

6. You can apply a Converter for exchanging data between objects of different types.

7. Using Object Factory + Singleton pattern, you can understand how to manage objects used in an application from a single location.

✅ Project Goals

• Understand the concept of learning tests for understanding specific technologies.

• Understand the concept of external API services.

• Using the Google Tasks API service, you can manage your to-do items.

• By applying DIP (Dependency Inversion Principle), you can flexibly apply data layer technologies.

• Understand the concept of Factory and create objects using Factory.

• Understand the concepts of date and time specified in RFC-3339 and be able to use them in applications using Java API.

Q. To take the Java Part 1 course, do I just need to know Java? What level of Java proficiency should I have?

In the Java Part 1 course, you'll implement a total of three mini projects. Two of these projects are built using pure Java only, while the remaining project additionally uses Google Tasks API technology to implement the application.

Since many of you may not have experience using the Google Tasks API, the course includes a certain portion of content covering how to use the Google Tasks API.

In conclusion, if you have a certain level of basic Java knowledge (variables, data types, standard input/output, concepts of classes and interfaces, etc.), you can take this course.

However, the course includes content that students may encounter for the first time (testing techniques, object-oriented design techniques, etc.) throughout the lectures, but I think these topics can be learned as you progress through the course.

Q. Why should I take this course?

As I briefly mentioned earlier, the most overwhelming part when learning programming languages at bootcamps or computer academies is not knowing how to create something visible using the programming language I've learned.

Although it's a small mini application, by having students think and contemplate on their own while directly implementing the application, the core goals of this lecture series are to help them gain confidence that "I can also create something on my own" and to "help them realize the direction they should take as developers going forward".

Therefore, I believe it can provide decent help to those who are struggling with application implementation.

Q. It seems like Java developers must know the Spring Framework to become developers, but is it really okay not to know Spring?

It doesn't matter if you have no knowledge of Spring at all.

When discussing Java-based web application development, we cannot leave out the Spring Framework, but I have seen many students hit a wall when trying to use the Spring Framework in applications without having a solid foundation in Java basics.

You can think of this as a lecture that includes the desire to prevent you from experiencing such problems.

Q. Using Java to create something on my own feels too vague and somewhat intimidating. Will taking this course make these feelings go away?

I don't think that feeling will go away just by listening to this lecture.^^;

However, if you complete the course to the end using the method I recommend and make the content covered in the lectures truly your own, I'm confident that you'll definitely be able to eliminate at least the fear of implementation.

Q. My implemented code might be very different from the instructor's code. What should I do?

Since I probably have more development experience than you all, I think there's a high likelihood that the code I write might be somewhat better code. (If you think otherwise, I'd be grateful for your feedback anytime. ^^;)

If you think the code I wrote is somewhat better code, I recommend that you try applying the code I wrote to the code you implemented.

Of course, you might not be able to judge whether it's better code or not, and it could take quite a bit of time to apply someone else's code to the code you've written.

However, I believe that you can better judge whether this is good or bad code only by applying it directly, and your skills will also improve further.

Q. Where can I download the lecture materials and source code explained in the course?

• To download the lecture materials and source code explained in the course, click the Github link listed in theLearning Materials section below and download from the corresponding Repository.