Java Scjp 6 Chapter 01

Front 1

Identifiers can only begin with

Back 1

letter, underscore, currency character

Front 2

Legal identifiers after the first character

Back 2

letter, underscore, currency character, numbers

Front 3

Identifiers max length

Back 3

meh... infinite I guess.

Front 4

True / False: A source code file can have any number of public classes, but only 1 default access class.

Back 4

False. 1 public class per java file. Many default access allowed.

Front 5

JavaBean method rules must

Back 5

use camelCase naming and naming conventions:
setVarName
getVarName
isBooleanName
addSomeListener
removeSomeListener

Front 6

Must a java file name must always match the public class name?

Back 6

Yes, unless there is no public class (then the file name can be whatever).

Front 7

True/False: A file can have any number of public classes, but must only have 1 default or private class.

Back 7

False. Can have many default, 1 public (optionally), and 0 private classes.

Front 8

In reference to package and/or import statements, where can comments go?

Back 8

Anywhere. //even here!

Front 9

True / False: The import statements are the first non-comment code in a java file

Back 9

Depends. True only if there is no package statement. Otherwise imports are the first non-comment code after the package statement.

Front 10

How many import and package statements are allowed in a java file?

Back 10

import = 0 to many
package = 0 to 1

Front 11

True / False: Files with no public classes have no naming restrictions.

Back 11

True. Only match file name to public class. If no public class then name it whatever!

Front 12

Name all access modifiers.

Back 12

public, private, protected.

Front 13

Name all access (visibility) levels.

Back 13

default, public, private, protected

Front 14

What visibility can a class have (pretend inner classes don't exist).

Back 14

default and public

Front 15

Where is a default level class viewable?

Back 15

It is accessible from any other class in the package.

Front 16

Class access (visibility) revolves around whether code in one class can:

Back 16

Create an instance of another class.
Extend (subclass) another class.
Access members (methods and variables) of another class.

Front 17

Name the legal non-access modifier for a class

Back 17

final, abstract, strictfp

Front 18

True / False:
public final abstract class People {}
Compiles just fine.

Back 18

WRONG! final and abstract... always illegal and preposterous when defining the same thing.

Front 19

What does a class marked final indicate?

Back 19

It can't be extended (subclassed).

Front 20

True / False: An abstract class can never be instantiated.

Back 20

True. Only a concrete subclass of abstract class can be instantiated.

Front 21

True / False: All classes that extend an abstract class must implement the abstract methods.

Back 21

False. The first concrete class must implement all the abstract methods up the whole inheritance hierarchy.

Front 22

Interfaces... briefly describe what they are.

Back 22

Contracts for WHAT a class can do. They say nothing about exactly HOW the class must do it.

Front 23

What classes can implement interfaces?

Back 23

Any class, from any inheritance tree.

Front 24

How many abstract methods is a non-abstract class allowed to have?

Back 24

0. If a class has any abstract methods it must be an abstract class.

Front 25

How many non-abstract methods can an abstract class have?

Back 25

An abstract class can have any number of abstract
or non-abstract methods.

Front 26

How many non-abstract methods can an interface have?

Back 26

0. All methods are abstract.

Front 27

Which is correct?
1. abstract interface Loveable { }
2. interface Loveable { }

Back 27

Both. Interfaces are always abstract, so it can be implicit (thus untyped as in 2).

Front 28

How do access levels for interface, abstract, and regular classes differ?

Back 28

They don't. All have default or public visibility,

Front 29

Interface variables are implicitly..

Back 29

public, static and final (really considered constants)

Front 30

Interface methods are implicitly (and can be marked) with both of these modifiers

Back 30

public abstract

Front 31

True / False: Interface constants can be marked with any combination of the words public static final, but none are required.

Back 31

True. Weird, right? These modifiers are in effect even if not present.

Front 32

A legal non-abstract implementing class must:

Back 32

Provide concrete implementations of methods.
Follow legal override rules for each method.
Must not declare any new (or broader) checked exceptions.

Front 33

True / False: Interfaces can implement any number of other interfaces.

Back 33

False. Interfaces can extend any number of interfaces.

Front 34

True / False. Interfaces can extend a classes.

Back 34

False. They can only extend interfaces.

Front 35

What are class "members" ?

Back 35

Methods themselves and instance variables. Basically all non-local variables in a class.

Front 36

Name all possible member access levels

Back 36

private, public, protected, default

Front 37

What type of visibility trumps member visibility?

Back 37

Class visibility. A member can be public, but the class may be default. Classes in other packages cannot see those methods marked public (because they can't see the class they're in).

Front 38

True / False: Public members can be accessed by all other classes, even in other packages.

Back 38

Um... True? Assuming the class is public. If the class is not visible then the public members are not.

Front 39

'this' always refers to:

Back 39

the currently executing object.

Front 40

Private methods are only accessible to:

Back 40

code in the same class.

Front 41

True / False: Private methods are not inheritable, but subclasses can legally have a method with the same exact signature.

Back 41

True. Since the subclass can't see the superclass method, it is legal to redefine. This is a type of "hiding".