静态方法有什么用，仅仅是为了直接调用吗？

静态方法不属于对象，的确是仅仅为了直接调用。

静态方法大多时候都是在工具类中用，工具类是为了我们使用而存在的，为了方便我们使用，所以有了静态方法

对象是用于封装数据的，如果一个对象并未封装特有数据，那么这样的情况下就使用静态static（下面例子说明了这个）

静态方法可以直接使用类调用，这样就不用在使用“new”去创建对象，这样节省了很多内存；
但是静态中不能使用 this 和super
静态方法可以用来制作工具类，封装完，打成jar包，以后可以直接调用

例子：
这是利用静态方法制作的工具类
（下面有调用工具类的使用类）

public class ArrayTool{

/**

   

    空参数构造函数

*/

    private ArrayTool(){}

//求最大值函数
    public static int getMax(int[] arr){

   

       int max=0;

       for(int x=1;x<arr.length;x++){

      

           if(arr[x]>arr[max])

           max=x;

      

       }

       return arr[max];

   

    }

    //求最小值函数
    public static int getMin(int[] arr){

   

       int min=0;

       for(int x=1;x<arr.length;x++){

      

           if(arr[x]<arr[min])

           min=x;

      

       }

       return arr[min];

   

    }

   

    //查找排序

    public static void SearchSort(int[] arr){

   

       for(int x=0;x<arr.length-1;x++){

      

           for(int y=x+1;y<arr.length;y++){

           

              if(arr[x]>arr[y]){

              

                  swap(arr,x,y);

              

              }

           

           }

      

       }

   

    }

   

    //冒泡排序
    public static void BubbleSort(int[] arr){

   

       for(int x=0;x<arr.length-1;x++){

      

           for(int y=0;y<arr.length-x-1;y++){

           

              if(arr[y]>arr[y+1]){

              

                  swap(arr,y,y+1);

              

              }

           

           }

      

       }

   

    }

   

    //对排序中的重复代码（比较部分）进行封装

    // 只对本类中排序方法使用,不对外提供，进行private 私有化

   

    /**

    给数组中元素进行位置的置换

    */

    private static void swap(int[] arr,int a,int b){

   

       int temp =arr[a];

       arr[a]=arr;

       arr=temp;

   

    }

       

    用于打印数组中的元素，打印形式是【element1,element2.......】

    */

       public static void PrintArray(int [] arr){

       System.out.print("[");

           for(int x=0;x<arr.length;x++){

           if(x!=arr.length-1){

              System.out.print(arr[x]+" ,");

              }else{

              

              System.out.println(arr[x]+"]");

              

              }

           

           }

    }

}

调用工具类：

ArrayToolDemo：//调用工具类； 静态类调用

class ArrayToolDemo{

    public static void main(String [] args)//new String[]

    {

      

       int [] arr={3,9,5,7,19,6};

       /*

       ArrayTool tool = new ArrayTool();

       int max = tool.getMax(arr);

       System.out.println(max);//取最大值

       tool.PrintArray(arr);//排序前数组打印

       tool.SearchSort(arr);//调用排序方法

       tool.PrintArray(arr);//排序后数组打印

       */

       int max = ArrayTool.getMax(arr);

       System.out.println(max);//取最大值

       }

}

静态的好处：
引用方便。对于公用类型的变量，直接用 类名.静态方法名  或者  类名.静态变量名就可引用并且直接可以修改其属性值，不用getter和setter方法。
保持数据的唯一性。此数据全局都是唯一的，修改他的任何一处地方，在程序所有使用到的地方都将会体现到这些数据的修改。
有效减少多余的浪费。

静态的方法就是不需要将类实例化就可以直接使用类名调用到方法或者属性。而非静态的就需要将此类实例化之后才能够调用到方法或者属性。

public class Test {
        static String staticstr = "静态的变量";
        String str = "非静态的变量";
        public static void test1(){
                System.out.println("静态方法");
        }
        public void test2(){
                System.out.println("非静态的方法");
        }
}
class Run{
        public static void main(String[] args) {
                Test.test1();//无需实例化就可以调用到方法
                System.out.println(Test.staticstr);
                Test test = new Test();
                test.test2();//需要实例化之后才能够调用的得到
                System.out.println(test.str);
        }
}

静态的方法一般的可以直接调用:class  A{
public static String ss(){ return "bbbb";};
}
class B{
public String aa(){
   return A.ss();
}
}
而非静态的方法需要new 一个对象:
class A{
public String ss(){
return "bbbb";
}
}
class B{
public String aa(){
   A a=new A();
  return a.ss();
}
}

静态的方法就是不需要将类实例化就可以直接使用类名调用到方法或者属性。而非静态的就需要将此类实例化之后才能够调用到方法或者属性。

public class Test {
        static String staticstr = "静态的变量";
        String str = "非静态的变量";
        public static void test1(){
                System.out.println("静态方法");
        }
        public void test2(){
                System.out.println("非静态的方法");
        }
}
class Run{
        public static void main(String[] args) {
                Test.test1();//无需实例化就可以调用到方法
                System.out.println(Test.staticstr);
                Test test = new Test();
                test.test2();//需要实例化之后才能够调用的得到
                System.out.println(test.str);
        }
}

静态的方法一般的可以直接调用:class  A{
public static String ss(){ return "bbbb";};
}
class B{
public String aa(){
   return A.ss();
}
}
而非静态的方法需要new 一个对象:
class A{
public String ss(){
return "bbbb";
}
}
class B{
public String aa(){
   A a=new A();
  return a.ss();
}
}

静态方法在类加载的时候就已经存在了，第一次调用这个方法时，这个类对象就会加载如jvm中（内存），并且只会加载一次，全类公有，可以用类名加 . 访问，也可以用这个类的对象调用，当用这个对象调用该方法时，就会调用jvm事先加载好的类对象的这个方法，且这个类对象在内存中只有一个，所以无论是哪个对象调用该方法时，都会调用事先加载好的方法，故不用new 这个类的对象，直接可以用类名加 . 调用

静态方法不仅仅是为了调用而存在的。很多时候设计静态方法的目的还有一种性能上的考虑，考虑到很多地方都需要使用到同一个方法，而方法的执行时在栈中的。如果每一个使用的方法都将同一个方法多次加载初始化，那么就会降低系统性能，所以为了提高性能将一个方法设计成为静态方法，所有使用这个方法的地方就可以共享该方法了，很多时候我们在使用工具类的时候，都愿意将该类中的方法设计成静态方法，就是为了提高性能而设计的。