DEV Community: joaofelipefaria

Java Fundamentals — Object-Oriented Programming

joaofelipefaria — Thu, 03 Sep 2026 13:41:27 +0000

Object-Oriented Programming (OOP) is a programming paradigm based on the idea of representing a system as a collection of objects that have characteristics and behaviors. Although there were earlier experiments with objects, Simula, created by Ole-Johan Dahl and Kristen Nygaard in the 1960s, is generally considered the first object-oriented programming language. The concepts that became the foundation of modern OOP were later popularized by languages such as Smalltalk and C++. The term and principles of object-oriented programming were also discussed in Smalltalk-80: The Language and its Implementation, by Adele Goldberg and David Robson.

Object orientation is interesting because it is, in many ways, a natural way for the human mind to think about the world. When we analyze a situation, we naturally categorize things according to characteristics they have in common. We identify a group such as Car, Person, or Account and define the characteristics that make something belong to that group. In programming, these categories become classes, while the concrete things belonging to those classes become objects. A Car can therefore be a class, while João's red car can be an object of that class.

A class is essentially a blueprint or definition that describes what its objects will have and what they will be able to do. The characteristics of an object are represented by properties, also called attributes or fields, while its behaviors are represented by methods. An object is a concrete entity created from a class. The act of creating an object is called instantiation, and the resulting object is an instance of that class. In Java, for example, Car myCar = new Car(); creates an instance of the Car class and assigns it to the myCar reference.

Java also provides mechanisms that make object-oriented design more powerful and flexible. Interfaces define contracts that classes can implement, allowing different classes to provide different implementations of the same behavior. Constructors are special methods used to initialize new objects. Java also supports static properties and methods, which belong to the class itself rather than to a particular instance. This makes them useful when a value or behavior should be shared across all instances or accessed without creating an object.

Another important Java concept is the initializer block, sometimes called an execution block. These blocks allow initialization logic to be executed when an object is created, or, in the case of static initializer blocks, when the class is initialized. Although they are less frequently used than constructors and methods, understanding them is important when studying how Java initializes classes and objects. Together with constructors, fields, methods, interfaces, and static members, they form an important part of the language's object model.

The fundamental concepts of OOP are not isolated features; they work together to model complex systems. A class defines the structure and behavior, an object represents a concrete instance of that definition, properties represent its state, and methods represent its behavior. Interfaces allow us to define contracts between components, while constructors control how objects are initialized. Static members, on the other hand, allow behavior or state to exist at the class level rather than at the individual object level.

Understanding these fundamentals is essential before moving into more advanced Java concepts such as encapsulation, inheritance, polymorphism, abstraction, composition, and dependency injection. Java is deeply rooted in object-oriented programming, and most of the language's design becomes much easier to understand once we stop thinking only in terms of instructions and start thinking in terms of objects, their responsibilities, their state, and their interactions.

Java (une brève introduction historique)

joaofelipefaria — Tue, 01 Sep 2026 11:23:07 +0000

Java est né au début des années 90, dans les bureaux de Sun Microsystems, principalement grâce au travail de James Gosling et de son équipe. L'idée initiale faisait partie du Green Project, qui cherchait à créer des logiciels pour une nouvelle génération de dispositifs électroniques. Le langage s'appelait à l'origine Oak. L'histoire raconte que le nom a dû être changé parce qu'une marque utilisait déjà ce nom. Certaines versions racontent également que Java aurait été inspiré par un café ou simplement par le café que buvaient les développeurs. ☕

Dès le début, l'une des grandes idées de Java était d'être multiplateforme, résumée par la célèbre phrase « Write Once, Run Anywhere ». À l'époque, faire fonctionner un programme sur différents systèmes d'exploitation n'était pas aussi simple qu'aujourd'hui. L'idée géniale a été d'ajouter une couche entre l'application et le système d'exploitation : la JVM (Java Virtual Machine). Ainsi, le code Java n'a pas besoin d'être compilé directement pour Windows, Linux ou une autre plateforme spécifique.

