Java Programming Operators and Data Types

Short-Circuit Evaluation

• In an || expression, if the first operand is true, the entire expression is true and the second operand is not evaluated.
• In an && expression, if the first operand is false, the entire expression is false and the second operand is not evaluated.
• Short-circuit evaluation can improve code efficiency and prevent runtime errors.
• It can prevent errors such as dividing by zero.

Comparisons

• Use the == operator for comparing primitive data types like int, boolean, and char.
• Avoid using == for comparing floating point numbers due to their inherent precision issues. Instead, use Math.abs(b - c) < epsilon where b, c, and epsilon > 0 are floating point types.
• For comparing strings, use StringObj.equals(Other_StringObj) or StringObj.equalsIgnoreCase(Other_StringObj).

DataTypes

• Primitive Data Types:
  • boolean: 1 byte
  • byte: 1 byte
  • char: 2 bytes
  • short: 2 bytes
  • int: 4 bytes
  • float: 4 bytes
  • double: 8 bytes
  • long: 8 bytes
• Derived Data Types:
  • array
  • function
• User-Defined Data Types:
  • enum
  • class

Type Casting

• A value of one type can be assigned to a variable of any type further to the right in this hierarchy: byte -> short -> int -> long.
• Values can also be cast in this order: int -> float -> double.
• A value of type char can be assigned to a variable of type int.

Class

• Everything in Java must be in a class.
• The class name must match the filename exactly.
• All classes (directly or indirectly) inherit from the Object class, which contains the toString() method.

Static

• The static keyword can be used with variables, methods, classes, and blocks in Java.
• Static variables and code are loaded into memory when the class is loaded.

Setters and Getters

• Setters (Mutators):
  • Used to set or update the value of a private field.
  • Public access modifier.
  • Have a void return type.
  • Can be used to (re)set individual attributes.
• Getters (Accessors):
  • Used to retrieve the value of a private field.
  • Public access modifier.
  • Have no parameters.
  • Not required if specific attributes should not be exposed.

Constructors

• Constructors are special methods used for initializing object attributes.
• They have the same name as the class and do not have a return type.
• Types of constructors:
  • Default Constructor: No parameters.
  • Parameterized Constructor: At least one parameter.
  • Copy Constructor: Creates a new object that is a copy of an existing object.

JUnit 5

• BeforeEach Annotation:
  • Runs a method before each test method in a class.
  • Use to set up the test environment.
• AfterEach Annotation:
  • Runs a method after each test method in a class.
  • Use to clean up after tests.

JUnit 5 Assertions

• assertTrue(test): Checks for a true condition.
• assertFalse(test): Checks for a false condition.
• assertEquals(expected, actual): Checks for equality between expected and actual values.
• assertNotEquals(unexpected, actual): Checks for inequality between expected and actual values.
• assertNull(value): Checks for null value.
• assertNotNull(value): Checks for non-null value.

Inheritance

• Inheritance is a mechanism for code reuse where a subclass inherits data and behavior from a superclass.
• The subclass extends the superclass using the extends keyword.

SOLID

• SOLID is an acronym for the following design principles:
  • Single Responsibility Principle (SRP): A class should have one and only one reason to change.
  • Open/Closed Principle (OCP): A class should be open for extension, but closed for modification.
  • Liskov's Substitution Principle (LSP): Subtypes should be substitutable for their base types.
  • Interface Segregation Principle (ISP): Clients should not be forced to depend on methods they don't use.
  • Dependency Inversion Principle (DIP): High-level modules should not depend on low-level modules. Both should depend on abstractions.

Factory

• Factory Pattern:
  • A creational design pattern that provides an interface for creating objects without specifying the concrete class.
  • Used for creating different types of objects based on input.

Command Pattern

• Command Pattern: Separates the request from the execution of the request.
• Key Components:
  • Client: Makes the request.
  • Invoker: Handles the request.
  • Receiver: Executes the actual request.
  • Command: Encapsulates the request.
  • ConcreteCommand: Defines the specific action to be executed.

Composite Pattern

• Composite Pattern:
  • Allows for recursive composition of objects.
  • Provides a uniform way to handle both individual objects (leaf nodes) and composite objects (tree nodes).
  • Key components:
    • Component: Common interface for all objects.
    • Leaf: Individual objects with no children.
    • Composite: Objects with children.

This quiz covers key concepts in Java programming pertaining to short-circuit evaluation, comparisons, and primitive data types. It focuses on best practices for evaluating expressions and comparing variables in Java to improve code efficiency and accuracy. Ideal for students looking to solidify their understanding of these foundational programming concepts.