General

Question 1

Java is platform independent

Answer 1

Programs written in Java can be executed on any operating system (Windows, Linux, Mac, etc.)

Question 2

Bytecode

Answer 2

Java compiles source code into bytecode. Bytecode is platform independent. There is no difference between bytecode for Windows, Mac, or Linux. The JVM converts bytecode into machine code for the specific platform that the user uses.

Advantage of this two-step compilation is that Java can be run on all platforms that have the JVM installed.

Question 3

JDK, JRE, JVM

Answer 3

JDK includes JRE, which contains the JVM

Question 4

Integrated Development Environment (IDE)

Answer 4

IDE contains text editor and GUI to debug, compile, and run programs.

Question 5

Package

Answer 5

A grouping of related classes and interfaces. Two or more files can have the same name if they belong to different packages.

Java has many pre-created packages, such as java.io (input/output) and java.awt (code for implementing GUI). To use pre-written packages, you need to import them.

Question 6

main() method

Answer 6

Whenever a Java application is started, the main() method is the first method to be called. main() takes an array of string as input.

Question 7

Statement

Answer 7

Every statement ends with a semicolon

Question 8

Declaration

Answer 8

Example: int age;

Your program allocates memory to store this data.

Question 9

Primitive data types

Answer 9

8 primitive data types.

4 of them are for integers:

• byte: Integers -128 to 127. Byte of storage.
• short: 2 bytes storage. -32768 to 32767
• int: 4 bytes storage. -2^31 to (2^31) - 1.
• long: 8 bytes. -2^63 to (2^63) - 1. Rarely used.

2 of them for floating point numbers (numbers with fractional parts):

• float: 4 bytes storage. -3.40282347 x 10^38 to 3.40282347 x 10^38. Precision of 7 digits. This means if you use float to store a number like 1.23456789 (10 digits), it will be rounded to 1.234568.
• double: 8 bytes storage. Range of -1.79769313486231570 x 10^308 to 1.79769313486231570 x 10^308. Precision of 15 digits.

By default, floating point in Java is double.

Two more primitive date types:

• char: stores single Unicode character. 2 bytes memory. When you initialize a char you need to put the character in single quotes.
• boolean: can only hold 2 values: true and false.

Question 10

Naming a variable

Answer 10

First character cannot be number. Reserved words cannot be used. Examples of reserved words are System, if, While, etc.

Question 11

Initialization

Answer 11

Giving a variable a value. You can initialize at deceleration or in a separate statement. You can initialize severance variables on the same line (you separate them by a comma).

Question 12

Basic operators

Answer 12

+, -, *, /, %

x = 7, y =2
x / y = 3 (rounds down to nearest integer)
x % y = 1 (gives remainder)

If either x or y is a floating point number, the result will be a floating point number.

Question 13

++ and - - operators

Answer 13

System.out.println(counter++); will first print counter and then increment it.

System.out.println(++counter); will first increment counter and then print it.

Question 14

Casting

Answer 14

Do not need to explicitly cast when converting smaller data to large data. (I.g., int to double).

When casting larger data to smaller data, need to explicitly cast.

Example: int x = (int) 20.9.
x = 20.

Question 15

String

Answer 15

String is a reference data type (not primitive data type). This means it’s an object. Specifically, an object of the String class.

To assign a String variable, you must enclose the text in double quotes.

“+” operator can concatenate two strings.

Java String class has methods.

Whenever you use a method, you need to use the dot operator.

Common ones:

• length(): total number of characters the string has (whitespace included)
• toUpperCase()/toLowerCase(): converts string to upper/lower case.

Example: String uCase “Hello World”.toUpperCase(); uCase = “HELLO WORLD”.

• substring(6): returns a substring starting from index 6 until the end. Indexing in Java starts at 0, not 1.
• substring(1, 8): same as above, but extracts from index 1 to 7. Stops AT index 8, NOT AFTER. Thus letter at index 8 is NOT included.
• charAt(1): returns character at index 1.
• equals(): returns true if two strings are identical. Example: boolean equalsOrNot = “This is Jamie”.equals(“This is Jamie”);
• split(): splits a string into substrings based on a user-defined separator (also known as delimiter). Returns an array that contains resulting substrings.

Example: String names = “Peter, John,” Andy, David”;
String[] splitNames = names.split(“, “); Delimiter is comma followed by space.

Question 16

Array

Answer 16

Collection of data that are normally related to each other.

