Software Development Flashcards

Question

What modifiers can be used for standard outer classes and nested classes in Java?

Answer 1

Standard outer classes (top-level classes) can only be declared with two modifiers: - public - default (package-private) Nested classes can be declared with any of the standard modifiers: - public, private, protected, or package-private.

Answer 2

Static nested class (doesn’t have access to instance members) Inner class (does have access to instance members)

Answer 3

- Closely linked classes can be located in one place for better organization. - If one class is only used by another, making it a nested class makes this relationship explicit. - Increases encapsulation by controlling visibility: - If the Engine class is nested inside the Car class, the private members of Car are visible to Engine. - Can also improve code readability.

Answer 4

- Can be difficult to spot in code - Will produce two class files on compilation - Inner classes can be directly accessed by the enclosing instance - All nested classes can be accessed externally through either the containing class or object

Answer 5

"this" refers to the inner type instance "OuterClass.this" refers to the instance of the surrounding (outer) class, when within the inner class code blocks.

Answer 6

Local classes are defined and exist solely within a block (usually a method)

Answer 7

Cannot contain public, protected, private, or static.

Answer 8

Can access all members of outer class instance like standard inner class member Cannot access method local variables unless they are declared as final

Answer 9

Classes that are declared without any class name at all

Answer 10

Not only may these be defined within a method, they may also be defined within an argument to a method.

Answer 11

To be able to perform multiple processes at same time Each process happens in parallel without having to wait for each other to be scheduled (including the potential interaction between them)

Answer 12

Parallelism

Answer 13

Most efficient use of hardware - gets the most out of the processor and its cores

Answer 14

Can be treated as lightweight processes Threads exist within a process

Answer 15

Easier to manage multiple threads under a process than have multiple different programs

Answer 16

OS can run threads in parallel - Virtually, on a single core processor - Actually, on a multi-core processor

Answer 17

Where the exact order in which processes are executed cannot be predicted

Answer 18

Multiple tasks are running at the same time, and the OS may decide to swich between them at different moments

Answer 19

In simple terms, it means that the system isn't stuck, frozen, or waiting forever—it ensures that things keep moving forward, like responding to user actions, processing data, or handling requests Examples: - A website showing search results when you hit "search." - A background task in an app eventually finishing its job.

Answer 20

1. Using the Thread class 2. Using the Runnable interface

Answer 21

1. Setting a flag 2. Interrupting

Answer 22

When two threads try to access/change data at the same time

Answer 23

In programming, atomic actions are self-contained, they can't be stopped in the middle - They either happen or don't

Answer 24

When thread 1 needs a resource in thread 2, and thread 2 needs a resourse in thread 1 This creates a deadlock and nothing happens as to run they both require resources from each other, creating an infinite cycle - deadlock

Answer 25

Where a thread can't gain regular access to shared resouces because another thread is frequently calling the objects methods

Answer 26

Similar to deadlock, except that it occurs when 2 threads are too busy responding to one another to work

Answer 27

Releases the lock and regains it using the notify()

Answer 28

Wait - Must occur in block synchronised on the monitor object - Releases the monitor (lock) when called; doesn't sacrifice the remainder of its time slice - Will wake up if notified via call Sleep - Doesn't need to occur in a synchronized block - Retains the monitor (lock) when called and sacrifices the remainder of its time slice - Can only be woken up by an interruption (not by notify)

Answer 29

Thread needs to wait to start until the start method is invoked goes between runnable and running, this is dependent on the OS

Answer 30

Identifies the current thread as doing something not particularly important

Answer 31

Causes the currently executing thread object to pause and allow other threads to execute If no other threads of the same priority need to execute, the thread continues.

Answer 32

Allows one thread to wait for the completion of another

Answer 33

Like sleep, responds to an interrupt

Answer 34

Need to ensure the data our threads are accessing is fresh (up to date) Stale data can lead to large issues

Answer 35

Variables that support atomic operations, ensuring that increments, decrements or reads happen as a single uninterruptible action

Answer 36

Volatile: : A volatile variable is a variable that can change at any moment, often due to factors outside the program Data Freshness: How recent or up-to-date the data is, fresh data is reliable and current.

Answer 37

Publishing an object is when you make it available outside its current scope

Answer 38

