---------------------- android培训、java培训、期待与您交流！ ----------------------
3.6 static（静态）关键字
（1）static关键字用于修饰成员（成员变量和成员函数）。
（2）被修饰后的成员具备以下特点：
①随着类的加载而加载。随着类的消失而消失。说明它的生命周期最长。所以不能把所有的都用静态变量。
②优先于对象存在。
静态是先存在的，对象是后存在的。
③被所有对象所共享。
④可以直接被类名调用。
（3）使用注意：
①静态方法只能访问静态成员
非静态方法即可以访问静态成员，也可以访问非静态成员。
②静态方法中不可以写this，super关键字
因为静态优先于对象存在，所以静态方法中不可以出现this。
③主函数是静态的
当成员被静态修饰后，就多了一种调用方式，除了可以被对象调用外，还可以直接被类名调用。类名.静态成员。
方法区、共享区
class StaticDemo
{
public static void main(String[] args)
{
//Person p=new Person();
//p.name="zhangsan";
//p.show();
//System.out.println(p.country);
System.out.println(Person.country);/*当成员被静态修饰后，就多了一种调用方式，
除了可以被对象调用外，还可以直接被类名调用。类名.静态成员。
*/
}
}
class Person
{
String name;//成员变量，实例变量，创建了实例才会出现内存中
static String country="CN";//静态的成员变量，类变量，只要加载类，就存在
public void show()
{
System.out.println(name+"::"+country);
}
}
实例变量和类变量的区别：
（1）存放位置：
类变量随着类的加载而存在于方法区中。
实例变量随着对象的建立而存在于堆内存中。
（2）生命周期：
类变量的生命周期最长，随着类的消失而消失。
实例变量生命周期随着对象的消失而消失。
静态可以修饰变量，也可修饰方法。
静态有利有弊：
利：
（1）对对象的共享数据进行单独空间的存储，节省空间，没必要让每一个对象中都存储一份。
（2） 可以被类名调用。
弊：
（1）生命周期过长。
（2）访问出现局限性。（静态虽好，但是只能访问静态）
Main函数：
public static void main(String[] args)
主函数是一个特殊的函数。作为程序入口，可以被JVM（虚拟机）调用。
主函数的定义：
Public：代表该函数的访问权限是最大的。
Static：代表主函数随着类的加载而加载。
Void：主函数没有具体的返回值。
Main：不是关键字，但是是一个特殊的单词，可以被jvm识别。
(String[] args)：函数的参数，参数类型是一个数组，该数组中的元素是字符串。字符串类型是数组。
主函数的格式是固定的，能被jvm识别。
主函数的args能改之外，其他的都不能改，否则就不是主函数了。
class MainDemo
{
public static void main(String[] args)
{
System.out.println(args);
System.out.println(args.length);
}
}
结果：
[Ljava.lang.String;@1ec8909
0
说明了：jvm在调用主函数时，传入的是new String[0]；
什么时候使用静态？？？？
（1）什么时候使用静态变量？
当对象中出现共享数据（相同的数据，不是相同的属性）时，该数据用静态。
对象中的特有数据要定义成非静态，存在于堆内存中。
（2）什么时候使用静态函数？
当功能（函数）内部没有访问到非静态数据（对象特有的数据）。
那么该功能就可以定义成静态的。
class MainDemo2
{
public static void main(String[] args)
{
Person p=new Person();
p.show();
}
}
class Person
{
String name;
public void show()
{
System.out.println("haha");
}
}
结果：
haha
（1）但是show函数就没访问非静态变量name，所以show函数可以定义成静态的。
（2）但是，show函数定义成静态的之后。
Person p=new Person();
p.show();
就没有必要了，可以直接用：Person.show();代替。
静态的应用------工具类
每一个应用程序中都有共性的功能。
可以将这些功能进行抽取，独立封装。以便复用。
class Bijiao
{
public static int getMin(int[] arr)
{
int min=0;
for (int a=0;a<arr.length ;a++ )
{
if (arr[a]<arr[min])
{
min=a;
}
}
return arr[min];
}
public static int getMax(int[] arr)
{
int Max=0;
for (int a=0;a<arr.length ;a++ )
{
if (arr[a]>arr[Max])
{
Max=a;
}
}
return arr[Max];
}
public static void selectSort(int[] arr)//排序
{
for (int x=0;x<arr.length ;x++ )
{
for (int y=x+1;y<arr.length ;y++ )
{
if (arr[x]>arr[y])
{
int temp=arr[x];
arr[x]=arr[y];
arr[y]=temp;
}
}
}
}
public static void maopao(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])
{
int temp=arr[y];
arr[y]=arr[y+1];
arr[y+1]=temp;
}
}
}
}
}
class ArrayToolDemo
{
public static void main(String[] args)
{
int[] arr={5,8,9,77,66,99,48,150};//定义数组
Bijiao tool=new Bijiao();//创建对象
int max=tool.getMax(arr);//调用方法
System.out.println("max="+max);
int min=tool.getMin(arr);
System.out.println("min="+min);
}
}
虽然可以通过建立Bijiao的对象使用这些工具，对数组进行操作。但是有一些问题：
（1）对象使用与封装数据的，可是Bijiao对象并未封装特有数据。
（2）操作数组的每一个方法都没有用到Bijiao对象中的特有数据。
这时可以把Bijiao中的方法都定义成static的，直接通过调用类名即可。
class ArrayToolDemo
{
public static void main(String[] args)
{
int[] arr={5,8,9,77,66,99,48,150};//定义数组
int max=Bijiao.getMax(arr);
System.out.println("max="+max);
int min=Bijiao.getMin(arr);
System.out.println("min="+min);
}
}
对象方法都静态后，可以方便于使用，但是该类还是可以被其他程序建立对象的。
为了更加严谨，强制该类不能建立对象。
可以通过将构造函数私有化完成。
上面的Bijiao类中有一个构造函数，把它私有化
private Bijiao（）{}
/**
（对类的描述信息）
*/
帮助文档的制作-----javadoc
类必须是public类型的。
一个类中默认会有一个空参数的构造函数。
它的权限和类的权限是一致的。
也就是说：默认的构造函数权限是随着类的变换而变化的。
---------------------- android培训、java培训、期待与您交流！ ----------------------