CSP 103 Pointers to Review.docx

CSP 103 Pointers to Review (OOP) Class: A blueprint or template for creating objects. It defines the properties (attributes) and behaviors (methods) that objects of the class will have. Object: An instance of a class. Objects represent real-world entities and encapsulate data and behavior. Inherita...

CSP 103 Pointers to Review (OOP) Class: A blueprint or template for creating objects. It defines the properties (attributes) and behaviors (methods) that objects of the class will have. Object: An instance of a class. Objects represent real-world entities and encapsulate data and behavior. Inheritance: A mechanism that allows a class (subclass or child class) to inherit properties and behaviors from another class (superclass or parent class). It promotes code reuse and establishes a relationship between classes. Encapsulation: The bundling of data (attributes) and methods that operate on that data within a single unit (class). It restricts access to some components, preventing accidental modification of data. Polymorphism: The ability of objects of different types to be treated as objects of a common type. It includes compile-time polymorphism (method overloading) and runtime polymorphism (method overriding). Abstraction: The process of simplifying complex systems by modeling classes based on the essential properties and behaviors they possess. Abstract classes and interfaces are used to achieve abstraction. Interface: A collection of abstract methods. It defines a contract for classes that implement it, ensuring that those classes provide specific functionalities. Method Overloading: Having multiple methods with the same name in a class, but with different parameter types or a different number of parameters. Method Overriding: Providing a specific implementation of a method that is already defined in the superclass. It occurs in subclasses that have a method with the same signature as a method in the superclass. Abstract Class: A class that cannot be instantiated and may have abstract methods. Abstract classes are meant to be extended by concrete (non-abstract) subclasses. Concrete Class: A class that can be instantiated. It provides concrete implementations for all abstract methods inherited from its abstract superclass. Constructor: A special method in a class that is called when an object is instantiated. It is used to initialize the object's state. Getter and Setter Methods: Methods used to retrieve (get) and modify (set) the values of private instance variables in a class, providing controlled access to the class's attributes. Instance Variable: variable defined in a class that represents the state of an object. Each object has its own copy of instance variables. Static Variable/Method: A variable or method that belongs to the class rather than to instances of the class. It is shared among all instances of the class. Method Signature: A method's signature consists of its name and the parameter list. The return type is also part of the signature. It uniquely identifies the method in a class. Return Type: The data type of the value that a method returns, if any. If a method does not return any value, its return type is specified as void. Parameters: Values that are passed into a method when it is called. A method may have zero or more parameters. Method Overloading: The ability to define multiple methods in a class with the same name but different parameter lists. It allows methods to perform similar tasks with different input types. Access Modifiers: Keywords such as public, private, or protected that control the visibility of a method. The choice of access modifier affects where the method can be accessed from. Return Statement: The return statement is used to exit a method and optionally return a value to the caller. It is mandatory for methods with a non-void return type. Void Method: A method that does not return any value. Its return type is specified as void. Method Call: The process of invoking a method. A method call consists of the method name followed by parentheses, optionally containing arguments. Method Declaration: The code that specifies the name, return type, parameters, and body of a method. It provides the method's signature and implementation. Static Method: A method that belongs to the class rather than an instance of the class. It can be called using the class name without creating an object. Instance Method: A method that operates on an instance of a class. It is called on an object of the class. Method Scope: The region of code where a method is accessible. The scope is determined by the method's access modifier. Method Invocation: The process of calling a method to execute its code. It involves specifying the method name and passing the required arguments. Recursive Method: A method that calls itself either directly or indirectly. Recursive methods are used for solving problems by breaking them down into smaller, similar sub-problems. In Java, the Collections framework provides a set of classes and interfaces that offer high-performance, reusable data structures. These structures include lists, sets, queues, maps, and more. The framework is designed to be flexible and extensible, allowing developers to manipulate and store collections of objects efficiently. Here are some key components of the Java Collections framework: Interfaces: Collection: The root interface for all collection classes. It defines the basic methods that all collections will have. List: An ordered collection that allows duplicate elements. Some common implementations are ArrayList, LinkedList, and Vector. Set: A collection that does not allow duplicate elements. Some implementations are HashSet, LinkedHashSet, and TreeSet. Queue: A collection used to hold elements before processing. Implementations include LinkedList, PriorityQueue, etc. Map: An object that maps keys to values. Common implementations are HashMap, LinkedHashMap, and TreeMap. Classes: ArrayList: A dynamic array implementation of the List interface. LinkedList: A doubly-linked list implementation of the List interface. HashSet: An implementation of the Set interface that uses a hash table for storage. HashMap: An implementation of the Map interface that uses a hash table for storage. TreeSet: An implementation of the Set interface that uses a red-black tree for storage. TreeMap: An implementation of the Map interface that uses a red-black tree for storage. Utility Classes: Collections: Provides various utility methods for manipulating collections, such as sorting, shuffling, and searching. Arrays: Contains utility methods for working with arrays, such as sorting and searching. Iterators: Iterator: An interface that provides methods to iterate over a collection. ListIterator: An interface that extends Iterator and provides additional methods to iterate bidirectionally and modify the list during iteration. Key Concepts: Generics: Introduced in Java 5, allows you to write classes and methods that can work with any data type. Concurrency Collection Classes: Introduced in Java 5, provides thread-safe collection classes, such as ConcurrentHashMap and CopyOnWriteArrayList. Comparator: An interface for comparing objects. It is used for custom sorting in collections like TreeSet and TreeMap. Exceptions in Java are events or conditions that occur during the execution of a program, disrupting its normal flow. These events can represent errors, exceptional conditions, or unexpected situations. Key concepts related to Java exceptions include: Exception Handling: The process of dealing with exceptions during program execution. It involves identifying, capturing, and responding to exceptions to ensure the program behaves predictably, even in the presence of errors. Throwable: The root class for all exceptions and errors in Java. Both Exception and Error classes extend from Throwable. Checked Exceptions: Exceptions that are checked at compile-time. These include exceptions derived from the Exception class (excluding RuntimeException and its subclasses). Examples are IOException and SQLException. Unchecked Exceptions: Exceptions that are not checked at compile-time. They include exceptions derived from RuntimeException or its subclasses. Examples are NullPointerException and ArrayIndexOutOfBoundsException. try-catch Block: A programming construct used to isolate and handle exceptions. The try block contains the code that may throw an exception, and the catch block specifies how to handle the exception. Throws Clause: A part of a method signature that declares the exceptions a method may throw. It allows these exceptions to be propagated to the calling method or caught using a try-catch block. finally Block: An optional block associated with a try-catch block. The code inside the finally block always executes, whether an exception occurs or not. It is commonly used for cleanup operations. Custom Exceptions: Developers can create their own exception classes by extending the Exception class or its subclasses. These custom exceptions allow developers to represent application-specific exceptional conditions. Exception Propagation: The process by which an exception is thrown from one method to another or from one part of the program to another. It can be achieved using the throws clause in method signatures. Exception Chaining: Throwing a new exception within a catch block, often with additional information, while preserving the information about the original exception. This is known as exception chaining. In Java, exceptions are categorized into two main types: checked exceptions and unchecked exceptions. Both types are subclasses of the Throwable class. 1. Checked Exceptions: Checked exceptions are exceptions that are checked at compile-time. Code that might throw a checked exception must either catch the exception or declare it in the method's throws clause. Examples of checked exceptions include: IOException: This exception is thrown when an input or output operation fails, such as when working with files or network connections. SQLException: It is thrown when there is an issue with database access or execution of SQL queries. FileNotFoundException: Thrown when attempting to access a file that does not exist. 2. Unchecked Exceptions (Runtime Exceptions): Unchecked exceptions, also known as runtime exceptions, are exceptions that are not checked at compile-time. They typically represent programming errors, and the compiler does not enforce handling or declaration. Examples of unchecked exceptions include: NullPointerException: Thrown when trying to access an object or invoke a method on a null reference. ArrayIndexOutOfBoundsException: Occurs when trying to access an array element with an invalid index. ArithmeticException: Thrown when an arithmetic operation (such as division by zero) results in an exceptional condition. IllegalArgumentException: Thrown to indicate that a method has been passed an illegal or inappropriate argument. 3. Error: Errors are exceptional conditions that are external to the application and typically indicate serious problems that cannot be handled by the application code. Unlike exceptions, errors are not meant to be caught or handled by the application. Examples of errors include: OutOfMemoryError: Thrown when the Java Virtual Machine (JVM) runs out of memory. StackOverflowError: Occurs when the call stack of a thread exceeds the maximum allowed stack size. NoClassDefFoundError: Indicates that the Java Virtual Machine (JVM) or the class loader cannot find the definition of a class. It's important to note that unchecked exceptions and errors are subclasses of RuntimeException or Error and their subclasses, while checked exceptions are subclasses of Exception (excluding RuntimeException).