1.关键字static
1.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 类加载过程（静态变量、成员变量、静态块、静态方法、构造方法）静态变量——>静态块——>成员变量——>构造代码块——>构造函数——>静态方法
class ClassLoad{static int number = 1;//静态变量(类变量)int xmember = 7;//成员变量ClassLoad(){System.out.println("构造函数运行了"+number+xmember);//编译通过}static{System.out.println("静态代码块运行了"+number);//既然能调用说明静态变量先入内存//System.out.println(xmember);//编译失败,说明成员变量还未初始化}{System.out.println("构造代码块运行了"+number+xmember);//编译通过}public static void show(){number = number+5;}}public class Client{public static void main(String[] args){System.out.println(ClassLoad.number);ClassLoad t2 =newClassLoad();ClassLoad.show();//}}
2.主函数main
/** 主函数:是一个特殊的函数.作为程序的入口,可以被jvm调用* public:代表着该函数访问权限是最大的.* static:代表主函数随着类的加载就已经存在了.* void:主函数没有具体的返回值* main:不是关键字,但是是一个特殊的单词,可以被jvm识别* (String[] args):函数的参数,字符串类型的数组args是arguments的缩写* jvm在调用主函数时,传入的是new String[0];* 主函数是固定格式的:JVM识别*/publicclassMainDemo {publicstaticvoidmain(String[] args){String[] arr = {"heihei","haha","hehe","hiahia"};MainTest.main(arr);}}classMainTest{publicstaticvoidmain(String[] args){}}
3.静态---什么时候使用
1.什么时候定义静态变量(类变量)?
当对象中出现共享数据时(不是相同属性),该数据被静态所修饰
对象中的特有数据要定义成非静态存在于堆内存中
2.什么时候定义静态函数?
当功能内部没有访问到非静态数据(对象的特有数据);
4.静态的应用----工具类
* 静态的应用。* 每一个应用程序中都有共性的功能，* 可以将这些功能进行抽取，独立封装。* 以便复用。** 虽然可以通过建立ArrayTool的对象使用这些工具方法，对数组进行操作。* 发现了问题：*1，对象是用于封装数据的，可是ArrayTool对象并未封装特有数据。*2，操作数组的每一个方法都没有用到ArrayTool对象中的特有数据。**这时就考虑，让程序更严谨，是不需要对象的。*可以将ArrayTool中的方法都定义成static的。直接通过类名调用即可。
将方法都静态后，可以方便于使用，但是该类还是可以被其他程序建立对象的。
为了更为严谨，强制让该类不能建立对象。
可以通过将构造函数私有化完成。
*接下来，将ArrayTool.class文件发送给其他人，其他人只要将该文件设置到classpath路径下，就可以使用该工具类。
*
*但是，很遗憾，该类中到底定义了多少个方法，对方去不清楚。因为该类并没有使用说明书。
*
*开始制作程序的说明书。java的说明书通过文档注释来完成。
*/
/**
*这是一个看可以对数组进行操作的工具类,该类中提供了,获取最值,排序等功能.
*@author Administer
*@version v1.1
*
*/
public class ArrayTool { /** * 空参数构造函数 */ private ArrayTool(){}//将方法都静态后，可以方便于使用，但是该类还是可以被其他程序建立对象的。 //为了更为严谨，强制让该类不能建立对象。可以通过将构造函数私有化完成。 /** *获取一个整形数组中的最大值。 *@param arr 接收一个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]; } /** *获取一个整形数组中的最小值。 *@param arr 接收一个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数组进行选择排序。 @param arr 接收一个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数组进行冒泡排序。 @param arr 接收一个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); } } } } /** 给数组中元素进行位置的置换。 @param arr 接收一个int类型的数组。 @param a 要置换的位置 @param b 要置换的位置 */ 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 -d myhelp -author - version Arraytool.java
javadoc生成的就是API---Application_Program_Interface
6.静态代码块
/** 静态代码块:给类初始化* 格式:*static{* 执行语句.*}*特点:随着类的加载而执行,只执行一次，并优先于主函数，无论在什么地方*/
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
//代码一class StaticCode{ { System.out.print("a");//构造代码块 } static{ System.out.print("b");// }}public class StaticCodeDemo{ static{ System.out.print("c"); } public static void main(String[] args){ new StaticCode(); new StaticCode();//此句代码会执行,但是内存里面.class文件已经加载，因此里面的静态代码块不会执行 StaticCode s = 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
|
//方法二class StaticCode{ int num = 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(int x){//带参数的构造函数 System.out.println("d"); }}public class StaticCodeDemo{ public static void main(String[] args){ new StaticCode(4);//到带参数的构造函数 }//结果ba9d,} |
|
1
2
3
4
5
6
7
|
//代码三//简单的代码块public void show(){ { System.out.println("xxxxxxxx"); }}
|
7.对象的初始化过程
/*Person p = new Person("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，提供一个方法可以获取到该对象。
对于事物该怎么描述，还怎么描述。当需要将该事物的对象保证在内存中唯一时，就将以上的三步加上即可。
*/
完整代码：本例中只有一个对象，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 String name; private Student(){}//将构造函数私有化 private static Student s = new Student();//在本类中创建一个本类对象 public static Student getInstance(){//提供获取该对象 return s; } public void setName(String name){ this.name = name; } public String getName(){ return name; } }public class SingleDemo { public static void main(String[] args){ Student s1 = Student.getInstance(); Student s2 = Student.getInstance();//只有一个对象 }} |
*************************************************************************************************
10.单例设计模式方式二
|
1
2
3
4
5
6
7
8
9
10
|
称为：饿汉式。------开发常用 这个是先初始化对象。Single类已加载，就已经创建好了对象。此时方式去中s已经有对象的引用地址class Single{ private static Single s = new Single(); private Single(){} public static Single getInstance(){ 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 Single s = null; private Single(){} public static Single getInstance(){ if(s==null){ //双重判断, 只在第一次创建实例时才同步，以后就不需要同步了提好了效率 synchronized(Single.class){ if(s==null) s = new Single(); } } return s; }} |
//记录原则：定义单例，建议使用饿汉式。比较上面两种写法：
饿汉式是典型的空间换时间，当类装载的时候就会创建类实例，不管你用不用，先创建出来，然后每次调用的时候，就不需要再判断了，节省了运行时间。
懒汉式是典型的时间换空间，也就是每次获取实例都会进行判断，看是否需要创建实例，浪费判断的时间。当然，如果一直没有人使用的话，那就不会创建实例，则节约内存空间。
扫一扫
725
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
