PPJ Flashcards
Java Programming Basics
1
Q
Physical components like processors, memory, storage, and input/output devices.
A
Hardware
2
Q
Software that manages hardware and provides services to applications.
A
Operating System
3
Q
Tools used to create software instructions.
A
Programming Language
4
Q
The smallest unit of data (0 or 1).
A
Bits
5
Q
A sequence of 8 bits.
A
Bytes
6
Q
A base-16 numbering system used for representing binary data.
A
Hexadecimal
7
Q
The central processing unit that executes instructions.
A
Processor
8
Q
Basic operations performed by the processor.
A
Instructions
9
Q
A sequence of instructions that performs a task.
A
Program
10
Q
Translates human-readable code into machine code.
A
Compiler
11
Q
Close to machine code (e.g., assembly language).
A
Low-level
12
Q
More human-readable (e.g., Python, Java, C++).
A
High-level
13
Q
values in the range [−128,127];
A
byte (1)
14
Q
values in the range [−32 768,32 767];
A
short (2)
15
Q
values in range[0,65 535] interpreted as Unicode code
points of characters (always non-negative);
A
char(2)
16
Q
values in the range [−2 147 483 648,2 147 483 647];
A
int (4)
17
Q
values in an astronomical range [−9 223 372 036 854 775 808, 9 223 372 036 854 775 807].
A
long (8)
18
Q
values in the range [≈1.4·10−45,≈ 3.4·10+38] positive or negative, with roughly 7 significant decimal digits – rarely used;
A
float (4)
19
Q
values in the range [≈4.9·10−324 ≈ 1.8·10+308] positive or negative, with roughly 16 significant decimal digits.
A
double (8)
20
Q
has only two possible values: true and false.
A
boolean
21
Q
Built-in data types for basic values like numbers or characters
A
Primitive types
22
Q
User-defined or pre-defined complex data structures.
A
Object types
23
Q
are named storage locations in memory that hold specific data types. Only primitive types can be directly assigned names. Object types are accessed through references.
Literals are the actual data values assigned to variables.
A
Variables
24
Q
Primitive types are stored on the ___, while objects reside on the ___
A
stack, heap
25
automatically manages memory allocation and deallocation for objects
garbage collector
26
0 1 1 0 1 1 0 0
0 1 0 1 0 1 0 1
6
---------------
& 0 1 0 0 0 1 0 0
AND
27
0 1 1 0 1 1 0 0
0 1 0 1 0 1 0 1
---------------
| 0 1 1 1 1 1 0 1
| 0 1 1 1 1 1 0 1
OR
28
0 1 1 0 1 1 0 0
0 1 0 1 0 1 0 1
---------------
^ 0 0 1 1 1 0 0 1
XOR
29
~ 0 1 1 0 1 1 0 0 -> 1 0 0 1 0 0 1 1
Negation
30
* A region of memory used for storing local variables and function call information.
* Follows LIFO (Last-In-First-Out) principle: values are added and removed from the top.
* Automatically managed by the JVM.
* Efficient for accessing and storing data.
* Variables declared within blocks are typically stored on the stack.
Stack
31
* A region of memory used for dynamically allocated objects.
* Requires manual memory management (allocation and deallocation).
* Slower to access than the stack due to pointer indirection.
* Objects created using new are stored on the heap.
* The garbage collector automatically reclaims unused heap memory.
Heap
32
* \a – (BEL) alert;
* \b – (BS) backspace;
* \f – (FF) form-feed (new page);
* \n – (LF) new line (linefeed);
* \r – (CR) carriage return;
* \t – (HT) horizontal tab;
* \v – (VT) vertical tab;
* \’ – apostrophe;
* \" – quotation mark;
* \\– backslash;
33
double x = 7.7;
int a = (int)x;
34
Symbols that represent actions to be performed on values (operands).
Operators
35
operate on two operands (e.g., +, -, *, /).
Binary operators
36
operate on one operand (e.g., ++, --).
Unary operators
37
is the only operator with three operands.
Ternary operator (?:)
38
Work with int, long, float, and double.
Arithmetic types
39
Operands may be converted to match the same type
Implicit conversion
40
Truncates the fractional part towards zero.
Integer division:
41
Remainder follows the sign of the first operand.
Negative operands
42
System.out.println(" 7 / 2 = " + ( 7 / 2 ));
43
Determines the order of operations when multiple
operators are present.
Operator Precedence:
44
* Defines the grouping of operands with the same
precedence.
* Most operators are left-to-right associative.
Associativity
45
are single orders for the computer to perform.
* They often correspond to multiple low-level machine instructions.
Instructions
46
are instructions that have a value (expressions) or don't (e.g., variable declarations).
Statements
47
Used to control program flow based on conditions.
Conditional Statements
48
if statement: executes a block of code if a condition is true.
else if statements: optional checks for additional conditions if the first fails.
else statement: optional block to execute if none of the previous conditions are true.
49
are expressions that evaluate to true or false.
Conditions
50
Similar to if statements but with multiple conditions.
Evaluates a selector expression against case values.
Executes code associated with the matching case.
break statement: exits the switch after a case is matched (optional).
default clause: executes if no case matches (optional).
Switch Statements
51
Used to repeat a block of code multiple times.
Loops
52
Executes the body as long as a condition is true.
Checks the condition before each iteration.
while loop
53
Similar to while but executes the body at least once.
Checks the condition after each iteration.
do-while loop
54
Concise loop construct with initialization, condition, and increment/decrement.
Executes the body as long as the condition is true, updating the expression after each iteration.
for loop
55
are the simplest data structure.
* They store a fixed-size collection of elements of the same type.
* Elements are ordered and accessed using their index (starting from 0).
Arrays
56
are created using the new keyword followed by the type and size in square brackets ([]).
* The size cannot be changed after creation.
* Example: int[] arr = new int[10]; creates an array of 10 integers.
Arrays
57
* Elements are accessed using their index within square brackets (arr[i]).
* Example: arr[3] = 25; assigns the value 25 to the fourth element (index 3).
58
* The for loop is commonly used to iterate through each element.
o for (int i = 0; i < arr.length; i++) { ... }
* Alternatively, the for-each loop can be used for concise iteration.
o for (int element : arr) { ... }
59
don't exist directly in Java.
* Instead, you create arrays of references to objects.
* Example: String[] names = new String[5];
* Arrays of objects
60
* Java doesn't have true multi-dimensional arrays.
* Arrays can hold references to other arrays, simulating multiple dimensions.
* Example: int[][] matrix = new int[3][4]; creates a 3x4 matrix of integers.
61
* Definition: Functions declared with the static keyword belong to the class itself, not to instances of the class.
* Access: Invoked using the class name followed by a dot (.) and the function name (ClassName.functionName()).
Static Functions
62
Static Functions
* Components:
o static keyword
o Return type ...
o Function name ...
o Parameter list ...
o Function body ...
(or void if no return value)
(starts with a lowercase letter)
(optional, enclosed in parentheses)
(enclosed in curly braces)
63
o Arguments passed are copies of values, pushed onto the program stack.
o Function operates on these copies, originals remain unchanged.
o Arrays are passed by reference (address of the array), but modifications affect the original array.
Static Functions
64
o Can call themselves within their definition.
o Important to have a base case to prevent infinite recursion.
* Recursive Functions:
65
o Defining multiple functions with the same name but different parameter lists.
o Compiler chooses the appropriate function based on argument types.
o Useful for functions with similar functionality but different input types.
* Function Overloading:
66
Represent real-world entities with data (fields) and actions (methods).
* Objects
67
Define blueprints for creating objects with specific characteristics.
* Classes
68
Fields and methods that belong to a class.
* Members
69
Accessed through object references.
o Non-static members
70
Belong to the class itself, accessed without object references
o Static members
71
* The new operator is used to create objects from a class definition.
* The object gets its own copy of non-static fields.
* Static fields are shared among all objects of the class.
Creating Objects
72
* Non-static methods are invoked on object references using dot notation (.).
* Static methods are accessed using the class name followed by the dot notation.
Member Access:
73
* Access control keywords (public, private, protected, default) determine how members can be accessed from other classes.
Member Visibility
74
* Special methods with the same name as the class.
* Used to initialize object fields during creation.
* Can be overloaded (have different parameter lists).
Constructors
75
* Methods used to access and modify private fields.
Getters and Setters:
76
* Used for data or functions common to all objects of the class.
* Accessible even before creating any objects.
Static Members
77
* Immutable: Once created, their content cannot be changed.
* Better for security and thread safety: Modifications require creating new objects, which makes them less prone to errors and safer in multi-threaded environments.
* Used for constant data: Ideal for storing data that won't be modified, like configuration values or text displayed on the screen.
* Slower for frequent modifications: String concatenation with the + operator creates new String objects each time.
Strings
78
* Mutable: Their content can be modified after creation.
* More efficient for frequent changes: Operations like append, insert, and delete directly modify the internal character array, avoiding unnecessary object creation.
* Can be less secure and thread-unsafe: Modifications happening concurrently can lead to unexpected results. Use with caution in multi-threaded environments.
* Used for building strings dynamically: Great for scenarios where you need to construct a string by combining different parts.
StringBuilders
79
* Ordered sequence of elements.
* Each element (node) holds data and a reference to the next node.
* Efficient for adding/removing elements at the beginning or end.
* Less efficient for random access or modifying elements in the middle.
* Good for implementing stacks and queues.
Singly Linked Lists
80
* Elements are added (pushed) and removed (popped) from the top.
* Think of a stack of plates - you remove the top plate first.
* Implemented using singly linked lists (adding/removing from the front) or arrays.
* Used for function calls, undo/redo functionality, and expression evaluation.
Stacks (LIFO - Last In, First Out)
81
* Elements are added (enqueued) at the back and removed (dequeued) from the front.
* Think of a line at a store - the first person in line gets served first.
* Implemented using singly linked lists (adding/removing from the beginning and end).
* Used for task scheduling, printer queues, and breadth-first search algorithms
Queues (FIFO - First In, First Out):
82
is a fundamental concept in object-oriented programming (OOP) that allows you to create new classes based on existing ones.
Inheritance
83
* Inheritance creates a relationship between classes, where a new class (subclass or derived class) inherits properties and behaviors from an existing class (superclass or base class).
84
* Think of it as "is-a" relationship. For example, a Dog is-a Animal.
85
Benefits of Inheritance:
* Code Reusability: You don't need to rewrite code for common functionalities present in the superclass. The subclass inherits these functionalities and can add its own specific behavior.
* Maintainability: Changes made to the superclass automatically propagate to subclasses that inherit from it, making code updates easier.
* Polymorphism: Inheritance enables polymorphism, where objects of different subclasses can be treated as objects of the superclass. This allows for flexible and dynamic behavior in your programs.
