# mouredev/hello-java

**Attribution required: if you use, quote, or summarise this content, you must credit and link back to [awesome-repositories.com](https://awesome-repositories.com/repository/mouredev-hello-java).**

4,304 stars · 395 forks · Java · Apache-2.0

## Links

- GitHub: https://github.com/mouredev/hello-java
- Homepage: https://mouredev.link/java
- awesome-repositories: https://awesome-repositories.com/repository/mouredev-hello-java.md

## Topics

`curso` `java` `poo` `programacion-orientada-a-objetos` `tutorial`

## Description

This project is a collection of instructional resources and curriculum materials designed to teach the Java language. It provides a structured programming course, a fundamentals guide, and an object-oriented programming tutorial, supported by a series of practical coding exercises and implementation challenges.

The curriculum focuses on implementing object-oriented patterns, including inheritance, polymorphism, and abstraction. It covers the creation of classes, the use of interfaces to define behavioral contracts, and the application of access modifiers to control data visibility.

The educational content also spans language fundamentals such as variable management, conditional logic, and iterative loops. It includes guidance on managing data structures through lists, sets, and maps, as well as implementing error handling using try-catch blocks and custom exceptions. Additional topics cover string manipulation and the use of scanners for console user input.

## Tags

### Education & Learning Resources

- [Java Language Guides](https://awesome-repositories.com/f/education-learning-resources/java-language-guides.md) — Offers a comprehensive overview of Java data types, operators, control flow, and exception handling.
- [Algorithm Implementation Practice](https://awesome-repositories.com/f/education-learning-resources/problem-solving-guides/interview-problem-solving/algorithm-implementation-practice.md) — Offers a collection of practical exercises for implementing core logic, operators, and algorithms.
- [Coding Exercises](https://awesome-repositories.com/f/education-learning-resources/coding-exercises.md) — Provides a collection of practical programming tasks to reinforce Java syntax and logic.
- [Data Structure Fundamentals](https://awesome-repositories.com/f/education-learning-resources/data-structure-fundamentals.md) — Teaches the fundamental use of arrays, lists, sets, and maps for data organization.
- [Object-Oriented Programming Concepts](https://awesome-repositories.com/f/education-learning-resources/educational-resources/languages-and-programming-concepts/programming-language-mastery-guides/object-oriented-programming-concepts.md) — Provides educational content covering essential classes, inheritance, encapsulation, and polymorphism in Java.
- [Java Programming Courses](https://awesome-repositories.com/f/education-learning-resources/java-programming-courses.md) — Provides a structured programming course and fundamentals guide for mastering the Java language.
- [Object-Oriented Modeling](https://awesome-repositories.com/f/education-learning-resources/object-oriented-modeling.md) — Provides instruction on mapping real-world entities to object-oriented programming structures. ([source](https://github.com/mouredev/hello-java/blob/main/basic/c08_oop/Classes.java))
- [Programming Courses](https://awesome-repositories.com/f/education-learning-resources/programming-courses.md) — Provides a structured educational program for beginners to learn Java and core programming fundamentals.
- [List Manipulation Exercises](https://awesome-repositories.com/f/education-learning-resources/list-manipulation-exercises.md) — Provides exercises for managing ordered collections with dynamic adding, removing, and searching. ([source](https://github.com/mouredev/hello-java/blob/main/basic/c05_structures/Lists.java))
- [Map Implementation Basics](https://awesome-repositories.com/f/education-learning-resources/map-implementation-basics.md) — Teaches how to map data using unique keys to retrieve, insert, and modify associated values. ([source](https://github.com/mouredev/hello-java/blob/main/basic/c05_structures/Maps.java))

### DevOps & Infrastructure

- [Error Tracking and Exception Handling](https://awesome-repositories.com/f/devops-infrastructure/devops/operational-reliability/error-tracking-and-exception-handling.md) — Covers the implementation of try-catch blocks to manage runtime exceptions and maintain stability.

### Programming Languages & Runtimes

- [Class Inheritance](https://awesome-repositories.com/f/programming-languages-runtimes/class-inheritance.md) — Instructs on creating hierarchical relationships where specialized classes inherit from base classes. ([source](https://github.com/mouredev/hello-java/blob/main/basic/c08_oop/Inheritance.java))
- [Visibility Modifiers](https://awesome-repositories.com/f/programming-languages-runtimes/class-inheritance/visibility-modifiers.md) — Teaches the use of public, private, and protected modifiers to control member visibility. ([source](https://github.com/mouredev/hello-java/blob/main/basic/c08_test_oop/Classes.java))
- [Class Definitions with Constructors](https://awesome-repositories.com/f/programming-languages-runtimes/class-method-definitions/class-definitions-with-constructors.md) — Provides instructions on defining class constructors to initialize object state. ([source](https://github.com/mouredev/hello-java/blob/main/basic/c08_oop/InheritanceExercises.java))
- [Class Hierarchies](https://awesome-repositories.com/f/programming-languages-runtimes/class-method-definitions/class-hierarchies.md) — Explains how to organize code through parent-child relationships to share state and behavior.
- [Multiple Interface Implementations](https://awesome-repositories.com/f/programming-languages-runtimes/class-system-implementations/multiple-interface-implementations.md) — Explains how to allow a single class to implement several interfaces for diverse behaviors. ([source](https://github.com/mouredev/hello-java/blob/main/basic/c08_oop/AbstractionExercises.java))
- [Native Collection Management](https://awesome-repositories.com/f/programming-languages-runtimes/collection-data-structures/object-collection-management/native-collection-management.md) — Teaches how to organize and retrieve data using built-in language collection types. ([source](https://github.com/mouredev/hello-java/blob/main/basic/c05_structures/StructuresExercises.java))
- [Conditional Logic](https://awesome-repositories.com/f/programming-languages-runtimes/conditional-logic.md) — Explains the use of boolean expressions to control program execution flow. ([source](https://github.com/mouredev/hello-java/blob/main/basic/c04_conditionals/ConditionalsExercises.java))
- [Execution Flow Control](https://awesome-repositories.com/f/programming-languages-runtimes/execution-flow-control.md) — Provides a foundation for directing program logic through conditionals and loops. ([source](https://github.com/mouredev/hello-java/blob/main/basic/c04_conditionals/Conditionals.java))
- [Function Definitions](https://awesome-repositories.com/f/programming-languages-runtimes/function-definitions.md) — Teaches how to encapsulate reusable logic into named methods with parameters and return values. ([source](https://github.com/mouredev/hello-java/blob/main/basic/c07_functions/Functions.java))
- [Interface Contract Implementations](https://awesome-repositories.com/f/programming-languages-runtimes/interface-contract-implementations.md) — Explains how to define abstract method sets using interfaces to ensure consistent behavior. ([source](https://github.com/mouredev/hello-java/blob/main/basic/c08_oop/AbstractionExercises.java))
- [Java Collections Framework](https://awesome-repositories.com/f/programming-languages-runtimes/java-collections-framework.md) — Provides comprehensive instruction on organizing information using Java arrays, lists, sets, and maps.
- [Loop Control Flow](https://awesome-repositories.com/f/programming-languages-runtimes/loop-control-flow.md) — Instructs on managing loop execution using break and continue statements. ([source](https://github.com/mouredev/hello-java/blob/main/basic/c06_loops/Loops.java))
- [Method Overloading](https://awesome-repositories.com/f/programming-languages-runtimes/method-overloading.md) — Teaches how to create multiple method versions that accept different parameter types. ([source](https://github.com/mouredev/hello-java/blob/main/basic/c08_oop/PolymorphismExercises.java))
- [Runtime Exception Handling](https://awesome-repositories.com/f/programming-languages-runtimes/runtime-exception-handling.md) — Teaches mechanisms for defining fallback handlers to recover from runtime errors using try-catch blocks.
- [Abstract Class Implementations](https://awesome-repositories.com/f/programming-languages-runtimes/runtime-execution-environments/runtime-environments/runtimes/type-definition-systems/abstract-classes/abstract-class-implementations.md) — Guides the use of abstract classes and interfaces to create consistent behavioral blueprints. ([source](https://github.com/mouredev/hello-java/blob/main/basic/c08_oop/Abstraction.java))
- [Abstract Base Classes](https://awesome-repositories.com/f/programming-languages-runtimes/runtime-execution-environments/runtime-environments/runtimes/type-definition-systems/abstract-classes/abstract-class-implementations/abstract-base-classes.md) — Explains how to create base classes that enforce method implementation in subclasses. ([source](https://github.com/mouredev/hello-java/blob/main/basic/c08_oop/InheritanceExercises.java))
- [Switch Statements](https://awesome-repositories.com/f/programming-languages-runtimes/switch-statements.md) — Teaches how to map a single variable to multiple outcomes using switch statements. ([source](https://github.com/mouredev/hello-java/blob/main/basic/c04_conditionals/Conditionals.java))
- [Variable and Constant Declarations](https://awesome-repositories.com/f/programming-languages-runtimes/variable-and-constant-declarations.md) — Teaches the definition of data containers with specific types to store and update values. ([source](https://github.com/mouredev/hello-java/blob/main/basic/c01_beginner/VariablesAndConstants.java))
- [Variable Assignments](https://awesome-repositories.com/f/programming-languages-runtimes/variable-assignments.md) — Provides instructional material on binding values to identifiers using direct and compound assignment operators. ([source](https://github.com/mouredev/hello-java/blob/main/basic/c02_operators/Operators.java))
- [Variable Scope Management](https://awesome-repositories.com/f/programming-languages-runtimes/variable-scope-management.md) — Teaches how to control variable visibility and accessibility using global and local scopes. ([source](https://github.com/mouredev/hello-java/blob/main/basic/c10_extras/Extras.java))
- [Custom Exception Definitions](https://awesome-repositories.com/f/programming-languages-runtimes/custom-exception-definitions.md) — Teaches how to create user-defined exception classes to represent domain-specific failure states. ([source](https://github.com/mouredev/hello-java/blob/main/basic/c09_exceptions/CustomException.java))
- [Exception Triggering](https://awesome-repositories.com/f/programming-languages-runtimes/exception-triggering.md) — Covers the mechanisms for manually raising exceptions when data fails to meet business rules. ([source](https://github.com/mouredev/hello-java/blob/main/basic/c09_exceptions/ThrowExample.java))
- [Input Data Validations](https://awesome-repositories.com/f/programming-languages-runtimes/input-data-validations.md) — Implements exception-based validation for provided values like negative numbers or password lengths. ([source](https://github.com/mouredev/hello-java/blob/main/basic/c09_exceptions/ExceptionsExercises.java))
- [Increment and Decrement Operators](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/language-features/language-extensions/variable-declarations/increment-and-decrement-operators.md) — Explains the use of sign inversion, increment, and decrement operators on single operands. ([source](https://github.com/mouredev/hello-java/blob/main/basic/c02_operators/Operators.java))
- [Null Reference Error Preventions](https://awesome-repositories.com/f/programming-languages-runtimes/null-reference-error-preventions.md) — Teaches techniques to prevent runtime crashes by checking for null references before method access. ([source](https://github.com/mouredev/hello-java/blob/main/basic/c10_extras/Extras.java))
- [Relational Value Comparisons](https://awesome-repositories.com/f/programming-languages-runtimes/relational-value-comparisons.md) — Explains how to use relational operators to compare values and produce boolean results. ([source](https://github.com/mouredev/hello-java/blob/main/basic/c02_operators/Operators.java))
- [Finally Blocks](https://awesome-repositories.com/f/programming-languages-runtimes/runtime-exception-handling/try-except-else-blocks/finally-blocks.md) — Explains the use of finally blocks to ensure unconditional code execution for resource cleanup. ([source](https://github.com/mouredev/hello-java/blob/main/basic/c09_exceptions/ExceptionsExercises.java))
- [String Manipulation](https://awesome-repositories.com/f/programming-languages-runtimes/string-manipulation.md) — Provides lessons on transforming, modifying, and concatenating text strings. ([source](https://github.com/mouredev/hello-java/blob/main/basic/c03_strings/Strings.java))
- [String Comparisons](https://awesome-repositories.com/f/programming-languages-runtimes/unicode-and-byte-string-distinction/string-byte-size-calculators/lexicographic-string-comparators/string-comparisons.md) — Includes exercises for evaluating string equality, emptiness, and lexicographical order. ([source](https://github.com/mouredev/hello-java/blob/main/basic/c03_strings/StringsExercises.java))
- [User Input Capture](https://awesome-repositories.com/f/programming-languages-runtimes/user-input-capture.md) — Provides guidance on capturing keyboard data from the standard input stream for program interaction.

### Software Engineering & Architecture

- [Interface-Driven Abstraction](https://awesome-repositories.com/f/software-engineering-architecture/abstraction-level-management/interface-driven-abstraction.md) — Instructs on using stable interfaces to decouple high-level modules from low-level implementations.
- [Polymorphism](https://awesome-repositories.com/f/software-engineering-architecture/architectural-design-patterns/object-oriented-foundations/polymorphism.md) — Explains how to treat entities of different types through a uniform interface. ([source](https://github.com/mouredev/hello-java/blob/main/basic/c08_oop/AbstractionExercises.java))
- [Iterative Loops](https://awesome-repositories.com/f/software-engineering-architecture/compile-time-code-generation/iterative-code-generation/iterative-loop-constructs/iterative-loops.md) — Covers the implementation of while, do-while, and for loops for sequence processing. ([source](https://github.com/mouredev/hello-java/blob/main/basic/c06_loops/LoopsExercises.java))
- [Logic Encapsulations](https://awesome-repositories.com/f/software-engineering-architecture/logic-encapsulations.md) — Demonstrates grouping sequences of statements into reusable methods to decompose complex tasks.
- [Object Composition](https://awesome-repositories.com/f/software-engineering-architecture/object-composition.md) — Teaches how to combine simple objects into complex ones by nesting class instances. ([source](https://github.com/mouredev/hello-java/blob/main/basic/c08_oop/Composition.java))
- [Object-Oriented Modeling](https://awesome-repositories.com/f/software-engineering-architecture/object-oriented-models/object-oriented-modeling.md) — Provides educational resources for representing real-world entities using classes and inheritance.
- [Polymorphism Patterns](https://awesome-repositories.com/f/software-engineering-architecture/polymorphism-patterns.md) — Teaches how to manage different subclass instances through a single base type to invoke shared methods.
- [Boolean Logic Combinators](https://awesome-repositories.com/f/software-engineering-architecture/boolean-logic-combinators.md) — Covers the use of AND, OR, and NOT operators to determine complex truth conditions. ([source](https://github.com/mouredev/hello-java/blob/main/basic/c02_operators/Operators.java))
- [Interface-Based Polymorphic Collections](https://awesome-repositories.com/f/software-engineering-architecture/polymorphism-patterns/interface-based-polymorphic-collections.md) — Demonstrates how to store diverse subclasses in a single list to invoke shared methods. ([source](https://github.com/mouredev/hello-java/blob/main/basic/c08_oop/InheritanceExercises.java))

### User Interface & Experience

- [Method Overrides](https://awesome-repositories.com/f/user-interface-experience/component-child-utilities/instance-references/parent-accessors/method-overrides.md) — Guides the redefinition of inherited methods to provide specialized behavior in child classes. ([source](https://github.com/mouredev/hello-java/blob/main/basic/c08_oop/Inheritance.java))

### Data & Databases

- [Collection Iteration](https://awesome-repositories.com/f/data-databases/collection-iterators/collection-iteration.md) — Instructs on using loops and for-each syntax to traverse elements within arrays and collections. ([source](https://github.com/mouredev/hello-java/blob/main/basic/c06_loops/LoopsExercises.java))
- [Fixed-Size Collections](https://awesome-repositories.com/f/data-databases/data-structures/structured-return-objects/collection-size-utilities/fixed-size-collections.md) — Explains the use of arrays as fixed-size collections for indexed access and modification. ([source](https://github.com/mouredev/hello-java/blob/main/basic/c05_structures/Arrays.java))
- [Unordered Unique Collection Management](https://awesome-repositories.com/f/data-databases/unordered-unique-collection-management.md) — Demonstrates how to create and manipulate collections of unique elements that filter duplicates. ([source](https://github.com/mouredev/hello-java/blob/main/basic/c05_structures/Sets.java))

### Scientific & Mathematical Computing

- [Arithmetic Operations](https://awesome-repositories.com/f/scientific-mathematical-computing/numerical-mathematical-foundations/arithmetic-number-types/arithmetic-operations.md) — Teaches basic mathematical calculations using standard Java arithmetic operators. ([source](https://github.com/mouredev/hello-java/blob/main/basic/c02_operators/Operators.java))