JAVA 基础 (static关键字)
2015-08-10 20:29
218 查看
1、 static(静态)关键字
用于修饰成员(成员变量和成员函数)
普通的成员变量也叫实例变量如:String name;
静态的成员变量也叫类变量如:staticString country=”CN”;
实例变量和类变量的区别:
①、 存放位置:
类变量随着类的加载而存在于方法区中;
实例变量随着对象的建立而存在于堆内存中。
②、 生命周期:
类变量生命周期最长,随着类的消失而消失;
实例变量生命周期随着对象的消失而消失。
被修饰后的成员具备以下特点:
①、 随着类的加载而加载(类加载了,成员就占内存,在共享区也可以叫方法区、数据区。而且静态会随着类的消失而消失);
②、 优先于对象存在;
③、 被所以对象所共享;
④、 可以直接被类名调用(格式:类名.静态成员)。
注意:
①、 静态方法只能访问静态成员(成员包括静态变量和静态方法),非静态方法既可以访问静态也可以访问非静态;
②、 静态方法中不可以写this,super关键字(因为静态优先于对象,而这些关键字用于对象);
③、 主函数是静态的:
public static void main(String[] args)
主函数:是一个特殊的函数。作为程序的入口,可以被Jvm调用,是程序的开始。
主函数的定义:
public:代表着该函数访问权限是最大的。
static:代表函数随着类的加载就已经存在了。
void:主函数没有具体的返回值。
main:不是关键字,但是是一个特殊的单词,可以被Jvm识别。
(String[] arr):函数的参数,参数是一个字符串类型的数组。
主函数是固定格式的:Jvm识别。
静态的利弊:
利处:对对象的共享数据进行单独空间的存储,节省空间。没有必要每个对象中都存储一份。
可以直接被类名调用。
弊端:生命周期过长。访问有局限性(只能访问静态)。
什么时候定义静态变量(类变量)呢?
答:当对象中出现共享数据(不是属性)时,该数据被静态所修饰。对象中的特有数据要定义成非静态存在于堆内存中。
什么时候定义静态函数呢?
答:当功能内部没有访问到非静态数据(对象的特有数据),那么该功能可以定义成静态的。
静态的应用:例ArrayTool.java和ArrayToolDemo.java 两个文件不在同一目录下时,要通过设置classpath,让虚拟机进行编译。
ArrayTool.java
/*
静态的应用:每个应用程序中都有共性的功能,可以将这些功能进行抽取,独立封装,以便复用。
虽然可以通过建立ArrayTool的对象使用这些工具方法,对数组进行操作。但是:
1、对象时用于封装数据的,可是ArrayTool对象并未封装特有数据。
2、操作数组的每一个方法都没有用的ArrayTool对象中的特有数据。
这时就考虑,让程序更严谨,是不需要对象的。
可以将ArrayTool中的方法都定义成static的,直接通过类名调用即可。
将方法都静态后,可以方便使用,但是该类还是可以被其他程序建立对象的(因为类中有系统默认的构造函数)。
为了更为严谨,强制让该类不能建立对象。可以通过将构造函数私有化完成。
即:private ArrayTool(){}
*/
/**
这是一个可以对数组进行操作的工具类,该类中提供了,获取最值,排序等功能。
@author FLJ
@version v1.1
*/
public class ArrayTool
{
/**
空参数构造函数。
*/
privateArrayTool(){}
/**
获取一个整形数组中的最大值。
@paramarr 接收一个int类型的数组。
@return会返回一个该数值中最大值。
*/
publicstatic int getMax(int[] arr)
{
int Max=0;
for(int x=0;x<arr.length-1;x++)
{
if(arr[Max]<arr[x])
{
Max=x;
}
}
return arr[Max];
}
/**
获取一个整形数组中的最小值。
@paramarr 接收一个int类型的数组。
@return会返回一个该数值中最小值。
*/
publicstatic int getMin(int[] arr)
{
int Min=0;
for(int x=0;x<arr.length-1;x++)
{
if(arr[Min]>arr[x])
{
Min=x;
}
}
return arr[Min];
}
/**
给int数组进行冒泡排序。
@paramarr 接收一个int类型的数组
*/
publicstatic void bubbleSort(int[] arr) //冒泡排序
{
for(int x=0;x<arr.length-1;x++)
{
for(inty=0;y<arr.length-x-1;y++)
{
if(arr[x]>arr[y])
{
swap(arr,y,y+1);
}
}
}
}
/**
给int数组进行选择排序。
@paramarr 接收一个int类型的数组
*/
publicstatic void selectSort(int[] arr) //选择排序
{
for(int x=0;x<arr.length-1;x++)
{
for(inty=x+1;y<arr.length-1;y++)
{
if(arr[x]>arr[y])
{
swap(arr,x,y);
}
}
}
}
/**
给数组中元素进行位置的置换。
@paramarr 接收一个int类型的数组。
@parama 要置换的位置
@paramb 要置换的位置
*/
privatestatic void swap(int[] arr,int a,int b) //只有该类中的排序用的了此功能,所以,定义成私有的增强隐秘性
{
if(arr[a]>arr)
{
inttemp=arr[a];
arr[a]=arr[b];
arr[b]=temp;
}
}
/**
用于打印数组中的元素。打印形式是:{element1,element2.....}
*/
publicstatic 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]+"}");
}
}
}
ArrayToolDemo.java
/*
静态的应用
*/
class ArrayToolDemo
{
publicstatic void main(String[] args)
{
int[] arr={3,6,87,3,4,56};
int max=ArrayTool.getMax(arr);
System.out.println("Max="+max);
/*
ArrayTool tool=new ArrayTool();
int max=tool.ge
b9d8
tMax(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);
*/
}
}
[b]2、 说明书
将class文件发送给其他人,他人只要将该文件设置到classpath路径下,就可以使用该工具类。但要想知道类中的方法,就要使用说明书。
JAVA的说明书通过文档注释来完成。【/** */】
用javadoc来生成帮助文档,格式:javadoc –d myhelp –author-version ArrayTool.java qi其中-d是添加目录的参数;其中myhelp,若当前目录中没有这个文件夹,就会生成一个myhelp文件夹,把需要的文件放入其中;其中–author –version,是要求生成的文件中体现作者和版本。还有,要注意文件中类必须是public型,否则获取权力达不到,无法生成。
一个类中默认会有一个空参数的构造函数。这个默认的构造函数的权限和所属类一致。
如果类被public修饰,那么默认的构造函数也带public修饰符;如果类没有被public修饰,那么默认的构造函数,也没有public修饰。
默认构造函数的权限是随着类的变化而变化的。
注意:自己又写出来的空构造函数,就不是系统默认的构造函数了。
3、 静态代码块
格式:
static
{
静态代码块中的执行语句。
}
特点:随着类的加载而执行,只执行一次,并优先于主函数。
用于对类进行初始化。
区分构造代码块,构造函数。例:staticK.java
/*
静态代码块,以及与构造代码块的区别
*/
class staticCode
{
intnum=9;
staticCode() //没有创建与之对应的对象,所以不会执行
{
System.out.println("b");
}
static //静态代码块。给类初始化
{
System.out.println("a");
//System.out.println("a"+num); 是不正确的,不可以引用非静态变量
}
{ //构造代码块,给对象初始化
System.out.println("c");
}
staticCode(intx) //构造函数,给对应对象进行初始化
{
System.out.println("d");
}
publicstatic void show()
{
System.out.println("show run");
}
}
class staticK
{
publicstatic void main(String[] args)
{
new staticCode(4); //结果是:a c d
staticCode.show();
}
}
/*
class staticK
{
static
{
System.out.println("b"); //静态代码块优先于主函数
}
publicstatic void main(String[] args)
{
new staticCode();
new staticCode(); //静态代码块只运行一次,所以,不再打印a
System.out.println("over");
}
static
{
System.out.println("c");
}
}
//运行结果是:b
c
a
over
*/
对象的初始化过程:先是默认初始化,再是显示初始化,再是构造代码块初始化,再是构造函数初始化。例如:Person p=new Person(“zhangsan”,20);
这句话都做了什么事情?
答:①、因为new用到了Person.class,所以会先找到Person.class文件并加载到内存中。
② 、执行该类中的static代码块,如果有的话,给Person.class类进行初始化。
③、在堆内存中开辟空间,分配内存地址。
④、在堆内存中建立对象的特有属性,并进行默认初始化。
⑤、对属性进行显示初始化。
⑥、对对象进行构造代码块初始化。
7、对对象进行对应的构造函数初始化。
⑧、将内存地址赋给栈内存中的p变量。
非静态一般是用this,this.变量,this.方法;静态一般是用类名,类名.变量,类名.方法。通常省略了this.和类名.
4、设计模式:解决某一类问题最行之有效的方法。Java中有23种设计模式。
单例设计模式:解决一个类在内存只存在一个对象。
怎样保证对象唯一:
其一,为了避免其他程序过多建立该类对象,先禁止其他程序建立该类对象;
其二,为了让其他程序可以访问到该类对象,只好在本类中,自定义一个对象;
其三,为了方便其他程序对自定义对象的访问,可以对外提供一些访问方式。
例:SingleDemo.java,,,SingleDemo1.java
SingleDemo.java
/*
单例设计模式一(开发常用的),代码的体现
步骤:
1、将构造函数私有化
2、在类中创建一个本类对象
3、提供一个方法可以获取到该对象
重要的几部代码,饿汉式(先初始化对象,Single类一进内存,就加载对象):
privateSingle(){}
privatestatic Single s=new Single();
publicstatic Single getInstance()
{
retrun s;
}
对于事物该怎么描述,还怎么描述;
当需要将该事物的对象保证在内存中唯一时,就将以上的三步加上即可。
*/
/*class Single
{
privateSingle(){}
privatestatic Single s=new Single();
publicstatic Single getInstance() //只有一个对象,所以不需要设set方法
{
retrun s;
}
}*/
class SingleDemo
{
publicstatic void main(String[] args)
{
//Single ss=Single.getInstance();
/*Strdent s1=new Student(); 不是唯一对象的情况下
s1.setAge(32);
Strdent s2=new Student();
s2.setAge(12); */
Student s1=Student.getStudent(); //在类中加私有对象后,s1和s2指向同一对象
s1.setAge(15);
System.out.println(s1);
Student s2=Student.getStudent();
System.out.println(s2);
}
}
class Student
{
privateint age;
privatestatic Student s=new Student();
privateStudent(){}
publicstatic Student getStudent()
{
return s;
}
publicvoid setAge(int age)
{
this.age=age;
}
publicint getAge()
{
return age;
}
}
SingleDemo1.java
/*
单例设计模式方式二
对象是方法被调用时,才初始化,也叫做对象的延时加载。成为:懒汉式。
Single类进内存,对象还没有存在,只有调用了getInstance方法时,才建立对象。
*/
class Single
{
privatestatic Single s=null;
privateSingle(){}
publicstatic Single getInstance()
{
if(s==null)
{
synchronized(String.class) //synchronized是上锁的功能,运用到多线程的知识,面试常考
{
if(s==null)
s=new Single();
}
}
return s;
}
}
class SingleDemo1
{
publicstatic void main()
{
System.out.println("over");
}
}
用于修饰成员(成员变量和成员函数)
普通的成员变量也叫实例变量如:String name;
静态的成员变量也叫类变量如:staticString country=”CN”;
实例变量和类变量的区别:
①、 存放位置:
类变量随着类的加载而存在于方法区中;
实例变量随着对象的建立而存在于堆内存中。
②、 生命周期:
类变量生命周期最长,随着类的消失而消失;
实例变量生命周期随着对象的消失而消失。
被修饰后的成员具备以下特点:
①、 随着类的加载而加载(类加载了,成员就占内存,在共享区也可以叫方法区、数据区。而且静态会随着类的消失而消失);
②、 优先于对象存在;
③、 被所以对象所共享;
④、 可以直接被类名调用(格式:类名.静态成员)。
注意:
①、 静态方法只能访问静态成员(成员包括静态变量和静态方法),非静态方法既可以访问静态也可以访问非静态;
②、 静态方法中不可以写this,super关键字(因为静态优先于对象,而这些关键字用于对象);
③、 主函数是静态的:
public static void main(String[] args)
主函数:是一个特殊的函数。作为程序的入口,可以被Jvm调用,是程序的开始。
主函数的定义:
public:代表着该函数访问权限是最大的。
static:代表函数随着类的加载就已经存在了。
void:主函数没有具体的返回值。
main:不是关键字,但是是一个特殊的单词,可以被Jvm识别。
(String[] arr):函数的参数,参数是一个字符串类型的数组。
主函数是固定格式的:Jvm识别。
静态的利弊:
利处:对对象的共享数据进行单独空间的存储,节省空间。没有必要每个对象中都存储一份。
可以直接被类名调用。
弊端:生命周期过长。访问有局限性(只能访问静态)。
什么时候定义静态变量(类变量)呢?
答:当对象中出现共享数据(不是属性)时,该数据被静态所修饰。对象中的特有数据要定义成非静态存在于堆内存中。
什么时候定义静态函数呢?
答:当功能内部没有访问到非静态数据(对象的特有数据),那么该功能可以定义成静态的。
静态的应用:例ArrayTool.java和ArrayToolDemo.java 两个文件不在同一目录下时,要通过设置classpath,让虚拟机进行编译。
ArrayTool.java
/*
静态的应用:每个应用程序中都有共性的功能,可以将这些功能进行抽取,独立封装,以便复用。
虽然可以通过建立ArrayTool的对象使用这些工具方法,对数组进行操作。但是:
1、对象时用于封装数据的,可是ArrayTool对象并未封装特有数据。
2、操作数组的每一个方法都没有用的ArrayTool对象中的特有数据。
这时就考虑,让程序更严谨,是不需要对象的。
可以将ArrayTool中的方法都定义成static的,直接通过类名调用即可。
将方法都静态后,可以方便使用,但是该类还是可以被其他程序建立对象的(因为类中有系统默认的构造函数)。
为了更为严谨,强制让该类不能建立对象。可以通过将构造函数私有化完成。
即:private ArrayTool(){}
*/
/**
这是一个可以对数组进行操作的工具类,该类中提供了,获取最值,排序等功能。
@author FLJ
@version v1.1
*/
public class ArrayTool
{
/**
空参数构造函数。
*/
privateArrayTool(){}
/**
获取一个整形数组中的最大值。
@paramarr 接收一个int类型的数组。
@return会返回一个该数值中最大值。
*/
publicstatic int getMax(int[] arr)
{
int Max=0;
for(int x=0;x<arr.length-1;x++)
{
if(arr[Max]<arr[x])
{
Max=x;
}
}
return arr[Max];
}
/**
获取一个整形数组中的最小值。
@paramarr 接收一个int类型的数组。
@return会返回一个该数值中最小值。
*/
publicstatic int getMin(int[] arr)
{
int Min=0;
for(int x=0;x<arr.length-1;x++)
{
if(arr[Min]>arr[x])
{
Min=x;
}
}
return arr[Min];
}
/**
给int数组进行冒泡排序。
@paramarr 接收一个int类型的数组
*/
publicstatic void bubbleSort(int[] arr) //冒泡排序
{
for(int x=0;x<arr.length-1;x++)
{
for(inty=0;y<arr.length-x-1;y++)
{
if(arr[x]>arr[y])
{
swap(arr,y,y+1);
}
}
}
}
/**
给int数组进行选择排序。
@paramarr 接收一个int类型的数组
*/
publicstatic void selectSort(int[] arr) //选择排序
{
for(int x=0;x<arr.length-1;x++)
{
for(inty=x+1;y<arr.length-1;y++)
{
if(arr[x]>arr[y])
{
swap(arr,x,y);
}
}
}
}
/**
给数组中元素进行位置的置换。
@paramarr 接收一个int类型的数组。
@parama 要置换的位置
@paramb 要置换的位置
*/
privatestatic void swap(int[] arr,int a,int b) //只有该类中的排序用的了此功能,所以,定义成私有的增强隐秘性
{
if(arr[a]>arr)
{
inttemp=arr[a];
arr[a]=arr[b];
arr[b]=temp;
}
}
/**
用于打印数组中的元素。打印形式是:{element1,element2.....}
*/
publicstatic 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]+"}");
}
}
}
ArrayToolDemo.java
/*
静态的应用
*/
class ArrayToolDemo
{
publicstatic void main(String[] args)
{
int[] arr={3,6,87,3,4,56};
int max=ArrayTool.getMax(arr);
System.out.println("Max="+max);
/*
ArrayTool tool=new ArrayTool();
int max=tool.ge
b9d8
tMax(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);
*/
}
}
[b]2、 说明书
将class文件发送给其他人,他人只要将该文件设置到classpath路径下,就可以使用该工具类。但要想知道类中的方法,就要使用说明书。
JAVA的说明书通过文档注释来完成。【/** */】
用javadoc来生成帮助文档,格式:javadoc –d myhelp –author-version ArrayTool.java qi其中-d是添加目录的参数;其中myhelp,若当前目录中没有这个文件夹,就会生成一个myhelp文件夹,把需要的文件放入其中;其中–author –version,是要求生成的文件中体现作者和版本。还有,要注意文件中类必须是public型,否则获取权力达不到,无法生成。
一个类中默认会有一个空参数的构造函数。这个默认的构造函数的权限和所属类一致。
如果类被public修饰,那么默认的构造函数也带public修饰符;如果类没有被public修饰,那么默认的构造函数,也没有public修饰。
默认构造函数的权限是随着类的变化而变化的。
注意:自己又写出来的空构造函数,就不是系统默认的构造函数了。
3、 静态代码块
格式:
static
{
静态代码块中的执行语句。
}
特点:随着类的加载而执行,只执行一次,并优先于主函数。
用于对类进行初始化。
区分构造代码块,构造函数。例:staticK.java
/*
静态代码块,以及与构造代码块的区别
*/
class staticCode
{
intnum=9;
staticCode() //没有创建与之对应的对象,所以不会执行
{
System.out.println("b");
}
static //静态代码块。给类初始化
{
System.out.println("a");
//System.out.println("a"+num); 是不正确的,不可以引用非静态变量
}
{ //构造代码块,给对象初始化
System.out.println("c");
}
staticCode(intx) //构造函数,给对应对象进行初始化
{
System.out.println("d");
}
publicstatic void show()
{
System.out.println("show run");
}
}
class staticK
{
publicstatic void main(String[] args)
{
new staticCode(4); //结果是:a c d
staticCode.show();
}
}
/*
class staticK
{
static
{
System.out.println("b"); //静态代码块优先于主函数
}
publicstatic void main(String[] args)
{
new staticCode();
new staticCode(); //静态代码块只运行一次,所以,不再打印a
System.out.println("over");
}
static
{
System.out.println("c");
}
}
//运行结果是:b
c
a
over
*/
对象的初始化过程:先是默认初始化,再是显示初始化,再是构造代码块初始化,再是构造函数初始化。例如:Person p=new Person(“zhangsan”,20);
这句话都做了什么事情?
答:①、因为new用到了Person.class,所以会先找到Person.class文件并加载到内存中。
② 、执行该类中的static代码块,如果有的话,给Person.class类进行初始化。
③、在堆内存中开辟空间,分配内存地址。
④、在堆内存中建立对象的特有属性,并进行默认初始化。
⑤、对属性进行显示初始化。
⑥、对对象进行构造代码块初始化。
7、对对象进行对应的构造函数初始化。
⑧、将内存地址赋给栈内存中的p变量。
非静态一般是用this,this.变量,this.方法;静态一般是用类名,类名.变量,类名.方法。通常省略了this.和类名.
4、设计模式:解决某一类问题最行之有效的方法。Java中有23种设计模式。
单例设计模式:解决一个类在内存只存在一个对象。
怎样保证对象唯一:
其一,为了避免其他程序过多建立该类对象,先禁止其他程序建立该类对象;
其二,为了让其他程序可以访问到该类对象,只好在本类中,自定义一个对象;
其三,为了方便其他程序对自定义对象的访问,可以对外提供一些访问方式。
例:SingleDemo.java,,,SingleDemo1.java
SingleDemo.java
/*
单例设计模式一(开发常用的),代码的体现
步骤:
1、将构造函数私有化
2、在类中创建一个本类对象
3、提供一个方法可以获取到该对象
重要的几部代码,饿汉式(先初始化对象,Single类一进内存,就加载对象):
privateSingle(){}
privatestatic Single s=new Single();
publicstatic Single getInstance()
{
retrun s;
}
对于事物该怎么描述,还怎么描述;
当需要将该事物的对象保证在内存中唯一时,就将以上的三步加上即可。
*/
/*class Single
{
privateSingle(){}
privatestatic Single s=new Single();
publicstatic Single getInstance() //只有一个对象,所以不需要设set方法
{
retrun s;
}
}*/
class SingleDemo
{
publicstatic void main(String[] args)
{
//Single ss=Single.getInstance();
/*Strdent s1=new Student(); 不是唯一对象的情况下
s1.setAge(32);
Strdent s2=new Student();
s2.setAge(12); */
Student s1=Student.getStudent(); //在类中加私有对象后,s1和s2指向同一对象
s1.setAge(15);
System.out.println(s1);
Student s2=Student.getStudent();
System.out.println(s2);
}
}
class Student
{
privateint age;
privatestatic Student s=new Student();
privateStudent(){}
publicstatic Student getStudent()
{
return s;
}
publicvoid setAge(int age)
{
this.age=age;
}
publicint getAge()
{
return age;
}
}
SingleDemo1.java
/*
单例设计模式方式二
对象是方法被调用时,才初始化,也叫做对象的延时加载。成为:懒汉式。
Single类进内存,对象还没有存在,只有调用了getInstance方法时,才建立对象。
*/
class Single
{
privatestatic Single s=null;
privateSingle(){}
publicstatic Single getInstance()
{
if(s==null)
{
synchronized(String.class) //synchronized是上锁的功能,运用到多线程的知识,面试常考
{
if(s==null)
s=new Single();
}
}
return s;
}
}
class SingleDemo1
{
publicstatic void main()
{
System.out.println("over");
}
}
相关文章推荐
- java对世界各个时区(TimeZone)的通用转换处理方法(转载)
- java-注解annotation
- java-模拟tomcat服务器
- java-用HttpURLConnection发送Http请求.
- java-WEB中的监听器Lisener
- Android IPC进程间通讯机制
- Android Native 绘图方法
- Android java 与 javascript互访(相互调用)的方法例子
- 介绍一款信息管理系统的开源框架---jeecg
- 聚类算法之kmeans算法java版本
- java实现 PageRank算法
- PropertyChangeListener简单理解
- 插入排序
- 冒泡排序
- 堆排序
- 快速排序
- 二叉查找树
- [原创]java局域网聊天系统