By default, we shouldn't have to publish an object unless we have to - if we do, we may need to confirm the thread-safe nature of the publishing

Answer 39

An object published when it should not have been

Answer 40

1. One of the simplest ways to ensure thread-safety 2. If the data doesn't need to be shared, confine it to a single thread 3. If data is only used by a single thread then its said to be confined 4. Thread confinement is an element of the programs design

Answer 41

Essentially a block of code that you can pass a round between objects

Answer 42

Tracking and managing your files by recording changes over time, you can recall specific versions later

Answer 43

In a team setting if a change is made that isn't wanted by other members, they can revert the changes back to before

Answer 44

- If a new person joins a team they can check the older versions to understand the progress of the project - Sharing of files and information about the project - Modern version control systems have atomic commits

Answer 45

Gives a development team a project wide undo button Place to store all files/documents/directories - repository Repository acts as a server Allows multiple developers to work on same code in controlled manner Keeps record of changes Can support multiple releases at same time Time machine can examine how project looked at particular dates/versions Can see who added/changed code - name/blame

Answer 46

As soon as you commit to a centralized repository others can see your changes Developers must push changes and pull updates from distributed repositories

Answer 47

Doesn't just store copies, it stores every version that has ever been checked in

Answer 48

Allow you to provide text for particularly important revisions Easier to remember and more informative than version numbers

Answer 49

Main code base that developers are working on

Answer 50

Like creating a copy of your project to work on separately without affecting the main version. You can make changes, try new features, or fix bugs in the branch, and later merge it back into the main project once everything works well.

Answer 51

Forking means creating a personal copy of someone else's project in your own repository. It’s like copying the whole project to your account so you can work on it independently.

Answer 52

Merging back the changes made in branch

Answer 53

Only one person can change a file at any one time

Answer 54

All files can be changed, but if changed in the repository since last check out then local copy needs to be updated before you can commit a change

Answer 55

The version control system doesn't know what you want - so it leaves it up to you to sort out If you commit a file which has changed since you last updated you will be told the commit has failed

Answer 56

Something that happens in a program (Such as: pressing a key)

Answer 57

A function/piece of code that waits for a specific event to happen, and responds by executing some action.

Answer 58

In event-driven programming, instead of repeatedly checking for events, the system waits and responds to an event only when it occurs - typically more efficient Polling on the other hand is less efficient, because it consumes resources even when nothing happens

Answer 59

Interrupts - where the hardware or OS alerts the software when an event occurs Event Listeners - where the system waits for an event to trigger a specific action

Answer 60

- Can check for button presses and clicking on graphical icons - Efficient use of resources

Answer 61

An object that generates an event

Answer 62

Extends the Waterfall Model by emphasizing testing at every stage. Follows a sequential process, where each development phase has a corresponding testing phase. The V shape illustrates thee relationship between developing on the left and testing on the right of the V. It ensures early testing and verification, but is rigid, making it less flexible for changes once a phase is complete

Answer 63

- Provides a statement of the goals and objectives of the system - Includes strategies, tactics, policies and constraints affecting the system - so contextualizes the system in the wider business - Clear statement of responsibilties and authorities to the various participants involved in the system - Specifies the processes for iniating, developing, maintaining and retiring the system

Answer 64

Cover three core areas: 1. Requirement gathering 2. Are the gathered requirements, clear, complete, consistent and unambiguous? 3. Clear statement of responsibilities and authorities to the various participants involved in the system - Also what can the system achieve with time?

Answer 65

Will describe the platforms, systems, products, services, that the developed system will depend on Typically will include an architecture diagram - this will show the interface, components and networks that need to be further specifed or developed

Answer 66

Specifies how the system will be constructed - for instance how the functions/objects/methods should be Once detailed design is generated it should be possible to write the tests before the actual system is implemented

Answer 67

Testing individual blocks of code in terms of correctness (Probably the most widely used testing type that you have done so far)

Answer 68

Testing the final system when grouped together or integrated Unexpected behaviour may arise at this point, which is checked for here

Answer 69

Testing the system as a whole - Also checks that it doesn't impair performance on the wider environment - Affecting broader resource availability on the OS - Affecting other applications working on the same system

Answer 70

Plans are developed during requirement analysis phase and are composed by users Is performed in a user environment that resembles the production environment and uses realistic data Ensures that the delivered system meets the users requirements and system is ready for use in real time It's based on validation rathjer than verification

