OCJP 6

• 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

• the method is not marked abstract
• the method has curly braces
• the method has code between the curly braces

• a var-arg parameter is declared with the syntay type ... name; for instance: doStuff(int...x){ }
• a var-arg method can have only on var-arg parameter
• in methods with normal parmeters and a var-arg, the var-arg must come last

• arrays can hold primitives or objects, but the array itself is always an object
• brackets can be 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

• 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
• ther 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

• an enum specifies a list of constant values assigned to a type
• an enum is not a string or an int
• an enum can declared outside or inside a class, but NOT in a method
• outside a classe an enum must NOT marked static, final, abstract, protected or private
• 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 myEnums values

• constructors
• methods
• variables
• constant class bodies

• can be send constants, using the syntax BIG(8), where the int 8 is passed to the enum constructor
• can have arguments
• can be overloaded
• can NEVER be invoked directly in code. They are always called automatically when an enum is initialized

• Local variables are declared in methods, constructors or blocks
• are dreated wehen teh method, constructor or block is entered and the variable will be destroyed once it exits the method, constructor or block
• access modifiers cannot be used for local variables
• local variables are implemented at stack level internally
• there is no default vlaue for local variables so local variables should be declared and an inital value should be assigned befoer the first use

• instance variables are declared in a class, but outside a method, constructor or any block
• when a space is allocated for an object in the heap a slot for each instance variable value is created
• instance variables are created when an object is created with the use of the key word 'new' and destroyed when the object is destroyed
• instance variables hold values that must be referenced by more than one method, constructor or block, or essential parts of an objects state that must be present through out the class
• instance variables can be declared in class level before or after use
• access modifiers can be given for instance variables
• instance variables have default values. For numbers the default value is 0, for Boolean it is false and for object references it is null. Values can be assigned during the declaration or within the constructor

• maintainability
• flexibility

• keep instance variables protected (with an access modifier, often private)
• make public accessor methods, and force calling code to use those methods rather than directly accessing the instance variable
• for the methods, use the JavaBeans naming convention of set <someProperty> and get <someProperty>

At runtime, when the Java Virtual Machine (JVM) encounters the new keyword, it will use the appropriate class to make an object which is an instance of that class. That object will have its own state, and access to all of

the behaviors defined by its class.

Each object (instance of a class) will have its own unique set of instance variables as defined in the class. Collectively, the values assigned to an object's instance variables make up the object's state.

When a programmer creates a class, she creates methods for that class. Methods are where the class' logic is stored. Methods are where the real work gets done. They are where algorithms get executed, and data gets manipulated.

1. Create an instance of class B.
2. Extend class B (in other words, become a subclass of class B)
3. Access certain methods and variables within class B, depending on the access control of those methods and variables

-> in effect, access means visibility.

• From the same class
• from any class in the same package
• from a subclass in the same package
• from a scubclass outside the same package
• from any non-subclass class outside the package

• 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