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