Answer 71

Highly structured, phases completed one at a time Works well where all requirements are understood Simple to understand Easy to manage - each phase has a definite end with a review

Answer 72

Once a project is in the tesing phase it is difficult to go back and change functionality Not suitable for projects where requirements might change No working software created until late in the cycle

Answer 73

Static Testing Dynamic Testing - White box testing - Black box testing - Grey box testing

Answer 74

Static Testing - accessing documents Dynamic Testing - testing that involves executing program code

Answer 75

Testing where the internals of the program are known, so can test explicit paths through the system

Answer 76

Treats code as a "black box", and therefore is only concerned with functionality

Answer 77

Know both the required functionality and also some of the implementation concepts which can be used in test design, but not code base exposed

Answer 78

Advantage - Code can be seen so tests can be designed to test many paths through the program Disadvantage - Knowledge of the internals will influence the testing - can lead to bias in test design

Answer 79

Advantage - No knowledge of internals so no bias - more likely to result in tests unexpected by programmer Disadvantage - High probability that tests will only test a small number of paths through the program

Answer 80

Principles of unit test are to test small specific areas of functionality within a program

Answer 81

Attempts to measure how much of your code has been tested It looks at the code directly, and uses a lot of techniques in unit testing to derive a formal message Different measures of coverage are often reffered to - some are simply infeasible to completely cover So often a choice has to be made about how much code can be covered

Answer 82

Function/method/subroutine coverage Statement coverage Decision coverage Predicate coverage

Answer 83

Has each method written, had a test written (and run) on

Answer 84

Has each line of code been processed by at least one of your suite of tests

Answer 85

Has every desicision edge been traversed in your code (if/else)

Answer 86

Has every condition been tested? (not always the same as decision coverage)

Answer 87

Where a variable takes its maximum or minimum possible value

Answer 88

Situations where multiple edge cases occur together, these are even rarer than edge cases, and can be harder to identify and handle

Answer 89

