Scjp 5 Study Guide Ch. 1

Front 1

abstract, boolean, break, byte, case, catch, char, class, const, continue, default, do, double, else, extends, final, finally, float, for, goto, if, implements, import, instanceof, int, interface, long, native, new, package, private, protected, public, return, short, static, strictfp, super, switch, synchronized, this, throw, throws, transient, try, void, volatile, while, assert, enum

Back 1

Keywords

Front 2

must start with letter, currency char, or connecting char such as underscore
after 1st char, may contain any combination of letters, currency, connecting, or numbers
no limit to number of chars
no Java keywords
case-sensitive
int _a;
int $c;
int _____2_w;

Back 2

Legal Identifiers

Front 3

int :b;
int -d;
int e#;
int .f;
int 7g;

Back 3

Illegal Identifiers

Front 4

one public class per source code file
comments can be anywhere
name of file must match the name of the public class
package name must be the first line before imports
imports must go between package and class declaration
imports and package statements apply to all classes in a file
a file can have more than one nonpublic class
files with no public classes can have a name that doesn't match any of the classes in the file

Back 4

Source File Declaration Rules

Front 5

class A can:
create instance of B
extend B
access certain methods and variables within B, depending

Back 5

Class Access "class A has access to class B"

Front 6

no modifier preceding
package-level access

Back 6

Default Access

Front 7

all classes from all packages have access

Back 7

Public Access

Front 8

final, abstract, strictfp

Back 8

Nonaccess

Front 9

class can't be subclassed
many classes in Java core library

Back 9

Final Classes

Front 10

can never be instantiated
sole purpose is to be extended

Back 10

Abstract Classes

Front 11

a contract for what a class can do without saying anything about how the class will do it
like a 100% abstract superclass that defines the methods a subclass must support, but not how they must be supported
names should be adjectives
can only have abstract methods
all methods are implicitly public and abstract
all variables must be public, static, and final - i.e., constants
methods must not be static
methods cannot be final, strictfp, or native
can extend one of more others like it
cannot extend anything but others like it
cannot implement another
types can be used polymorphically

Back 11

Interface

Front 12

public abstract interface Rollable {}

Back 12

Legal Interface Declaration (abstract modifier is redundant)

Front 13

public and abstract identifiers on interface methods is

Back 13

redundant since all interface methods are implicitly public and abstract

Front 14

just as interface methods are always public and abstract whether you say so or not, any variable defined in an interface must be - and implicitly is -

Back 14

a public constant

Front 15

public, protected, default, private

Back 15

Access Modifiers

Front 16

all classes, regardless of package can access

Back 16

public method or public variable member

Front 17

can't be accessed by code in any class other than the class in which the ___ ___ was declared

Back 17

private member

Front 18

when a member is declared private, a subclass can / can't inherit it?

Back 18

a subclass can't inherit it

Front 19

can a private method be overridden by a sublass?

Back 19

no - the subclass cannot inherit a private method, so it is simply declaring a new method with the same name

Front 20

what is the one critical difference between protected and default access control?

Back 20

a default member may be accessed only if the class accessing the member belongs to the same package, whereas a protected member can be accessed (through inheritance) by a subclass even if the subclass is in a different package

Front 21

the subclass can see the protected member only through ___

Back 21

inheritance

Front 22

can access modifiers be applied to local variables

Back 22

NO - there is never a case where an access modifier can be applied to a local variable

Front 23

the ___ keyword prevents a method from being overridden in a subclass and is often used to enforce the API functionality

Back 23

final

Front 24

a ___ argument must keep the same value it had when it was passed into the method

Back 24

final

Front 25

a method that has been declared (as ___) but not implemented

Back 25

abstract

Front 26

an abstract method ends with a ___ and has no ___ ___

Back 26

semicolon, curly braces

Front 27

it is illegal to have even a single abstract method in a ___ ___

Back 27

non-abstract class

Front 28

the first concrete subclass of an abstract class must

Back 28

implement all abstract methods of the superclass

Front 29

a method can never, ever, ever be marked as both ___ and ___, or both ___ and ___

Back 29

abstract and final
abstract and private

Front 30

the ___ and ___ modifiers are virtually opposites

Back 30

abstract and final

Front 31

the abstract modifier can never be combined with the ___ modifier

Back 31

static

Front 32

the ___ keyword indicates that a method can be accessed by only one thread at a time

Back 32

synchronized

Front 33

the synchronized modifier can be applied only to ___ - not variables, not classes, just ___

Back 33

methods

Front 34

the synchronized modifier can be matched with any of the four ___ ___

Back 34

access modifiers (three access modifier keywords)

Front 35

indicates that a method is implemented in platform-dependent code, often in C

Back 35

native
can be applied only to methods

Front 36

forces floating points to adhere to the IEEE 754 standard
can modify a class or method but never a variable

Back 36

strictfp

Front 37

when you declare it, you must specify the type of argument(s) this parameter of your method can receive (this can be a primitive type or an object type)

Back 37

var-arg type

Front 38

to declare a method follow the type with an ellipsis (...), a space, and then the name of the array that will hold the parameters received

Back 38

basic syntax of var-arg type

Front 39

