关键字 static 用于表示字段或方法属于类本身而不是示例。如果对象 Clock 是静态的，所有 Hello 班级将分享这个 Clock 公共数据成员（字段）。如果使其非静态，则 Hello 可以有一个独特的 Clock 现场。
问题是您向类中添加了一个main方法 Hello 这样你就可以运行代码了。这里的问题是main方法是静态的，因此它不能引用其中的非静态字段或方法。您可以通过两种方式解决此问题：
使所有字段和方法 Hello 类static，以便可以在main方法中引用它们。这真的不是一件好事（或者是一个错误的理由不能使一个字段和/或一个方法成为静态的）
创建的示例 Hello 在main方法中初始化，并以最初的方式访问它的所有字段和方法。
对您来说，这意味着对代码进行以下更改：

package hello;

public class Hello {

    private Clock clock = new Clock();

    public Clock getClock() {
        return clock;
    }

    public static void main(String args[]) {
        Hello hello = new Hello();
        hello.getClock().sayTime();
    }
}

这里有人问了一个关于“静态”这个词的选择问题

静态变量只能在静态方法中访问，因此当我们声明静态变量时，getter和setter方法将是静态方法
静态方法是我们可以使用类名访问的类级别
下面是静态变量getter和setter的示例：

public class Static 
{

    private static String owner;
    private static int rent;
    private String car;
    public String getCar() {
        return car;
    }
    public void setCar(String car) {
        this.car = car;
    }
    public static int getRent() {
        return rent;
    }
    public static void setRent(int rent) {
        Static.rent = rent;
    }
    public static String getOwner() {
        return owner;
    }

    public static void setOwner(String owner) {
        Static.owner = owner;
    }

}

main() 是一种静态方法，有两个基本限制：
静态方法不能使用非静态数据成员或直接调用非静态方法。 this() 以及 super() 不能在静态上下文中使用。

class A {  
    int a = 40; //non static
    public static void main(String args[]) {  
        System.out.println(a);  
    }  
}

输出：编译时错误

理解静态概念

public class StaticPractise1 {
    public static void main(String[] args) {
        StaticPractise2 staticPractise2 = new StaticPractise2();
        staticPractise2.printUddhav(); //true
        StaticPractise2.printUddhav(); /* false, because printUddhav() is although inside StaticPractise2, but it is where exactly depends on PC program counter on runtime. */

        StaticPractise2.printUddhavsStatic1(); //true
        staticPractise2.printUddhavsStatic1(); /*false, because, when staticPractise2 is blueprinted, it tracks everything other than static  things and it organizes in its own heap. So, class static methods, object can't reference */

    }
}

二等舱

public class StaticPractise2 {
    public static void printUddhavsStatic1() {
        System.out.println("Uddhav");
    }

    public void printUddhav() {
        System.out.println("Uddhav");
    }
}

也可以认为静态成员没有“this”指针。它们在所有示例中共享。

//Here is an example 

public class StaticClass 
{
    static int version;
    public void printVersion() {
         System.out.println(version);
    }
}

public class MainClass 
{
    public static void main(String args[]) {  
        StaticClass staticVar1 = new StaticClass();
        staticVar1.version = 10;
        staticVar1.printVersion() // Output 10

        StaticClass staticVar2 = new StaticClass();
        staticVar2.printVersion() // Output 10
        staticVar2.version = 20;
        staticVar2.printVersion() // Output 20
        staticVar1.printVersion() // Output 20
    }
}

我喜欢“helper”类中的静态方法（只有在可能的情况下）。
调用类不需要创建helper类的另一个成员（示例）变量。只需调用helper类的方法。此外，helper类也得到了改进，因为您不再需要构造函数，也不需要成员（示例）变量。
可能还有其他优势。

静态方法不使用它们所定义的类的任何示例变量。在这一页可以找到一个很好的解释

static使时钟成员成为类成员而不是示例成员。如果没有static关键字，您将需要创建hello类的示例（它有一个clock成员变量）。

Hello hello = new Hello();
hello.clock.sayTime();

在java中 static 关键字可以简单地视为表示以下内容：
“不考虑或不涉及任何特定示例”
如果你想到 static 这样，在遇到它的各种上下文中就更容易理解它的用法：
一 static 字段是属于类而不是任何特定示例的字段
一 static 方法是一种没有概念的方法 this ; 它是在类上定义的，并且不知道该类的任何特定示例，除非向它传递引用
一 static 成员类是一个嵌套类，不知道其封闭类的示例的任何概念或知识（除非向其传递对封闭类示例的引用）

static 成员属于类而不是特定示例。
这意味着一个静态字段只存在一个示例[1]，即使您创建了一百万个类示例或没有创建任何示例。它将被所有示例共享。
自 static 方法也不属于特定示例，它们不能引用示例成员。在给出的例子中， main 不知道 Hello 类（因此 Clock 类）应参考。 static 成员只能参考 static 成员。当然，示例成员可以访问 static 成员。
旁注：当然， static 成员可以通过对象引用访问示例成员。
例子：

public class Example {
    private static boolean staticField;
    private boolean instanceField;
    public static void main(String[] args) {
        // a static method can access static fields
        staticField = true;

        // a static method can access instance fields through an object reference
        Example instance = new Example();
        instance.instanceField = true;
    }

[1] ：根据运行时特征，它可以是每个类加载器、appdomain或线程一个，但这不是重点。

字段可以分配给类或类的示例。默认情况下，字段是示例变量。通过使用 static 字段成为类变量，因此只有一个 clock . 如果你在一个地方做了一个改变，它在任何地方都是可见的。示例变量彼此独立地更改。

到目前为止，这个讨论忽略了类加载器的考虑。严格地说，java静态字段是在给定类加载器的类的所有示例之间共享的。

为了补充现有的答案，让我试着用一张图片：
所有储蓄账户都适用2%的利率。因此它是静态的。
平衡应该是个体的，所以它不是静态的。