In my first week I mentioned general topics about OOP, where I was able to learn quite a bit about these topics in a short amount of time. However, there were still topics left to cover. Taking into account that this is just the basics of OOP, I am in the process of deciding if Java will be the language I want to focus on 100%, even after finishing university, I have to say that I have a particular liking for the backend because of my experience in testing, which may be a factor in my decision.

During this second week I didn’t have much time to review topics like threads, enums, or generics that I had pending. However, I progressed on a small project simulating a restaurant, where the following actions can be performed:

• Create products or meals ?
• Place orders based on those products and indicate how many were consumed.
• Display individual order after adding it.
• Display all orders, with the option to add as many orders as the user wants.

I mainly created it to cover all aspects of OOP, including data validation, and to keep practicing logic. I have it almost finished but am still adding details; I’ll upload it to my repository once it’s ready.

Additionally, I covered another OOP topic and other topics that are extremely useful.

Which ones? Relational classes, try and catch, and files.

I will briefly mention how these topics have been useful to me and how I understand their practical applications.

Relational Classes

Relational classes are a topic that has taken me some time to understand and use. However, once you get the hang of it, they can be implemented easily. The way I’ve used this concept the most is the 1-to-N relationship, which is used to link multiple objects of a Class B to a Class A.

For example, if I want a car to have multiple owners, I need a relationship from the Owners class to the Cars class.

In the Car class constructor, a list (I’ve used ArrayList) needs to be passed, and this list is created based on objects from the Owner constructor. Thus, the owner with their attributes (name, age, ID, etc.) will be linked to a Car constructor, which will be able to create objects with these properties.

Here’s a simple example that shows how a 1-to-N relationship is applied: https://pastebin.com/dX6SDWwp

This is useful when you need to “connect” certain objects with others, so that you have a direct relationship and they are not just connected by arrays or another different method.

Try and Catch ??

The use of try and catch in Java is something I’ve implemented more than in the other language I’ve used. I think this is because my IDE automatically suggests using try and catch for some exceptions that require it.

This topic is just a highlight compared to another language like C , where I used it very little and preferred other techniques to avoid errors. However, I am gradually getting used to using try and catch to predict errors and avoid sudden system crashes.

Files - JSON/GSON - Serialization and Deserialization ?

Working with files in Java took up 70% of my learning time last weekend. Despite this, I feel there is a bit more information and examples compared to C , where I also implemented file usage with matrices to maintain data without rewriting it.

This was useful for systems like:

• Shopping carts
• Inventory management
• Orders, or any system where data retention is necessary.

In this case, with Java, I need to use objects, so this involves serialization and deserialization.

Here I noticed a big difference, as the way of writing depends heavily on the type of data you want. My main issue, which took hours of research, was that when I saved characters to my .txt file, they appeared in binary format when opening the file, but they displayed as characters in the console.

I found online that there are two ways to read and write data:

• Via bytes
• Via characters

The method I was using was byte-based since I was passing objects directly.

I don’t yet feel knowledgeable enough to share the differences between the various ways to use the Writer and Reader subclasses, but I’m working on a real-world exercise where I’ll use objects stored in an ArrayList and learn how to serialize and deserialize them using GSON (to keep the objects in their state within the system in a .json file) and then write this data to a .txt file to store them as records in an organized way.

Closing

Last week, I didn’t make as much progress as I would’ve liked, but working with files took many hours of research, application, and concept differentiation, pulling bits from every article I reviewed to reach a final result that I’ll test in a “real” project and share how it went.

It’s important to mention that this specific handling and the scenario I mentioned with GSON and .txt is something I’m required to do for university. However, there are other ways, like JPA or databases, to handle this. It’s not strictly necessary to use GSON and .txt to maintain data in a system.

With nothing more to add, if anyone has any input on files or the topics I mentioned, feel free to comment and share your suggestions!

Happy coding! ?

The above is the detailed content of Java OOP: Week The OOP Adventure Continues. For more information, please follow other related articles on the PHP Chinese website!