Chapter 1 - Declarations and Access Control Flashcards
To pass the SCJP 6 exam
Access Modifiers Members can use
public
protected
default
private
Access Modifiers Classes can use
default
public
Class
A template that describes the kinds of state and behavior that objects of this type support
Object
When JVM encounters new keyword, make an instance of that class. Object will have its own state, and access to all behaviors defined by its class.
State
Each object has its own unique set of instance variables as defined by the class. All instance variables make up the objects state
Inheritance
Code in one class can be reused in other class. Superclasses are extended to more specific sub classes. Subclass inherits accessible instance variables and methods.
Interface
100-percent abstract superclass that identified the methods a subclass must support, but not how they must be supported.
Legal identifiers
- start with a letter, $, or connecting character like a _. Identifiers CANNOT start with a number
- after 1st character, can contain letters, $, connecting characters or numbers
- no limit to # of characters
- cant use JAVA keywords
- Identifiers are CASE sensitive
Classes and interfaces
First letter should be Capitalized, if more than 1 word, use camelcase.
Methods
First letter should be lowercase, then normal camelCase
Variables
start with lowercase, use camelCase
CONSTANTS
UPPER_CASE. use underscores for more than 1 word.
JavaBeans
Java classes that have properties. Properties are private instance variables only accessible by getter and setter methods
JavaBeans Naming Rules #1
If property is NOT boolean, methods prefix must be get, example getSize()
JavaBeans Naming Rules #2
If property is boolean, the getter method is get or is. For example getStopped() or isStopped()
JavaBeans Naming Rules #3
Setter method must prefex set, example setSize()
JavaBeans Naming Rules #3
Setter methods must be marked public, with void return type
JavaBeans Naming Rules #4
Getter methods must be marked public, take no arguments, and have a return type that matches the argument type of setter method for that property
JavaBean Listener Naming Rules #1
Listener methods names used to register a listener, must use the prefix add, followed by listener type: addActionListener()
JavaBean Listener Naming Rules #2
Listener methods used to remove a listener must use the prefix remove
JavaBean Listener Naming Rules #3
Listener method names must end with the word “Listener”
Source File Declaration Rules #1
There can be only one public class per source code file
Source File Declaration Rules #2
Comments can appear at the beginning or end of any line in the source code
Source File Declaration Rules #3
If there is a public class in a file, the name of the file must match the name of the public class. Example: public class Dog { } must be in source file as Dog.java
Source File Declaration Rules #3
If class is part of package, the package statement must be the first line in source file, before any import statements
Source File Declaration Rules #3
If there are import statements, they must go between the package statement and the class declaration. If NO package statement, import statements MUST be first line of source
Source File Declaration Rules #4
import and package statements apply to all classes within a source code file.
Source File Declaration Rules #5
A file can have more than one nonpublic class
Source File Declaration Rules #6
Files with no public classes can have a name that does not match any of the classes in the file.
Modifiers fall into two categories
Access modifiers: public, protected, private
Non-access modifiers: strictfp, final, and abstract
Class Access - 3 things
When code has access to another class:
- Create an instance of class
- Extend class
- Access certain accessable methods and variables
Default Access
Class has no modifier preceding it in the declaration. Think of it as package-level access. Classes with default can only be seen by classes within same package.
Public Access
A class declared as public gives all classes from all packages access to the public class.If public class you are accessing is in different package, must import the public class.
Can a class be marked as final and abstract
NO
Final Class
final class means the class can’t be subclassed. Guarantees none of the methods in the class will ever be overridden
Abstract class
can NEVER be instantiated. Methods in abstract class end in semicolon rather than curly pair brace {}. If a single method is marked as abstract, the WHOLE class must be declared as abstract
Interface
declares what a class can do, without saying anything about HOW the class will do it.
Interface
implicitly public and abstract
must NOT be marked as static
Interface
all variables in interface must be public, static, and final. They can only declare CONSTANTS, not instance variables.
Interface legal declarations
public abstract interface Rollable { } //abstract redundant
public interface Rollable { }
Interface method modifiers
public and abstract modifiers are redundant but acceptable.
Interface constants
they must be public, static, and final, but done have to be declared that way. You CANNOT change the value of a interface CONSTANT!
Interface constants
any combination of LEGAL modifiers is OK, as is using no modifiers at all.
Interface constants
can NEVER be given a value by the implementing or any other class.
Subclass
if a subclass inherits a member, it’s exactly as if the subclass actually declared the member itself
Private Members
Members marked private can’t be accessed by code in any class other than the class in which the private member was declared.
Private Members
you can declare a matching method in a subclass the same as the superclass marked private and its just as if the superclass private method does NOT exist.
Can a private method be overridden by a subclass?
Technically NO. CAREFUL. Subclass method with same name as private superclass method makes it look and feel as if overwritten.
Protected and Default Methods
default member may be accessed only if the class accessing it is in the same package protected members: may be accessed by inheritance even if subclass is different package
Protected and Default methods
behavior differs only when talking about subclasses
Protected Methods
Protected: accessible to all other classes inside package and inheritable by any subclasses outside the package
Protected Method behavior once a subclass has inherited it
The member become PRIVATE to any code outside the subclass, with exception of subclasses of subclass.
Final Method
Final keyword prevents a method from being overridden in a subclass.
Final Arguments
Method arguments are essentially the same as variable declarations that appear in parenthesis.If arg defines var as final, it cannot be modified in the method.
Abstract Methods
A method that has been declared, but not implemented; has NO functional code. Ends with a semi colon instead of a curly brace.
Abstract Methods in Public class
Will NOT compile if even one method is defined as abstract in a class. You can have abstract class with no abstract methods.
Abstract Method subclass inheritance
The first concrete subclass of an abstract class MUST implement all abstract methods of the superclass, unless the subclass is ALSO abstract.
Methods can never be marked as
abstract and final, or both abstract and private…. it just would’t make SENSE!
Private Methods
cannot be overridden, so they CANNOT be marked abstract.
Abstract Method
can never be combined with the static modifier
Synchronized Modifier
method can only be accessed by one thread at a time. Can ONLY be applied to methods,NEVER variables nor classes.
Native Methods
method is implemented in platform dependent code like C. Must end with semicolon indicating there is no implementation.
StrictFP Methods (Floating point)
can declare individual methods and or classes as strictfp, but NEVER variables.
Constructor
Every time you make a new object, at least one constructor is invoked
Constructor
Must have the same name as the class in which they are declared
Constructors
Can’t be marked static, final or abstract
Primitives
Eight types, char, boolean, byte, short, int, long, double, or float. Once declared a primative type can never be changed.
Reference Variable
Declared to be a specific type, and that type can never change.
Primitive sequence from small to big
Byte, short, int, long, double, float
Primitive number types are all signed
That effects their ranges… First bit: 0=positive, 1=negative
Range of numeric primatives
byte 8 short 16 int 32 long 64 float 32 double 64
char
contains a single, 16 bit Unicode character
instance variables
defined inside the class, but outside of any method, and only initialized when class is instantiated
instance variables
fields that belong to each UNIQUE object
instance variables
can be marked final
cannot be marked abstract, synchronized, strictfp, native or static
local variables
variables declared within a method
local variables
always on stack, not on the heap
local variables
must be initialized before they are used
array declarations
arrays are OBJECTS that store multiple values of the SAME type.
arrays
ALWAYS objects on the HEAP
array of Primatives
declared by stating the type of elements the array will hold, followed by square brackets on either side of the identifier:
int[] key;
int key [];
array of Objects
Thread[] threads; // Recommended
Thread threads []; // legal but less readable
Multidimensional arrays
String[] [] [] occupantName; // 3 dim array
String[] managername[]; // 2 dim array
array declaration
never legal to include size of array in your declaration.
int [5] scores ; // illegal
JVM doesn’t allocate space until you actually instantiate the array object.
Final Variables
once initialized to value; CANNOT reinitialize or change it
Final Object Reference Variable
once assigned can never refer to a different object. The data within object can be modified, but the reference variable cannot.
Burn this in
there are no final objects, only final references
Transient Variables
tell JVM to skip the variable when you attempt to serialize it.
Volatile Variables
can only be applied to instance variables.
Can mark as Static
methods
variables
a class nested within another class, but not within a method
Initialization blocks
static members
exist before you ever make a new instance of a class, and will only be ONE copy.
enums
cannot declare them in a method
enums
semicolon on declaration is optional enum CoffeeSize ( BIG, HUGE, SMALL ) ; //; not required
enums
you can NEVER invoke an enum constructor directly, the enum constructor is automatically invoked.
enums
you can declare more than one argument to the constuctor. as BIG(i, “A”)
