This would mean that you can declare instances of them:

  42 x;

  class FourtyTwo : 42 { };

  typedef 42 fourty_two;

  
  int fubar(true x, int n) { return n + 1; }
  int fubar(false x, int n) { return n - 1; } 

int factorial( int x ; x < 1 ) { throw new IllegalArgumentException( "Factorial is undefined for negative numbers" ); }
int factorial( 1 x ) { return 1; }
int factorial( 2 x ) { return 2; } // optimization
int factorial( int x ) { return x * factorial( x - 1 ); }

int factorial( int x ) {
  if ( x < 1 ) throw new IllegalArgumentException( "Factorial is undefined for negative numbers" );
  if ( x == 1 ) return 1;
  if ( x == 2 ) return 2; // optimization
  return x * factorial( x - 1 );
}

abstract class Byte {
  abstract Byte instance(); // this function is automatically generated by the compiler and returns the singleton of the class
  abstract Byte increment();
  abstract Byte decrement();
}
 
class -128b extends Byte {
  Byte increment() { return -127b.instance(); }
  Byte decrement() { throw new IllegalStateException( "-128b is the smallest Byte and therefore can't be decremented" ); }
}
 
class -127b extends -128b {
  Byte increment() { return -126b.instance(); }
  final Byte decrement() { return super; }
}
 
class -126b extends -127b {
  Byte increment() { return -125b.instance(); }
}
 
...
 
class 127b extends 126b {
  final Byte increment() { throw new IllegalStateException( "127b is the largest Byte and therefore can't be incremented" ); 
}

> int factorial( int x ; x < 1 ) { throw new
> IllegalArgumentException( "Factorial is undefined for
> negative numbers" ); }
> int factorial( 1 x ) { return 1; }
> int factorial( 2 x ) { return 2; } // optimization
> int factorial( int x ) { return x * factorial( x - 1 ); }
>