---------------------- 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培训、期待与您交流! ----------------------