java，

java，

bat处理文件，对象的克隆，内存泄露，单例设计模式
===============================================bat处理文件===============================================

bat处理文件：bat处理文件就是可以一次性执行多个文件。

为什么要学bat处理文件？
快速运行一个软件的时候一般会把软件打包成一个jar包。jar 双击运行仅对图形化界面起作用，对于控制台是不起作用的。一般想要快速启动一个控制台的程序，就会使用bat处理文件。

如何编写bat处理文件？
编写一个自定义文件，然后把自定义文件类型改为.bat即可，然后把要执行的命令写在bat处理文件就行。

bat处理文件常用的命令：
echo 向控制台输出指定的内容。
echo off 隐藏echo off 后面执行过的命令(但结果会显示)。
@ 一般用于隐藏当前执行的命令
title 改变当前控制台窗口的标题
color 指定控制台的背景颜色和前景颜色
%注释的内容%
pause 让当前控制台停留
%1--%9 给bat处理文件传入参数

具体可以看下面图片的做法：
图片
下面是bat处理文件时候一些小问题：
一般看到找不到主类这样的问题，就要考虑下要不要设置set classpath 。 例如运行一个压缩包的时候，就要设置set classpath或者也可以用 -classpath这种格式。
set classpath和 -classpath之间的区别？
set classpath是对当前控制台有作用；
-classpath是对本次操作有作用。
例如一个名叫text的zip压缩包，包名为day24，里面的类名是Demo;
set classpath=.\text.zip；
java day24.Demo

java -classpath(空格).\text.zip;(空格)day24.Demo

==================================对象的克隆=============================================================

对象的克隆分为：浅克隆和深克隆。

对象浅克隆要注意的细节：
1.如果一个对象需要调用clone的方法克隆，那么该对象所属的类必须要实现Cloneable接口。
2.Cloneable接口只是一个标示接口而已，没有任何方法。
3.对象的浅克隆就是克隆一个对象的时候，如果被克隆的对象中维护了另外一个类的对象，这时只是克隆另外一个对象的地址，而并没有把另外一个对象也克隆一份。

下面一个例子正好可以说明这些情况：

package day27;

import java.io.Serializable;

class Address {
String city;
public Address(String city){
this.city=city;
}
}

public class Person implements Cloneable{
int id;
String name;
Address address;
public Person(int id,String name){
this.id=id;
this.name=name;
}
public Person(int id , String name,Address address){

this.id=id;
this.name=name;
this.address=address;
}
public String toString(){
return "编号："+this.id+"姓名："+this.name+"地址："+address.city;
}
public Object clone()throws CloneNotSupportedException{
return super.clone();
}
}
public class Demo1 {

public static void main(String[] args) throws CloneNotSupportedException {
Address address = new Address("湖北");
Person p1 = new Person(110,"狗娃",address);
Person p2 = (Person)p1.clone();
p2.address.city="湖南";
System.out.println(p1);
System.out.println(p2);
}

}

结果如下图：
图片
再可以结合下面图片来分析：
图片


Person p1=p2 这个并不是克隆，只是对象内容地址的引用 ，并不属于克隆。
下面图片正好说明此情况：
图片

对象的深克隆：对象的深克隆就是利用对象的输入输出流把对象先写到文件上，然后再读取对象的信息。
下面例子说明对象的深克隆：

package day27;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

class Address implements Serializable{ //
String city;
public Address(String city){
this.city=city;
}
}

public class Person implements Cloneable,Serializable {//只有支持 java.io.Serializable 或 java.io.Externalizable 接口的对象才能从流读取。
int id;
String name;
Address address;
public Person(int id,String name){
this.id=id;
this.name=name;
}
public Person(int id , String name,Address address){

this.id=id;
this.name=name;
this.address=address;
}
public String toString(){
return "编号："+this.id+"姓名："+this.name+"地址："+address.city;
}
public Object clone()throws CloneNotSupportedException{
return super.clone();
}
}

public class Demo2 {

public static void main(String[] args) throws IOException, ClassNotFoundException {
Address address = new Address("湖北");
Person p1 = new Person(110,"狗娃",address);
writeObj(p1);
Person p2=readObj();
p2.address.city="长沙";
System.out.println(p1);
System.out.println(p2);

}
public static Person readObj() throws IOException, ClassNotFoundException{
FileInputStream fileInputStream = new FileInputStream("F:\\obj.txt");
ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
return (Person) objectInputStream.readObject();
}
public static void writeObj(Person p) throws IOException{
//建立一个文件的输出利用对象
FileOutputStream fileOutputStream = new FileOutputStream("F:\\obj.txt");
ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
objectOutputStream.writeObject(p);
objectOutputStream.close();

}

}

结果如下图图片
===================================================内存泄露===========================================



package day27;

import java.util.Arrays;
//
//先进后出
class StackList{
Object[] obj;
int index = 0;
public StackList(){
this.obj=new Object[3];
}
//添加内容
public void add(Object o){
ensu();
obj[index++]=o;
}
//出栈 :删除集合中的元素并且返回
public Object pop(){
int tex=--index;
Object o=obj[tex];
obj[tex]=null;//让该位置不再引用指定的对象 好让垃圾回收机制回收
return o;
}
//检查当前数组是否够用
public void ensu(){
if(index==obj.length){
int newlength = obj.length*2;
obj=Arrays.copyOf(obj, newlength);
}
}
public int size() {

return index;
}
}

public class Demo3 {
public static void main(String[] args){
StackList list = new StackList();
list.add("狗娃");
list.add("狗剩");
list.add("铁蛋");
list.add("美美");
int size= list.size();
for(int i=0; i<size;i++){
System.out.println(list.pop());
}
}

}

结果的顺序是 美美，铁蛋，狗剩，狗娃。

==========================================单例设计模式===============================================


package day27;
饿汉单例设计模式步骤:
1.私有化构造函数。
2.声明本类的引用类型变量，并且使用该变量指向本类对象。
3.提供一个公共静态的方法获取本类对象。
class SIngle{
private Single(){}
private static Single s=new Single();
public static Single get(){
return s;
}
}
懒汉单例设计模式：//一般不采用！！！！（懒汉单例设计模式一般是线程不安全的）
1.私有化构造函数。
2.声明本类的引用类型变量，但是不要创建对象。
3.提供公共静态的方法获取本类的对象，获取之前先判断是否已经创建了本类对象，如果已经创建了，那么直接返回对象即可，如果还没有创建，那么先创建本类对象，然后再返回。
class Single{
private Single(){}
private static Single s;
public static Single get(){
if(s==null){
synchronized("锁"){ //这样能够保证线程安全 ，并且在外面再加一个S==null 这样效率比不加 效率高 （第一次低 以后每次都快）
if(s==null){
s=new Single();
}
}
}
return s;
}
}