Combining extreme inputs - Testing with both min and max values together (e.g., a max sized file with invalid characters) Multiple boundary conditions - Checking how a system behaves when several limits are hit at the same time (e.g., a nearly full database with a complex query

Answer 90

It's not possible to test every single aspect of even a moderately simple system - no. of possible inputs are too large - Too many possible paths through the system Testing cannot assert that the software functions correctly under all conditions, but that it functions incorrectly under specific conditions

Answer 91

It is often very difficult or impossible to "prove" a piece of code works, we can only satisfy ourselves that we haven't disproved that it works - Designing tests with this in mind is critical

Answer 92

- Reduces time spent on debugging - Helps communicate codes inteded use - illustrates how you expect the code to perform on various inputs and conditions - The code shouldn't drift away from the limits put on them by tests

Answer 93

Right – are the boundary results correct (or "right") B – are all the boundary conditions correct? I – can you check the inverse relationships? C – can you cross-check the results using some other means? E – can you force error conditions to occur? P – are the performance characteristics within bounds?

Answer 94

1. You've flexed your right bicep 2. Automatic 3. Thorough 4. Repeatable (should produce same results each time) 5. Independent (of each other test and of the environment) 6. Professional (written and maintained to the same standard as the shipped code)

Answer 95

- Improve the tests while fixing bugs - Prove the tests by introducing bugs

Answer 96

If the production code class is called Account and a method is called createAccount; Test should be called testCreateAccount You may have more than one test method that tests createAccount but they should all begin with test

Answer 97

Test code must be written to do a number of things: 1. Set up all conditions needed for testing (create any required objects, allocate any needed resources) 2. Call the method to be tested on the object 3. Verify that the object/class to be tested functions as expected 4. Clear up after itself

Answer 98

Used to verify that the code being tested behaves as expected. If the assertion fails, the test is considered to have failed, and it usually indicates that there is a bug or issue in the code being tested.

Answer 99

assertEqual(actual, expected) checks if the actual value equals the expected value. assertNotEqual(actual, expected) checks that the actual value doesn't equal the expected value.

Answer 100

assertTrue(condition) checks that the boolean condition is True assertFalse(condition) checks that the boolean condition is False

Answer 101

assertNull(value) checks if the value is null assertNotNull(value) checks if the value is not null

Answer 102

assertSame(expected, actual) checks whether two objects are of the same instance assertNotSame(expected, actual) checks whether two objects are not of the same instance

Answer 103

fail(message) wil fail test immediately if flow of control passes to this statement

Answer 104

Cheap placeholder objects that are predictable and allow us to test the method we need to in the current class

Answer 105

When the real object: - has non deterministic behaviour (not sure how the object will behave) - is difficult to set up - has behaviour that is hard to trigger - is slow - has (or is) a user interface - does not yet exist

Answer 106

1. Use an interface to describe the object 2. Implement the interface for production code 3. Implement the interface in a mock object for unit testing

Answer 107

They allow us to group multiple tests classes to run as a single batch They also allow us to run a specific subset of unit tests from multiple test classes

Answer 108

Can help you design your code better You see the code from the user's perspective - not the developers

Answer 109

Assertions about classes/objects that should not change - should definitely test these when developing unit tests

Answer 110

Meant to provide a general reusable solution to one type of problems during software development Theory of design patterns is that someone has already solved your similar pattern problems

Answer 111

Primarily based on the following principles of OOP design - Identify the aspects of your application that vary and separate them from what stays the same - Program to an interface, not an implementation - Favour 'object composition' over class inheritance

Answer 112

Creational Patterns - object creation Stuctural Patterns - composition of classes and objects Behavioural Patterns - interaction between objects

Answer 113

Helps you create objects without specifying their exact class. Think of it as a "factory" that produces items (objects) based on a request, but you don't need to know how the factory makes them

Answer 114

It’s like a factory that creates a set of related products (objects), but you don't need to know exactly what products are being made. Instead, you just ask for the product, and the abstract factory ensures it's the right type for your system. Here’s a simple example: Imagine you have two types of furniture, Modern and Victorian. For each type, you can have a Chair and a Sofa. Instead of creating each item separately, the Abstract Factory would create a "furniture factory" for each style (Modern and Victorian), and each factory would know how to create the appropriate Chair and Sofa.

Answer 115

- Both used for object creation - Factory Pattern uses inheritance and gives you a complete object in one shot - Abstract Factory Pattern uses composition and returns a family of related classes

Answer 116

Helps create a complex object by breaking the construction into smaller, manageable steps. It allows you to build an object in a controlled way, step by step, and you can customize the object easily.

Answer 117

- The Builder specifies the interface for creating parts of the complex (Product) object. - The ConcreteBuilder objects create and assemble the parts that make up the Product through the Builder interface. - The Director object takes responsibility for the construction process of the complex (Product) object, however it delegates the actual creation and assembly to the Builder interface. - The Product represents the complex object that is created by the ConcreteBuilder object(s). - The Product consists of multiple parts that are created separately by the ConcreteBuilder objects.

Answer 118

The main difference is - Factory pattern construct a complete object in one shot - Abstract factory pattern returns a family of related classes - Builder pattern constructs a complex object step by step

Answer 119

- Encapsulates the way a complex object is constructed - Allows objects to be constructed in a multistep and varying process (as opposed to one-step factories) - Hides the internal representation of the product from the client

Answer 120

Ensures that a class has only one instance, and provides a global point of access to it

Answer 121

Examples - Windows managers - File systems - Print spoolers

Answer 122

Static Member: Create a private static variable of the Singleton class. This is the only instance of Singleton class Private constructor: Create a private constructor for making sure an outer class can NOT instantiate object from the Singleton class Static public method: Create a global point of access to get a Singleton instance

Answer 123

The instance of Singleton class is created at the time of class loading

Answer 124

To create the singleton, to ensure that the singleton instance is not created until the getInstance() method is called for the first time (created only when needed)

Answer 125

The easier way to create a thread-safe singleton class is to make the global access method synchronized, so that only one thread can execute this method at a time.

Answer 126

To avoid this extra overhead every time, double checked locking principle is used. The synchronized block is used inside the if condition with an additional check to ensure that only one instance of singleton class is created.

Answer 127

Attaches additional behavioural responsibilities to an object dynamically. Decorators provide a flexible alternative to sub classing for extending functionality

Answer 128

- Code should be open for extension but closed for modification - Try and design classes that are easy to extend to add new behaviour, but without changing the existing code base - Code extension doesn't only have to come through inheritance in OOP - Favour object composition over class inheritance

Answer 129

Takes time and effort Introduces new levels of abstraction to the object composition

Answer 130

- You can use one or more decorators to wrap an object - Decorators have the same super type as the objects they decorate - Objects can be decorated at any time, so we can perform dynamic runtime decoration - Behaviour comes through the composition of decorators with the base components

Answer 131

Encapsulates a request as an object, thereby letting you parameterise other objects with different requests, queue or log requests, and support undoable operations

Answer 132

Holds a command and at some point asks the Command to carry out a request by calling its execute() method

Answer 133

Is like a "request" or "order" that tells an object (or system) to do something specific Example: Think of it like sending a written instruction (the command) to a worker (the receiver) without worrying about how the worker completes the task. You just give the command, and the worker handles the rest.

Answer 134

It takes the request and knows how to perform it by calling the correct method on the appropriate object (called the "receiver"). Imagine you give a worker a task, like "turn on the light." The ConcreteCommand is the actual instruction, saying "I want you to turn on this specific light." It packages the action in a way that the system can execute it.

Answer 135

Performs the work required to carry out the request. Effectively any class can act as a Receiver

Answer 136

Creates and sends commands. The client is responsible for specifying what action needs to be performed, but it doesn't directly carry out the action itself.

Answer 137

1. Factory pattern 2. Abstact factory pattern 3. Builder pattern 4. Singleton pattern 5. Decorator pattern 6. Command pattern

Answer 138

OOP design

Answer 139

- Encapsulate what varies - Program to an interface, not an implementation - Favour "object composition" over class inheritance - "open-close principle" - classes should be open for extension but close for modification - "Dependency inversion principle" - Depend upon abstractions. Do not depend upon concrete classes

Answer 140

Add stability to code by making more bugs detectable at compile time

Answer 141

- Add stability to code by making types detectable at compile time allowing you to use different types and ensure type safety - Allows generic programming for reusable algorithms - Use can lead to safer code, as bugs that may appear at runtime, can be deleted at compile time

Answer 142

- Avoids casting objects - Ensures type-safe collections and methods

Answer 143

1. Generic types 2. Generic methods 3. Generic constructors

Answer 144

- Requires careful type casting during retrieval - Prone to runtime errors

Answer 145

Container container = new Container<>(); container.add(3.7); // Type-safe Double value = container.get();

Answer 146

- E: Element (used in collections) - K: Key - N: Number - T: Type - V: Value Use single, uppercase letters by convention

Answer 147

MyClass obj = new MyClass<>(); obj.genericMethod("Hello");

Answer 148

Use bounds for restricting types Syntax: - extends: T extends Number - super: T super Number

Answer 149

Subtyping allows a type (subtype) to inherit behavior and attributes from another type (supertype). Subtypes can be used in places where supertypes are expected. Double and Integer are subtypes of Number ?: Known as wilcard

Answer 150

- Compiler removes all generic type information during compilation - Generic types are replaced with raw types at runtime

Answer 151

Happens when the type of data stored in the heap memory doesn’t match the type the program expects. This can lead to errors or unexpected behavior. Example: Imagine you have a box labeled "Toys," but someone puts "Books" in it. When you later grab something from the box expecting a toy, you might get a book instead. That confusion is like heap pollution in code.

Answer 152

Mixing raw and generic types - leads to warnings or runtime errors

Answer 153

- Use parameterized types consistently in new code - Avoid mixing raw types with generics

Answer 154

An object that groups multiple elements into a single unit Example: Poker hand: collection of cards Mail folder: collection of letters Telephone directory: mapping names to phone numbers

Answer 155

Group of key-value pairs

Answer 156

Collection: A group of objects known as elements Map: A group of objects where keys map to values

Answer 157

Purpose: Root interface of most collection classes Key Methods: Basic Operations: Add, remove, size, clear, etc. Bulk Operations: Add all, remove all, retain all. Array Operations: Convert the collection to an array.

Answer 158

Contains no duplicate elements. Two Sets are considered equal if they have the same elements.

Answer 159

HashSet: Fastest but no guaranteed order TreeSet: Sorted order, slower than HashSet LinkedHashSet: Ordered by insertion order

Answer 160

A list is an ordered collection of elements. It may contain duplicate elements

Answer 161

ArrayList: Uses dynamically resizing arrays LinkedList: Uses doubly linked list.

Answer 162

Get/set elements by index Add/remove elements at specific positions

Answer 163

Definition: Stores elements for processing, typically in FIFO order Key methods: - Add/Offer: Insert elements - Remove/Poll: Retrieve and remove the head of the queue - Peek: Retrieve the head without removing it

Answer 164

Definition: A Deque (double-ended queue) supports insertion and deletion at both ends. Key Methods: - Insert: addFirst(), addLast(), offerFirst(), offerLast() - Remove: removeFirst(), removeLast(), pollFirst(), pollLast() - Examine: getFirst(), getLast(), peekFirst(), peekLast()

Answer 165

A Map stores key-value pairs, where each key maps to at most one value.

Answer 166

Key Methods: - put(K key, V value): Add a key-value pair - get(Object key): Retrieve the value for a key - remove(Object key): Remove a key-value pair - containsKey(Object key): Check if a key exists

Answer 167

- HashMap: Fastest, no order guarantees - TreeMap: Sorted by keys - LinkedHashMap: Maintains insertion order

Answer 168

Allows a program to inspect and manipulate its structure at runtime (classes, methods, constructors, fields)

Answer 169

- Examine the class structure at runtime - Dynamically invoke methods or access fields - Interact with objects that were not known at compile time

Answer 170

Class cls = new Circle().getClass();

Answer 171

Class cls = Class.forName("java.lang.String");

Answer 172

Class cls = int.class;

Answer 173

Every object has an immutable Class instance, which provides runtime properties and serves as the entry point for reflection.

Answer 174

getFields(): Returns all public fields. getDeclaredFields(): Returns all fields, regardless of access modifier.

Answer 175

getConstructors(): Returns public constructors. getDeclaredConstructors(): Returns all constructors, including private ones.

Answer 176

getMethods(): Returns all public methods. Retrieve a specific method: - Method method = cls.getMethod("methodName", ParameterTypes);

Answer 177

Class.newInstance(): - Calls the no-argument constructor. - Requires the constructor to be visible. Preferred: - Constructor constructor = cls.getDeclaredConstructor(ParameterTypes); Object obj = constructor.newInstance(Arguments);

Answer 178

Controlled by JVM Manager: - Public fields/methods are accessible by default - Private fields/methods need: - field.setAccessible(true); Risks: - Can expose private data - May create security vulnerabilities in restricted environments

Answer 179

Reflection is slower than direct execution due to runtime resolution. Risks: - Breaking abstractions (unexpected side effects). - Reduced portability across Java versions. - Harder to optimize reflective code.

Answer 180

- Testing: Simulate states or enforce conditions. - Debugging: Inspect programs and identify errors dynamically. - Code Analysis: Inspect class structures for higher test coverage.

Answer 181

Enables dynamic interactions with Java objects. Use with caution due to security risks and slower performance. Commonly used in tools like debugging, testing frameworks, and dynamic proxies.

Answer 182

Communication between computers over a network. Enables the Internet, mobile apps, and distributed computing.

Answer 183

1. TCP (Transmission Control Protocol): Reliable communication. 2. UDP (User Datagram Protocol): Fast but less reliable communication. 3. RMI (Remote Method Invocation): Interaction between Java Virtual Machines (JVMs).

Answer 184

- Reliable, connection-based communication. - Guarantees: - Data arrives in order. - Errors are reported if data order is violated. - Used for applications needing data integrity (e.g., HTTP, FTP).

Answer 185

- Unreliable, connectionless communication. - Features: - No guaranteed data order or packet delivery. - Lightweight, minimal error-checking. - Ideal for live streaming or gaming.

Answer 186

Direct data to the correct application on a machine

Answer 187

Identifies the computer on a network

Answer 188

Identifies the application on a network

Answer 189

0-1023: Well-known ports (HTTP port 80 etc.)

Answer 190

Endpoints for communication between two machines

Answer 191

A server listens on a specific IP and port for client connections Workflow: - Server binds a socket to a port - Client connects using the server's hostname and port - if accepted, a new socket is created for communication

Answer 192

- Communication involves sending independent packets (datagrams) - No dedicated channel or guarantees for delivery/order

Answer 193

1. Open a socket 2. Create input and output streams 3. Read/write data based on the server's protocol 4. Close the streams and socket

Answer 194

- Send data using DatagramPacket - Server processes datagrams independently, with no guaranteed sequence

Answer 195

Answer 196

- Java's networking API simplifies communication using TCP and UDP. - TCP: Reliable, suited for critical data transfer. - UDP: Lightweight, faster, less reliable. - Choose based on the application’s need for reliability, speed, and data integrity.

Answer 197

Allows an object in one JVM (Java Virtual Machine) to invoke methods on an object in another JVM, possibly on a different physical machine.

Answer 198

- Server: Creates and registers remote objects. - Client: Obtains references to remote objects and invokes methods on them.

Answer 199

- Enables distributed object communication. - Supports thin-client architecture by offloading processing to servers.

Answer 200

Remote Object Location: - The registry maps remote objects to names. - References to remote objects are passed for method invocations. Remote Object Communication: - RMI handles communication, making it resemble local method calls. Class Definitions: - RMI dynamically supports passing class definitions and object contents.

Answer 201

Registry: Maps remote objects to names. - Methods: bind(), rebind(), lookup(). Server: Registers remote objects in the registry. Client: Looks up remote objects and invokes methods.

Answer 202

The interface must extend java.rmi.Remote and its methods must throw RemoteException Example: public interface Adder extends Remote { int add(int a, int b) throws RemoteException; }

Answer 203

The process where a program on one computer calls methods or interacts with objects on another computer through RMI

Answer 204

Define permissions for downloaded code Example: grant codeBase "file:/path/to/classes/*" { permission java.security.AllPermission; };

Answer 205

Server Setup: 1. Compile server-side classes. 2. Start RMI Registry (rmiregistry). 3. Launch server application. Client Setup: 1. Compile client-side classes. 2. Run the client with server details (hostname, port).

Answer 206

- Simplifies distributed computing by abstracting network communication - Easily calls methods on remote objects - Facilitates scalable and modular system design.

Answer 207

- Tied to Java, limiting cross-platform capabilities. - Security configuration requires careful setup. - Network latency affects performance.

Answer 208

RMI enables downloading a class definition along with the object reference during remote method invocation

Answer 209

Allows the client to automatically download and use classes from the server at runtime, without needing to have those classes already present on the client machine

Answer 210

Classes must be downloadable during RMI

Answer 211

Every Java class used by the JVM is loaded by a class loader. It manages how classes are loaded into the JVM

Answer 212

1. Bootstrap Class Loader: - Loads core Java libraries. - Part of the JVM for efficiency. 2. Extension Class Loader: - Loads classes from the system-wide extension directory. 3. System Class Loader: - Loads classes from the current directory or CLASSPATH.

Answer 213

Bootstrap > Extension > System

Answer 214

Can dynamically add classes or search application directories for JAR files. Example: Subclass java.lang.ClassLoader.

Answer 215

Layers: 1. Application Layer: Contains client and server programs 2. Stub & Skeleton Layer: Redirects client calls to remote RMI services 3.Remote Reference Layer: Manages references between client and server objects 4. Transport Layer: Handles communication via TCP/IP .

Answer 216

Distributed = Multiple devices sharing the load. Non-Distributed = One device doing all the work.

Answer 217

RMI stubs act as client-side proxies for remote objects. - Forward method invocations to the actual remote object.

Answer 218

1. Dynamic Behavior: Extend JVM behavior dynamically at runtime. 2. Seamless Remote Communication: Remote method calls behave like local method calls. 3. Cross-Platform Compatibility: Supports enterprise systems across multiple platforms.

Answer 219

Software Development Life Cycle: - Models: Waterfall, Prototyping, RAD, Agile, V-Model, Test-Driven Development. Core Java Concepts: - Nested classes, concurrency, event listeners. Testing Frameworks: - Unit testing with JUnit or mock objects. Design Patterns: - Factory, Singleton, Builder, Decorator. Advanced Java Features: - Generics, Collections, Reflection, Sockets, RMI.

Answer 220

Like a proxy on the client-side that makes the call to the remote object

Answer 221

Helps on the server-side to receive the call and pass it to the actual remote object

Answer 222

1. Planning 2. Requirement Analysis 3. System Design 4. Implementation 5. Testing 6. Deployment 7. Operation and Maintenance