C'est ici qu'intervient le fameux bytecode. Lorsque nous écrivons un programme Java, le compilateur transforme le code source .java en bytecode, généralement stocké dans des fichiers .class. Ce bytecode n'est pas exactement du code natif du processeur. Il est exécuté par la JVM, qui connaît les particularités de la plateforme sur laquelle elle fonctionne. Au fil des années, la JVM est devenue extrêmement sophistiquée, notamment grâce à des techniques comme la compilation JIT (Just-In-Time), qui permet de transformer certaines parties du bytecode en code natif pendant l'exécution.

Java a maintenant plus de 30 ans. Et il est assez intéressant de voir à quel point le langage a évolué pendant cette période. Generics, annotations, lambdas, Streams, modules, records, pattern matching, sealed classes et, plus récemment, les virtual threads, ne sont que quelques exemples de cette évolution. Quelqu'un qui a appris Java il y a 15 ou 20 ans découvrirait probablement un langage assez différent en regardant le Java moderne.

C'est aussi pour cela que certains vieux stéréotypes sur Java ne sont plus vraiment d'actualité. « Java est lent », « Java est extrêmement verbeux », « Java demande trop de code »... Certaines de ces critiques étaient effectivement justifiées à certaines époques. 😅 Mais comparer Java moderne avec Java 5 ou Java 6 n'est pas vraiment juste. Le langage est devenu beaucoup plus expressif et a supprimé une grande partie du boilerplate au fil des années, tout en conservant le typage statique qui fait partie de ses caractéristiques fondamentales.

Et il y a quelque chose d'assez intéressant : malgré toute cette évolution, beaucoup d'entreprises utilisent encore Java 8. Java 8 est sorti en 2014 et reste présent dans un très grand nombre de systèmes d'entreprise. Depuis, nous avons eu d'importantes versions LTS (versions avec support long), comme Java 11, Java 17, Java 21 et Java 25. Cette longévité montre également l'une des grandes forces de l'écosystème Java : la compatibilité. L'attention portée à la compatibilité avec les anciennes versions permet aux systèmes de continuer à évoluer sans devoir être entièrement réécrits à chaque nouvelle version.

Au final, connaître un peu l'histoire de Java nous aide à comprendre où nous en sommes arrivés. La JVM, le bytecode, la portabilité et l'attention portée à la compatibilité ne sont pas apparus par hasard. Ils font partie d'une histoire de plus de trois décennies. Java a énormément évolué, mais il conserve encore certaines des idées fondamentales qui lui ont permis d'aller aussi loin. Et comprendre d'où nous venons aide beaucoup à comprendre le Java que nous utilisons aujourd'hui.

Java (a brief historical introduction)

joaofelipefaria — Tue, 01 Sep 2026 11:22:30 +0000

Java was born in the early 1990s, inside the offices of Sun Microsystems, mainly through the work of James Gosling and his team. The original idea was part of the Green Project, which aimed to create software for a new generation of electronic devices. The language was originally called Oak. The story goes that the name had to be changed because there was already a brand using it. Some versions of the story also say that Java was inspired by a coffee shop, or simply by the coffee the developers were drinking. ☕

From the very beginning, one of Java's main ideas was to be cross-platform, summarized by the famous phrase “Write Once, Run Anywhere”. At the time, making software run on different operating systems was not nearly as simple as it is today. The big idea was to introduce a layer between the application and the operating system: the JVM (Java Virtual Machine). This way, Java code doesn't need to be compiled directly for Windows, Linux, or another specific platform.

This is where the famous bytecode comes in. When we write a Java program, the compiler transforms the .java source code into bytecode, usually stored in .class files. This bytecode isn't exactly native processor code. It is executed by the JVM, which understands the specific platform where it is running. Over the years, the JVM became extremely sophisticated, using techniques such as JIT (Just-In-Time) compilation to turn parts of the bytecode into native code during execution.

Java is now more than 30 years old. And it's interesting to see how much the language has changed during that time. Generics, annotations, lambdas, Streams, modules, records, pattern matching, sealed classes and, more recently, virtual threads, are just a few examples of how the platform has evolved. Someone who learned Java 15 or 20 years ago would probably find a very different language when looking at modern Java.

