您的位置：首页 > 编程语言 > Java开发

JAVASE_06天_@面向对象_构造和静态和单例设计模式

2014-03-04 09:21 162 查看
1.关键字static1.1静态:static
用法:是一个修饰符,用于修饰成员(成员变量,,成员函数)------------静态的成员变量,也叫类变量，类方法1.静态内容被类的所有对象所共享..--放在了方法区(共享区,数据区)，2.局部变量无法使用static修饰符3.类名可以直接调用当成员被静态修饰后,就多了一种调用方式,除了可以被对象调用外,还可以直接被类名调用.形式:类名.静态成员
1.2，static特点:
1.随着类的加载而加载.随着类的消失而消失,,,,,说明它的生命周期最长.
类加载时,成员变量(实例变量)不存在,当创建对象时,才存在
2.优先于对象存在
3.被所有对象所共享
4.可以直接被类名所调用1.3，实例变量和类变量的区别:1.存放位置
类变量随着类的加载而存在与方法区中.
实例变量随着对象的建立而存在与堆内存中
2.生命周期
类变量生命周期长,随着类的消失而消失
实例变量生变周期随着对象的消失而消失1.4，静态使用注意事项:
1.静态方法只能访问静态成员.----错误提示:无法从静态上下文中引用非静态变量
非静态方法既可以访问静态也可以访问非静态
2.静态方法中不可以定义this,super关键字.
因为静态优先于对象存在,所以静态方法中不可以出现this.
3.主函数是静态的
静态有利有弊
利处:对对象的共享数据进行单独空间的存储,节省空间.
没有必要每一个对象中都存储一份.
可以直接被类名调用
弊端:上生命周期过长.
访问出现局限性.(静态虽好.只能访问静态）
1.5，java类加载过程（静态变量、成员变量、静态块、静态方法、构造方法）
静态变量——>静态块——>成员变量——>构造代码块——>构造函数——>静态方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
classClassLoad{

staticintnumber=1;
//静态变量(类变量)

intxmember=7;
//成员变量

ClassLoad(){

System.out.println(
"构造函数运行了"
+number+xmember);
//编译通过
}

static{

System.out.println(
"静态代码块运行了"
+number);
//既然能调用说明静态变量先入内存

//System.out.println(xmember);//编译失败,说明成员变量还未初始化

}

{

System.out.println(
"构造代码块运行了"
+number+xmember);
//编译通过
}

publicstaticvoidshow(){

number=number+5;

}

}

publicclassClient{

publicstaticvoidmain(String[]args){

System.out.println(ClassLoad.number);

ClassLoadt2=
new
ClassLoad();

ClassLoad.show();//

}

}
2.主函数main
/*
*主函数:是一个特殊的函数.作为
程序的入口
,可以被jvm调用
*public:代表着该函数访问权限是最大的.
*static:代表主函数随着类的加载就已经存在了.
*void:主函数没有具体的返回值
*main:不是关键字,但是是一个特殊的单词,可以被jvm识别
*(String[]args):函数的参数,字符串类型的数组args是arguments的缩写
*jvm在调用主函数时,传入的是newString[0];
*主函数是固定格式的:JVM识别
*/

public
class
MainDemo{

public
static
void
main(String[]args){

String[]arr={
"heihei"
,
"haha"
,
"hehe"
,
"hiahia"
};

MainTest.main(arr);

}

}

class
MainTest{

public
static
void
main(String[]args){


}

}
3.静态---什么时候使用
1.什么时候定义静态变量(类变量)?
当对象中出现共享数据时(不是相同属性),该数据被静态所修饰
对象中的特有数据要定义成非静态存在于堆内存中
2.什么时候定义静态函数?
当功能内部没有访问到非静态数据(对象的特有数据);4.静态的应用----工具类*静态的应用。*每一个应用程序中都有共性的功能，*可以将这些功能进行抽取，独立封装。*以便复用。**虽然可以通过建立ArrayTool的对象使用这些工具方法，对数组进行操作。*发现了问题：*1，对象是用于封装数据的，可是ArrayTool对象并未封装特有数据。*2，操作数组的每一个方法都没有用到ArrayTool对象中的特有数据。**这时就考虑，让程序更严谨，是不需要对象的。*可以将ArrayTool中的方法都定义成static的。直接通过类名调用即可。将方法都静态后，可以方便于使用，但是该类还是可以被其他程序建立对象的。
为了更为严谨，强制让该类不能建立对象。
可以通过将构造函数私有化完成。*接下来，将ArrayTool.class文件发送给其他人，其他人只要将该文件设置到classpath路径下，就可以使用该工具类。
*
*但是，很遗憾，该类中到底定义了多少个方法，对方去不清楚。因为该类并没有使用说明书。
*
*开始制作程序的说明书。java的说明书通过文档注释来完成。
*/
/**
*这是一个看可以对数组进行操作的工具类,该类中提供了,获取最值,排序等功能.
*@authorAdminister
*@versionv1.1
*
*/

public
class
ArrayTool{

/**

*空参数构造函数

*/

private
ArrayTool(){}
//将方法都静态后，可以方便于使用，但是该类还是可以被其他程序建立对象的。

//
为了更为严谨，强制让该类不能建立对象。可以通过将构造函数私有化完成。

/**

*获取一个整形数组中的最大值。

*@paramarr接收一个int类型的数组。

*@return会返回一个该数组中最大值。

*/

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];

}