Can be declared int[] userAge or int userAge[]. Latter syntax is not proffered.

3 ways to declare and initialize array:

1) int[] userAge = new int[] {21, 22, 23, 24, 25};

Can be simplified to:

2) int[] userAge = {21, 22, 23, 24, 25};
3) int[] userAge = new int[5]; Default values are 0. We then have to initialize.

Question 17

Array methods (Arrays class)

Answer 17

Arrays come with pre-written methods. They’re found in java.until.Arrays class. To use them, you have to add the statement import java.until.Arrays; to your program. This tells the compiler where to find the code for these methods. Import statement must appear after package statement and before class declaration.

We don’t need an import statement to use String methods since the String class is present in the java.lang package which is imported by default.

Commonly used methods:

• equals(). Returns true if two arrays are equal. (I.g,: boolean result = Arrays.equals(arr1, arr2);

All methods in Arrays are static. Hence we had to add “Arrays” in front of the method name.

• copyOfRange(): 3 arguments. Copy the contents of one array into another. Example: int[] dest = Arrays.copyOfRange(source, 3, 7); Copies elements from 3 to 6 (NOT 7).
• toString(): 1 argument. Returns a String representation of array contents.
• sort(): sorts array in ascending order. Does not return new array. It modifies existing array.
• binarySearch(): 2 arguments. Allows you to search for specific value in SORTED array. Make sure array is sorted first.

Example: int foundIndex = Arrays.binarySearch(myInt, 78); Returns index of 78 if it exists in array myInt. If the number is not found, it will return a negative number. Negative means it’s it’s not found, and the number tells you which POSITION (NOT INDEX) should be if it were to exist in the array (I.g,: -4 means position 4, index 3).

Question 18

Fields vs methods

Answer 18

Come back

Question 19

Array length

Answer 19

No length() method. Instead, we use field length.

userAge.length; (no “()” )

Question 20

Primitive Type vs. Reference Type

Answer 20

All data types in Java fall into one of two categories: Primitive Type or Reference Type. There are only 8 primitive types. The rest are reference types.

Reference types include Strings, arrays, classes, and interfaces.

One of the main differences between the two is how data is stored.

Primitive type stores its own data. With int myNumber = 5; the variable “myNumber” stored the actual value 5.

Reference type does not store the actual data. Instead, it stores a reference to the data. It does not tell the compiler what the value of the data is; it tells the compiler where to find the actual data.

For example, with String message = “Hello”; the variable message does not store the string “hello”. Instead, message stores the address of the memory location of “hello”.

Question 21

Strings are immutable

Answer 21

Immutable means the value cannot be changed. When we update a Strong variable, we are actually creating a new string and assigning the memory address to the String variable.

Example:

String message = “hello”;

update message:

message = “World”;

The compiler does not go to the storage location where “Hello” is stored and change the value to “World.” Instead, it creates a new string “World” and stores it somewhere else in memory. This new address is then assigned to the variable message. In other words, there are TWO string now: “Hello” and “World”. If “Hello” is no longer needed, it is destroyed to free up memory. This is called garbage collection, which Java handles automatically.

Question 22

System.out.println();

Answer 22

PrintStream class tbc

Question 23

Escape sequences

Answer 23

Sometimes we need to print special “unprintable” characters, such as a tab or a newline. You need to use the \ (backsplash) character to escape characters that would otherwise have a different meaning.

Example:

System.out.println(“Hello\tWorld”);

Output:

Hello World

Commonly used escape sequences:

Printing a newline: \n.
Example:
System.out.println(“Hello\nWorld”);

Output:

Hello
World

Print the backslash character itself:
Example: System.out.println(\);

To print double quotes so that the double quotes don’t end the string: \”
Example: System.out.println(“I am 5’9\” tall”);

Output:

I am 5’9” tall

Question 24

Formatting outputs: printf()

Answer 24

printf() is more complex than println(), but it offers more control.

printf() requires more than one argument. The first argument is the string to be formatted. The other arguments replace the format specifiers (%.3f, %d, etc.) which serve as placeholders.

Format specifiers always begin with a percent sign % and end with a converter (such as f or d). In between % and converter, you can add flags. For example, in %.3f, “.3” is a flag. It indicates that we want to display the number with 3 decimal places.

Question 25

Converters

Answer 25

Integer converter: d.
Works for integers such as byte, short, int, and long.

Floating point converter: f. Works for float and double.

Newline converter: n. Moves cursor to next line.

Question 26

Flags

Answer 26

Width flag: total width of output.

Example: System.out.printf(“%8d”, 12);

Output:
12

System.out.printf(“%8.2d”, 12.4);

Output:
12.40

Thousands separator flag: ,

Example: System.out.printf(“%,d”, 12345);

Output:
12,345

System.out.printf(“%,.2f”, 12345.56789);

Output:
12,345.57

Question 27

Accepting input from user

Answer 27

Easiest and most common way is to use Scanner object. Import Scanner class using import java.until.Scanner;

Create a scanner object and pass System.in as an argument

System.in tells the compiler that you want to get input from the standard input device, normally a keyboard.

Scanner reader = new Scanner(System.in);

Scanner has methods we can use to read input from the user.

Most commonly used methods:

-nextInt();
-nextDouble();
-nextLine();
for reading int, double, and String stats types respectively. They return those values.

If you type the wrong data type, the methods will try to convert them. If that fails, you’ll get an error.

Question 28

Ternary operator: 3 > 2 ? 10 : 5;

Answer 28

If condition (3 > 2 in this case) is true then return 10. Else return 5.

Example:
int num = 3 > 2 ? 10 : 5;

num is equal to 10.

Question 29

Enhanced For Statement

Answer 29

Can be used when working with Arrays and Collections.

Syntax:

for(variable declaration : name of array)
{

}

Question 30

Do-while Statement

Answer 30

do-while is similar to while statement with one main difference—the code within the curly braces of a do-while statement is executed at least once.

Example:

int counter = 100;

do {
System.out.println(counter);
} while (counter < 0);

Counter 100 will print ONCE.

Question 31

Branching: break vs. continue

Answer 31

Break exists the loop permanently. Continue skips everything written below it and goes to the next iteration.

Question 32

Exception handling

Answer 32

Tbc

Question 33

Object Oriented Programming

Answer 33

OOP is an approach to programming that breaks a programming problem into objects that interact with each other.

Objects are created from templates known as classes. Class can be thought of as a blueprint of a building; an object is the actual building that we build based on the blueprint.

Writing our own class:

accessModofier class ClassName {

}

Example:

public class Car {

}

Access modifiers are like gate keepers. They control who had access to that class. In other words, they control whether other classes can use a particular field or method in that class.

Public means it can be accessed by any class in the program. Package-Private means it’s only accessible to other classes within the same package. There can be more than one package within a single Java application.

If you do not write an access modifier, it is package-private by default.

Convention is to use PascalCasing when naming a class (first letter of EVERY word is capitalized).

Contents of class are enclosed in curly braces. Contents include constructors, fields, methods, interfaces, and other classes.

There can only be one public class per Java file and that public class must have the same name as the file. The main() method is inside this public class.

Question 34

Fields

Answer 34

Fields are variables declared at top. Can be declared public, private, or protected. Package-Private by default.

Private means it can only be accessed within its own class (different than package-private).

This is encapsulation—hiding data and behavior from other classes that don’t need to know about them. This makes it easier to change code in the future.

Final keyword means that the value cannot be changed after it is created. A final variable must be initialized at deceleration or within constructor.

Question 35

Methods

Answer 35

A method can access all fields declared in the class. It can also declare local variables. These are only accessible within the method.

Can be more than one return statement, but once it encounters the first one it’ll exit the method.

Sometimes a method does not need to return an answer but simply uses the return statement to exit the method.

Question 36

Overloading

Answer 36

Two methods in the same class with the same name. They need different signatures. Signature is the name of the method and the parameters.

Question 37

Getter and Setter Methods

Answer 37

Fields declared private cannot be accessed outside the class. If they’re needed by another class, we use getter and setter methods.

Why do we allow this if it seeks to contradict encapsulation? Because it gives us greater control over the rights other classes have when accessing private fields. For example, we can use if-statements in setter method to control what the private field can be set to.

Convention is to name setter methods startling with “set” and getter methods starting with “get”.

Question 38

Constructors

Answer 38

Constructors are a block of a code similar to a method that construct and object from a the class template. It’s always the same name as the class, and is commonly used to initialize fields in the class.

Constructor is the first block of code that is called when we create an object from the class.

A constructor does NOT have a return value and we do NOT have to use the void keyword.

A class can have more than one constructor as long as the signature is different.

Declaring a constructor is optional. If we don’t declare one, a default constructor will automatically be generated. Default constructor does not have any parameters, and it initializes fields to their default values. (0 for numeric type and null for reference type.)

Question 39

Dot operator for objects

Answer 39

Only needed when accessing members of a class from a different class. Not needed in same class.

Question 40

Static keyword

Answer 40

If you want to call methods are access fields of a class without creating an object, you use the static keyword in that class for that object or field.

To access non-static methods you need to create an object of the class. Not so for static members. We just use the class name to access them.

Question 41

Pass by value

Answer 41

Java is pass by value. But when you pass a reference type variable, a copy of its address is provided. Hence changing it in the method will change the argument value.

For primitive type values you pass a copy of the value and not the address. Hence changing it in the method had no effect on the the argument.

Question 42

Inheritance

Answer 42

Key concept of OOP. Inheritance allows us to create a new class from an existing class so that we can effectively reuse existing code. All classes in Java are inherited from a pre-written base class known as the Object class.

Object class has pre-written methods, such as toString(), that we can use whenever we work with classes.

Question 43

Parent class, base class, or superclass. Child class or subclass.

Answer 43

For a class to inherit a class, you write “extends ParentClassName” after the name of the child class.

One exception is inheriting Object class. We don’t need to use the keyword “extends”.

A child class inherits all PUBLIC and PROTECTED fields and methods from the parent class. This means we can use those methods and fields without coding them in the child class.

Child class does NOT inherit private fields and methods of the parent class. Thus it cannot access these methods directly.

When we write the child class constructor, the parent class constructor is called first. By default it calls the parameterless constructor. If we want it call a non-parameterless constructor in the parent class, you have to use the “super” keyword.

Example:

public NormalMember (String pName, int pMemberID, int pMemberSince)
{
super (pName, pMemberID, pMemberSince);

System.out.println(“Child Constructor with 3 parameters”) ;
}

Super must be the first statement in the constructor.

Private fields are NOT inherited, which means the child cannot access them directly. However, these fields DO exist in child class. It just must use constructors or setter or and getter to access them.

You can assign members of child class to parent class type. For example, an array of members can be set to both NormalMember and VIPMember if NormalMember and VIPMember are child classes of member. You can also assign Member (parent type) to it.

Question 44

Overriding

Answer 44

Overriding a method simply means writing a new version of the method in the child class.

Question 45

Annotations

Answer 45

Example: @Override. Annotations are metadata that provide the compiler with extra info.

Question 46

Polymorphism

Answer 46

Closely related to inheritance. Polymorphism refers to a program’s ability to use the correct method for an object based on its run-time type.

Example:

Question 47

Abstract classes

Answer 47

An abstract class is a special type of class that is created purely to be a base class for other classes to derive from. They cannot be instantiated.

In other words, if FourWheelVehicles is an abstract class, the statement

FourWheelVehicle myVeh = new FourWheelVehicle();

will give you an error as you cannot create an object of an abstract class.

Abstract classes may have fields and methods just like any other class. In addition, they can have a special type of method known as abstract methods. Abstract methods are methods that have NO BODY and MUST be implemented in the DERIVED class.

The keyword abstract is written as the first word of the class declaration. It is also written before “public/private” of a method that is meant to be abstract. Additionally, braces are not added after the method declaration, since it has no body. We end the deceleration with a semicolon instead.

Question 48

Interfaces

Answer 48

Interfaces are like abstract classes in that they cannot be instantiated. Instead, they must be implemented by classes or extended by other interfaces.

When a class implements an interface, it had to implement all the abstract methods in that interface.

One key difference between an abstract class and an interface is that a class can only extend one abstract class but can implement multiple interfaces.

Another difference is that an interface can only contain abstract methods (up until Java 7), while an abstract class can contain non-abstract methods.

You don’t need to write abstract in an interface. It is abstract by default.

You use “implements” for interface, not “extends.”

In Java 8, interfaces can have default and static methods.

Question 49

Access modifiers

Answer 49

4 total:

• private
• public
• protected
• package private by default

In short, anything that is declared as public is accessible everywhere;
there are no restrictions on accessing public fields. On the other hand,
anything declared as private is only accessible within the class in which
it is declared. Anything declared as protected is accessible within the
class in which it is declared, any class that is derived from it and any
class that is in the same package as the class that it is declared in. Finally,
anything declared without an access modifier is package-private and is
only accessible within the package in which it is declared.

Public is accessible anywhere. Package-private only same package. Protected in inherited classes and package. Private only in the class it was declared.

Question 50

Collections

Answer 50

The Java Collections Framework is a set of pre-written classes and interfaces that Java provides to help organize and manipulate groups of data.

Question 51

Autoboxing and Unboxing

Answer 51

Because Java is an object oriented, primitive types need to sometimes be converted to Objects. Java provides wrapper classes for this. Each primitive type has a corresponding wrapper class.

Wrapper classes are:

• Boolean
• Character
• Byte
• Short
• Integer
• Long
• Float
• Double

Converting is easy.

From int to Integer: 
Integer intObject = new Integer(100); 

From Integer to int:
int m = intObject.intValue();

Autoboxing enables automatic conversion.

We can just do
Integer intObject = 100;

Likewise, unboxing converts from Integer to int as follows:
int m = intObject;

Question 52

Wrapper classes

Answer 52

Wrapper classes also have a major use of providing methods for converting strings into primitive types.

For example, you can convert a string to an int using Integer.parseInt();

If the string (like “ABC”) cannot be converted, the method will throw a NumberFormatException.

Can also convert string to double.

Question 53

Lists

Answer 53

Very similar to array, but more flexible. Most importantly, it’s size can be changed.

List is an interface that is part of Collections Framework.

They most common classes that implement list are ArrayList and LinkedList.

Question 54

ArrayList

Answer 54

Implements List interface. Like all collections, can only store objects, not primitive types. Thus, you must use wrapper classes for primitive types.

Syntax for declaration:

ArrayList al = new ArrayList<>();

You could instead declare it using List:

List al = new ArrayList<>();

This is allowed because List is superinterface of ArrayList.

Methods:

Can be used declared ArrayList or declared List and assigned an ArrayList to it.

• add(); or
• add(index, value);
  To add members to list.
• set(index, value);
  To change value.
• remove(index);
  To remove value.
• get(index);
  To get element.
• size();
  Number of elements in List.
• contains(value);
  To check if List contains value.
• indexOf(value);
  Index of first occurrence of value.
  Returns -1 if value doesn’t exist.
• toArray();
  Returns array of objects (object superclass).
  Cab also specify to return Integer array and the like with Integer[] arr = xyz.toArray(new Integer[0]);
• clear();
  Te remove all elements in the list.

Question 55

LinkedList

Answer 55

Very similar to ArrayList. Both implement List interface. Main difference is implementation. ArrayList uses resizing array. LinkedList uses doubly linked list.

If need for frequent addition or deletion, used linked list.

LinkedList also implements Queue and Deque, interfaces in java collections.

Thus, you have to use LinkedList instead of ArrayList if you methods from these interfaces, such as peek(), getFirst(), addLast(), etc.

Linkedlist uses more memory than ArrayList. Also more time consuming to find an element as you have to iterate.

Thus, if memory is an issue or there is a frequent need to find elements, linked list is not advised.

Declaration:

LinkedList ll = new LinkedList<>();

Or

List ll = new LinkedList<>();

Methods:

All methods in ArrayList exist in LinkedList, since they both implement List.

However, because it implements Queue and Deque interfaces as well, it as access to their methods. HOWEVER, YOU MUST DECLARE IT A LINKEDLIST AND NOT A LIST TO USE THESE METHODS.

Peek(), getFirst(), and getLast() do not remove element.

Question 56

File handling

Answer 56

Getting input from user is not always practical. Sometimes we need to read information from a file. Java provides classes and methods to work with files. To use, import java.io.*.

Classes I’ll focus on:

• File
• BufferReade
• FileReader
• BufferReader
• BufferWriter
• FileWriter

Question 57

Reading a text file

Answer 57

We use FileReader class. FileReader reads file as a stream of characters, one by one. TBC…

Question 58

Writing to a text file

Answer 58

We use the BufferWriter and FileWriter class.

Question 59

class hierarchy

Answer 59

LinkedList implements Collection, Lisr, Queue, and Deque

ArrayList implements List and Collection

TreeSet implements SortedSet, Set, and Collection

PriorityQueue implants Queue and Collection

Stack implements List and Collection

Question 60

Java Map hierarchy

Answer 60

Notable Classes that implements Map are Hashtable, Hashmap, TreeMap, and LinkedHashMap.

Question 61

Collection interfaces

Answer 61

Set

List

Queue

Deque