That's why some of the old stereotypes about Java don't make as much sense anymore. “Java is slow”, “Java is extremely verbose”, “Java requires too much code”... Some of these criticisms were certainly valid at different points in time. 😅 But comparing modern Java with Java 5 or Java 6 isn't exactly fair. The language has become much more expressive and has eliminated a lot of boilerplate over the years, while still keeping static typing as one of its fundamental characteristics.

And there is something interesting: despite all this evolution, many companies still run Java 8. Java 8 was released in 2014 and is still present in a huge number of enterprise systems. Since then, we have had important LTS (Long-Term Support versions) releases such as Java 11, Java 17, Java 21 and Java 25. This longevity also shows one of the major strengths of the Java ecosystem: compatibility. The strong focus on backward compatibility allows systems to keep evolving without having to be rewritten from scratch with every new version.

At the end of the day, learning a little about Java's history helps us understand how we got here. The JVM, bytecode, portability and the focus on compatibility didn't happen by accident. They are all part of a history that spans more than three decades. Java has changed a lot, but it still carries some of the fundamental ideas that helped it come this far. And understanding where we came from helps us understand the Java we use today.

Java (rápida introdução histórica)

joaofelipefaria — Tue, 01 Sep 2026 11:21:47 +0000

Java nasceu no início dos anos 90, dentro dos escritórios da Sun Microsystems, principalmente pelas mãos de James Gosling e seu time. A ideia inicial fazia parte do Green Project, que buscava criar software para uma nova geração de dispositivos eletrônicos. A linguagem originalmente se chamava Oak. A história conta que o nome precisou ser alterado porque já existia uma marca com esse nome. Algumas versões também dizem que a inspiração para Java veio de uma cafeteria ou simplesmente do café que os desenvolvedores consumiam. ☕

Desde o começo, uma das grandes ideias do Java era ser multiplataforma, resumida na famosa frase “Write Once, Run Anywhere”. Na época, fazer um programa funcionar em diferentes sistemas operacionais não era tão simples quanto hoje. A grande sacada foi colocar uma camada entre a aplicação e o sistema operacional: a JVM (Java Virtual Machine). Assim, o código Java não precisa ser compilado diretamente para Windows, Linux ou outra plataforma específica.

É aí que entra o famoso bytecode. Quando escrevemos um programa Java, o compilador transforma o código .java em bytecode, normalmente armazenado em arquivos .class. Esse bytecode não é exatamente código nativo do processador. Ele é executado pela JVM, que conhece as particularidades da plataforma onde está rodando. Com o tempo, a JVM ficou extremamente sofisticada, utilizando técnicas como JIT (Just-In-Time) compilation para transformar partes do bytecode em código nativo durante a execução.

Java já tem mais de 30 anos de história. E é interessante perceber o quanto a linguagem mudou nesse período. Generics, annotations, lambdas, Streams, módulos, records, pattern matching, sealed classes e, mais recentemente, virtual threads, são apenas alguns exemplos da evolução da plataforma. Quem aprendeu Java há 15 ou 20 anos provavelmente vai encontrar uma linguagem bem diferente quando olhar para Java moderno.

Por isso, alguns dos velhos estereótipos sobre Java já não fazem tanto sentido. “Java é lento”, “Java é extremamente verboso”, “Java exige código demais”... Algumas dessas críticas tinham bastante fundamento em determinadas épocas. 😅 Mas comparar Java moderno com Java 5 ou Java 6 não é exatamente justo. A linguagem ficou muito mais expressiva e eliminou bastante boilerplate ao longo dos anos, sem abandonar a tipagem estática que sempre foi uma de suas características.

E tem uma coisa curiosa: apesar de toda essa evolução, muitas empresas ainda rodam Java 8. Java 8 foi lançado em 2014 e continua presente em uma quantidade enorme de sistemas corporativos. Depois dele, tivemos versões LTS (versões de suporte longo) importantes, como Java 11, Java 17, Java 21 e Java 25. Essa longevidade também mostra uma das grandes forças do ecossistema Java: compatibilidade. A preocupação em manter compatibilidade com versões anteriores permite que sistemas continuem evoluindo sem precisar ser reescritos a cada nova versão.

