黑马程序员_java面向对象总结【2】(静态、单例设计模式)
2013-12-24 22:45
746 查看
--------------android培训、java培训、期待与您交流!
--------------
一、静态(static)
1、static关键字
用法:是一个修饰符,用于修饰成员(成员变量,成员函数)
当成员被静态修饰后,就多了一种调用方式,除了被对象调用外,还可以直接被类名调用。格式:类名.静态成员
被static修饰后的成员具备以下特点:
(1)随着类的加载而加载(随着类的消失而消失,说明静态的生命周期最长)
(2)优先于对象存在(静态先存在,对象后存在)
(3)被所有对象所共享
(4)可以直接被类名调用
实例变量和静态变量区别:
(1)存放位置:静态变量随着类的加载而存在于方法区中;实例变量随着对象的建立而存在堆内存中。
(2)生命周期:静态变量生命周期最长,随着类的消失而消失;而实例变量生命周期随着对象的消失而消失。
使用注意:
(1)静态方法只能访问静态成员(非静态方法既可以访问静态也可以访问非静态。)
(2)静态方法中不可以写this,super关键字(因为静态优先于对象存在,所以静态方法中不可以出现this)
(3)主函数是静态的
静态利弊:
利:对对象的共享数据进行单独空间的存储,节省空间,没有必要每个对象中都存储一份;可以直接被类名调用。
弊:生命周期过长;访问出现局限性(静态虽好,只能访问静态)
例:
2、main函数
public static void main(String[] args)
主函数:是一个特殊函数,作为程序入口,可以被jvm调用。
主函数定义:
public:代表该函数的访问权限是最大的。
static:代表主函数随着类的加载而加载。
void:主函数没有具体的返回值。
main:不是关键字,但是是一个特殊的单词,可以被jvm识别。
String[] args:主函数参数,参数类型是一个数组,数组中的元素是字符串。字符串类型的数组。
主函数是固定格式的:虚拟机识别。
jvm在调用主函数时,传入的是new String[0];
main函数传参举例:
3、静态什么时候使用
什么时候使用静态?
两个方面着手:因为静态修饰的内容有成员变量和函数。
什么时候定义静态变量?
当对象中出现共享数据时,该数据被静态所修饰,对象中的特有数据要定义成非静态存在于堆内存中。
什么时候定义静态函数?
当功能内部没有访问到非静态数据(对象的特有数据)时,则该功能可以定义成静态的。
4、静态的应用(工具类)
每一个应用程序中都有共性的功能,可以将这些功能进行抽取,独立封装,以便复用。
虽然可以通过建立ArrayTool的对象使用这些工具方法,对数组进行操作。
但存在问题:
1:对象是用于封装数据的,可是ArrayTool对象并未封装特有数据。
2:操作数组的每一个方法都没有用到ArrayTool对象中的特有数据。
这时就考虑,让程序更严谨,是不需要对象的。可以将ArrayTool中的方法都定义成static的。直接通过类名调用即可。
将方法都静态后,可以方便于使用,但是该类还是可以被其他程序建立对象的。
为了更为严谨,强制让该类不能建立对象。
可以通过将构造函数私有化完成。
例:ArrayTool工具类
5、帮助文档的制作javadoc(工具类)
制作一个工具类并提供给他人使用,但他人并不知道此工具类中的方法,为让他人能方便使用该工具类,则要制作程序的说明书。java的说明书通过文档注释来完成。
制作程序的说明书--API文档:
API英文全称 Application Program Interface 应用程序接口
java的说明书通过文档注释来完成
dos执行生成帮助文档的命令:
javadoc -d help -author -version Demo.java
javadoc java制作文档的工具
-d 目录
help 是文件夹名,如果当前没有该文件夹,会自动在当前目录创建。
-author 作者
-version 版本号
Demo.java 要制作的文档的java文件
要生成文档,必须在类名前加上public修饰,否则会报错。方法被public修饰才能在文档中看到,被private修饰的方法是不会出现文档中。
一个类中默认会有一个空参数的构造函数,
这个默认的构造函数的权限和所属类一致。
如果类被public修饰,那么默认的构造函数也带public修饰符。
如果类没有被public修饰,那么默认的构造函数,也没有public修饰。
默认构造构造函数的权限是随着的类的变化而变化的。
java工具类注释说明书实例:
6、静态代码块
静态代码块:
格式:static
{
静态代码块中的执行语句。
}
特点:随着类的加载而执行,只执行一次,并优先于主函数。
用于给类进行初始化。
7、对象的初始化过程
Person p = new Person("zhangsan",20);
该语句做了什么事情?
对象的初始化过程:
1、因为new用到了Person.class,所以会先找到Person.class文件并加载到内存中。(new Person();)
2、执行该类中的静态代码块,如果有的话,给Person.class类进行初始化。
3、在堆内存中开辟空间,分配内存地址。(例如内存中开辟了空间,分配地址为0x0023)
4、在堆内存中建立对象的特有属性,并进行默认初始化。(建立特有属性name和age,默认初始化:name=null;age=0;)
5、对属性进行显示初始化。(类中定义属性的时候已经有显示的定义值,例:private String name="lisi"。则对属性显示初始化:name="lisi",age=0)
6、对对象进行构造代码块初始化。
7、对对象进行对应的构造函数初始化。(进行构造函数初始化:name="zhangsan",age=20)
8、将内存地址赋给栈内存中的p变量。(将内存地址0x0023赋给p,则p指向对象Person("zhangsan",20))
图例:
8、对象调用成员过程
例:
过程图例:
[b]二、单例设计模式
设计模式:解决某一类问题最行之有效的方法。
java中有23种设计模式:
单例设计模式:解决一个类在内存中只存在一个对象。
保证对象唯一的方法:
1、为了避免其他程序过多建立该类对象,先禁止其他程序建立该类对象。
2、还为了让其他程序可以访问到该类对象,只好在本类中自定义一个对象。
3、为了让其他程序对自定义的访问,可以对外提供一些访问方式。
上述三步代码体现:
1、将类的构造函数私有化。
2、在类中创建一个本类对象。
3、提供一个方法可以获取到该对象。
单例设计模式使用:
对于事物该怎么描述,还怎么描述。
当需要该事物的对象保证在内存中唯一时,就将以上的三步加上即可。
代码:
图例:
单例实例代码:
饿汉式和懒汉式:
饿汉式:类一进入内存就建立了对象,即在类中就先初始化对象。
例:
Single类一进内存就已经创建好对象,
懒汉式:对象是方法被调用时才初始化,也称为对象的延迟加载。
例:Single类进内存,对象还没有存在,只有调用了getInstance方法时,才建立对象。
实际开发中一般利用饿汉式,安全简单,而且懒汉式会出现问题。
懒汉式出现问题:
例如A程序和B程序,A程序判断完s==null,cpu切换到另一程序,A程序挂起;接着cpu开始执行B程序,B程序判断完s==null,cpu又切换到另一程序,B程序挂起。等到A程序恢复执行,则建立一个对象s,接下来当B程序开始执行,B又会进行创建对象s,由于这是单例设计,所以这里两个对象会冲突报错,产生安全问题。
这个问题可以用synchronized关键字(同步)来对程序加锁解决(暂未学到)。
懒汉式程序示例:
原则:定义单例时,建议使用饿汉式。
--------------
一、静态(static)
1、static关键字
用法:是一个修饰符,用于修饰成员(成员变量,成员函数)
当成员被静态修饰后,就多了一种调用方式,除了被对象调用外,还可以直接被类名调用。格式:类名.静态成员
被static修饰后的成员具备以下特点:
(1)随着类的加载而加载(随着类的消失而消失,说明静态的生命周期最长)
(2)优先于对象存在(静态先存在,对象后存在)
(3)被所有对象所共享
(4)可以直接被类名调用
实例变量和静态变量区别:
(1)存放位置:静态变量随着类的加载而存在于方法区中;实例变量随着对象的建立而存在堆内存中。
(2)生命周期:静态变量生命周期最长,随着类的消失而消失;而实例变量生命周期随着对象的消失而消失。
使用注意:
(1)静态方法只能访问静态成员(非静态方法既可以访问静态也可以访问非静态。)
(2)静态方法中不可以写this,super关键字(因为静态优先于对象存在,所以静态方法中不可以出现this)
(3)主函数是静态的
静态利弊:
利:对对象的共享数据进行单独空间的存储,节省空间,没有必要每个对象中都存储一份;可以直接被类名调用。
弊:生命周期过长;访问出现局限性(静态虽好,只能访问静态)
例:
class Person{ String name;//成员变量,也叫实例变量 /*country成员变量被静态修饰之后,其就被放入了方法区;不是存在于每个对象之中,而是被对象所共享访问。 */ static String country="China";//静态变量,类变量 /*静态方法中只能调用静态成员变量,例如country;而不能调用非静态变量,例如调用name就会出错。 * */ static public void show(){ //System.out.println(name+":"+country); System.out.println(country); } } public class Demo { public static void main(String args[]){ Person p=new Person(); System.out.println(p.country);//对象调用 System.out.println(Person.country);//类名直接调用静态变量 Person.show();//类名直接调用静态方法 } }
2、main函数
public static void main(String[] args)
主函数:是一个特殊函数,作为程序入口,可以被jvm调用。
主函数定义:
public:代表该函数的访问权限是最大的。
static:代表主函数随着类的加载而加载。
void:主函数没有具体的返回值。
main:不是关键字,但是是一个特殊的单词,可以被jvm识别。
String[] args:主函数参数,参数类型是一个数组,数组中的元素是字符串。字符串类型的数组。
主函数是固定格式的:虚拟机识别。
jvm在调用主函数时,传入的是new String[0];
main函数传参举例:
public class MainDemo { public static void main(String[] args) { String arr[]={"haha","hehe","heihei"}; MainTest.main(arr); } } class MainTest{ public static void main(String[] args) { for(String i:args) System.out.println(i); } }
3、静态什么时候使用
什么时候使用静态?
两个方面着手:因为静态修饰的内容有成员变量和函数。
什么时候定义静态变量?
当对象中出现共享数据时,该数据被静态所修饰,对象中的特有数据要定义成非静态存在于堆内存中。
什么时候定义静态函数?
当功能内部没有访问到非静态数据(对象的特有数据)时,则该功能可以定义成静态的。
public class MainDemo { public static void main(String[] args) { Person.show();//类名直接调用静态方法。 } } class Person{ String name; public static void show(){ System.out.println("Hello World!"); }//该方法没有访问到非静态数据,则可以定义为静态。 }
4、静态的应用(工具类)
每一个应用程序中都有共性的功能,可以将这些功能进行抽取,独立封装,以便复用。
虽然可以通过建立ArrayTool的对象使用这些工具方法,对数组进行操作。
但存在问题:
1:对象是用于封装数据的,可是ArrayTool对象并未封装特有数据。
2:操作数组的每一个方法都没有用到ArrayTool对象中的特有数据。
这时就考虑,让程序更严谨,是不需要对象的。可以将ArrayTool中的方法都定义成static的。直接通过类名调用即可。
将方法都静态后,可以方便于使用,但是该类还是可以被其他程序建立对象的。
为了更为严谨,强制让该类不能建立对象。
可以通过将构造函数私有化完成。
例:ArrayTool工具类
class ArrayTool{ /*为了更为严谨,强制让该类不能建立对象。 可以通过将构造函数私有化完成。 */ private ArrayTool(){} //获得最大值 public static int getMax(int arr[]){ int max=0; for(int i=1;i<arr.length;i++){ if(arr[max]<arr[i]){ max=i; } } return arr[max]; } //获得最小值 public static int getMin(int arr[]){ int min=0; for(int i=1;i<arr.length;i++){ if(arr[min]>arr[i]){ min=i; } } return arr[min]; } //选择排序 public static void selectsort(int arr[]){ int max; //外循环进行元素顺序调换 //内循环获得每趟中部分数组中的最大元素下标 for(int i=1;i<arr.length;i++){ max=0; for(int j=1;j<=arr.length-i;j++){ if(arr[j]>arr[max]){ max=j; } swap(arr,arr.length-i,max); } } show(arr); } //冒泡排序 public static void bubblesort(int arr[]){ for(int i=1;i<arr.length;i++){ for(int j=0;j<arr.length-i;j++){ if(arr[j]>arr[j+1]){ /*相邻元素进行比较,若较前元素大于较后元素, * 将其调转位置 * */ swap(arr,j,j+1); } } } show(arr); } //调转位置函数 private static void swap(int arr[],int a,int b){ int temp=arr[a]; arr[a]=arr; arr[b]=temp; } public static void show(int arr[]){ for(int i:arr){ System.out.print(i+" "); } System.out.println(); } } public class Demo { public static void main(String args[]){ int arr[]={3,0,1,8,2,7,6,4,9,5}; int max=ArrayTool.getMax(arr); System.out.println("max="+max); int min=ArrayTool.getMin(arr); System.out.println("min="+min); ArrayTool.show(arr); ArrayTool.selectsort(arr); } }
5、帮助文档的制作javadoc(工具类)
制作一个工具类并提供给他人使用,但他人并不知道此工具类中的方法,为让他人能方便使用该工具类,则要制作程序的说明书。java的说明书通过文档注释来完成。
制作程序的说明书--API文档:
API英文全称 Application Program Interface 应用程序接口
java的说明书通过文档注释来完成
dos执行生成帮助文档的命令:
javadoc -d help -author -version Demo.java
javadoc java制作文档的工具
-d 目录
help 是文件夹名,如果当前没有该文件夹,会自动在当前目录创建。
-author 作者
-version 版本号
Demo.java 要制作的文档的java文件
要生成文档,必须在类名前加上public修饰,否则会报错。方法被public修饰才能在文档中看到,被private修饰的方法是不会出现文档中。
一个类中默认会有一个空参数的构造函数,
这个默认的构造函数的权限和所属类一致。
如果类被public修饰,那么默认的构造函数也带public修饰符。
如果类没有被public修饰,那么默认的构造函数,也没有public修饰。
默认构造构造函数的权限是随着的类的变化而变化的。
java工具类注释说明书实例:
/** 这是一个可以对数组进行操作的工具类,该类提供功能:获取最值、排序。 @author DuanGuangyu @version V1.0 */ public class ArrayTool{ /** * 空参数构造函数 */ private ArrayTool(){} /**获取一个整形数组中的最大值。 * @param arr接收一个int类型的数组 * @return 返回该数组中的最大值 */ public static int getMax(int arr[]){ int max=0; for(int i=1;i<arr.length;i++){ if(arr[max]<arr[i]){ max=i; } } return arr[max]; } /**获取一个整形数组中的最小值。 * @param arr接收一个int类型的数组 * @return 返回该数组中的最小值 */ public static int getMin(int arr[]){ int min=0; for(int i=1;i<arr.length;i++){ if(arr[min]>arr[i]){ min=i; } } return arr[min]; } /** * 给int数组进行选择排序。 * @param arr 接收一个int类型的数组。 */ public static void selectsort(int arr[]){ int max; //外循环进行元素顺序调换 //内循环获得每趟中部分数组中的最大元素下标 for(int i=1;i<arr.length;i++){ max=0; for(int j=1;j<=arr.length-i;j++){ if(arr[j]>arr[max]){ max=j; } swap(arr,arr.length-i,max); } } show(arr); } /** * 给int数组进行冒泡排序。 * @param arr 接收一个int类型的数组。 */ public static void bubblesort(int arr[]){ for(int i=1;i<arr.length;i++){ for(int j=0;j<arr.length-i;j++){ if(arr[j]>arr[j+1]){ /*相邻元素进行比较,若较前元素大于较后元素, * 将其调转位置 * */ swap(arr,j,j+1); } } } show(arr); } /** * 调换数组中元素位置 * @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 ... * @param arr 接收一个int类型的数组。 */ public static void show(int arr[]){ for(int i:arr){ System.out.print(i+" "); } System.out.println(); } }
6、静态代码块
静态代码块:
格式:static
{
静态代码块中的执行语句。
}
特点:随着类的加载而执行,只执行一次,并优先于主函数。
用于给类进行初始化。
class StaticCode{ //构造函数给对应对象初始化 StaticCode(){ System.out.println("b"); } StaticCode(int x){ System.out.println("d"); } //静态代码块给类初始化 static{ System.out.println("a"); } //构造代码块给对象初始化 { System.out.println("c"); } public static void show(){ System.out.println("show run"); } } public class StaticCodeDemo { //该类中的两个static代码块先执行,然后执行main函数 static{ System.out.println("haha"); } public static void main(String[] args) { new StaticCode(5); /* //new StaticCode(); new StaticCode();//StaticCode类中的static代码块随着类的加载而执行,只执行一次。 System.out.println("Hello World!"); StaticCode.show(); */ } static{ System.out.println("heihei"); } }
7、对象的初始化过程
Person p = new Person("zhangsan",20);
该语句做了什么事情?
对象的初始化过程:
1、因为new用到了Person.class,所以会先找到Person.class文件并加载到内存中。(new Person();)
2、执行该类中的静态代码块,如果有的话,给Person.class类进行初始化。
3、在堆内存中开辟空间,分配内存地址。(例如内存中开辟了空间,分配地址为0x0023)
4、在堆内存中建立对象的特有属性,并进行默认初始化。(建立特有属性name和age,默认初始化:name=null;age=0;)
5、对属性进行显示初始化。(类中定义属性的时候已经有显示的定义值,例:private String name="lisi"。则对属性显示初始化:name="lisi",age=0)
6、对对象进行构造代码块初始化。
7、对对象进行对应的构造函数初始化。(进行构造函数初始化:name="zhangsan",age=20)
8、将内存地址赋给栈内存中的p变量。(将内存地址0x0023赋给p,则p指向对象Person("zhangsan",20))
图例:
8、对象调用成员过程
例:
class Person { private String name; private int age; private static String country = "cn"; Person(String name,int age) { this.name = name; this.age = age; } { System.out.println(name+".."+age); } public void setName(String name) { this.name = name; } public void speak() { System.out.println(this.name+"..."+this.age); } public static void showCountry() { System.out.println("country="+country); } } class PersonDemo { public static void main(String[] args) { Person p = new Person(); p.setName("lisi"); } }
过程图例:
[b]二、单例设计模式
设计模式:解决某一类问题最行之有效的方法。
java中有23种设计模式:
单例设计模式:解决一个类在内存中只存在一个对象。
保证对象唯一的方法:
1、为了避免其他程序过多建立该类对象,先禁止其他程序建立该类对象。
2、还为了让其他程序可以访问到该类对象,只好在本类中自定义一个对象。
3、为了让其他程序对自定义的访问,可以对外提供一些访问方式。
上述三步代码体现:
1、将类的构造函数私有化。
2、在类中创建一个本类对象。
3、提供一个方法可以获取到该对象。
单例设计模式使用:
对于事物该怎么描述,还怎么描述。
当需要该事物的对象保证在内存中唯一时,就将以上的三步加上即可。
代码:
class Single{ private Single(){}//私有化构造函数,禁止其他程序建立本类对象。 private static Single s=new Single();//在类中创建一个本类对象,对其进行静态私有修饰。 public static Single getInstance(){ return s; }//向外提供本类对象。 } public class SingleDmo { public static void main(String[] args) { Single ss=Single.getInstance();//获得Single类类型的对象。 Single s1=Single.getInstance();//s1和ss都是同一个对象。 } }
图例:
单例实例代码:
class Single{ private int num; public void setNum(int num){ this.num=num; } public int getNum(){ return num; } private Single(){}//私有化构造函数,禁止其他程序建立本类对象。 private static Single s=new Single();//在类中创建一个本类对象,对其进行静态私有修饰。 public static Single getInstance(){ return s; }//向外提供本类对象。 } public class SingleDmo { public static void main(String[] args) { Single s1=Single.getInstance();//获得Single类类型的对象。 Single s2=Single.getInstance();//s1和s2都是同一个对象。 //分别赋两个值 s1.setNum(5); s2.setNum(6); //输出的都是6.因为两个对象其实都是一个对象,先给对象中num赋的5被后来的6覆盖了。 System.out.println("s1:"+s1.getNum()); System.out.println("s2:"+s2.getNum()); } }
饿汉式和懒汉式:
饿汉式:类一进入内存就建立了对象,即在类中就先初始化对象。
例:
Single类一进内存就已经创建好对象,
class Single{ private Single(){} private static Single s=new Single();//先初始化对象 public static Single getInstance(){ return s; }//向外提供本类对象。 }
懒汉式:对象是方法被调用时才初始化,也称为对象的延迟加载。
例:Single类进内存,对象还没有存在,只有调用了getInstance方法时,才建立对象。
实际开发中一般利用饿汉式,安全简单,而且懒汉式会出现问题。
懒汉式出现问题:
例如A程序和B程序,A程序判断完s==null,cpu切换到另一程序,A程序挂起;接着cpu开始执行B程序,B程序判断完s==null,cpu又切换到另一程序,B程序挂起。等到A程序恢复执行,则建立一个对象s,接下来当B程序开始执行,B又会进行创建对象s,由于这是单例设计,所以这里两个对象会冲突报错,产生安全问题。
这个问题可以用synchronized关键字(同步)来对程序加锁解决(暂未学到)。
懒汉式程序示例:
class Single{ private Single(){} private static Single s=null; public static Single getInstance(){ if(s==null){ synchronized(Single.class){ if(s==null){ s=new Single(); return s; } } } }//向外提供本类对象。 }
原则:定义单例时,建议使用饿汉式。
相关文章推荐
- 黑马程序员--Java学习笔记之面向对象思想(单例模式详解、匿名对象、静态、final)
- 黑马程序员--Java笔记04--面向对象 及单例设计模式
- 黑马程序员—Java面向对象(单例设计模式、面向对象的继承、final关键字)
- Java面向对象 Main函数 静态的应用 单例设计模式
- Java面向对象 Main函数 静态的应用 单例设计模式
- 1、Java面向对象笔记(匿名对象)(static 静态修饰符)(单例设计模式)
- JAVA面向对象知识点总结(4)— 单例设计模式:饿汉式、懒汉式
- 黑马程序员--Java面向对象之this、static和单例设计模式
- 黑马程序员_Java基础_面向对象(Static的使用、对象初始化和调用成员过程、单例设计模式)
- 黑马程序员——Java面向对象总结
- 黑马程序员-面向对象-06天-5(单例设计模式)
- Java面向对象,单例设计模式
- 黑马程序员_java面向对象总结
- 黑马程序员—java面向对象总结(1)
- 黑马程序员---java基础----面向对象总结
- Java面向对象设计模式
- 黑马程序员_java面向对象思想学习总结
- 黑马程序员:Java基础总结----单例设计模式
- 黑马程序员面试题面向对象一(封装,构造函数,this,static,单例设计模式,继承)
- JAVA基础再回首(二十六)——面向对象思想设计原则、设计模式、简单工厂模式、工厂方法模式、单例设计模式之饿汉式和懒汉式、Runtime类