Programming 2 Flashcards
Difference between a byte-based stream and character-based stream.
Byte-based uses InputStream and OutputStream.
Character-based uses a Reader and Writer.
Steps for a Java I/O operation
Get a file ready with the File class
Set up a Stream
Using Read or Write
Close the Stream
Byte-based vs Character-based
Byte-based
Uses InputStream and OutputStream.
Setting up the stream creates a new file if one doesn’t already exist.
New line with \r\n
Best for raw data, e.g. mouse and keyboard.
Character-based
Uses Reader and Writer.
Creates a new file, or overwrites an existing one.
Best for pure text.
ByteArray Stream
Reads and writes directly into memory.
Normally used for generating temporary data.
Pipeline stream
Mainly used for communicating and connecting between threads.
Object serialisation
Used to store objects to the disk so they can be written to a data stream.
Only properties are serialised.
Done with an ObjectOutputStream.
Object deserialisation
Used to unflatten an object when pulling it off the disk.
Done with ObjectInputStream.
Object versioning
A serialised object has a hash of the object’s class written as part of its state when serialised.
During deserialisation, the serial version UID is compared to the existing classes, and if they don’t match the deserialisation fails and it results in an InvalidClassException.
Requirements for serialisation
An object can be serialised if:
All the fields are primitives or Strings.
Any class referenced in variables are also declared as Serializable.
(Ignoring static properties)
Types of String comparisons
Double equals (==)
Checks if the variables point to the same String in the heap.
.equals()
Checks if the variables have equal values.
Verification vs Validation
Verification: testing software correctly implements a specific function.
Validation: testing software satisfies customer requirements.
White-box vs Black-box testing
White-box: using known inputs and outputs.
Black-box: used to test without knowledge on the internal workings of the software.
Unit testing
Includes:
Identifying the code to be tested in isolation.
Developing a suite of test cases.
Writing a test harness for each case.
White-box testing done by developers.
Integration testing
Repeatedly testing the combination of larger collections of code units.
A mix of white- and black-box testing done by testers.
System testing
Testing the entirety of the system.
Black-box testing done at the end of development.
Testing in isolation
If a class depends on another, a ‘fake’ subclass of the required class is made, a mock or stub object.
A stub object
Passes data to the main program being tested in isolation.
Often uses hard-coded values for simplicity.
A driver object
A fake main program that accepts test case data and passes it on to the components being tested.
Used to fulfil requirements of missing or incomplete components.
Types of integration testing
Top-down
Bottom-up
Sandwich
Big Bang
Top-down itegration
Tests the high-level moules in isolation with stub dependencies.
Adds in the actual modules being called and tests them together.
Repeats until all modules are included.
Bottom-up integration
Tests the low-level moules in isolation.
Adds in the modules that call this module and tests them together.
Repeats until all modules are included.
Sandwich integration
Identifies the top, middle, and bottom layers.
The top is tested with Top-down integration, the bottom with Bottom-up integration. Then the middle is included.
Big Bang integration
Non-incremental, in which each unit is tested thoroughly in isolation.
Then the whole system is integrated and tested together at once.
JVM
Java Virtual Machine
WORA
Write Once, Run Anywhere
Class loader and Method area
The class loader locates .class files, verifies them through their bytecode
Then loads them into the method area in the shared memory.
Machine’s memory architecture
Comprised of:
Shared memory, one heap and one method area per JVM instance.
Private memory, one java stack and program counter per thread.
Program Counter
Holds the address of the next bytecode instruction to execute, for each thread.
Java stack
Holds state information for the thread.
E.g. which methods have been called, local variables, parameters, and used for performing calculations.
Execution engine
The part of the JVM which describes how bytecode is executed, and what the expected behaviour should be. Done in terms of the JVM instruction set.
The Heap
Located in the shared memory.
Stores object instances, the values of all non-static fields.
Can be primitives or references/pointers to other instances in the heap.
Non-primitive data are stored as their own object instance.
Stack frame
When a thread calls a method, a new frame is pushed onto the thread’s Java stack. All local variables, parameters, and temporary calculations are done within this frame.
Recursion
Defining an entity in terms of itself, e.g. a method calling itself, or a list containing a list.
Defining a pointer in C for a primitive or array variable
Primitive variable:*pointer = &var
Array variable:*pointer = array*pointer = &array[0]
Accessing a pointer in C
Access to the memory location: *pointer
Access to the memory address: pointer
