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

- 日理万妓 2022-02-27 10:22 184阅读 0赞

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();
        }
    {

这段代码运行会报错：

![20190327142824945.png][]

原因是，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]
        }
    }

![20190327154523923.png][]

上图倒数第二行里，输入类名后接着输入三个参数就会把这三个参数传入到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);
        }
    
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NodXl1ZGV4aWFvd3U_size_16_color_FFFFFF_t_70][]

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，直接用类名就可以调用，十分方便。

[20190327142824945.png]: /images/20220227/b66d1c5ff5f24882a13a1795c44cf0cf.png
[20190327154523923.png]: /images/20220227/77400c24969a4b90956f5b76f0101377.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NodXl1ZGV4aWFvd3U_size_16_color_FFFFFF_t_70]: /images/20220227/a841178dbcf84ef99c0b53a9cb183bcb.png