Module 5 to Module 6

static imports

this feature was introduced in Java SE 5.0 and are used to import static members (attributes and methods) individually or collectively

static imports

name the syntax:

import static ..;

import static ..\*;

import static java.lang.Math.\*;

type the syntax of math static import

wrapper classes

the class equivalent of all Java Primitive Data Types

java.lang

wrapper classes can be found inside the ? package and are used to create object representation of a primitive value

uppercase

wrapper classes can be easily memorized, they are all spelled out and all first characters are in ?

Boolean

wrapper class of boolean

Byte

wrapper class of byte

Character

wrapper class of char

Double

wrapper class of double

Float

wrapper class of float

Integer

wrapper class of int

Long

wrapper class of long

Short

wrapper class of short

unboxing

extracting **primitive values** from a **wrapper object** is called ?

boxing

converting primitive datatype to object is called ?

unboxing

int num2 = j.intValue();

boxing

Integer i = new Integer(num);

boxing

Integer j = new Integer(200);

Java SE 5

what version did a feature called Autoboxing and Autounboxing was introduced?

autoboxing and autounboxing

features introduced which allows us to extract primitive values from Wrapper class reference variables

autoboxing

name the syntax:

int num = 100;

Integer i = num;

Integer j = 200;

int num2 = j;

autounboxing

name the syntax:

int num = 100;

Integer i = num;

Integer j = 200;

int num2 = j;

==**int sum = i + j:**==

final

this keyword can be used for attributes, methods and classes

false

(T OF F) methods that are declared final can be overriden

reused and inherited

final methods can still be ? and ? it is just their implementation that you cannot change or override

**constants**

(final keyword) as for attributes, once declared as final you cannot change their values. they are considered as **?**

subclassed

classes once declared final cannot be ?

true

(T OR F) extending final classes will cause a compilation error

error

Will this produce a compilation error? (error or no error)

public class MyString extends String {}

\
(String class is a FINAL CLASS)

once

values for blank final variables can be assigned only ?

false

(T OR F)

\
(values for blank final variables can be assigned only ?). Once assigned, you __**can change its value**__

body

a value must be assigned to a blank final variable within the ? of the constructor.

cannot

(a value must be assigned to a blank final variable within the ? of the constructor). Otherwise, you ? create an object __**if you have not assigned a value to a blank variable**__

enum

starting Java 5, ? was added as a new language feature that allows the declaration of a fix set of constants

constants

all the values declared inside an enum are ? and therefore usually written in all **uppercase values**

enum

allows a set of values declared in a descriptive manner

abstract

this keyword can only be used for **classes and for methods only**

abstract

means that “there are no concrete implementation”

implementation

abstract methods do not have any ? in its method body, just the method signature

true

(T OR F)

as a rule, if a **class** contains an **abstract method**, the __**class**__ must also ==**be declared as abstract themselves**==

instantiate

if a class is declared as abstract, you __**cannot**__ ? objects from an abstract class

abstract classes

serves as a template that forces it subclasses to override methods that should be present in all sub-classes

java interface

contract between the client and the class that implements that interface

interface

in java, ? is used to declare a contract that should be implemented by the client code

abstract, instantiate

all methods in the interface are all ? and should be overriden by the implementing class, and like an abstract class, we cannot ? an object using the keyword __**new**__ because an __**interface is not a “concrete” class**__

inheritance

implementing multiple interfaces is java’s way to implement multiple ?

**public static final**

an interface can also have variables inside them but once a variable is declared it is automatically converted into a ? variable

constants

(**public static final**) these variables are now treated as ? which means we cannot change the values of the variables in an interface

public static final double pi = 3.14;

all classes that implements the interface will inherit these constant values

\
example:

\
\
what is it equivalent to:

**default**

in java 8, the ? method can now be included in an interface

default

this feature will allow the developers to create a scalable interface, an interface that can be updated without causing an error to the implementing classes

methods

in __**pre java 8**__, once an interface has been set and implemented by the classes you cannot add any ? in the interface, because if you do, you will __**break the chain of the interface and class implementation**__

