Java Primitive Data Types

Type Length Range
byte 8-bit signed two’s complement integer. minimum: -128; maximum: 127 (inclusive)
short 16-bit signed two’s complement integer. minimum: -32,768; maximum: 127 (inclusive)
int 32-bit signed two’s complement integer.
in Java 8 and later: int can represent an unsigned 32-bit integer.
signed — minimum: -231; maximum: 231-1 (inclusive)
unsigned — minimum: 0; maximum: 232-1
long 64-bit signed two’s complement integer.
in Java 8 and later: int can represent an unsigned 64-bit integer.
signed — minimum: -263; maximum: 263-1 (inclusive)
unsigned — minimum: 0; maximum: 264-1
float single-precision 32-bit IEEE 754 floating point. See Java Language Specification. Don’t use for precise values, such as currency.
double single-precision 64-bit IEEE 754 floating point. See Java Language Specification. Don’t use for precise values, such as currency.
boolean not precisely defined true and false
char single 16-bit Unicode character minimum: '\u0000' (0); maximum: '\uffff' (65,535) inclusive
Data Type Default Value
byte 0
short 0
int 0
long 0L
float 0.0f
double 0.0d
boolean false
char '\u0000'
String (or any object) null

Java Language Keywords — A’s (2)

Keywords: abstract, assert

abstract

As a class modifier, abstract is a nonaccess modifier that declares a class which cannot be instantiated. You cannot create an object from abstract classes. However, you can create subclasses from abstract classes by extending them. An abstract class may or may not include abstract methods. If a class includes abstract methods, the class itself must be declared abstract. When a subclass does not provide all of the abstract methods in its parent class, the subclass must also be declared abstract.

As a method modifier, abstract declares a method that must be implemented by a subclass. The first concrete (not abstract) subclass must implement all abstract methods of the superclass. Abstract methods cannot have the modifiers final or private because subclasses need to access the methods in order to implement them.

It is a compile-time error if a abstract method declaration also contains any one of the keywords private, static, final, native, strictfp, or synchronized.

An abstract method is declared without an implementation. In other words, without braces, and followed by a semicolon, as in the following example code:

public abstract class Shape {
  int x, y;
  ...
  void moveTo(int x, int y) {
    ...
  } // moveTo(int, int)

  abstract void draw();
  abstract void scale(int factor);
} // class Shape

Then each concrete subclass of Shape, such as Circle and Triangle, must implement the draw and scale methods:

class Circle extends Shape {
  void draw() {
    ...
  } // draw()

  void scale(int factor) {
    ...
  } // scale(int)
} // class Circle

class Triangle extends Shape {
  void draw() {
    ...
  } // draw()

  void scale(int factor) {
    ...
  } // scale(int)
} // class Triangle

Abstract class provide default functionality for the subclasses, whereas an interface mandates a list of functions or properties. So, objects that extends an abstract class “Is-A” subclass; objects that implement an interface “Must-Do” the functions, or “Must-Have” the constants or nested types of the interface.

If an abstract class contains only abstract method declarations, it should be declared as an interface instead. Still, keep in mind that when you make a change to an abstract class all of the subclasses will now have this new functionality. On the other hand, once an interface is changed, any class that implements it that will be broken.

assert
[awaiting definition note]

Java Language Keywords (overview)

So I’m trying to memorize the list of keywords in the Java programming language. You cannot use any of them as identifiers in your code. true, false, and null are not keywords. They are actually literals. Likewise, you cannot use them as identifiers in your code.

abstract assert boolean break byte
case catch char class const*
continue default do double else
enum extends final finally float
for goto* if implements import
instanceof int interface long native
new package private protected public
return short static strictfp super
switch synchronized this throw throws
transient try void volatile while

* reserved, currently not used

So, in all, there are 50 keywords to remember. To make it easier for myself I’ll study them in alphabetical group (i.e. 2 start with a; 3 start with b; 6 start with c; etc.).

Next, the A’s →