OCJP 6

• from the same class
• from any class in the same package
• from a subclass in the same package
• from a subclass outside the same package (THROUGH INHERITANCE)

• from the same class
• from any class in the same package
• from a subclass in the same package

• from the same class

• 8 bits
• 1 byte
• mim. Range: -2⁷
• max. Range: 2⁷-1

• 16 bits
• 2 byte
• mim. Range: -2¹⁵
• max. Range: 2¹⁵-1

• 32 bits
• 4 byte
• mim. Range: -2³¹
• max. Range: 2³¹-1

• 64 bits
• 8 byte
• mim. Range: -2⁶³
• max. Range: 2⁶³ - 1

• 32 bits
• 4 bytes

• 64 bits
• 8 bytes

final

• final
• public
• protected
• private
• static
• transient
• volatile

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

final class cannot be subclassed

final method cannot be overridden by a subclass

• final variable cannot be assigned a new value, once the initial method is made
• final reference variables cannot refer to a different object once the object has been assinged to the final variable
• final reference variables must be initialized before the constructor completes

• identifiers can begin with a letter, an underscore, or a currency character
• after the first character, identifiers can also include digits
• identifiers can be of any length
• javaBeans methods must be named using camelCase, and dependign on the method's purpose, must start with set, get, is, add or remove

• a source code file can have only one public class
• if the source file contains a public class, the filename must match the public class name
• a file can have only one package statement, but multiple imports
• the package statements (if any) must be the fist (non-comment) line in a source file
• the import statements (if any) must come after the package and before the class declaration
• if there is noc package statement, import statements must be the first (non-comment) statements in the source file
• package and import statements apply to all classes in the file
• a file can have more than one nonpublic class
• files with no public classes have no naming restrictions

• public
• protected
• private

• public
• protected
• private
• default

• public
• default

• a class cannot be both final and abstract
• a final class cannot be subclassed
• an abstract class cannot be instantiated
• a single abstract method in a class means the whole class must be abstract
• an abstract class can have both abstract and nonabstract methods
• the first concrete class to extend an abstract class must implement all of its abstract methods

• interfaces are contracts for what a class can do, but they say nothing about the way in which the class must do it
• interfaces can be implemented by any class, form any inhertance tree
• an interface is like a 100% abstract class, and is implicitly abstract whether you type the abstract modifier in the declaration or not

• an interface can have only abstract methods, no concrete method ist allowed
• interface methods are by default public and abstract - explicit declaration of these modifiers is optional

• interfaces can have constants, which are always implicitly public, static and final
• interface constant declarations of public, static and final are optional in any combination

• it provides concrete implementations for the interface's methods
• it must follow all legal override rules for the methods it implements
• it must not declare any new checked exceptions for an implementation method
• it must not declare any checked exceptions that are broader than the exceptions declared in the interface method
• it may declare runtime exceptions on any interface method impementation regardless of the interface declaration
• it must maintain the exact signature (allowing for covaraint returns) and return type of the methods it implements (but does not have to declare the exceptions of the interface)

true

a class can extend only one class (no multiple inheritance), but it can implement many interfaces

Interfaces can extend one or more other interfaces

• methods
• nonlocal variables

• public
• protected
• private
• default

• code in one class can acsess a member of another clas
• a subclass can inherit a member of its superclass

• if a superclass memeber is public, the subclass inherits it - regardless of package
• members accessed without the dot operator (.) must belong to the same class
• this. always refers to the currently executing object
• this.aMehtod() is the same as just invoking aMethod()
• private members can be accessed only by cone in the same class
• private members are not visible to subclasses, so private members cannot be inherited

• differ only when subclasses ar involved
• default members can be accessed only by classes in the same package
• protected members can be accessed by other classes in the same package, plus subclasses reagdless of package
• protected = package plus kids (subclasses)
• inheritance is the only mechanism for a subclass outside the package to access a protected member of its superclass)
• a protected member inherited by a subclass form another package is not accessible to any other class in the subclass package, except for the subclass own subclasses

• loca (method, automatic, or stack) variable declarations cannot have access modifiers
• final is the only modifiers available to local variables
• local variables don't get default values, so they must be initialized before use