A series of Java projects developed whilst with FDM.
A simple project built whilst studying abstract classes.
This Java project showcases the use of Java annotations, including '@Retention' and '@Target', to develop a simple login application. The application demonstrates the power of annotations in simplifying and organizing code, as well as enabling automated data validation.
This project implements a bank management system using interfaces and overrides. The system enables the creation of different types of bank accounts, including personal and business accounts, and offers functionality such as depositing and withdrawing funds, transferring money between accounts, and resetting account balances. The project demonstrates the use of OOP concepts, including polymorphism and inheritance.
This Java collections project explores the different types of collections available in Java. The code demonstrates the flexibility and utility of different collection classes in Java and shows how they can be used to solve a variety of problems
This project is a Java Constructors project, showcasing the use of constructors in Java classes. The main application is represented by the "MainApp" class, which demonstrates the creation of User and Admin objects and their relationships.
In this project, the code creates different custom exceptions to handle different scenarios that may occur during the execution of the program.
This allows users to create vehicles from different classes, and utilizes generics to create lists based on the abstract vehicle class that each vehicle class inherits from.
A simple project demonstrating basic IO operations, utilising Input Streams and File Readers.
Some simple questions and answers relating to Java algorithms.
This project involves creating Data Access Objects (DAOs) and annotating data models to persist data in a SQL database.
A fun project using Java servlets in a DAO pattern. The goal was to separate the user interface from the business-logic layer of the app.
A more basic implementation of the above.
The third JSP servlets project I developed. This one has much more to it, and it creates an entire exam structure, with questions and answers, and an exam. Uses the DAO structure as before, with HTTP servlet requests to handle connections between the various elements. One of the tougher projects I developed, but with time the microservices structure became much easier.
A basic example of logging in Java.
Experimenting with muti-threading. Also came back to some of the earlier work with exception handling and scanners.
A fun project, where I built a simple multi-player game in Java.
A basic game which playes itself. The project makes use of inout streams and serialization techniques, along with some exception handling.
Nothing remarkable here. just a simple thing I put together whilst learning Java singletons. Defines a filing cabinet class, and updates its static member variable 'count' whenever instantiated.
Basic project developed whilst learning Spring annotations. Make use of various annotations such as @Component and @Value.
Similar to the above, a very simple app which let me explore the use of aspects in Spring to modularize an app better. Part of a series of programs based around microservices.
A more complicated Spring project. Defines a number of different messaging services, and uses Spring beans to add and remove data from the application context.
My first implentation of a Spring MVC project. Creates a simple login and authentication service in the model-view-control pattern.
Builds upon the previous project, but now implements an interceptor from the springFramework package to preHandle requests and throw a simple exception.
A great project to build, as it allowed me to persist data with SQL. I'd used SQL plenty before in other MVC packages, so exploring it in Java let me have some fun. It uses the JavaX persistence package to finetune the SQL database at the model level.
Similar to the above, a project that builds a persistence environment with some JSON serialization.
Contains both a streams and a serializable app. Utilizes streams to continuously read from an input file and then serializes the data.
Uses JUnit to enable test-driven development. A number of classes and methods were defined in the test package, then created piece-by-piece by testing and watching them fail.
Uses the JUnit package to enable testing. The app was entirely test-driven in its development.