黑马程序员技术交流社区
标题:
java中的static用法有哪些
[打印本页]
作者:
_王涛
时间:
2013-3-22 16:48
标题:
java中的static用法有哪些
本帖最后由 _王涛 于 2013-3-22 21:52 编辑
我们知道,java中
static
关键字有时候是一个不可缺少的字眼,那么在java中它到底都能够修饰什么呢?该什么时候用呢?有些情况下用了static又没有什么明显好处,有谁可以详细的介绍一下“static”呢?举例说明,越详细越好,回答问题有积分的哦!!
作者:
陈原野
时间:
2013-3-22 16:58
这个有点像“全局”的概念。
public class MyClass{
public static void aStaticMethod() { ... }; //静态方法
public void aNonStaticMethod() { ... } ; //非静态方法
...
}
当你定义了一个类,如果里面的方法或变量定义为static的,那么该方法或函数对于该类的对象只有一个,因此可以用类名来引用并访问,比如MyClass.aStaticMethod()
而非静态的方法或变量,你是必须创建一个该类的新的对象的,比如上面的非静态方法,就必须用new MyClass().aNonStaticMethod( ).
说起来,这个很好理解的。
举个简单例子,你买了某个品牌的小汽车,你的小汽车对于这个品牌的车子就应该创建个对象,你开车,自己修车都应该是非静态方法。
而街上那些汽车修理店对你这种牌子的车所有来修车的来说是公共的,他们的修车,洗车这些方法应该是静态方法。
另外,还有一些规则,比如静态方法内部不能有非静态方法,而非静态方法内是可以用静态方法的,这就要你多练习来掌握了
作者:
我手心里的宝
时间:
2013-3-22 17:00
static 可以修饰属性 方法 内部类
修饰属性: public static int age=15;
这样修饰属性之后,age就是类的属性了 不管new 多少对象,所有对象共享一份age,不过哪个对象对其修改,age都会变化
修饰方法:
修饰的方法为静态方法,可以直接通过类名调用:例如:Arrays.asList(collection);
修饰类:只能修饰内部类
修饰内部类之后,访问内部类可以直接这样new 对象 Outer.Inner obj=new Outer.Iner();
具体的你看毕老师的讲解去吧 呵呵
作者:
戴乾刚
时间:
2013-3-22 17:09
被static修饰的成员变量和成员方法独立于该类的任何对象。也就是说,它不依赖类特定的实例,被类的所有实例共享。只要这个类被加载,Java虚拟机就能根据类名在运行时数据区的方法区内找到他们。因此,static对象可以在它的任何对象创建之前访问,无需引用任何对象。
static变量前可以有private修饰,表示这个变量可以在类的静态代码块中,或者类的其他静态成员方法中使用(当然也可以在非静态成员方法中使用),但是不能在其他类中通过类名来直接引用,这一点很重要。实际上你需要搞明白,private是访问权限限定,static表示不要实例化就可以使用
用static修饰的代码块表示静态代码块,当Java虚拟机(JVM)加载类时,就会执行该代码块
1.static变量
按照是否静态的对类成员变量进行分类可分两种:一种是被static修饰的变量,叫静态变量或类变量;另一种是没有被static修饰的变量,叫实例变量。两者的区别是:
对于静态变量在内存中只有一个拷贝(节省内存),JVM只为静态分配一次内存,在加载类的过程中完成静态变量的内存分配,可用类名直接访问(方便),当然也可以通过对象来访问(但是这是不推荐的)。对于实例变量,没创建一个实例,就会为实例变量分配一次内存,实例变量可以在内存中有多个拷贝,互不影响(灵活)。
2.static方法
静态方法可以直接通过类名调用,任何的实例也都可以调用,因此静态方法中不能用this和super关键字,不能直接访问所属类的实例变量和实例方法(就是不带static的成员变量和成员成员方法),只能访问所属类的静态成员变量和成员方法。因为static方法独立于任何实例,因此static方法必须被实现,而不能是抽象的abstract。
3.static代码块
static代码块也叫静态代码块,是在类中独立于类成员的static语句块,可以有多个,位置可以随便放,它不在任何的方法体内,JVM加载类时会执行这些静态的代码块,如果static代码块有多个,JVM将按照它们在类中出现的先后顺序依次执行它们,每个代码块只会被执行一次。
作者:
kingsummerlucky
时间:
2013-3-22 17:37
static表示“全局”或者“静态”的意思,用来修饰成员变量和成员方法,也可以形成静
态static代码块,但是Java语言中没有全局变量的概念。
被static修饰的成员变量和成员方法独立于该类的任何对象。也就是说,它不依赖类
特定的实例,被类的所有实例共享。只要这个类被加载,Java虚拟机就能根据类名在运行
时数据区内找到他们。因此,static对象可以在它的任何对象创建之前访问,无需引用任
何对象。
用public修饰的static成员变量和成员方法本质是全局变量和全局方法,当声明类的
对象时,不生成static变量的副本,而是类的所有实例共享同一个static变量。
static变量前可以有private修饰,表示这个变量可以在类的静态代码块中,或者类的
其他静态成员方法中使用,当然也可以在非静态成员方法中使用,但是不能在其他类中通
过类名来直接引用,这一点很重要。实际上你需要搞明白,private是访问权限限定,
static表示不要实例化就可以使用,这样就容易理解多了。static前面加上其它访
问权限关键字的效果也以此类推。
static修饰的成员变量和成员方法习惯上称为静态变量和静态方法,可以直接通过类
名来访问,访问语法为:
类名.静态方法名(参数列表...)
类名.静态变量名
用static修饰的代码块表示静态代码块,Java虚拟机(JVM)加载类时,采用先加载静
态的,再加载其它的代码。所以马上就会执行static代码中的内容。
1、static变量
按照是否静态的对类成员变量进行分类可分两种:一种是被static修饰的变量,叫静
态变量或类变量;另一种是没有被static修饰的变量,叫实例变量。两者的区别是:
对于静态变量在内存中只有一个拷贝(节省内存),JVM只为静态分配一次内存,在加
载类的过程中完成静态变量的内存分配,可用类名直接访问(方便),当然也可以通过对
象来访问(但是这是不推荐的)。
对于实例变量,每创建一个实例,就会为实例变量分配一次内存,实例变量可以在内
存中有多个拷贝,互不影响(灵活)。
2、静态方法
静态方法可以直接通过类名调用,任何的实例也都可以调用,因此静态方法中不能用
this和super关键字,不能直接访问所属类的实例变量和实例方法(就是不带static的成员
变量和成员方法),只能访问所属类的静态成员变量和成员方法。因为实例成员与特
定的对象关联!这个需要去理解,想明白其中的道理,不是记忆!!!
因为static方法独立于任何实例,因此static方法必须被实现,而不能是抽象的
abstract。
3、static代码块
static代码块也叫静态代码块,是在类中独立于类成员的static语句块,可以有多个,\
位置可以随便放,它不在任何的方法体内,JVM加载类时会执行这些静态的代码块,如果
static代码块有多个,JVM将按照它们在类中出现的先后顺序依次执行它们,每个代码块
只会被执行一次。例如:
public class Test5 {
private static int a;
private int b;
static {
Test5.a=3;
System.out.println(a);
Test5 t=new Test5();
t.f();
t.b=1000;
System.out.println(t.b);
}
static {
Test5.a=4;
System.out.println(a);
}
public static void main(String[] args) {
}
static {
Test5.a=5;
System.out.println(a);
}
public void f(){
System.out.println("hhahhahah");
}
}
运行结果:
3
hhahhahah
1000
4
5
利用静态代码块可以对一些static变量进行赋值,最后再看一眼这些例子,都一个
static的main方法,这样JVM在运行main方法的时候可以直接调用而不用创建实例。
作者:
王瑞
时间:
2013-3-22 17:39
看看我的学习日志,希望对你有帮助
3.6 static(静态)关键字
static(静态)关键字:
用于修饰成员(成员变量和成员函数)
被修饰后的成员有以下特点:
•随着类的加载而加载
也就说:静态会随着类的消失而消失。说明它的生命周期最长。
•优先于对象存在
明确一点:静态是先存在。对象是后存在的。
•被所有对象所共享
•可以直接被类名调用
静态方法使用注意:
1,静态方法只能访问静态成员。
非静态方法既可以访问静态也可以访问非静态。
2,静态方法中不可以定义this,super关键字。
因为静态优先于对象存在。所以静态方法中不可以出现this。
3,主函数是静态的。
实例变量和类变量的区别:
1,存放位置。
类变量随着类的加载而存在于方法区中。
实例变量随着对象的建立而存在于堆内存中。
2,生命周期:
类变量生命周期最长,随着类的消失而消失。
实例变量生命周期随着对象的消失而消失。
静态的利弊
利处:对对象的共享数据进行单独空间的存储,节省空间。没有必要每一个对象中都存储一份。可以直接被类名调用。
弊端:生命周期过长。访问出现局限性。(静态虽好,但是只能访问静态。)
什么使用静态?
要从两方面下手:
因为静态修饰的内容有成员变量和函数。分析这两种情况。
什么时候定义静态变量(类变量)呢?
当对象中出现共享数据时,该数据被静态所修饰。(所有对象都有这个共性所以共享)
对象中的特有数据要定义成非静态存在于堆内存中。(就是每个对象不同的没有对象的内容,不能定义成静态)
什么时候定义静态函数呢?(静态函数只能定义静态)
当功能内部没有访问到非静态数据(对象的特有数据,如不同人的名字),那么该功能可以定义成静态的。
演示代码:
class Person
{
String name;//成员变量,实例变量。没有被静态修饰,对象建立前不存在
static String country = "CN";//静态的成员变量,属于类变量。因为每个Person都有CN的国籍,所以直接把这个变量被静态修饰,这样被所用对象共享,随着类的加载而加载并且优先于对象存在(对象建立前就有,建立后随着对象加载而加载),可以直接被类名调用
public static void show()//被静态修饰的方法。为什么可以用静态修饰,因为功能内部没有访问到非静态数据(对象的特有数据,如不同人的名字),如果下面的输出语句里面有name值的输出,函数就不能用static修饰
{
System.out.println("::::");//括号内不能+name如("::::"+name),这样语法错误。因为name默认为this.name,this.super语句不能用于静态语句中。原因是静态在String name之前存在于方法区之中,不能调用非静态的变量。
//this.haha();语法错误,因为this.super语句不能用于静态语句中。
}
public void haha()
{}
}
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); //没有对象,但是county是静态变量,所以可以直接被类名调用。
Person.show();//匿名函数调用
}
}
作者:
王瑞
时间:
2013-3-22 17:40
还有一些~~~
扩展知识:
堆区:
1.存储的全部是对象,每个对象都包含一个与之对应的class的信息。(class的目的是得到操作指令)
2.jvm只有一个堆区(heap)被所有线程共享,堆中不存放基本类型和对象引用,只存放对象本身
栈区:
1.每个线程包含一个栈区,栈中只保存基础数据类型的对象和自定义对象的引用(不是对象),对象都存放在堆区中
2.每个栈中的数据(原始类型和对象引用)都是私有的,其他栈不能访问。
3.栈分为3个部分:基本类型变量区、执行环境上下文、操作指令区(存放操作指令)。
方法区:
1.又叫静态区,跟堆一样,被所有的线程共享。方法区包含所有的class和static变量。
2.方法区中包含的都是在整个程序中永远唯一的元素,如class,static变量。
被静态修饰的变量存在于方法区
Main主函数:
主函数:是一个特殊的函数。作为程序的入口,可以被jvm调用。
定义:
主函数的定义:
public:代表着该函数访问权限是最大的。(需要被虚拟机)
static:代表主函数随着类的加载就已经存在了。(调用对象之前就已经存在)
void:主函数没有具体的返回值。
main:不是关键字,但是是一个特殊的单词,可以被jvm识别。
(String[] args):函数的参数,参数类型是一个数组,该数组中的元素是字符串。字符串类型的数组。args是名字,写这个是因为早期写arguments,简写成args。这个是可以改的。因为大家都这样写,为了可读性,就写成args了。
主函数是固定格式的:目的是被jvm识别。Jvm只识别这个。
class MainDemo
{
public static void main(String[] args)//args是一个数组。
{
System.out.println(args);//输出的是一个哈希值,显示的是args在内存中的地址值。里面每一个值都是null
System.out.println(args.length);//输出数组的长度,为0
//由此可见,main被调用的时候,jvm在调用主函数时,传入的是new String[0]
String[] arr = {"hah","hhe","heihei","xixi","hiahia"};//给数组装数据。
MainTest.main(arr);//执行MainTest中的main函数
}
}
class MainTest
{
public static void main(String[] args)//虽然有两个主函数,但是在两个类中,所以语句合法
{
for(int x=0; x<args.length; x++)
System.out.println(args[x]);//依次打印出数组中的每个数组值。
}
}
静态使用的工具应用(ArrayTool):
每一个应用程序中都有共性的功能,可以将这些功能进行抽取,独立封装。以便复用。
虽然可以通过建立ArrayTool的对象使用这些工具方法,对数组进行操作。
发现了问题:
1,对象是用于封装数据的,可是ArrayTool对象并未封装特有数据。
2,操作数组的每一个方法都没有用到ArrayTool对象中的特有数据。
这时就考虑,让程序更严谨,是不需要对象的。
可以将ArrayTool中的方法都定义成static的。直接通过类名调用即可。
public class ArrayTool
{
private ArrayTool(){}//私有化构造函数,不让外界使用。将方法都静态后,可以方便于使用,但是该类还是可以被其他程序建立对象的。为了更为严谨,强制让该类不能建立对象。可以通过将构造函数私有化完成。记住这个私有化类的格式,是用构造函数来做的。
public static int getMax(int[] arr)//定义一个数组求最大值。被修饰成静态是因为没有访问到对象的特有属性。好处是随着类的加载而加载,优先于对象存在,被所有对象所共享,可以直接被类名调用。
{
int max = 0;
for(int x=1; x<arr.length; x++)
{
if(arr[x]>arr[max])
max = x;
}
return arr[max];
}
public static int getMin(int[] arr)// 每一个应用程序中都有共性的功能,可以将这些功能进行抽取,独立封装。以便复用。
{
int min = 0;
for(int x=1; x<arr.length; x++)
{
if(arr[x]<arr[min])
min = x;
}
return arr[min];
}
public static void selectSort(int[] arr)
{
for (int x=0; x<arr.length-1 ; x++ )
{
for(int y=x+1; y<arr.length; y++)
{
if(arr[x]>arr[y])
{
swap(arr,x,y);
}
}
}
}
public static void bubbleSort(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])
{
swap(arr,y,y+1);
}
}
}
}
private static void swap(int[] arr,int a,int b)
{
int temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
public static void printArray(int[] arr)
{
System.out.print("[");
for(int x=0; x<arr.length; x++)
{
if(x!=arr.length-1)
System.out.print(arr[x]+", ");
else
System.out.println(arr[x]+"]");
}
}
}
接下来,将ArrayTool.class文件发送给其他人,其他人只要将该文件设置到classpath路径下,就可以使用该工具类。直接调用,如ArrayTool.getMax(arr);可以直接调用
class ArrayToolDemo
{
public static void main(String[] args)
{
int[] arr = {3,1,87,32,8};
int max = ArrayTool.getMax(arr);
System.out.println("max="+max);
/*
ArrayTool tool = new ArrayTool();
int max = tool.getMax(arr);//上一个演示代码中构造函数ArrayTool()已经被private私有化,不能简历对象了,所以这样的语句会编译失败。只能直接使用匿名函数调用ArrayTool.getMax(arr);
System.out.println("max="+max);
int min = tool.getMin(arr);
System.out.println("min="+min);
tool.printArray(arr);
tool.selectSort(arr);
tool.printArray(arr);
int[] arr1 = {};
ArrayTool tool1 = new ArrayTool();
*/
}
}
作者:
Walking Walking
时间:
2013-3-22 18:23
把毕老师的视频找出来好好看看,你就明白了
作者:
陈雨
时间:
2013-3-22 20:20
毕老师的视频里面讲的蛮详细的.好像是6天的视频吧,就是类讲完了,接下来就讲static了.我正好看到这里,班门弄斧一下.
1.static属于成员变量修饰类用的.它不是存放在栈、堆里的,而是存放在方法区的。比如说一类person里面有一属性国籍为CN,所有的对象中国人来说他们的国籍都是CN,所以避免每个对象初始化时都赋予CN的国籍,浪费内存,而将CN提取出来放在方法区里,设置为静态变量,放在这里相当于是共享资料,对象用时就从这里提取出来。
2.坏处就是静态变量的生命周期,类在它在,类亡它亡,也就是只要类一建立,Static变量就自动加载了,即使对象还没建立.所以对于那些不是固定的属性,用Static建立就会很占内存.
欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/)
黑马程序员IT技术论坛 X3.2