Java Fundamentals Flashcards
How does garbage collection work?
Unreferenced objects are identified and marked as ready for garbage collection.
Marked objects are deleted.
Memory may be compacted after the GC deletes objects so that the remaining objects are in a contiguous block at the start of the heap.
How is the heap divided in the HotSpot JVM?
- Young gen (eden, survivor0, survivor1)
- Old gen (tenured)
- Perm gen
What is CMS GC?
- Concurrent Mark Sweep
- Concurrent and parallel
- Designed to minimize pauses (good choice for responsive apps - e.g. GUIs)
- G1 is designed to replace CMS
What is Parallel GC?
- Efficient but can result in long pauses due to compaction
Options for GC performance tuning
Use compiler flags
- Change GC (CMS or G1 instead of parallel)
- Change the initial and maximum size of the heap
- Change the size of heap sections
Static variable
A variable shared by every instance of that class
Static methods
Methods that manipulate only static variables
Static class
Inner class not tied to enclosing class
Static keyword
Used around a block of code to specify code that runs when the JVM is first started before instances of the class are created. Often used to initialize static variables.
Java void vs null
Void means a method does not return a result. Null means a variable doesn’t reference a value or an object.
Difference between interface and abstract class.
An interface is a contact. It specifies method signatures only. Prior to Java 8, it was not possible to include method implementations in an interface. In Java 8, it’s possible to add a method implementation to an interface using the default keyword.
Abstract classes can have constants, members, method stubs (methods without a body) and defined methods, whereas interfaces can only have constants and methods stubs.
Methods and members of an abstract class can be defined with any visibility, whereas all methods of an interface must be defined as public (they are defined public by default).
When inheriting an abstract class, a concrete child class must define the abstract methods, whereas an abstract class can extend another abstract class and abstract methods from the parent class don’t have to be defined.
Similarly, an interface extending another interface is not responsible for implementing methods from the parent interface. This is because interfaces cannot define any implementation.
A single class can only inherit from one parent class. A single class can implement several interfaces.
A child class can only extend a single class (abstract or concrete), whereas an interface can extend or a class can implement multiple other interfaces.
A child class can define abstract methods with the same or less restrictive visibility, whereas a class implementing an interface must define the methods with the exact same visibility (public).
Java interface default methods
Beginning with Java 8, interface methods can include an implementation using the default keyword. The ability to add a default implementation makes it much easier to add a new method to an interface without having to update each implementing class separately.
If a class extends multiple interfaces that contain default methods with the same name, then that class must override the default methods. Otherwise, it will generate a compile-time error.
Eliminates the need for base classes that contain a default implementation.
If any the method of any class in the class hierarchy has the same name as an interface default method, the interface method is ignored. Default interface methods cannot be used to override class behavior.
Default interface methods were added in part to support adding lambda expressions to Java collections.
Java interface static methods
Implementation cannot be overridden by class methods. Good choice for implementing utility classes (e.g sorts).
Java 8 Functional Interfaces
In java.util.function package (e.g. Consumer, Supplier, Function, Predicate).
Previously, you needed to create an anonymous class in order to override a single method
Runnable r = new Runnable(){
@Override
public void run() {
System.out.println("My Runnable");
}};
Using lambda expression
Runnable r1 = () -> System.out.println(“My Runnable”);
Polymorphism
Means “many forms”. Declare a variable using a superclass class/interface type and a subclass/concrete class implementation.