No fim das contas, aprender um pouco da história do Java ajuda a entender onde chegamos. A JVM, o bytecode, a portabilidade e a preocupação com compatibilidade não surgiram por acaso. São decisões que fazem parte de uma história de mais de três décadas. Java mudou muito, mas continua carregando algumas das ideias fundamentais que fizeram a linguagem chegar tão longe. E entender de onde viemos ajuda bastante a entender o Java que usamos hoje.

[FR] MapData App (un terrain de jeu full-stack)

joaofelipefaria — Sat, 29 Mar 2025 17:42:34 +0000

Bienvenue dans le Projet MapData : Votre Terrain de Jeu Full-Stack !

Salut, développeur ! Prêt à plonger dans un projet qui n'est pas seulement une expérience d'apprentissage, mais aussi un environnement pratique pour le développement full-stack avec Java et Angular ? Laissez-moi vous présenter le Projet MapData, un système modulaire parfait pour gérer les données cartographiques et les métadonnées, tout en vous offrant la flexibilité d'explorer plusieurs frameworks et outils.

Qu'est-ce que le Projet MapData ?

Le Projet MapData est avant tout un environnement de travail de base pour les développeurs full-stack. Il repose sur une architecture de microservices avec une API backend, une application frontend Single Page Application (SPA) et des utilitaires pour gérer la base de données et l'environnement. Que vous soyez un développeur expérimenté ou débutant, ce projet est une excellente opportunité pour explorer les technologies modernes.

Voici ce qui est inclus :

mapdata-api : Une API RESTful pour gérer les données cartographiques et les métadonnées.
mapdata-app : Une application frontend élégante basée sur Angular pour l'interaction utilisateur.
mapdata-db : Gère la création et la maintenance du schéma de la base de données.
mapdata-web : Une version frontend légère utilisant HTML, CSS et JavaScript pur.
mapdata-automations-python : Scripts Python pour automatiser et gérer l'environnement.

Et le meilleur ? Vous pouvez changer les frameworks ! Vous voulez essayer Quarkus au lieu de Spring Boot ? React au lieu de Angular ? Allez-y ! Le projet est conçu pour être flexible.

La Technologie Derrière la Magie

Voici un aperçu rapide :

Java : Le backend est construit avec Java, le langage incontournable pour les applications d'entreprise. Fiable, évolutif et parfaitement intégré avec des frameworks comme Spring Boot ou Quarkus.
Angular : Le frontend SPA est construit avec Angular, un framework puissant pour créer des applications web dynamiques et réactives.
Docker : Tout fonctionne dans des conteneurs, ce qui simplifie le déploiement et la gestion de l'environnement.
Python : Les scripts d'automatisation sont écrits en Python, une langue polyvalente idéale pour les tâches d'automatisation.
JavaScript Pur : Pour ceux qui aiment la simplicité, le composant mapdata-web est une version frontend pure en HTML/JS.

Comment Créer l'API et l'Application

Création de l'API

Clonez le dépôt :

   git clone https://github.com/joaofelipefaria/mapdata.git
   cd mapdata/mapdata-api

Construisez le projet :

   mvn clean install

Lancez l'API :

   java -jar target/mapdata-api-0.0.1-SNAPSHOT.jar

Création de l'Application

Accédez au répertoire de l'application :

   cd mapdata/mapdata-app

Installez les dépendances :

   npm install

Lancez l'application en mode développement :

   ng serve

Accédez à l'application à l'adresse http://localhost:4200.

Et la Base de Données et le Web ?

mapdata-db : Ce composant gère le schéma de la base de données. Configurez simplement le fichier pom.xml et exécutez :

   mvn clean install

Cela créera toutes les tables et séquences nécessaires.

mapdata-web : Vous voulez un frontend simple ? C'est celui qu'il vous faut. Ouvrez simplement le fichier index.html dans votre navigateur, et c'est parti.

Automatisation : Votre Nouveau Meilleur Ami

Gérer les environnements peut être compliqué, mais pas avec mapdata-automations-python. Ces scripts Python vous permettent de démarrer, arrêter et gérer les services Docker facilement. Par exemple :

