- Variables and objects
- Variables of primitive types hold the values of the primitive types directly.
- Variables of reference types hold references (pointers) to objects, which resides in the garbage-collected heap.
- Garbage collection
- Programmers are not responsible for deallocating memory.
- When an object is no longer accessible from any where in the program, it becomes garbage.
- The garbage-collector in the Java virtual machine automatically reclaims the memory occupied by garbages.
- public void finalize()
- invoked by the Java runtime just before the object is garbage-collected
- System.gc()
- suggest to the Java virtual machine to do a garbage-collection
- Null reference
- null
- A reference does not refer to any object.
- The followings are not the same:
- String s1 = null;
- String s2 = "";
- Alias of objects
- two or more reference variables refer to the same object.
- Parameters in a Java method are passed by value
- The actual parameters (the values passed in) are assigned to the formal parameters (declared in the method header)
- For parameters of primitive types, the formal parameter is a copy of the actual parameter.
- For parameters of reference types (objects), the formal parameter is an alias of the actual parameter.
- Example: Num.java, ParameterTester.java, ParameterPassing.java
- Static fields are per class, instead of per instance.
- Static methods can only use the static fields of the class.
- Static fields can be used by all methods.
- Static fields and static methods can be used without creating instances of the class:
- Static fields are shared among all the instances of the class.
- Static fields can be initialized in a static block:
- ClassName.staticField
ClassName.staticMethod(parameters, ...)
- public class MyClass {
private static int value;
static {
value = ...;
}
// ...
}
- A class nested inside another class.
- An inner class has access to the variables and methods of the outer class, even if they are declared private.
- Inner classes can be protected by the outer class from external use.
- Intended for small helper classes of the outer class.
- A Java interface consists of declarations of abstract methods and constants.
- An abstract method declaration is a method header without a method body.
- An interface defines a contact without an implementation.
- An interface cannot be instantiated, since it has no implementation.
- Interfaces are to be implemented by classes. A class that implements an interface is responsible for providing implementations of all the abstract methods declared in the interface.
- An interface provides a client's view of a software component, and a class implementing the interface provides the implementer's view of the software component.
- Examples:
- public interface Comparable {
public int compareTo(Object o);
}
public interface Iterator {
public boolean hasNext();
public Object next();
public void remove();
}