the var-arg must be the ___ parameter in the method's signature, and you can have only ___ var-arg in a method

Back 39

last, one

Front 40

void doStuff(int... x) {} // expects 0 to many ints as parameters
void doStuff2(char c, int... x) {} // expects first a char, then 0 to many ints
void doStuff3(Animal... animal) {} // 0 to many Animals

Back 40

legal var-args

Front 41

void doStuff4(int x...) {}
void doStuff5(int... x, char... y) {}
void doStuff6(String... s, byte b) {}

Back 41

illegal var-args

Front 42

a ___ can't ever, ever, ever have a return type

Back 42

constructor

Front 43

can have all the normal access mods
must have the same name as the class they are in
can't be marked static
can't be marked final or abstract
can't be overridden

Back 43

constructor declarations

Front 44

what are the two types of variables in Java?

Back 44

primitives, reference variables

Front 45

can be one of 8 types: char, boolean, byte, short, int, long, double, float
once declared, type cannot change - in most cases its value can change

Back 45

primitives

Front 46

used to refer to (or access) an object. declared to be of a specific type and that type can never be changed. can be used to refer to any object of the declared type, or of a subtype of the declared type (a compatible type)

Back 46

reference variables

Front 47

defined inside the class but outside any methods. are only initialized when the class is instantiated. the fields that belong to each unique object

Back 47

instance variables

Front 48

sequence from small to big for integer types

Back 48

byte, short, int, long

Front 49

which is bigger double or float?

Back 49

double

Front 50

how many bits for a double?

Back 50

64

Front 51

how many bits for a float?

Back 51

32

Front 52

what is the bit depth of a boolean?

Back 52

it's virtual machine dependent

Front 53

can use any of the 4 access levels (which means they can be marked with any of the three access modifiers)
can be final
can be transient
cannot be abstract
cannot be synchronized
cannot be strictfp
cannot be native
cannot be static, because then they'd become class variables

Back 53

instance variables

Front 54

modifiers on local variables

Back 54

final

Front 55

modifiers on non-local variables

Back 55

final, public, protected, private, static, transient, volatile

Front 56

modifiers on methods

Back 56

final, public, protected, private, static, abstract, synchronized, strictfp, native

Front 57

variables declared within a method. destroyed when the method ends. are always on the stack, not the heap

Back 57

local variables

Front 58

there is no such thing as a stack ___, only a stack ___

Back 58

object, variable

Front 59

objects that store multiple variables of the same type or variables that are all subclasses of the same type
can hold either primitives or object references

Back 59

arrays

Front 60

there is no such thing as a ___ array, but you can make an array of ___

Back 60

primitive, primitives

Front 61

are declared by stating the type of elements it will hold (object or primitive) followed by square brackets to either side of the indentifier
int[] key;
int key [];

Back 61

array

Front 62

it is never legal to include the ___ of the array in your declaration

Back 62

size

Front 63

declaring with keyword ___ makes it impossible to reinitialize a variable when it has been initialized with an explicit value

Back 63

final

Front 64

a reference variable marked ___ can't ever be reassigned to a different object

Back 64

final

Front 65

there are no final ___ only final ___

Back 65

object, references

Front 66

if you mark an instance variable as ___, you're telling the JVM to ignore this variable when you attempt to serialize the object containing it

Back 66

transient

Front 67

tells the JVM that a thread accessing the variable must always reconcile its own private copy of the variable with the master copy in memory

Back 67

volatile

Front 68

used to create variables and methods that will exist independently of any instances created for the class
exist before you ever make a new instance of the class, and there will be only one copy of the member regardless of the number of instances of that class
all instances of a given class, share the same value for any given ___ variable

Back 68

static

Front 69

things you can mark as static

Back 69

methods, variables, nested class, initialization blocks

Front 70

things you can not mark as static

Back 70

constructors, non-nested classes, interfaces, method local inner classes, local variables

Front 71

can be declared as their own separate class or as a class member, however they must not be declared within a method

Back 71

enum

Front 72

the semicolon is ___ at the end of the enum declaration

Back 72

optional

Front 73

it is important to remember that ___ are not String or ints. think of them as a kind of class

Back 73

enums

Front 74

specifies a list of constant values that can be assigned to a particular type

Back 74

enum

Front 75

NOT a String of an int; a ___'s constant's type is the ___ type. For example, WINTER, SPRING, SUMMER, FALL are of the ___ type Season

Back 75

enum

Front 76

an enum can be declared ___ or ___ but not ___

Back 76

outside a class, inside a class, in a method

Front 77

an enum declared ___ a class must NOT be marked static, final, abstract, protected, or private

Back 77

outside

Front 78

enums can contain

Back 78

constructors, methods, variables, constant class bodies

Front 79

enum constants can ___ using the syntax BIG(8) where the int literal 8 is passed to the enum constructor

Back 79

send arguments to the enum constructor

Front 80

enum constructors ___ have arguments and ___ be overloaded

Back 80

can, can

Front 81

enum constructors can ___ be invoked directly in code.

Back 81

NEVER, they are always called automatically when an enum is initialized

Front 82

three access modifiers

Back 82

public, protected, private

Front 83

four access levels

Back 83

public, protected, private, default