1. Identifiers (Objective 1.3)
    ❑ 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 depending on the method's purpose, must start with set, get, is, add, or remove.
  2. Declaration Rules (Objective 1.1)
    ❑ 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 statement (if any) must be the first (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 no package statement, import statements must be the first (noncomment) 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.
  3. Class Access Modifiers (Objective 1.1)
    ❑ There are three access modifiers: public, protected, and private.
    ❑ There are four access levels: public, protected, default, and private.
    ❑ Classes can have only public or default access.
    ❑ A class with default access can be seen only by classes within the same package.
    ❑ A class with public access can be seen by all classes from all packages.
    ❑ Class visibility revolves around whether code in one class can
    ❑ Create an instance of another class
    ❑ Extend (or subclass), another class
    ❑ Access methods and variables of another class
  4. Class Modifiers (Nonaccess) (Objective 1.2)
    ❑ Classes can also be modified with final, abstract, or strictfp.
    ❑ 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.
  5. Interface Implementation (Objective 1.2)
    ❑ Interfaces are contracts for what a class can do, but they say nothing aboutthe way in which the class must do it.
    ❑ Interfaces can be implemented by any class, from any inheritance tree.
    ❑ An interface is like a 100-percent abstract class, and is implicitly abstractwhether you type the abstract modifier in the declaration or not.
    ❑ An interface can have only abstract methods, no concrete methods allowed.
    ❑ Interface methods are by default public and abstract—explicit declarationof 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 optionalin any combination.
    ❑ A legal nonabstract implementing class has the following properties:
    ❑ 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 animplementation 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 methodimplementation regardless of the interface declaration.
    ❑ It must maintain the exact signature (allowing for covariant returns)and return type of the methods it implements (but does not have todeclare the exceptions of the interface).
    ❑ A class implementing an interface can itself be abstract.
    ❑ An abstract implementing class does not have to implement the interfacemethods (but the first concrete subclass must).
    ❑ A class can extend only one class (no multiple inheritance), but it can implement many interfaces.
    ❑ Interfaces can extend one or more other interfaces.
    ❑ Interfaces cannot extend a class, or implement a class or interface.
    ❑ When taking the exam, verify that interface and class declarations are legal before verifying other code logic.
  6. Member Access Modifiers (Objectives 1.3 and 1.4)
    ❑ Methods and instance (nonlocal) variables are known as "members."
    ❑ Members can use all four access levels: public, protected, default, private.
    ❑ Member access comes in two forms:
    ❑ Code in one class can access a member of another class.
    ❑ A subclass can inherit a member of its superclass.
    ❑ If a class cannot be accessed, its members cannot be accessed.
    ❑ Determine class visibility before determining member visibility.
    ❑ public members can be accessed by all other classes, even in other packages.
    ❑ If a superclass member 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.aMethod() is the same as just invoking aMethod().
    ❑ private members can be accessed only by code in the same class.
    ❑ private members are not visible to subclasses, so private members can-not be inherited.
    ❑ Default and protected members differ only when subclasses are 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 regardless of package.
    ❑ protected = package plus kids (kids meaning subclasses).
    ❑ For subclasses outside the package, the protected member can be
    accessed only through inheritance; a subclass outside the package cannot
    access a protected member by using a reference to a superclass instance
    (in other words, 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 from another package is
    not accessible to any other class in the subclass package, except for the
    subclass' own subclasses.
  7. Local Variables (Objective 1.3)
    ❑ Local (method, automatic, or stack) variable declarations cannot haveaccess modifiers.
    ❑ final is the only modifier available to local variables.
    ❑ Local variables don't get default values, so they must be initialized before use.
  8. Other Modifiers—Members (Objective 1.3)
    ❑ final methods cannot be overridden in a subclass.
    ❑ abstract methods are declared, with a signature, a return type, andan optional throws clause, but are not implemented.
    ❑ abstract methods end in a semicolon—no curly braces.
    ❑ Three ways to spot a non-abstract method:
    ❑ The method is not marked abstract.
    ❑ The method has curly braces.
    ❑ The method has code between the curly braces.
    ❑ The first nonabstract (concrete) class to extend an abstract class must implement all of the abstract class' abstract methods.
    ❑ The synchronized modifier applies only to methods and code blocks.
    ❑ synchronized methods can have any access control and can also bemarked final.
    ❑ abstract methods must be implemented by a subclass, so they must be inheritable. For that reason:
    ❑ abstract methods cannot be private.
    ❑ abstract methods cannot be final.
    ❑ The native modifier applies only to methods.
    ❑ The strictfp modifier applies only to classes and methods.
  9. Methods with var-args (Objective 1.4)
    ❑ As of Java 5, methods can declare a parameter that accepts from zero tomany arguments, a so-called var-arg method.
    ❑ A var-arg parameter is declared with the syntax type... name; for instance:doStuff(int... x) { }
    ❑ A var-arg method can have only one var-arg parameter.
    ❑ In methods with normal parameters and a var-arg, the var-arg must come last.
  10. Variable Declarations (Objective 1.3)
    ❑ Instance variables can
    ❑ Have any access control
    ❑ Be marked final or transient
    ❑ Instance variables can't be abstract, synchronized, native, or strictfp.
    ❑ It is legal to declare a local variable with the same name as an instancevariable; this is called "shadowing."
    ❑ final variables have the following properties:
    ❑ final variables cannot be reinitialized once assigned a value.
    ❑ final reference variables cannot refer to a different object once theobject has been assigned to the final variable.
    ❑ final reference variables must be initialized before the constructor completes.
    ❑ There is no such thing as a final object. An object reference marked finaldoes not mean the object itself is immutable.
    ❑ The transient modifier applies only to instance variables.
    ❑ The volatile modifier applies only to instance variables.
  11. Array Declarations (Objective 1.3)
    ❑ Arrays can hold primitives or objects, but the array itself is always an object.
    ❑ When you declare an array, the brackets can be to the left or right of the variable name.
    ❑ It is never legal to include the size of an array in the declaration.
    ❑ An array of objects can hold any object that passes the IS-A (or instanceof)test for the declared type of the array. For example, if Horse extends Animal,then a Horse object can go into an Animal array.
  12. Static Variables and Methods (Objective 1.4)
    ❑ They are not tied to any particular instance of a class.
    ❑ No classes instances are needed in order to use static members of the class.
    ❑ There is only one copy of a static variable / class and all instances share it.
    ❑ static methods do not have direct access to non-static members.
  13. Enums (Objective 1.3)
    ❑ An enum specifies a list of constant values assigned to a type.
    ❑ An enum is NOT a String or an int; an enum constant's type is the enumtype. For example, SUMMER and FALL are of the enum type Season.
    ❑ An enum can be declared outside or inside a class, but NOT in a method.
    ❑ An enum declared outside a class must NOT be marked static, final,abstract, protected, or private.
    ❑ Enums can contain constructors, methods, variables, and constant class bodies.
    ❑ enum constants can send arguments to the enum constructor, using thesyntax BIG(8), where the int literal 8 is passed to the enum constructor.
    ❑ enum constructors can have arguments, and can be overloaded.
    ❑ enum constructors can NEVER be invoked directly in code. They are alwayscalled automatically when an enum is initialized.
    ❑ The semicolon at the end of an enum declaration is optional. These are legal:enum Foo { ONE, TWO, THREE}enum Foo { ONE, TWO, THREE};
    ❑ MyEnum.values() returns an array of MyEnum's values.
Card Set
Two minute drill and questions from the Book "Sun Certified Programmer for Java 6 Study Guide" written by Kathy Sierra and Bert Bates