Singletons are used for when you want exactly one instance of a class, that the entire application shares.

Good examples for this principle are classes that are in charge of accessing external resources. For example, you'd want the entire application share the same database connection (or at least connection pool), not have every class that needs it open its own connection.

While I agree with the other answers, the OP was asking why not have a class with all static methods (possibly with static fields) instead of a singleton where you have one instance.

Why use Singletons?

You can Google "singleton" to find all sorts of reasons. From JavaWorld:

Sometimes it's appropriate to have exactly one instance of a class: window managers, print spoolers, and filesystems are prototypical examples. Typically, those types of objects—known as singletons—are accessed by disparate objects throughout a software system, and therefore require a global point of access. Of course, just when you're certain you will never need more than one instance, it's a good bet you'll change your mind.

Why use a Singleton instead of a class with all static methods?

A few reasons

1. You could use inheritance
2. You can use interfaces
3. It makes it easier to do unit testing of the singleton class itself
4. It makes it possible to do unit testing of code that depends on the singleton

For #3, if your Singleton was a database connection pool, you want to insure that your application has only one instance, but do unit testing of the database connection pool itself without hitting the database (possibly by using a package-scope constructor or static creational method):

public class DatabaseConnectionPool {
  private static class SingletonHolder {
    public static DatabaseConnectionPool instance = new DatabaseConnectionPool(
        new MySqlStatementSupplier());
  }

  private final Supplier<Statement> statementSupplier;

  private DatabaseConnectionPool(Supplier<Statement> statementSupplier) {
    this.statementSupplier = statementSupplier;
  }

  /* Visibile for testing */
  static DatabaseConnectionPool createInstanceForTest(Supplier<Statement> s) {
    return new DatabaseConnectionPool(s);
  }

  public static DatabaseConnectionPool getInstance() {
    return SingletonHolder.instance;
  }

  // more code here
}

(notice the use of the Initialization On Demand Holder pattern)

You can then do testing of the DatabaseConnectionPool by using the package-scope createInstanceForTest method.

Note, however, that having a static getInstance() method can cause "static cling", where code that depends on your singleton cannot be unit tested. Static singletons are often not considered a good practice because of this (see this blog post)

Instead, you could use a dependency injection framework like Spring or Guice to insure that your class has only one instance in production, while still allowing code that uses the class to be testable. Since the methods in the Singleton aren't static, you could use a mocking framework like JMock to mock your singleton in tests.

The simple plain English¹ version is: Singleton Class is a Class that has, and can only have, only one instance.

But can't you just then use a static class for that?

No. That's not what a "static" class is in Java. In Java "static" classes can have multiple instances just like any other class.

The static keyword is used (for classes) to mean that the instance of a nested class is not tied to a specific instance of the enclosing class. And that means that expressions in the nested class cannot refer to instance variables declared in the enclosing class.

Prior to Java 1.5 (aka Java 5), there was no support for the singleton design pattern in Java. You just implemented them in plain Java; e.g.

    /** There is only one singer and he knows only one song */
    public class Singer {
        private static Singer theSinger = new Singer();
        private String song = "I'm just a singer";

        private Singer() { 
            /* to prevent instantiation */
        }

        public static Singer getSinger() { 
            return theSinger; 
        }

        public String getSong() {
            return song;
        }
    }

Java 1.5 introduced the enum types which can be used to implement singletons, etc.

    /** There are two Singers ... no more and no less */
    public enum Singer {
        DUANE("This is my song"),
        RUPERT("I am a singing bear");
        
        private String song;

        Singer(String song) {
            this.song = song;
        }
        
        public String getSong() {
            return song;
        }
    }

^{1 - Of course, you need to understand what "class" and "instance" mean. Since the Programming / IT English meanings of these words is different to the "plain English" meanings, it is a stretch to call this a "plain English" description. On the other hand, if the reader doesn't already understand what "class" and "instance" mean, they don't have the base knowledge needed to understand the "singleton" idea, or see the point of it.}