is a sub-group containing the access modifiers. abstract - Specifies that a class only serves as a base class and cannot be instantiated. static - Used only for member classes, specifies that the member class does not belong to a specific instance of the containing class. final - Classes marked as final cannot be extended from and cannot have any subclasses. strictfp - Specifies that all floating-point operations must be carried out conforming to IEEE 754 and forbids using enhanced precision to store intermediate results. Access modifiers The access modifiers, or inheritance modifiers, set the accessibility of classes, methods, and other members. Members marked as public can be reached from anywhere. If a class or its member does not have any modifiers, default access is assumed. public class Foo { int go() { return 0; } private class Bar { } } The following table shows whether code within a class has access to the class or method depending on the accessing class location and the modifier for the accessed class or class member: Constructors and initializers A constructor is a special method called when an object is initialized. Its purpose is to initialize the members of the object. The main differences between constructors and ordinary methods are that constructors are called only when an instance of the class is created and never return anything. Constructors are declared as common methods, but they are named after the class and no return type is specified: class Foo { String str; Foo() { // Constructor with no arguments // Initialization } Foo(String str) { // Constructor with one argument this.str = str; } } Initializers are blocks of code that are executed when a class or an instance of a class is created. There are two kinds of initializers, static initializers and instance initializers. Static initializers initialize static fields when the class is created. They are declared using the static keyword: class Foo { static { // Initialization } } A class is created only once. Therefore, static initializers are not called more than once. On the contrary, instance initializers are automatically called before the call to a constructor every time an instance of the class is created. Unlike constructors instance initializers cannot take any arguments and generally they cannot throw any checked exceptions (except in several special cases). Instance initializers are declared in a block without any keywords: class Foo {