MODULE 1

OBJECT-ORIENTED PROGRAMMING

PROGRAMMING PARADIGM = approaches to structuring or organizing code

PROCEDURAL PROGRAMMING = executed one after another in a sequence

VARIABLES = named computer memory

PROCEDURES = grouped of logical units

FUNCTIONAL PROGRAMMING = builds computer program

FUNCTIONS = basic units

OBJECT-ORIENTED PROGRAMMING = extension / different approach to writing computer program

OBJECTS = real world / main building

OOP CONCEPTS

CLASS = group or collection

CLASS DEFINITION = describe what attributes

ATTRIBUTES = details the characteristics

OBJECT = specific and concrete

DATA MEMBERS = has both features called DATA MEMBERS

FUNCTION MEMBERS = operations called FUNCTION MEMBERS

METHOD = self-contained block

DATA ABSTRACTION = background details

ABSTRACTED DATA = information is hidden

DATA ENCAPSULATION = wrapping up and function

DATA HIDING = insulates data from outside programs

INHERITANCE = share attributes

POLYMORPHISM (poly means = many / morph means = form) = feature of language

OPERATOR LOADING = different instances

FUNTION OVERLOADING = different return types

METHOD = containing series

METHOD HEADER = method can interact

PUBLIC = (access modifier = allows any other class)

STATIC = without instantiating

VOID = returns no data

RETURN TYPE = sends back

METHOD NAME = legal identifier class

PARENTHESE = surround string [] args

METHOD BODY = carry out the work

IMPLEMENTATION = between a pair

FULLY QUALIFIED IDENTIFIER = complete name

CLASSES AND OBJECTS

CLASS HEADER = naming the class

CLASS BODY = between a set of curly braces

DATA FIELDS = data components

STATIC = once per class

NON-STATIC = once per object

INFORMATION HIDING = creating private access

ACCESSOR METHOD OR GETTERS = retrieve values called ACCESSOR METHOD OR GETTERS

MUTATOR METHODS OR SETTER = set or change field value called MUTATOR METHODS OR SETTER

CONSTRUCTOR = creates and initializes object

INHERITANCE

INHERITANCE = allows one class / behavior and attributes

CODE REUSABILITY = allowing the subclass

IS-A = relationship

METHOD OVERRIDING = present both superclass and subclass

SUPER KEYWORD IN INHERITANCE = subclass overrides / superclass

CHILD CLASS = derived class

PARENT CLASS = base class

EXTENDS = inheritance between two classes

SUPER = called method superclass

INTERFACE

INTERFACE = class without specifying

IMPLEMENTS = implement an interface

MULTIPLE INTERFACE = possible to implement

EXTENDS = implementing with another interface

DEBUGGING = rectifying errors

TYPICAL DEBUGGING
- EXAMINING THE ERROR SYMPTOMS = crashes, error message, or unexpected behavior / identify
- IDENTIFYING THE CAUSE = root cause
- FIXING THE ERROR = correction

DEBUGGING TECHNIQUE

UNDERSTANDING THE PROBLEM = changes to the code

BACKTRACKING (BACKWARD DEBUGGING) = began and works backward

DEBBUGING TOOLS = give valuable insight

BREAKPOINTS = temporarily stop

STEPPING = manually move

BINARY SEARCH = narrow the scope

RUBBER DUCKING = explaining an objects like rubber duck

LOG ANALYSIS = strategic areas

CLUSTERING BUGS = group error

TAKE BREAKS = mentally taxing

TAKE NOTES = resource for future / documenting

BASIC EXCEPTION HANDLING

EXCEPTION = unexpected error

EXCEPTION HANDLING = manage or resolve such error

RUNTIME ERROR = unplanned exception

SYNTAX ERROR = during program

ERROR CLASS = more serious error

EXCEPTION CLASS = less serious error

IO EXCEPTION = thrown while accessing data

RUNTIME EXCEPTION = during the execution

ARITHMETIC EXCEPTION = wrong mathematical

INDEXOUTOFBOUNDS EXCEPTION = index used array, list, string…

ARRAYINDEXOUTOFBOUNDS EXCEPTION = illegal index

NOSUCHELEMENT EXCEPTION = element being request

INPUTMISMATCH EXCEPTION = proper type

VIRTUALMACHINE ERROR = java virtual machine broken

OUTOFMEMORY ERROR = insufficient space

INTERNAL ERROR = unexpected internal error

THE TRY, CATCH, AND FINALLY BLOCKS

TRY BLOCK = create segment / might go wrong

CATCH BLOCK = handles an exception that might be throws

