Is it true that Java is purely object-oriented.?

Java is considered 'hybrid' because it includes primitive data types (like `int`, `boolean`) which are not objects, although wrapper classes (`Integer`, `Boolean`) exist to treat them as objects.

Is it true that All exceptions in Java are objects.?

While all exceptions are objects derived from `Throwable`, primitive types are not objects and thus not exceptions.

Java Object-Oriented Programming Cheat Sheet

Java's object-oriented paradigm centers on classes and objects, enabling code reusability through inheritance and modularity via packages, while robustly handling errors with exceptions and concurrent execution with multithreading.

Core Principles

Classes define blueprints for objects, encapsulating data and behavior.
Inheritance allows subclasses to inherit properties from superclasses, promoting code reuse.
Polymorphism enables objects of different classes to respond to the same method call in their own way.
Abstraction hides complex implementation details, exposing only essential features.
Encapsulation bundles data and methods within a class, controlling access.

Action Steps

1. Define a Class: Specify attributes (variables) and behaviors (methods) to model real-world entities.
2. Create Objects: Instantiate classes to create concrete instances with unique states.
3. Utilize Constructors: Implement constructors to initialize object states upon creation.
4. Implement Inheritance: Extend existing classes to reuse code and establish 'is-a' relationships.
5. Handle Exceptions: Use try-catch-finally blocks to manage runtime errors gracefully.
6. Create Threads: Implement Runnable or extend Thread to enable concurrent execution.
7. Organize with Packages: Group related classes and interfaces for better code management and access control.

Key Terms

JVM (Java Virtual Machine): An abstract computing machine that enables a computer to run a program written in Java.
Bytecode: Intermediate code generated by the Java compiler, which is then interpreted by the JVM.
Class: A blueprint or template for creating objects, defining their properties and behaviors.
Object: An instance of a class, possessing state (data) and behavior (methods).
Constructor: A special method used to initialize the state of an object when it is created.
Inheritance: A mechanism where a new class (subclass) inherits properties and behaviors from an existing class (superclass).
Polymorphism: The ability of an object to take on many forms, typically achieved through method overriding and interfaces.
Abstraction: Hiding the implementation details and showing only the necessary features of an object.
Encapsulation: Bundling data (variables) and methods that operate on the data within a single unit (class) and restricting access to it.
Exception: An event that disrupts the normal flow of program execution, typically an error.
Thread: A lightweight sub-process, the smallest unit of processing that can be scheduled by an operating system.
Package: A mechanism for organizing classes and interfaces into logical groups, aiding in modularity and access control.

Pro Tips

Use `final` for variables that should not be reassigned to ensure immutability and prevent accidental changes.
Employ `static` members when a variable or method belongs to the class itself, not to any specific instance.
Leverage `StringBuffer` for mutable string operations, as it's more efficient than repeated `String` concatenation.
Implement `finally` blocks to guarantee execution of critical cleanup code, regardless of whether an exception occurred.
Use thread priorities judiciously; setting them too high can starve lower-priority threads, impacting overall application responsiveness.

Pitfalls to Avoid

Forgetting to initialize variables leads to `NullPointerException` or incorrect program logic.
Overriding methods without understanding method signatures can cause `NoSuchMethodError` or unexpected behavior.
Ignoring checked exceptions forces the compiler to flag errors, but failing to handle them properly can lead to runtime crashes.
Improper synchronization in multithreaded programs causes race conditions, leading to data corruption and unpredictable results.

Myth vs Reality

Java is purely object-oriented.: Java is considered 'hybrid' because it includes primitive data types (like `int`, `boolean`) which are not objects, although wrapper classes (`Integer`, `Boolean`) exist to treat them as objects.
All exceptions in Java are objects.: While all exceptions are objects derived from `Throwable`, primitive types are not objects and thus not exceptions.

Real World Examples

Modeling a 'Car' in Java.: Create a `Car` class with attributes like `color`, `model`, `speed` and methods like `startEngine()`, `accelerate()`, `brake()`. Objects like `myHonda = new Car('red', 'Civic')` can then be created.
Implementing a 'Shape' hierarchy.: Define an abstract `Shape` class with an abstract `calculateArea()` method. Create subclasses like `Circle` and `Rectangle` that extend `Shape` and provide their specific implementations for `calculateArea()`, demonstrating inheritance and polymorphism.
Handling file input errors.: Use a `try-catch` block when reading from a file to catch `FileNotFoundException` or `IOException`, preventing the program from crashing if the file doesn't exist or cannot be accessed.