/**

*获取一个整形数组中的最小值。

*@paramarr接收一个int类型的数组。

*@return会返回一个该数组中最小值。

*/

public
static
int
getMix(
int
[]arr){

int
min=
0
;

for
(
int
i=
0
;i<arr.length;i++){

if
(arr[i]>arr[min]){

min=i;

}

}

return
arr[min];

}

/**

给int数组进行选择排序。

@paramarr接收一个int类型的数组。

*/

public
static
void
selectSort(
int
[]arr){

for
(
int
i=
0
;i<arr.length;i++){

for
(
int
j=i;j<arr.length;j++){

if
(arr[i]>arr[j]){

swap(arr,i,j);

}

}

}

}

/**

给int数组进行冒泡排序。

@paramarr接收一个int类型的数组。

*/

public
static
void
bubbleSort(
int
[]arr){

for
(
int
i=
0
;i<arr.length;i++){

for
(
int
j=
0
;j<arr.length-i-
1
;j++){

if
(arr[j]>arr[j+
1
]){

swap(arr,j,j+
1
);

}


}

}

}

/**

给数组中元素进行位置的置换。

@paramarr接收一个int类型的数组。

@parama要置换的位置

@paramb要置换的位置

*/

private
static
void
swap(
int
[]arr,
int
a,
int
b){

int
temp=arr[a];

arr[a]=arr[b];

arr[b]=temp;

}

/**

用于打印数组中的元素。打印形式是：[elemet1,element2,...]

*/

public
static
void
printArray(
int
[]arr){

System.out.println(
"["
);

for
(
int
x=
0
;x<arr.length;x++){

if
(x!=arr.length-
1
){

System.out.println(arr[x]+
","
);

}

else
{

System.out.println(arr[x]+
"]"
);

}


}

}

}