THROW STATEMENT = handled elsewhere

FINALLY BLOCK = the end

COMPUTER FILE = data stored

TEXT FILES = text editor

BINARY FILES = encoded as text

ROOT DIRECTORY = permanent file

PATH = hierarchy of directories

PATH IDENTIFIER = separates the path

THE PATH AND FILES CLASSES

PATH CLASS = containing information

FACTORY = creates other objects

ABSOLUTE PATH = not need any information

RELATIVE PATH = depends on other path

BACKSLASH (\) = windows operating

SLASH (/) = delimiter

RETRIEVING PATH INFORMATION

STRING TOSTRING () = return the string

PATH GETFILENAME () = return the file

INT GETNAME COUNT () = return the number

PATH GETNAME (INT) = return the name

CHECKACCESS () = verify that a file exists

NO ARGUMENT = no argument

READ = read the file

WRITE = write the file

EXECUTE = execute the file

READATTRIBUTES () = retrieve useful

THE IO CLASSES
CLASSES
INPUTSTREAM = performing input

FILEINPUTSTREAM = child inputstream read disk file

BUFFEREDOUTPUTSTREAM = handles input

OUTPUTSTREAM = performing output

FILEOUTPUTSTREAM = child of outputstream

BUFFEREDOUTPUTSTREAM = child of filteroutputstream handles output

PRINTSTREAM = child of filteroutputstream. Java system

READER = reading character

BUFFEREDREADER = read text

BUFFEREDWRITER = write text

OUTPUTSTREAM METHODS

VOID CLOSE () = close the output

VOID FLUSH () = byte are buffered

VOID WRITE (byte[] b) = writes all bytes

VOID WRITER (byte[] b, int off, int len) = offset position off
MODULE 5

ENUMERATION (ENUM) = fixed set

ENUM CONSTANT = list of value

TO STRING () = return the name

ORDINAL () = return the integer

EQUALS = return true

COMPARE TO () = return a negative

VALUEOF () = parameter and returns

VALUES () = array of enumerated constant

TYPE-SAFE = appropriate behavior

NESTED CLASSES

NESTED CLASSES = store them together

STATIC MEMBER CLASS = all static

NON-STATIC MEMBER CLASS (INNER CLASS) = all data

LOCAL CLASS = method body

ANONYMOUS CLASS = no identifier

REGULAR EXPRESSION (REGEX) = character or a sequence

MATCHES () = match against and specified

( [] ) = regular expression for character

DOT (.) = represent single character

Hyphen (-) = specific range

REPETITION OPERATORS
REPETITION OPERATORS = number of times

( * ) = 0 or more occurrences

( ? ) = 0 or 1 occurrences

( + ) = 1 or more occurrences

{ x } = x occurrences

{x , y} = between x & y occurrences

{x,} = x or more occurrences

PATTERN AND MATCHER

MATCHER = between pattern and string

REGEX OPERATIONS
FIND () = looking for the next subsequence

SPLIT () = split the string / wishes to split

REPLACEALL () = replace all the occurrence

MULTITHREADED PROGRAM = two or more parts

THREAD = smallest unit

PROCESS = group of associated

SINGLE-THREADED PROCESS = contain exactly one thread

MULTITHREADED PROCESS = support more than one thread

SHARE ENVIRONMENT = share the same memory

CONCURRENCY = executing multiple thread

THREAD SCHEDULER = operating system / currently executing

CONTEXT SWITCH = storing threads / later later storing

MAIN THREAD = special thread / created by java vm

THREAD METHODS

START () = start/ calling its run method

RIN () = entry point

SETNAME () = set thread name

GETNAME () = obtain thread name

SETPRIORITY () = set thread priority

GETPRIORITY () = obtains thread priority

ISALVIE () = still running

JOIN () = waits for a thread to terminate

SLEEP () = period of time

THREAD PRIORITY = numeric value

GENERIC TYPE (GENERICS) = one or more non-specified

PARAMETERIZED TYPE = no special significant / gen is generic class also called PARAMETERIZED TYPE

E = element

K = key

N = number

T = type

V = value

WILDCARD ARGUMENTS
WILDCARD ARGUMENT = unknown type / question mark

UNBOUNDED WILDCARD = denoted <?>

UPPER-BOUNDED WILDCARD = subtype

LOWER-BOUNDED WILDCARD = specific type / super type

Extends = implement a thread class / run () method

Implements = extend the runnable interface

MIN_PRIORITY = lowest value

MAX_PRIORITY = maximum value

NORM_PRIORITY = default value