Java中static、this、super、final用途,用法及实例
本文具体讲解了Java中static、this、super、final用法，具体内容有static的静态方法、静态变量、静态类；this & super在一般方法中和在构造函数中的情况；final的成员、方法、类和它在设计模式中的应用。
AD：一、static请先看下面这段程序：public class Hello{public static void main(String[] args){ //(1)System.out.println("Hello,world!"); //(2)}}看过这段程序，对于大多数学过Java 的从来说，都不陌生。
即使没有学过Java，而学过其它的高级语言，例如C，那你也应该能看懂这段代码的意思。
它只是简单的输出“Hello,world”，一点别的用处都没有，然而，它却展示了static关键字的主要用法。
在1处，我们定义了一个静态的方法名为main，这就意味着告诉Java编译器，我这个方法不需要创建一个此类的对象即可使用。
你还得你是怎么运行这个程序吗？一般，我们都是在命令行下，打入如下的命令(加下划线为手动输入)：javac Hello.javajava HelloHello,world!这就是你运行的过程，第一行用来编译Hello.java这个文件，执行完后，如果你查看当前，会发现多了一个Hello.class文件，那就是第一行产生的Java二进制字节码。
第二行就是执行一个Java程序的最普遍做法。
执行结果如你所料。
在2中，你可能会想，为什么要这样才能输出。
好，我们来分解一下这条语句。
（如果没有安装Java文档，请到Sun的官方网站浏览J2SE API）首先，System是位于ng包中的一个核心类，如果你查看它的定义，你会发现有这样一行：public static final PrintStream out;接着在进一步，点击PrintStream这个超链接，在METHOD页面，你会看到大量定义的方法，查找println，会有这样一行：public void println(String x)好了，现在你应该明白为什么我们要那样调用了，out是System的一个静态变量，所以可以直接使用，而out所属的类有一个println方法。
静态方法通常，在一个类中定义一个方法为static，那就是说，无需本类的对象即可调用此方法。
如下所示：class Simple{static void go(){System.out.println("Go...");}}public class Cal{public static void main(String[] args){Simple.go();}}调用一个静态方法就是“类名.方法名”,静态方法的使用很简单如上所示。
一般来说，静态方法常常为应用程序中的其它类提供一些实用工具所用，在Java的类库中大量的静态方法正是出于此目的而定义的。
静态变量静态变量与静态方法类似。
所有此类实例共享此静态变量，也就是说在类装载时，只分配一块存储空间，所有此类的对象都可以操控此块存储空间，当然对于final则另当别论了。
看下面这段代码：class Value{static int c=0;static void inc(){c++;}}class Count{public static void prt(String s){System.out.println(s);}public static void main(String[] args){Value v1,v2;v1=new Value();v2=new Value();v1.inc();prt("v1.c="+v1.c+" v2.c="+v2.c);}}结果如下：v1.c=0 v2.c=0v1.c=1 v2.c=1由此可以证明它们共享一块存储区。
static变量有点类似于C中的全局变量的概念。
值得探讨的是静态变量的初始化问题。
我们修改上面的程序：class Value{static int c=0;Value(){c=15;}Value(int i){c=i;}static void inc(){c++;}}class Count{public static void prt(String s){System.out.println(s);}Value v=new Value(10);static Value v1,v2;Static{prt("v1.c="+v1.c+" v2.c="+v2.c);v1=new Value(27);prt("v1.c="+v1.c+" v2.c="+v2.c);v2=new Value(15);}public static void main(String[] args){Count ct=new Count();prt("ct.c="+ct.v.c);prt("v1.c="+v1.c+" v2.c="+v2.c);v1.inc();prt("v1.c="+v1.c+" v2.c="+v2.c);prt("ct.c="+ct.v.c);}}运行结果如下：v1.c=0 v2.c=0v1.c=27 v2.c=27v1.c=15 v2.c=15ct.c=10v1.c=10 v2.c=10v1.c=11 v2.c=11ct.c=111234下一页>>Pasted from </art/200701/37490.htm>这个程序展示了静态初始化的各种特性。
如果你初次接触Java，结果可能令你吃惊。
可能会对static后加大括号感到困惑。
首先要告诉你的是，static定义的变量会优先于任何其它非static变量，不论其出现的顺序如何。
正如在程序中所表现的，虽然v出现在v1和v2的前面，但是结果却是v1和v2的初始化在v的前面。
在static{后面跟着一段代码，这是用来进行显式的静态变量初始化，这段代码只会初始化一次，且在类被第一次装载时。
如果你能读懂并理解这段代码，会帮助你对static关键字的认识。
在涉及到继承的时候，会先初始化父类的static变量，然后是子类的，依次类推。
非静态变量不是本文的主题，在此不做详细讨论，请参考Think in Java中的讲解。
静态类通常一个普通类不允许声明为静态的，只有一个内部类才可以。
这时这个声明为静态的内部类可以直接作为一个普通类来使用，而不需实例一个外部类。
如下代码所示：public class StaticCls{public static void main(String[] args){OuterCls.InnerCls oi=new OuterCls.InnerCls();}}class OuterCls{public static class InnerCls{InnerCls(){System.out.println("InnerCls");}}}输出结果会如你所料。
InnerCls和普通类一样。
内部类的其它用法请参阅Think in Java中的相关章节，此处不作详解。
二、this & super在上节中，我们讨论了static的种种用法，通过用static来定义方法或成员，为我们编程提供了某种便利，从某种程度上可以说它类似于C语言中的全局函数和全局变量。
但是，并不是说有了这种便利，你便可以随处使用，如果那样的话，你便需要认真考虑一下自己是否在用面向对象的思想编程，自己的程序是否是面向对象的。
好了，现在开始讨论this&super这两个关键字的意义和用法。
在Java中，this通常指当前对象，super则指父类的。
当你想要引用当前对象的某种东西，比如当前对象的某个方法，或当前对象的某个成员，你便可以利用this来实现这个目的，当然，this的另一个用途是调用当前对象的另一个构造函数，这些马上就要讨论。
如果你想引用父类的某种东西，则非super莫属。
由于this与super有如此相似的一些特性和与生俱来的某种关系，所以我们在这一块儿来讨论，希望能帮助你区分和掌握它们两个。
在一般方法中最普遍的情况就是，在你的方法中的某个形参名与当前对象的某个成员有相同的名字，这时为了不至于混淆，你便需要明确使用this关键字来指明你要使用某个成员，使用方法是“this.成员名”，而不带this的那个便是形参。
另外，还可以用“this.方法名”来引用当前对象的某个方法，但这时this就不是必须的了，你可以直接用方法名来访问那个方法，编译器会知道你要调用的是那一个。
下面的代码演示了上面的用法：public class DemoThis{private String name;private int age;DemoThis(String name,int age){setName(name); //你可以加上this来调用方法，像这样：this.setName(name);但这并不是必须的setAge(age);this.print();}public void setName(String name){=name;//此处必须指明你要引用成员变量}public void setAge(int age){this.age=age;}public void print(){System.out.println("Name="+name+" Age="+age);//在此行中并不需要用this，因为没有会导致混淆的东西}public static void main(String[] args){DemoThis dt=new DemoThis("Kevin","22");}}这段代码很简单，不用解释你也应该能看明白。
在构造函数中你看到用this.print(),你完全可以用print()来代替它，两者效果一样。
下面我们修改这个程序，来演示super的用法。
class Person{public int c;private String name;private int age;protected void setName(String name){=name;}protected void setAge(int age){this.age=age;}protected void print(){System.out.println("Name="+name+" Age="+age);}}public class DemoSuper extends Person{public void print(){System.out.println("DemoSuper:");super.print();}public static void main(String[] args){DemoSuper ds=new DemoSuper();ds.setName("kevin");ds.setAge(22);ds.print();}}1234下一页>>在DemoSuper中，重新定义的print方法覆写了父类的print方法，它首先做一些自己的事情，然后调用父类的那个被覆写了的方法。
java中this和super的用法
java中this和super的用法
一、this的用法
1、当this表示当前对象时：
在类的方法中，this表示当前对象，它总是指向调用该方法的对象，这就是说，在类的方法中，“this”永远指向当前对象。
2、局部变量和属性
当一个局部变量或者成员变量名字相同时，this可以用来区分这两个变量，指明属性，要么this引用实例的属性，要么就是方法的局部变量。
3、用this调用构造函数
有时可以使用this调用同一类中其他构造函数，如：
public class A{
public A(){
}
public A(int a){
this();
}
}
4、强调调用成员变量
当this.x和x表示同一个成员变量时，可以使用this.x来强调x是成员变量，而不是局部变量。
二、super的用法
1、调用父类的构造函数
每个子类构造函数默认都会调用父类的默认的无参数的构造函数，可以使用super来调用父类有参数的构造函数。
2、调用父类的成员函数
子类可以调用自己不具备的父类函数，或者重写父类函数，重写时也可以使用super来调用父类函数。
3、调用父类的成员变量
由于子类不能直接访问父类的成员变量，需要使用super来访问父类的成员变量。
Java关键字final、static使用总结
Java关键字final、static使⽤总结假如⼀个变量存在于⼀个函数中,函数调⽤结束后,普通变量会被释放内存。
⽽静态变量的内存则不会释放。
假如后⾯的程序段要调⽤该函数，该函数中该静态变量的值可以继续使⽤。
⼀、final根据程序上下⽂环境，Java关键字final有“这是⽆法改变的”或者“终态的”含义，它可以修饰⾮抽象类、⾮抽象类成员⽅法和变量。
你可能出于两种理解⽽需要阻⽌改变：设计或效率。
final类不能被继承，没有⼦类，final类中的⽅法默认是final的。
final⽅法不能被⼦类的⽅法覆盖，但可以被继承。
final成员变量表⽰常量，只能被赋值⼀次，赋值后值不再改变。
final不能⽤于修饰构造⽅法。
注意：⽗类的private成员⽅法是不能被⼦类⽅法覆盖的，因此private类型的⽅法默认是final类型的。
1、final类final类不能被继承，因此final类的成员⽅法没有机会被覆盖，默认都是final的。
在设计类时候，如果这个类不需要有⼦类，类的实现细节不允许改变，并且确信这个类不会载被扩展，那么就设计为final类。
2、final⽅法如果⼀个类不允许其⼦类覆盖某个⽅法，则可以把这个⽅法声明为final⽅法。
使⽤final⽅法的原因有⼆：第⼀、把⽅法锁定，防⽌任何继承类修改它的意义和实现。
第⼆、⾼效。
编译器在遇到调⽤final⽅法时候会转⼊内嵌机制，⼤⼤提⾼执⾏效率。
例如：View Code1public class Test1 {23public static void main(String[] args) {4// TODO ⾃动⽣成⽅法存根5 }67public void f1() {8 System.out.println("f1");9 }10//⽆法被⼦类覆盖的⽅法11public final void f2() {12 System.out.println("f2");13 }1415public void f3() {16 System.out.println("f3");17 }1819private void f4() {20 System.out.println("f4");21 }22 }2324public class Test2 extends Test1 {2526public void f1(){27 System.out.println("Test1⽗类⽅法f1被覆盖!");28 }2930public static void main(String[] args) {31 Test2 t=new Test2();32 t.f1();33 t.f2(); //调⽤从⽗类继承过来的final⽅法34 t.f3(); //调⽤从⽗类继承过来的⽅法35//t.f4(); //调⽤失败，⽆法从⽗类继承获得3637 }38 }3、final变量（常量）⽤final修饰的成员变量表⽰常量，值⼀旦给定就⽆法改变！final修饰的变量有三种：静态变量、实例变量和局部变量，分别表⽰三种类型的常量。
final和static的用法
final和static的用法final和static的用法final的用法•修饰类：被final修饰的类不能被继承。
这样可以确保类的完整性和安全性，避免被其他类修改或扩展。
•修饰方法：被final修饰的方法不能被子类重写。
这样可以确保方法的行为不会被修改，提高程序的稳定性和可靠性。
•修饰变量：被final修饰的变量称为常量，只能被赋值一次，之后不能再更改。
常量的命名通常使用全大写字母，多个单词之间用下划线分隔。
static的用法•修饰成员变量：被static修饰的成员变量属于类，而不是对象。
所有的对象共享同一个static变量的值，在内存中只会有一份拷贝。
•修饰方法：被static修饰的方法称为静态方法，可以直接通过类名调用，不需要创建对象。
静态方法只能访问静态成员，不能访问非静态成员。
•修饰代码块：被static修饰的代码块称为静态代码块，用于在类加载时执行一些初始化操作。
静态代码块只会在类加载时执行一次，且先于静态方法和构造方法执行。
•修饰内部类：被static修饰的内部类称为静态内部类，与外部类没有绑定关系，可以直接通过类名访问。
静态内部类不能访问外部类的非静态成员。
•修饰导入语句：在导入语句中使用import static可以导入静态成员，使得可以直接使用静态成员的名称，而不需要通过类名访问。
final和static的结合使用•final修饰的变量可以与static修饰的变量结合使用，称为静态常量。
静态常量在内存中只有一份拷贝，并且不能被修改。
•final修饰的方法可以与static修饰的方法结合使用，称为静态方法。
静态方法可以直接通过类名调用，而且不能被子类重写。
以上是final和static的一些基本用法和结合使用的情况。
它们在Java编程中非常常用，能够提高程序的效率和安全性。
通过合理使用final和static，我们可以更好地控制类的继承关系、变量的不可修改性和方法的可靠性。
final修饰类的例子final class MyClass {// class implementation}在这个例子中，被final修饰的类MyClass不能被继承。
java中final和static使用总结
java中final和static使用总结static表示“全局”或者“静态”的意思，用来修饰成员变量和成员办法，也可以形成静态static代码块，但是Java语言中没有全局变量的概念。
被static修饰的成员变量和成员办法自立于该类的任何对象。
也就是说，它不依靠类特定的实例，被类的全部实例分享。
只要这个类被加载，Java虚拟机就能按照类名在运行时数据区的办法区内定找到他们。
因此，static对象可以在它的任何对象创建之前拜访，无需引用任何对象。
用public修饰的static成员变量和成员办法本质是全局变量和全局办法，当声明它类的对象市，不生成static变量的副本，而是类的全部实例分享同一个static变量。
static变量前可以有private修饰，表示这个变量可以在类的静态代码块中，或者类的其他静态成员办法中用法（固然也可以在非静态成员办法中用法--废话），但是不能在其他类中通过类名来挺直引用，这一点很重要。
事实上你需要搞明了，private是拜访权限限定，static表示不要实例化就可以用法，这样就简单理解多了。
static前面加上其它拜访权限关键字的效果也以此类推。
static修饰的成员变量和成员办法习惯上称为静态变量和静态办法，可以挺直通过类名来拜访，拜访语法为：类名.静态办法名(参数列表...) 类名.静态变量名用static修饰的代码块表示静态代码块，当Java虚拟机（JVM）加载类时，就会执行该代码块（用处十分大，呵呵）。
1、static变量根据是否静态的对类成员变量举行分类可分两种：一种是被static修饰的变量，叫静态变量或类变量；另一种是没有被static修饰的变量，叫实例变量。
两者的区分是：对于静态变量在内存中惟独一个拷贝（节约内存），JVM只为静态分配一次内存，在加载类的过程中完成静态变量的内存分配，可用类名挺直拜访（便利），固然也可以通过对象来拜访（但是这是不推举的）。
java中static的基本用法
java中static的基本用法Java中static的基本用法在Java中，关键字static用于声明类成员（方法和变量）的静态特性。
静态成员属于类本身，而不是类的实例。
在本文中，我们将讨论Java中static的几种基本用法。
静态变量（Static Variables）静态变量是在类的范围内声明的，只有一个副本，所有类的实例共享它。
以下是静态变量的一些特点：•静态变量在内存中只有一份副本，无论创建类的实例多少次。
•静态变量可以直接通过类名访问，无需创建类的实例。
•静态变量可以与实例变量和实例方法共存。
下面是静态变量的声明和访问示例：public class MyClass {static int count = 0; // 静态变量public static void main(String[] args) {(); // 直接通过类名访问静态变量}}静态方法（Static Methods）静态方法是在类中声明的方法，可以直接通过类名调用，无需创建类的实例。
有以下几点需要注意：•静态方法只能访问静态变量和调用其他静态方法。
•静态方法内部不能使用this关键字，因为它无法引用实例变量。
•静态方法常用于创建工具类和提供公共功能。
以下是静态方法的示例：public class MathUtils {public static int add(int a, int b) {return a + b;}public static void main(String[] args) {int sum = (5, 10); // 直接通过类名调用静态方法(sum);}}静态块（Static Blocks）静态块是在类中使用静态关键字static声明的代码块，用于在类加载时执行一些初始化操作。
以下是静态块的特点：•静态块在类加载时执行，且只执行一次。
•静态块不能传递参数。
•静态块常用于加载驱动程序或执行其他静态操作。
final、static、staticfinal修饰符的用法与区
final、static、staticfinal修饰符的⽤法与区摘⾃：、在Java中，只要是被定义为final的类，也可以说是被final修饰的类，就是不能被继承的。
final规定：当你将final⽤于类⾝上时，⼀个final类是⽆法被任何⼈继承的，那也就意味着此类在⼀个继承树中是⼀个叶⼦类，并且此类的设计已被认为很完美⽽不需要进⾏修改或扩展。
对于final类中的成员，你可以定义其为final，也可以不是final。
⽽对于⽅法，由于所属类为final的关系，⾃然也就成了final型的。
你也可以明确的给final 类中的⽅法加上⼀个final，但这显然没有意义。
1.修饰类 当⽤final修饰⼀个类时，表明这个类不能被继承。
final类中的成员变量可以根据需要设为final，但是要注意final类中的所有成员⽅法都会被隐式地指定为final⽅法。
2.修饰⽅法 使⽤final修饰⽅法的原因有两个。
第⼀个原因是把⽅法锁定，以防任何继承类修改它的含义；第⼆个原因是效率。
在早期的Java实现版本中，会将final⽅法转为内嵌调⽤。
但是如果⽅法过于庞⼤，可能看不到内嵌调⽤带来的任何性能提升。
在最近的Java版本中，不需要使⽤final⽅法进⾏这些优化了。
因此，只有在想明确禁⽌该⽅法在⼦类中被覆盖的情况下才将⽅法设置为final。
注：⼀个类中的private⽅法会隐式地被指定为final⽅法。
3.修饰变量 对于被final修饰的变量，如果是基本数据类型的变量，则其数值⼀旦在初始化之后便不能更改；如果是引⽤类型的变量，则在对其初始化之后便不能再让其指向另⼀个对象。
虽然不能再指向其他对象，但是它指向的对象的内容是可变的。
final、static、static final的区别：static作⽤于成员变量⽤来表⽰只保存⼀份副本，⽽final的作⽤是⽤来保证变量不可变。
final：final可以修饰：属性，⽅法，类，局部变量（⽅法中的变量）final修饰的属性的初始化可以在编译期，也可以在运⾏期，初始化后不能被改变。
Javastatic和final修饰符
Javastatic和final修饰符static 修饰符静态变量：static 关键字⽤来声明独⽴于对象的静态变量，⽆论⼀个类实例化多少对象，它的静态变量只有⼀份拷贝。
静态变量也被称为类变量。
局部变量不能被声明为 static 变量。
静态⽅法：static 关键字⽤来声明独⽴于对象的静态⽅法。
静态⽅法不能使⽤类的⾮静态变量。
静态⽅法从参数列表得到数据，然后计算这些数据。
对类变量和⽅法的访问可以直接使⽤ classname.variablename 和 classname.methodname 的⽅式访问。
如下例所⽰，static修饰符⽤来创建类⽅法和类变量。
public class InstanceCounter {private static int numInstances = 0;protected static int getCount() {return numInstances;}private static void addInstance() {numInstances++;}InstanceCounter() {InstanceCounter.addInstance();}public static void main(String[] arguments) {System.out.println("Starting with " +InstanceCounter.getCount() + " instances");for (int i = 0; i < 500; ++i){new InstanceCounter();}System.out.println("Created " +InstanceCounter.getCount() + " instances");}}以上实例运⾏编辑结果如下:Started with 0 instancesCreated 500 instancesfinal 修饰符final 变量：final 变量能被显式地初始化并且只能初始化⼀次。
java中的static、final、this、super关键字
java中的static、final、this、super关键字static关键字1. 所有的static关键字修饰的都是类相关的，类级别的2. 所有被static关键字修饰的，都是采⽤"类名."的⽅式访问，不需要new对象访问3. static修饰的变量：类变量4. static修饰的⽅法：类⽅法5. static是不允许⽤来修饰局部变量（原因在变量和常量常量中做了解释）注解：实例⽅法/变量等，必须先有对象，才能访问，不然可能会空指针异常（ng.NullPointerException）注意：空指针异常只要"空引⽤"访问"实例"相关的都是会发⽣空指针异常的。
什么时候成员变量声明为实例变量，什么时候声明为静态变量？ 当⼀个对象独享⼀份的是实例变量，当所有对象共享⼀份的是静态变量实例相关的：⼀定需要通过"引⽤."来访问。
静态相关的：使⽤"类名."访问，但是使⽤"引⽤."访问也⾏（建议不要这样使⽤，这样会让别⼈困惑这个变量是实例的）注解：1. 当使⽤"引⽤."去访问静态变量或者静态⽅法时，在底层实际上是使⽤的"类名."去访问的静态变量，2. 当⼀个对象通过new关键字创建出对象，并且把对象创建出的地址赋值给变量，那么这个变量就是"引⽤"3. 当这个⽅法体当中，直接访问了实例变量，那么这个⽅法⼀定是实例⽅法静态代码块语法1static {2 java语句;3 java语句;4 }static 静态代码块在什么时候执⾏呢？ 类加载时执⾏，并且只执⾏⼀次(特点/特征)注解：静态代码块在类加载时执⾏，并且在主⽅法（main⽅法）执⾏之前执⾏，并且⼀般按照⾃上⽽下的顺序执⾏静态代码块的作⽤： 静态代码块实际上是SUN公司给我们java程序员的⼀个特殊的时刻/时机，这个时机叫做：类加载时机(就是在类加载前做⼀些准备⼯作)注意：static块可以出现类中的任何地⽅，除了⽅法内部，任何⽅法内部都不⾏原因：静态代码快是最先执⾏的，在类加载时就执⾏了（优先级最⾼）注解：静态代码块⾥可以访问静态变量，因为静态变量也是在类加载时初始化，但是静态变量的代码必须在静态代码块之前进⾏声明和初始化才能访问。
Java中static与final的用法
Java中static与final的⽤法
static
static意为静态的，但凡被static修饰说明属于类，不属于类的对象。
加载：static在类加载时初始化（加载）完成。
可修饰：
内部类
⽅法
成员变量
代码块
注意：
static⽅法不能兼容this关键字。
你不能覆盖Java中的静态⽅法，因为⽅法覆盖基于运⾏时的动态绑定，静态⽅法在编译时使⽤静态绑定进⾏绑定。
虽然可以在⼦类中声明⼀个具有相同名称和⽅法签名的⽅法，看起来可以在Java中覆盖静态⽅法，但实际上这是⽅法隐藏。
final
加载：final可以在编译（类加载）时初始化，也可以在运⾏时初始化，初始化后不能被改变。
可修饰：类、内部类、⽅法、成员变量、局部变量、基本类型、引⽤类型。
final修饰基本类型：值不能被修改
final修饰引⽤类型：引⽤不可以被修改也就是说不能指向其他对象，但是该引⽤的对象内容可以被修改
final修饰⽅法，⽅法不可以重写，但是可以被⼦类访问，前提是⽅法不是private类型
final修饰类，类不可以被继承
static final
可修饰：成员变量、⽅法、内部类。
成员变量：属于类的变量且只能赋值⼀次
⽅法：属于类的⽅法且不可以被重写
内部类：属于外部类，且不能被继承。
static用法 java
static用法javaJava中的static关键字用于定义静态成员，也可以修饰类、方法和变量。
它表示静态的、共享的属性或方法，不依赖于具体实例的存在。
本文将详细介绍static关键字的用法及其在Java中的应用。
一、静态成员变量静态变量是属于类的，而不是属于类的实例对象。
使用static关键字可以将一个变量声明为静态成员变量。
静态变量与类的所有实例共享，当其中一个实例修改了静态变量的值，其他实例也会受到影响。
静态变量在内存中只有一个副本，节省了内存空间。
在类中，静态变量的定义方式为：[访问修饰符] static 数据类型变量名;下面举个例子来说明静态变量的用法：javapublic class StaticVariableExample {public static int count = 0;public String name;public StaticVariableExample(String name) { = name;count++;}}上述代码中，count是类StaticVariableExample的静态成员变量，表示创建了多少个类的实例对象。
在每个对象的构造函数中，count的值都会加1。
这样，每次创建一个实例对象，count的值就会增加。
静态变量的访问方式为：类名.静态变量名。
例如，通过StaticVariableExample.count来访问count变量。
二、静态方法静态方法是属于类的，而不是属于类的实例对象。
使用static关键字可以将一个方法声明为静态方法。
静态方法可以直接通过类名来调用，不需要先创建类的实例对象。
静态方法只能访问类中的静态成员变量或静态方法。
在类中，静态方法的定义方式为：[访问修饰符] static 返回值类型方法名([参数列表]){方法体}下面举个例子来说明静态方法的用法：javapublic class StaticMethodExample {public static int add(int a, int b) {return a + b;}}上述代码中，add方法是静态方法，用于计算两个整数的和。