default

? method is only allowed to either be public or have a default access modifier

protected, private

(default interface methods) the ? and ? access modifiers are not allowed to be used

java 8

what version was the interface static methods introduced?

interface static methods

these are methods declared inside an interface that has an actual method body and are declared static

interface static methods

since they are static they can be called thru the name of the interface

functional interface

essentially an interface that has only one abstract method declared

functional interface

on top of an interface declaration a @FunctionalInterface annotation is placed to declare an interface a ?

one abstract method

what is important is that the functional interface should only have ? and it can also have __**any number of default methods**__

Runnable, Comparable, ItemListener

functional interfaces can also be found in standard API like the ?, ? , and ?

Runnable, Comparable, ItemListener

these interfaces only have one abstract method in them and therefore they are considered as functional interfaces

lambda expressions

was introduced in java 8 to simplify calling of methods

\->

lambda operator

additional class

using the lambda operator, we can easily provide an implementation of the methods without creating any ?

exception

is an object representation of an abnormal condition that arises in a **code sequence either at compile time or at runtime**

exception object

? handles unexpected situations like network failure, misspelled or missing filename, printers that suddenly goes offline and the likes

exception class

is a subclass of the **Throwable** class that represents mild errors that can be caught and handled

error

a subclass of the **Throwable** class that represents severe problems that an application should not try to catch

checked, compile

exceptions can be classified either as a ? exception that can be encountered at ? time or as an unchecked exception that can be seen at runtime

unchecked, runtime

(exceptions can be classified either as a ? exception that can be encountered at ? time ) or as an ? exception that can be seen at ?

RuntimeException

unchecked exceptions are commonly known as ?

notify, layman

\#1 reason why we need exception handling

\
To ? the users in ? term what happened during system crash

save

\#2 reason why we need exception handling

\
To enable the users to ? all, if not most, unsaved data during system crash

exit

\#3 reason why we need exception handling

\
To enable users to ? program gracefully

throws

if a method is unable to complete the task in the usual way, Java allows it an **alternative exit route**: it does not seek to return a value from the method where the exception object occurred, instead it ? an object encapsulating the error information, Java then begins a search for a handler that can deal with that error

finally

an optional code block that is usually placed after the last catch block

finally block

contains codes that needs to execute regardless if there is an exception object or not

exception

in java, ? object is an instance of the class Exception which is a subclass of the Throwable class

|

in java se 7, multiple Exception objects can be caught inside the single catch block using what operator

\
catch(IOException ? SQLException ex)

true

(T OR F) starting java se 7, a try block can now have resource parameters

parameterized try block

these resources are objects that need to be closed after execution

false

(T OR F) any object that implements the interface java.lang.AutoCloseable which includes all types of objects that implements the interface java.io.Closeable, __**cannot**__ be used as a resource that can be passed as a parameter to a try block

Exception

to create your own Exception object, you simple create a class that extends the class ?

creating your own exception

what is being done below:

\
class **BadTastingFoodException** extends **Exception**

checked

extending the class **Exception** will automatically make your user defined exception a ? exception

unchecked

extending the class **RuntimeException** will automatically make your user-defined exception an ? exception

assertion

a statement in java which ensures the correctness of any assumptions which have been done in the program

true

when an assertion is executed it is assumed to be **?**

AssertionError

if the assertion is __**false**__ the JVM will throw an ?

runtime

assertion checks can be programmatically placed in codes and can be **enabled** or **disabled** during ?

assertion checking

what is happening below:

assert

assertion checking

what is happening below:

assert : ;

\-ea

if you want to enable the assertion check you may want to rerun your application by adding the ? after the java keyword

\
java ? TestAssert 15 300

detail_expression

if you want to customize the displayed message, you can customize the part

AssertionError

if the returns a false value it will throw an ?

true

(T OR F) only an interface can extend to multiple interfaces

dotted line

what line do we use for interface (UML)

solid line

what line do we use for inheritance (UML)