5.帮助文档的制作
javadoc的java文件中类必须是public代码在上面
命令:javadoc-dmyhelp-author-versionArraytool.java
javadoc生成的就是API---Application_Program_Interface6.静态代码块
/*
*静态代码块:给类初始化
*格式:
*static{
*执行语句.
*}
*特点:
随着类的加载而执行,只执行一次，并优先于主函数，无论在什么地方
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//代码一

classStaticCode{

{

System.out.print(
"a"
);
//构造代码块

}

static{

System.out.print(
"b"
);
//

}

}

publicclassStaticCodeDemo{

static{

System.out.print(
"c"
);

}

publicstaticvoidmain(String[]args){

new
StaticCode();

new
StaticCode();
//此句代码会执行,但是内存里面.class文件已经加载，因此里面的静态代码块不会执行

StaticCodes=
null
;

System.out.print(
"d"
);

}

static{

System.out.print(
"e"
);

}

//结果cebaad
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
//方法二

classStaticCode{

intnum=9;


{
//构造代码块,给对象初始化

System.out.print(
"a"
+num);
//注意：字符串加号问题,this可以省略

}

static{
//静态代码块,给类初始化

//System.out.print("b"+mum);//无法从静态上下文中引用非静态变量，如果将num加上static修饰就可以

System.out.print(
"b"
);

}

StaticCode(){
//构造函数

System.out.println(
"c"
);

}

StaticCode(intx){
//带参数的构造函数

System.out.println(
"d"
);

}

}

publicclassStaticCodeDemo{

publicstaticvoidmain(String[]args){

new
StaticCode(4);
//到带参数的构造函数

}

//结果ba9d,

}
1
2
3
4
5
6
7
//代码三

//简单的代码块

publicvoidshow(){

{

System.out.println(
"xxxxxxxx"
);

}

}

7.对象的初始化过程
/*
Personp=newPerson("zhangsan",20);
该句话都做了什么事情？
1，因为new用到了Person.class.所以会先找到Person.class文件并加载到内存中。
2，执行该类中的
static代码块
，如果有的话，给Person.class类进行初始化。
3，在堆内存中开辟空间，分配内存地址。
4，在堆内存中建立对象的特有属性。并进行默认初始化。
5，对属性进行
显示初始化
。
6，对对象进行构造代码块初始化。
7，对对象进行对应的构造函数初始化。
8，将内存地址付给栈内存中的p变量。
*/
如图所示:8.对象调用成员变量9.单例设计模式方式一
/*
设计模式：解决某一类问题最行之有效的方法。
java中有23种设计模式,
单例设计模式：解决一个类在内存只存在一个对象。
想要保证对象唯一。1，为了避免其他程序过多建立该类对象。先禁止其他程序建立该类对象
2，还为了让其他程序可以访问到该类对象，只好在本类中，自定义一个对象。
3，为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。
这三部怎么用代码体现呢？
1，
将构造函数私有化.
2，在本类中创建一个静态的本类对象,以为方法是静态的!!
3，提供一个方法可以获取到该对象。
注意:本类对象和属性全部私有!,对象和方法全部static
对于事物该怎么描述，还怎么描述。
当需要将该事物的对象保证在内存中唯一时，就将以上的三步加上即可。
*/完整代码：本例中只有一个对象，3个引用s,s1,s2.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class
Student{

private
Stringname;


private
Student(){}
//将构造函数私有化

private
static
Students=
new
Student();
//在本类中创建一个本类对象

public
static
StudentgetInstance(){
//提供获取该对象

return
s;

}

public
void
setName(Stringname){

this
.name=name;

}

public
StringgetName(){

return
name;

}

}

public
class
SingleDemo{

public
static
void
main(String[]args){

Students1=Student.getInstance();

Students2=Student.getInstance();
//只有一个对象

}

}

*************************************************************************************************

10.单例设计模式方式二
1
2
3
4
5
6
7
8
9
10
称为：饿汉式。------开发常用

这个是先初始化对象。

Single类已加载，就已经创建好了对象。此时方式去中s已经有对象的引用地址

class
Single{

private
static
Singles=
new
Single();

private
Single(){}

public
static
SinglegetInstance(){

return
s;

}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/*对象是方法被调用时，才初始化，也叫做对象的延时加载。

称为：懒汉式。------------面试考

Single类加载，s=null，此时对象还未存在，只有调用了getInstance方法时，才建立对象。

*/

class
Single{

private
static
Singles=
null
;

private
Single(){}

public
static
SinglegetInstance(){

if
(s==
null
){

//双重判断,只在第一次创建实例时才同步，以后就不需要同步了提好了效率

synchronized
(Single.
class
){

if
(s==
null
)

s=
new
Single();

}

}

return
s;

}

}
//记录原则：定义单例，建议使用饿汉式。
比较上面两种写法：饿汉式是典型的空间换时间，当类装载的时候就会创建类实例，不管你用不用，先创建出来，然后每次调用的时候，就不需要再判断了，节省了运行时间。懒汉式是典型的时间换空间，也就是每次获取实例都会进行判断，看是否需要创建实例，浪费判断的时间。当然，如果一直没有人使用的话，那就不会创建实例，则节约内存空间。
                                            

                                        

                        
                        内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 点击这里给我发消息 
                    

                    

                    

                        

                         标签： 
                                                

                        

                    


                

            


            

                
相关文章推荐

                

                
            

        

        

            

            
            

                

                    
新的分享

                    

                        
                    

                

            


            

                

                    
章节导航