java设计模式基础入门.docx
《java设计模式基础入门.docx》由会员分享，可在线阅读，更多相关《java设计模式基础入门.docx（28页珍藏版）》请在冰豆网上搜索。
java设计模式基础入门
packagecn.itcast.bat;
/*
bat处理文件:
bat处理文件就是可以一次性执行多个命令的文件。
为什么要学bat处理文件，快速运行一个软件我一般都会把软件打包一个jar包。
jar双击可以运行仅对于图形化界面的软件起作用，对于控制台的程序是不起作用的。
对于控制台的程序我们可以使用bat处理文件快速启动一个项目。
如何编写bat处理文件呢？
步骤：
编写一个自定义的文本文件，然后把后缀名改成bat即可，然后把你所要执行的命令写在bat处理文件中即可。
bat处理文件常用的命令：
echo向控制台输出指定的内容。
echooff隐藏echooff后面执行过的命令。
@隐藏当前行执行的命令。
title改变当前控制台窗口的标题
color指定控制台的背景颜色与前景颜色
%注释的内容%
pause:
让当前控制台停留。
%1~%9:
给bat处理文件传入参数。
*/
publicclassDemo1{
publicstaticvoidmain（String[]args）{
System.out.println（"哈哈..."）;
}
}
packagecn.itcast.copy;
/*
对象的克隆
对象的浅克隆:
对象浅克隆要注意的细节：
1.如果一个对象需要调用clone的方法克隆，那么该对象所属的类必须要实现Cloneable接口。
2.Cloneable接口只不过是一个标识接口而已，没有任何方法。
3.对象的浅克隆就是克隆一个对象的时候，如果被克隆的对象中维护了另外一个类的对象，这时候只是克隆另外一个对象的地址，而没有把
另外一个对象也克隆一份。
4.对象的浅克隆也不会调用到构造方法的。
对象的深克隆：
*/
publicclassDemo1{
publicstaticvoidmain（String[]args）throwsException{
Addressaddress=newAddress（"广州"）;
Personp1=newPerson（110,"狗娃",address）;
Personp2=（Person）p1.clone（）;//clone（）克隆了一个对象。
p2.name="狗剩";
p2.address.city="长沙";
System.out.println（"p1:
"+p1）;
System.out.println（"p2:
"+p2）;
}
}
packagecn.itcast.copy;
importjava.io.FileInputStream;
importjava.io.FileOutputStream;
importjava.io.IOException;
importjava.io.ObjectInput;
importjava.io.ObjectInputStream;
importjava.io.ObjectOutputStream;
/*
对象的深克隆：
对象的深克隆就是利用对象的输入输出流把对象先写到文件上，然后再读取对象的
信息这个过程就称作为对象的深克隆。
ObjectInputStream
ObjectOutputStream
*/
publicclassDemo2{
publicstaticvoidmain（String[]args）throwsIOException,ClassNotFoundException{
Addressaddress=newAddress（"广州"）;
Personp1=newPerson（110,"狗娃",address）;
writeObj（p1）;
Personp2=readObj（）;
p2.address.city="长沙";
System.out.println（"p1:
"+p1）;
System.out.println（"p2:
"+p2）;
}
//再从文件中读取对象的信息
publicstaticPersonreadObj（）throwsClassNotFoundException,IOException{
FileInputStreamfileInputStream=newFileInputStream（"F:
\\obj.txt"）;
//创建对象的输入流对象
ObjectInputStreamobjectInputStream=newObjectInputStream（fileInputStream）;
return（Person）objectInputStream.readObject（）;
}
//先要把对象写到文件上。
publicstaticvoidwriteObj（Personp）throwsIOException{
//建立一个文件的输出流对象
FileOutputStreamfileOutputStream=newFileOutputStream（"F:
\\obj.txt"）;
//建立对象的输出流
ObjectOutputStreamobjectOutputStream=newObjectOutputStream（fileOutputStream）;
//把对象写出
objectOutputStream.writeObject（p）;
//关闭资源
objectOutputStream.close（）;
}
}
packagecn.itcast.copy;
importjava.io.Serializable;
classAddressimplementsSerializable{
Stringcity;
publicAddress（Stringcity）{
this.city=city;
}
}
publicclassPersonimplementsCloneable,Serializable{
intid;
Stringname;
Addressaddress;
publicPerson（intid,Stringname）{
this.id=id;
this.name=name;
}
publicPerson（intid,Stringname,Addressaddress）{
this.id=id;
this.name=name;
this.address=address;
System.out.println（"=======构造方法调用了==="）;
}
@Override
publicStringtoString（）{
return"编号：
"+this.id+"姓名：
"+this.name+"地址：
"+address.city;
}
@Override
publicObjectclone（）throwsCloneNotSupportedException{
returnsuper.clone（）;
}
}
packagecn.itcast.factory;
importjava.io.BufferedReader;
importjava.io.FileNotFoundException;
importjava.io.FileReader;
importjava.lang.reflect.Constructor;
importjava.lang.reflect.Field;
importcn.itcast.reflect.Person;
/*
工厂设计模式就是用于产生对象的。
*/
classCar{}
classBMWextendsCar{}
classBSJextendsCar{}
publicclassDemo1{
publicstaticvoidmain（String[]args）throwsException{
Personp=（Person）getInstance（）;
System.out.println（p）;
}
//需求：
编写一个工厂方法根据配置文件返回对应的对象。
publicstaticObjectgetInstance（）throwsException{
//读取配置文件
BufferedReaderbufferedReader=newBufferedReader（newFileReader（"info.txt"））;
//读取第一行:
读取类文件的信息
StringclassName=bufferedReader.readLine（）;
//通过完整类名获取对应的Class对象
Classclazz=Class.forName（className）;
//获取到对应的构造方法
Constructorconstructor=clazz.getDeclaredConstructor（null）;
constructor.setAccessible（true）;
Objecto=constructor.newInstance（null）;
//给对象设置对应的属性值
Stringline=null;
while（（line=bufferedReader.readLine（））!
=null）{
String[]datas=line.split（"="）;
Fieldfield=clazz.getDeclaredField（datas[0]）;
//设置可以访问
field.setAccessible（true）;
if（field.getType（）==int.class）{
field.set（o,Integer.parseInt（datas[1]））;
}else{
field.set（o,datas[1]）;
}
}
returno;
}
}
packagecn.itcast.list;
importjava.util.Arrays;
/*
内存泄露
需求：
编写一个类使用数组模拟堆栈的存储方式。
堆栈存储特点：
先进后出，后进先出。
注意：
不再使用的对象，应该不要让变量指向该对象，要让该对象尽快的被垃圾回收期回收。
*/
classStackList{
Object[]elements;
intindex=0;//当前的索引值
publicStackList（）{
this.elements=newObject[3];
}
//添加内容
publicvoidadd（Objecto）{
//添加元素之前应该要先检查是否容量够用。
ensureCapcity（）;
elements[index++]=o;
}
//出栈:
删除集合的元素，并且返回。
publicObjectpop（）{
inttempIndex=--index;
Objecto=elements[tempIndex];
elements[tempIndex]=null;//让该位置不再引用着指定的对象,让垃圾回收期赶快回收该垃圾。
returno;
}
//检查当前的数组使用够用。
publicvoidensureCapcity（）{
if（index==elements.length）{
//计算一个新的长度
intnewLength=elements.length*2;
elements=Arrays.copyOf（elements,newLength）;
}
}
//获取当前的元素个数
publicintsize（）{
returnindex;
}
}
publicclassDemo1{
publicstaticvoidmain（String[]args）{
StackListlist=newStackList（）;
list.add（"狗娃"）;
list.add（"狗剩"）;
list.add（"铁蛋"）;
list.add（"美美"）;
intsize=list.size（）;
for（inti=0;iSystem.out.println（list.pop（））;
}
}
}
packagecn.itcast.observer;
//人是要根据天气做出相应的处理的。
publicclassEmpimplementsWeather{
Stringname;
publicEmp（Stringname）{
this.name=name;
}
//人是要根据天气做出相应的处理的。
"晴天","雾霾","刮风","冰雹","下雪"
publicvoidnotifyWeather（Stringweather）{
if（"晴天".equals（weather））{
System.out.println（name+"高高兴兴的去上班!
!
"）;
}elseif（"雾霾".equals（weather））{
System.out.println（name+"戴着消毒面具去上班!
"）;
}elseif（"刮风".equals（weather））{
System.out.println（name+"拖着大石头过来上班!
"）;
}elseif（"冰雹".equals（weather））{
System.out.println（name+"戴着头盔过来上班!
"）;
}elseif（"下雪".equals（weather））{
System.out.println（name+"戴着被子过来上班!
"）;
}
}
}
packagecn.itcast.observer;
publicclassStudentimplementsWeather{
Stringname;
publicStudent（Stringname）{
super（）;
this.name=name;
}
publicvoidnotifyWeather（Stringweather）{
if（"晴天".equals（weather））{
System.out.println（name+"高高兴兴的去开学!
!
"）;
}elseif（"雾霾".equals（weather））{
System.out.println（name+"吸多两口去上学!
"）;
}elseif（"刮风".equals（weather））{
System.out.println（name+"在家睡觉!
"）;
}elseif（"冰雹".equals（weather））{
System.out.println（name+"在家睡觉!
"）;
}elseif（"下雪".equals（weather））{
System.out.println（name+"等下完再去上学!
"）;
}
}
}
packagecn.itcast.observer;
//订阅天气预报的接口
publicinterfaceWeather{
publicvoidnotifyWeather（Stringweather）;
}
packagecn.itcast.observer;
importjava.util.Random;
publicclassWeatherMain{
publicstaticvoidmain（String[]args）throwsException{
//工人
Empe=newEmp（"小明"）;
Empe2=newEmp（"如花"）;
//学生
Students1=newStudent（"狗娃"）;
Students2=newStudent（"狗剩"）;
WeatherStationstation=newWeatherStation（）;
station.addListener（e）;
station.addListener（e2）;
station.addListener（s1）;
station.addListener（s2）;
station.startWork（）;
}
}
packagecn.itcast.observer;
importjava.util.ArrayList;
importjava.util.Random;
/*
观察者设计模式：
观察者设计模式解决的问题时当一个对象发生指定的动作时，要通过另外一个对象做出相应的处理。
需求：
编写一个气象站、一个工人两个类，当气象站更新天气的时候，要通知人做出相应的处理。
问题1：
气象站更新了多次天气，然后人才做一次的处理。
问题2：
目前气象站只能通知一个人而已。
问题3：
在现实生活中出了工人群体要关注天气，其他的群体也需要关注天气
观察者设计模式的步骤：
1.当前目前对象发生指定的动作是，要通知另外一个对象做出相应的处理，这时候应该把对方的相应处理方法定义在接口上。
2.在当前对象维护接口的引用，当当前对象发生指定的动作这时候即可调用接口中的方法了。
*/
//气象站
publicclassWeatherStation{
String[]weathers={"晴天","雾霾","刮风","冰雹","下雪"};
//当前天气
Stringweather;
//该集合中存储的都是需要收听天气预报的人
ArrayListlist=newArrayList（）;//程序设计讲究低耦合---->尽量不要让一个类过分依赖于另外一个类。
publicvoidaddListener（Weathere）{
list.add（e）;
}
//开始工作
publicvoidstartWork（）{
finalRandomrandom=newRandom（）;
newThread（）{
@Override
publicvoidrun（）{
while（true）{
updateWeather（）;//每1~1.5秒更新一次天气1000~1500
for（Weathere:
list）{
e.notifyWeather（weather）;
}
ints=random.nextInt（501）+1000;//500
try{
Thread.sleep（s）;
}catch（InterruptedExceptione）{
e.printStackTrace（）;
}
}
}
}.start（）;
}
//更新天气的方法
publicvoidupdateWeather（）{
Randomrandom=newRandom（）;
intindex=random.nextInt（weathers.length）;
weather=weathers[index];
System.out.println（"当前的天气是：
"+weather）;
}
}
packagecn.itcast.reflect;
/*
反射：
当一个字节码文件加载到内存的时候，jvm会对该字节码进行解剖，然后会创建一个对象的Class对象，把字节码文件的信息全部都
存储到该Class对象中，我们只要获取到Class对象，我们就可以使用字节码对象设置对象的属性或者调用对象的方法等操作....
注意：
在反射技术中一个类的任何成员都有对应的类进行描述。
比如：
成员变量（Field）方法---->Method类
*/
publicclassDemo1{
Personp;
publicstaticvoidmain（String[]args）throwsClassNotFoundException{
//Personp=newPerson（110,"狗娃"）;
//推荐使用：
获取Class对象的方式一
Classclazz1=Class.forName（"cn.itcast.reflect.Person"）;
System.out.println（"clazz1:
"+clazz1）;
//获取Class对象的方式二：
通过类名获取
Classclazz2=Person.class;
System.out.println（"clazz1==clazz2?
"+（clazz1==clazz2））;
//获取Class对象的方式三：
通过对象获取
Classclazz3=newPerson（110,"狗娃"）.getClass（）;
System.out.println（
升级会员 