How ofkira/hello-java works
1. Repository purpose
- This is a Java fundamentals teaching repository, not a production application.
- Its architecture is organized as a sequence of independent lesson modules that build from basic syntax to OOP, exceptions, and miscellaneous topics.
2. Top-level structure
- The repo is centered under basic/, with chapter folders c00_... through c10_....
- Images/ contains static assets for the README/course presentation.
- There is no visible backend, frontend, database, or service orchestration layer; the “system” is the course content itself.
3. Course progression as the main dependency chain
- The folders form a linear curriculum:
- c00_helloworld → first program and first exercises
- c01_beginner → variables, constants, primitive types
- c02_operators → operators
- c03_strings → string APIs
- c04_conditionals → branching
- c05_structures → arrays, lists, sets, maps
- c06_loops → iteration and loop control
- c07_functions → methods, parameters, return values, overloads
- c08_oop → object-oriented design
- c09_exceptions → error handling and custom exceptions
- c10_extras → miscellaneous Java features
- For diagramming, the important boundary is that each chapter is mostly self-contained, but the curriculum flow is sequential.
4. Content pattern inside each chapter
- Most lesson folders contain one or more concept demonstration classes plus a matching *Exercises.java.
- This creates two distinct content paths:
- instructional examples (HelloWorld.java, Operators.java, Strings.java, etc.)
- practice problems (HelloWorldExercises.java, OperatorsExercises.java, etc.)
- The exercises are not a separate subsystem; they are the practice counterpart to the instructional code.
5. Core language fundamentals subsystem
- The early chapters (c00–c07) focus on imperative programming fundamentals:
- syntax and program entry
- data types and variables
- expressions and operators
- string manipulation
- conditionals
- collections and iteration
- reusable functions
- These chapters demonstrate standard Java library usage, but only at the level needed to teach the language basics.
6. Data structures and control flow
- c05_structures groups the basic collection abstractions: Arrays, Lists, Sets, and Maps.
- c06_loops covers the main iteration patterns and loop-control flow.
- Architecturally, these chapters are the bridge between “syntax” and “program logic,” showing how data moves through loops and collections.
7. OOP subsystem
- c08_oop is the largest architectural block and introduces object-oriented concepts:
- Classes.java and Person.java show class/object modeling
- AccessModifiers.java and basic/c08_test_oop/Classes.java demonstrate package-level access boundaries
- Inheritance.java, Polymorphism.java, Abstraction.java, and Composition.java show the main OOP relationships
- This is the first part of the repo where multiple classes collaborate in a more realistic object model.
8. Boundary-testing package
- basic/c08_test_oop/Classes.java exists specifically to test or demonstrate access modifier behavior across a different package.
- That folder is important in an architecture diagram because it represents a visibility boundary, not just another example file.
9. Exception-handling subsystem
- c09_exceptions isolates runtime failure handling:
- Exceptions.java for try/catch-style handling
- ThrowExample.java for explicit exception throwing
- CustomException.java for domain-specific exception types
- ExceptionsExercises.java for practice
- The key architectural idea here is the separation between normal control flow and error flow.
10. Extras and wrap-up
- c10_extras collects additional Java topics that don’t fit the main progression.
- Extras.java, ExtrasExample.java, and ExtrasExercises.java again follow the same lesson/exercise split.
- This acts as a catch-all extension layer rather than a distinct subsystem.
11. Runtime and tooling context
- The repo targets Java JDK 21+ per the README.
- There is no obvious build automation or dependency management visible in the tree, which suggests the code is meant to be run directly in an IDE or simple Java project setup.
- That means the repo architecture is primarily educational source organization, not deployable infrastructure.
12. How to draw it
- A good architecture diagram would show:
- a single top-level “Java course” system
- a chapter-by-chapter pipeline from fundamentals to OOP and exceptions
- each chapter containing example classes and exercise classes
- a small shared “support” area for classes like Person, CustomException, and the access-modifier test package
- The main boundary is between curriculum modules and the readme/media assets, not between services or tiers.
Main entry points: c08_oop OOP · c09_exceptions Exceptions · c01_beginner Beginner · c02_operators Operators
Components 22
Docs & assets
Repository documentation and static presentation assets.
Curriculum
Linear Java lesson chapters from fundamentals to extras.
- Java course · Top-level teaching repository organized as a sequential chapter flow.
basic - Hello world · First program and first exercises.
basic/c00_helloworld - Beginner · Variables, constants, and primitive types.
basic/c01_beginner - Operators · Expressions and operators.
basic/c02_operators - Strings · String APIs and manipulation.
basic/c03_strings - Conditionals · Branching and decision-making.
basic/c04_conditionals - Structures · Arrays, lists, sets, and maps.
basic/c05_structures - Loops · Iteration and loop control.
basic/c06_loops - Functions · Methods, parameters, return values, and overloads.
basic/c07_functions - OOP · Classes, relationships, and access boundaries.
basic/c08_oop - Exceptions · Try/catch handling and custom exceptions.
basic/c09_exceptions - Extras · Miscellaneous Java topics and wrap-up.
basic/c10_extras
OOP internals
Object-oriented modeling and visibility-boundary examples inside chapter 08.
- Classes · Class and object modeling.
basic/c08_oop/Classes.java - Person · Shared domain object used by OOP examples.
basic/c08_oop/Person.java - Access · Access modifier behavior within the package.
basic/c08_oop/AccessModifiers.java - Test package · Cross-package access test for modifier behavior.
basic/c08_test_oop/Classes.java - Relationships · Inheritance, polymorphism, abstraction, and composition.
basic/c08_oop
Exception internals
Normal-flow and error-flow examples inside chapter 09.
- Exceptions · Normal exception handling flow.
basic/c09_exceptions/Exceptions.java - Throwing · Explicit exception throwing examples.
basic/c09_exceptions/ThrowExample.java - Custom error · Domain-specific exception definition.
basic/c09_exceptions/CustomException.java
Connections 29
- README → Java course: describes · Documentation frames the course structure.
- Java course → Hello world: starts with · Curriculum begins with the first runnable program.
- Hello world → Beginner: next · Fundamentals progress into variables and primitive types.
- Beginner → Operators: next · Types and variables feed into expressions and operators.
- Operators → Strings: next · Operators lead into string manipulation.
- Strings → Conditionals: next · String handling precedes branching logic.
- Conditionals → Structures: next · Conditional logic bridges to collections and structured data.
- Structures → Loops: next · Collections are exercised with iteration patterns.
- Loops → Functions: next · Looping sets up reusable functions and decomposition.
- Functions → OOP: next · Procedural basics transition into object-oriented design.
- OOP → Exceptions: next · OOP fundamentals lead into error handling.
- Exceptions → Extras: next · Exception handling is followed by extra topics.
- Hello world → Beginner: practices · Each chapter pairs explanation with exercises.
- Beginner → Operators: practices · Each chapter pairs explanation with exercises.
- Operators → Strings: practices · Each chapter pairs explanation with exercises.
- Strings → Conditionals: practices · Each chapter pairs explanation with exercises.
- Conditionals → Structures: practices · Each chapter pairs explanation with exercises.
- Structures → Loops: practices · Each chapter pairs explanation with exercises.
- Loops → Functions: practices · Each chapter pairs explanation with exercises.
- Functions → OOP: practices · Each chapter pairs explanation with exercises.
- OOP → Classes: introduces · Core OOP chapter starts with class modeling.
- Classes → Person: uses · Class examples collaborate with a person model.
- OOP → Access: covers · Access modifiers are taught as a dedicated topic.
- Access → Test package: checks · A separate package demonstrates visibility boundaries.
- OOP → Relationships: covers · Inheritance, polymorphism, abstraction, and composition are grouped together.
- Exceptions → Exceptions: introduces · Exception handling begins with try/catch flow.
- Exceptions → Throwing: extends · Explicit throwing shows how failures propagate.
- Exceptions → Custom error: defines · Custom exception types support domain-specific failures.
- Exceptions → Custom error: exercises · Practice work reinforces exception handling concepts.