Java基础知识（六）静态&主函数

static静态修饰

1用于修饰对象中成员变量或者成员函数，被修饰的成员为所有对象共享从而达到节约空间的目的。

2被修饰的成员可以被类名直接调用。

3静态随着类的加载而加载。

4优先于对象存在：非静态变量只有在创建对象后才存在，而静态变量在类加载到内存时就存在了。

class Person
{
    String name;    //成员变量，又称实例变量
    static String country = "China";   //静态成员变量，又称类变量
}

内存除了栈内存、堆内存外还有个共享区（又称方法区、数据区），用来存放方法和一些共享数据。静态成员变量就被放在共享区内。所以不建议定义太多静态成员变量，因为它们始终在共享区内会占用大量内存。即，如果不是被所有对象共享就不要定义成静态。

实例变量与类变量区别：

1存放位置不同：类变量随着类的加载而存在于方法区中。实例变量随着对象的建立而存在于堆内存中。（存在于对象中）

2生命周期不同：类变量生命周期最长，随着类的消失而消失。实例变量随着对象的消失而消失。

静态使用注意事项：

1 静态方法只能访问静态成员（变量、方法），非静态方法啥都可以访问。

先来看一种报错：

class Person
{    
    String name;
    
    static String country = "China";

    public static void show()
    {
        System.out.println("::::"+name);
    }
}
class Test
{
    public static void main(String[] args)
    {
        Person.show();
    }
{

这段代码运行会报错：

原因是，name是非静态成员变量，是在对象建立后才存在的，而现在连对象都还没建立，更谈不上对象中的变量了。

2 静态方法中不可以定义this、super关键字。因为此时对象还没存在。

3主函数是静态的。

静态的利弊：

利：给对象共享内容单独存储，节省空间。可以直接被类名调用。

弊：生命周期过长，访问有局限性。

什么时候用静态？

对象中出现共享数据时

什么时候用静态函数？

当功能内部没有访问到非静态数据（该对象特有的数据），此时可以定义静态函数。

关于主函数。

class Main
{    
    //public 权限最大  static 类在我在 void 不需要返回值因为是JVM调用的
    public static void main(String[] args)  //传的参数是一个字符类型数组，名字叫args，是  
                                            // argumens（参数）的简写
    {
        System.out.println(args.length);    //此时长度是0
        System.out.println(args[0]);         //这里会报错，数组长度是0，说明没有元素，自然没[0]
    }
}

上图倒数第二行里，输入类名后接着输入三个参数就会把这三个参数传入到string[]那个数组中去，结果args.length就变成了3.

另外，main函数也可以重载。毕竟main函数也只是个普通函数，只是JVM能够固定识别它罢了。下面代码输出70。

class Test
{
    public static void main(String[] args)
    {
        main(70);
    }
    public static void main(int x)
    {
        System.out.println(x);
    }

}

class ArrayTool
{
    public static int getMax(int[] arr)
    {
        int max=0;
        for (int i=0;i<arr.length;i++)
        {
            if(arr[i]>arr[max])
            {
                max=i;
            }
        }
        return arr[max];
    }

    public static int getMin(int[] arr)
    {
        int min=0;
        for (int i=0;i<arr.length;i++)
        {
            if(arr[i]<arr[min])
            {
                min=i;
            }
        }
        return arr[min];
    }

    public static void selectSort(int[] arr)
    {
        for (int i=0;i<arr.length-1;i++)
        {
            for(int j=i+1;j<arr.length;j++)
            {
                if(arr[i]>arr[j])
                swap(arr,i,j);
            }
        }
    }

    private static void swap(int[] arr,int a,int b)
    {
        int temp=arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }

    public static void bubbleSort(int[] arr)
    {
        for (int i=0;i<arr.length-1;i++)
        {
            for(int j=0;j<arr.length-i-1;j++)
            {
                if(arr[j]>arr[j+1])
                swap(arr,j,j+1);
            }
        }
    }

    public static int halfSort(int[] arr,int num)
    {
        int max,min,mid;
        max=arr.length-1;
        min=0;
        mid=(max+min)/2;
        while(arr[mid]!=num)
        {
            if(arr[mid]>num)
            {
                max=mid-1;
            }
            else if(arr[mid]<num)
            {
                min=mid+1;
            }

            if(min>max) return -1;

            mid=(max+min)/2;

        }

        return mid;
    }
    public static void printArr(int[] arr)
    {
        System.out.print("[");
        for (int i=0;i<arr.length;i++)
        {
            System.out.print(arr[i]+" ");
        }
        System.out.println("]");
    }
}

class ArrayTest
{
    public static void main(String[] args)
    {
        int[] arr = {89,70,66,110,4,3,6,2,1,0};
        //ArrayTool.bubbleSort(arr);
        ArrayTool.selectSort(arr);

        ArrayTool.printArr(arr);
        int ans=ArrayTool.halfSort(arr,66);

        int max=ArrayTool.getMax(arr);
        int min=ArrayTool.getMin(arr);
         System.out.println("ans="+ans+",max="+max+",min="+min);
    }
}

之所以要在工具类各个函数中用static ，一是因为这些函数都是用来给各个对象调用的公用函数，谁都可以用，二是因为，它们用new关键字创建对象后对象内根本没有封装什么数据，这个新创建出的对象仅仅是为了执行一次这些函数，如果加上static，直接用类名就可以调用，十分方便。