Démarrez l'environnement :

   python run_env.py

Arrêtez tout :

   python shutdown_env.py

C'est aussi simple que ça. Plus besoin de commandes Docker manuelles !

Prêt à Vous Lancer ?

Le Projet MapData est bien plus qu'un simple projet : c'est un terrain de jeu pour les développeurs full-stack. Que vous construisiez quelque chose de nouveau ou que vous exploriez simplement, c'est l'environnement parfait pour affiner vos compétences. Alors, qu'attendez-vous ? Clonez le dépôt et commencez à coder !

GITHUB

https://github.com/joaofelipefaria/mapdata

MapData App (a full-stack playground)

joaofelipefaria — Sat, 29 Mar 2025 17:36:38 +0000

Welcome to the MapData Project: Your Full-Stack Playground!

Hey there, developer! Are you ready to dive into a project that’s not just a learning experience but also a practical environment for full-stack Java and Angular development? Let me introduce you to the MapData Project, a modular system that’s perfect for managing map data and metadata while giving you the flexibility to explore multiple frameworks and tools.

What’s the MapData Project?

At its core, the MapData Project is a basic work environment for full-stack developers. It’s built around a microservices architecture with a backend API, a frontend Single Page Application (SPA), and utilities to manage the database and environment. Whether you’re a seasoned developer or just starting out, this project is a great way to get your hands dirty with modern tech.

Here’s what’s included:

mapdata-api: A RESTful API built to handle map data and metadata. It’s your backend powerhouse.
mapdata-app: A sleek Angular-based frontend for user interaction.
mapdata-db: Handles database schema creation and maintenance.
mapdata-web: A lightweight frontend using pure HTML, CSS, and Vanilla JavaScript.
mapdata-automations-python: Python scripts to automate and manage the environment.

Oh, and did I mention? You can swap out frameworks! Want to try Quarkus instead of Spring Boot? React instead of Angular? Go for it! The project is designed to be flexible.

The Tech Behind the Magic

Let’s break it down:

Java: The backend is built with Java, the go-to language for enterprise applications. It’s reliable, scalable, and integrates seamlessly with frameworks like Spring Boot or Quarkus.
Angular: The frontend SPA is built with Angular, a powerful framework for creating dynamic, responsive web applications.
Docker: Everything runs in containers, making deployment and environment management a breeze.
Python: The automation scripts are written in Python, a versatile language that’s perfect for scripting and task automation.
Vanilla JavaScript: For those who love simplicity, the mapdata-web component is a pure HTML/JS version of the frontend.

How to Create the API and App

Creating the API

Clone the repository:

   git clone https://github.com/joaofelipefaria/mapdata.git
   cd mapdata/mapdata-api

Build the project:

   mvn clean install

Run the API:

   java -jar target/mapdata-api-0.0.1-SNAPSHOT.jar

Creating the App

Navigate to the app directory:

   cd mapdata/mapdata-app

Install dependencies:

   npm install

Run the app in development mode:

   ng serve

Access the app at http://localhost:4200.

What About the Database and Web?

mapdata-db: This component manages the database schema. Just configure the pom.xml file and run:

   mvn clean install

It’ll create all the necessary tables and sequences for you.

mapdata-web: Want a simple frontend? This is your go-to. Just open the index.html file in your browser, and you’re good to go.

Automations: Your New Best Friend

Managing environments can be a pain, but not with mapdata-automations-python. These Python scripts let you start, stop, and manage Docker services with ease. For example:

Start the environment:

   python run_env.py

Shut everything down:

   python shutdown_env.py

It’s that simple. No more manual Docker commands!

Multiple Framework Choices

One of the coolest things about the MapData Project is its flexibility. Want to try a different backend framework like Quarkus? Or maybe a frontend in React or Flutter? The project is modular, so you can experiment with different tech stacks without breaking a sweat.

Ready to Dive In?

The MapData Project is more than just a project—it’s a playground for full-stack developers. Whether you’re building something new or just exploring, this is the perfect environment to sharpen your skills. So, what are you waiting for? Clone the repo and start coding!

GITHUB

https://github.com/joaofelipefaria/mapdata