Coding exercises and projects from my education at SoftUni
All of the solutions have passed 100/100 - you can check them here: Java OOP
Course Curriculum: Java OOP
Working with Abstraction:
In the Working with Abstraction module, I delved into the concept of abstraction. I learned how to abstract away complex details and create more manageable code. This included understanding abstract classes and methods, allowing me to implement abstraction effectively in Java.
Encapsulation:
In the Encapsulation module, I focused on encapsulating data and methods within classes in Java. I learned how to keep class fields private and control access through public methods, ensuring data integrity and promoting better code structure. This concept is key for creating secure and maintainable software.
Inheritance:
In the Inheritance module, I delved into the powerful concept of building relationships between classes in Java. This involved creating new classes that inherit attributes and behaviors from existing ones, fostering a streamlined and hierarchical code structure. By inheriting from a base class, I honed the skill of reusing code intelligently, thereby enhancing both development efficiency and code maintainability.
Interfaces and Abstraction:
Within the Interfaces and Abstraction module, I focused on two pivotal concepts in Java that contribute to creating modular and flexible code structures. Through abstraction, I learned to create abstract classes with method signatures, leaving the implementation details to the derived classes. By implementing interfaces, I gained the ability to achieve multiple inheritances, allowing a class to inherit from more than one source.
Polymorphism:
In the Polymorphism module, I explored the concept of polymorphism in Java, which enables objects of different classes to be treated as objects of a common superclass. This powerful feature allowed me to write more flexible and extensible code. By using method overriding and interfaces, I could achieve runtime polymorphism, making my code adaptable to different scenarios and simplifying maintenance.
SOLID:
In the SOLID module, I learned about the SOLID principles, which are fundamental guidelines for writing clean and maintainable code. Each letter in SOLID represents a principle: Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion. These principles helped me design software that is modular, flexible, and easy to extend, promoting good software architecture practices.
Reflection and Annotation:
In the Reflection and Annotation module, I delved into the advanced features of Java that allow for introspection and meta-programming. Reflection allowed me to examine and manipulate class metadata at runtime, which can be useful for tasks like creating dynamic objects and invoking methods dynamically. Annotations, on the other hand, helped me add metadata to code elements, enabling customization and configuration in a more structured way.
Exceptions and Error Handling:
In the Exceptions and Error Handling module, I focused on how to handle exceptions and errors gracefully in Java. I learned about the try-catch block, exception hierarchies, and how to create custom exceptions. Understanding proper error handling techniques is crucial for writing robust and reliable software that can gracefully recover from unexpected situations.
Debugging Techniques:
In the Debugging Techniques module, I explored various debugging tools and strategies available in Java. This included using IDE debugging features, printing debugging statements, and analyzing stack traces. Effective debugging is essential for identifying and resolving issues in code, ensuring that software behaves as expected.
Unit Testing:
In the Unit Testing module, I learned how to write and execute unit tests using frameworks like JUnit. Unit testing is a critical part of the software development process, allowing me to systematically test individual components of my code to ensure they function correctly in isolation. This practice enhances code quality and reduces the likelihood of introducing bugs.
Test Driven Development:
In the Test Driven Development (TDD) module, I practiced a development methodology where I wrote tests before writing the actual code. TDD promotes a systematic and disciplined approach to software development, ensuring that code is designed to meet specific requirements and is thoroughly tested from the outset.
Design Patterns:
In the Design Patterns module, I studied common design patterns such as Singleton, Factory, Observer, and more. These patterns provide proven solutions to recurring design problems in software development. By applying design patterns appropriately, I was able to create more maintainable, extensible, and efficient software architectures.
Upon completing the Java OOP Course, I have deepened my understanding of advanced Java programming concepts that revolve around object-oriented principles. This course provided me with an in-depth exploration of topics such as class design, inheritance, encapsulation, polymorphism, and abstraction in Java. Through engaging practical exercises and workshops, I have honed my skills and knowledge, positioning myself to excel in advanced Java OOP programming scenarios.
