第27天 批处理、对象的克隆、内存溢出、设计模式、反射

1	批处理文件(bat)
快速运行一个软件我一般都会把软件打包成一个jar包
bat处理文件就是可以一次性执行多个命令的文件。
jar双击可以运行仅对于图形化界面的软件起作用，对于控制台的程序是不起作用的。
对于控制台的程序我们可以使用bat处理文件快速启动一个项目。
批处理的作用就是自动的连续执行多条命令 .编写bat处理文件可以使用记事本的方式:
常见批处理文件的命令：
echo 表示显示此命令后的字符
tiltle 设置窗口的标题。
echo off 表示在此语句后所有运行的命令都不显示命令行本身
color 设置窗体的字体颜色。
@与echo off相象，但它是加在每个命令行的最前面，表示运行时不显示这一行的命令行（只能影响当前行）。
pause 运行此句会暂停批处理的执行并在屏幕上显示Press any key to continue...的提示，等待用户按任意键后继续
rem 表示此命令后的字符为解释行（注释），不执行，只是给自己今后参考用的（相当于程序中的注释） 或者%注释的内容%
%[1-9]表示参数，参数是指在运行批处理文件时在文件名后加的以空格（或者Tab）分隔的字符串
2	对象的克隆
2.1	对象的浅拷贝
浅复制(浅克隆)被复制对象的所有变量都含有与原来对象相同的值，而所有的对其他对象的引用仍然只指向原来的对象，换言之，浅复制仅仅复制锁考虑的对象，而不复制它所引用的对象。package cn.itcast.copy;

import java.io.Serializable;

class Address implements Serializable {
String city;

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

public class Person implements Cloneable, Serializable {
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;
System.out.println("=======构造方法调用了===");
}

@Override
public String toString() {
return "编号：" + this.id + " 姓名：" + this.name + " 地址：" + address.city;
}

@Override
public Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
1. 如果一个对象需要调用clone的方法克隆，那么该对象所属的类必须要实现Cloneable接口。
2. Cloneable接口只不过是一个标识接口而已，没有任何方法。
3. 对象的浅克隆就是克隆一个对象的时候，如果被克隆的对象中维护了另外一个类的对象，这时候只是克隆另外一个对象的地址，而没有把另外一个对象也克隆一份。
4. 对象的浅克隆也不会调用到构造方法的。
package cn.itcast.copy;

public class Demo1 {
public static void main(String[] args) throws Exception {
Address address = new Address("广州");
Person p1 = new Person(110, "狗娃", address);
Person p2 = (Person) p1.clone(); //clone() 克隆了一个对象。

p2.name = "狗剩";
p2.address.city = "长沙";
System.out.println("p1:" + p1);
System.out.println("p2:" + p2);
}
}
2.2	对象深拷贝
深复制(深克隆)被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量，那些引用其他对象的变量将指向被复制过的新对象，而不再试原有的那些被引用的对象，换言之，深复制把要复制的对象所引用的对象都复制了一遍。
把对象写到流里的过程是串行化（Serilization）过程，但是在Java程序师圈子里又非常形象地称为“冷冻”或者“腌咸菜（picking）”过程；而把对象从流中读出来的并行化（Deserialization）过程则叫做“解冻”或者“回鲜(depicking)”过程。应当指出的是，写在流里的是对象的一个拷贝，而原对象仍然存在于JVM里面，因此“腌成咸菜”的只是对象的一个拷贝，Java咸菜还可以回鲜。
在Java语言里深复制一个对象，常常可以先使对象实现Serializable接口，然后把对象（实际上只是对象的一个拷贝）写到一个流里（腌成咸菜），再从流里读出来（把咸菜回鲜），便可以重建对象。
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

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:" + p1);
System.out.println("p2:" + p2);
}

//再从文件中读取对象的信息
public static Person readObj() throws ClassNotFoundException, IOException {
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();
}
}
3.内存溢出
由于Java具备自动的垃圾回收机制,当我们使用完对象之后,它们会被自动回收,是不是我们在Java程序中不需要再考虑内存管理了吗?
请看如下程序:
注意:从栈中弹出的对象不会作为垃圾回收,即使程序不再使用这些对象,因为栈内部继续维护着这些对象.最终可能会导致内存占用的不断增加,程序性能降低.这就是内存泄漏.
改进版本
class StackList {
Object[] elements;
int index = 0; //当前的索引值

public StackList() {
this.elements = new Object[3];
}

//添加内容
public void add(Object o) {
//添加元素之前应该要先检查是否容量够用。
ensureCapcity();
elements[index++] = o;
}

//出栈: 删除集合的元素，并且返回。
public Object pop() {
int tempIndex = --index;
Object o = elements[tempIndex];
elements[tempIndex] = null; //让该位置不再 引用着指定的对象,让垃圾回收期赶快回收该垃圾。

return o;
}

//检查当前的数组使用够用。
public void ensureCapcity() {
if (index == elements.length) {
//计算一个新的长度
int newLength = elements.length * 2;
elements = Arrays.copyOf(elements, newLength);
}
}

//获取当前的元素 个数
public int size() {
return index;
}
}

public class Demo1 {
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());
}
}
}
4.设计模式
设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。
4.1观察者模式
有时又被称为
发布-订阅<Publish/Subscribe>模式、
模型-视图<Model/View>模式、
源-收听者<Source/Listener>模式
或从属者<Dependents>模式）
这是软件设计模式的一种。
观察者模式（Observer）完美的将观察者和被观察的对象分离开。
此种模式中，一个目标物件管理所有相依于它的观察者物件，并且在它本身的状态改变时主动发出通知。
这通常透过呼叫各观察者所提供的方法来实现。
此种模式通常被用来实作事件处理系统。
有多个观察者时，不可以依赖特定的通知次序。
Swing大量使用观察者模式，许多GUI框架也是如此。
气象站：
观察者设计模式：观察者设计模式解决的问题时当一个对象发生指定的动作时，要通过另外一个对象做出相应的处理。
需求： 编写一个气象站、一个工人两个类，当气象站更新天气 的时候，要通知人做出相应的处理。
问题1： 气象站更新了多次天气，然后人才做一次的处理。
问题2： 目前气象站只能通知一个人而已。
问题3： 在现实生活中出了工人群体要关注天气，其他 的群体也需要关注天气
观察者设计模式的步骤：
1. 当前目前对象发生指定的动作是，要通知另外一个对象做出相应的处理，这时候应该把对方的相应处理方法定义在接口上。
2. 在当前对象维护接口的引用，当当前对象发生指定的动作这时候即可调用接口中的方法了。
package cn.itcast.observer;
import java.util.ArrayList;
import java.util.Random;
//气象站
public class WeatherStation {
String[] weathers = { "晴天", "雾霾", "刮风", "冰雹", "下雪" };

//当前天气
String weather;
//该集合中存储的都是需要收听天气预报的人
ArrayList<Weather> list = new ArrayList<Weather>(); //程序设计讲究低耦合---->尽量不要让一个类过分依赖于另外一个类。

public void addListener(Weather e) {
list.add(e);
}

//开始工作
public void startWork() {
final Random random = new Random();

new Thread() {
@Override
public void run() {
while (true) {
updateWeather(); // 每1~1.5秒更新一次天气  1000~1500

for (Weather e : list) {
e.notifyWeather(weather);
}

int s = random.nextInt(501) + 1000; //  500

try {
Thread.sleep(s);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}.start();
}

//更新天气的 方法
public void updateWeather() {
Random random = new Random();
int index = random.nextInt(weathers.length);
weather = weathers[index];
System.out.println("当前的天气是： " + weather);
}
}

package cn.itcast.observer;

import java.util.Random;

package cn.itcast.observer;

//人 是要根据天气做出相应的处理的。
public class Emp implements Weather {
String name;

public Emp(String name) {
this.name = name;
}

//人是要根据天气做出相应的处理的。  "晴天","雾霾","刮风","冰雹","下雪"
public void notifyWeather(String weather) {
if ("晴天".equals(weather)) {
System.out.println(name + "高高兴兴的去上班!!");
} else if ("雾霾".equals(weather)) {
System.out.println(name + "戴着消毒面具去上班!");
} else if ("刮风".equals(weather)) {
System.out.println(name + "拖着大石头过来上班!");
} else if ("冰雹".equals(weather)) {
System.out.println(name + "戴着头盔过来上班!");
} else if ("下雪".equals(weather)) {
System.out.println(name + "戴着被子过来上班!");
}
}
}

public class WeatherMain {
public static void main(String[] args) throws Exception {
//工人
Emp e = new Emp("小明");
Emp e2 = new Emp("如花");

//学生
Student s1 = new Student("狗娃");
Student s2 = new Student("狗剩");

WeatherStation station = new WeatherStation();
station.addListener(e);
station.addListener(e2);
station.addListener(s1);
station.addListener(s2);

station.startWork();
}
}
package cn.itcast.observer;

//订阅天气预报的接口
public interface Weather {
public void notifyWeather(String weather);
}

package cn.itcast.observer;

public class Student implements Weather {
String name;

public Student(String name) {
super();
this.name = name;
}

public void notifyWeather(String weather) {
if ("晴天".equals(weather)) {
System.out.println(name + "高高兴兴的去开学!!");
} else if ("雾霾".equals(weather)) {
System.out.println(name + "吸多两口去上学!");
} else if ("刮风".equals(weather)) {
System.out.println(name + "在家睡觉!");
} else if ("冰雹".equals(weather)) {
System.out.println(name + "在家睡觉!");
} else if ("下雪".equals(weather)) {
System.out.println(name + "等下完再去上学!");
}
}
}
4.2单例
Singleton
是指只能拥有一个实例的类就是单例类。
私有构造方法。
获取方式
通过公共的静态方法创建单一的实例。
两种模式
懒汉模式 – 通常被称为延迟加载。注意存在线程安全问题.
饿汉模式
懒汉式的单例模式线程安全问题的解决方案：
package cn.itcast.single;

/*
单例设计模式：

懒汉单例设计模式(线程安全问题 的解决方案):
步骤：
1. 私有化构造函数。
2. 声明本类引用类型变量，但是不要创建对象。
3. 声明一个公共静态的方法获取本类的对象，获取之前先判断是否已经创建了本类的对象了，如果已经创建了
就不要在创建直接返回即可，如果还没有创建，那么就先创建本类的引用类型变量，然后再返回。

*/

//懒汉单例设计模式
class Single {
//	声明本类引用类型变量，但是不要创建对象。
private static Single s;

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

//	声明一个公共静态的方法获取本类的对象
public static Single getInstance() {
if (s == null) {
synchronized ("锁") {
if (s == null) {
s = new Single();
}
}
}

return s;
}
}

public class Demo1 {
}
5．反射
类字节码文件是在硬盘上存储的，是一个个的.class文件。我们在new一个对象时，JVM会先把字节码文件的信息读出来放到内存中，第二次用时，就不用在加载了，而是直接使用之前缓存的这个字节码信息。

字节码的信息包括：类名、声明的方法、声明的字段等信息。在Java中“万物皆对象”，这些信息当然也需要封装一个对象，这就是Class类、Method类、Field类。

通过Class类、Method类、Field类等等类可以得到这个类型的一些信息，甚至可以不用new关键字就创建一个实例，可以执行一个对象中的方法，设置或获取字段的值，这就是反射技术。
5.1Class类
5.1获取Class对象的三种方式

Java中有一个Class类用于代表某一个类的字节码。
Java提供了三种方式获取类的字节码
forName()。forName方法用于加载某个类的字节码到内存中，并使用class对象进行封装
类名.class
对象.getClass()

/**
* 加载类的字节码的3种方式
* @throws Exception
* */
public void test1() throws Exception {
// 方式一
Class clazz1 = Class.forName("cn.itcast.gz.reflect.Person");
// 方式二
Class clazz2 = Person.class;
// 方式三
Person p1 = new Person();
Class clazz3 = p1.getClass();
}
5.2通过Class类获取类型的一些信息
1. getName()类的名称（全名，全限定名）
2 getSimpleName()类的的简单名称（不带包名）
3. getModifiers(); 类的的修饰符
4.创建对象
无参数构造创建对象
newInstance()
5. 获取指定参数的构造器对象，并可以使用Constructor对象创建一个实例
Constructor<T> getConstructor(Class<?>... parameterTypes)

/**
* 通过Class对象获取类的一些信息
*
* @throws Exception
* */
private static void test2() throws Exception {

Class clazz1 = Class.forName("cn.itcast.gz.reflect.Person");
// 获取类的名称
String name = clazz1.getName();
System.out.println(name); // cn.itcast.gz.reflect.Person
// 获取类的简单名称
System.out.println(clazz1.getSimpleName()); // Person
// 获取类的修饰符
int modifiers = clazz1.getModifiers();
System.out.println(modifiers);
// 构建对象(默认调用无参数构造.)
Object ins = clazz1.newInstance();
Person p = (Person) ins;
System.out.println(p); // cn.itcast.gz.reflect.Person@c17164
// 获取指定参数的构造函数
Constructor<?> con = clazz1.getConstructor(String.class, int.class);
// 使用Constructor创建对象.
Object p1 = con.newInstance("jack", 28);
System.out.println(((Person) p1).getName());
}

5.3通过Class类获取类型中的方法的信息
1.获取公共方法包括继承的父类的方法
getMethods()返回一个数组,元素类型是Method
2.获取指定参数的公共方法
getMethod("setName", String.class);
3.获得所有的方法,包括私有
Method[] getDeclaredMethods()
4.获得指定参数的方法,包括私有
Method getDeclaredMethod(String name, Class<?>... parameterTypes)
/**
* 获取公有方法.
* @throws Exception
* */
private static void test3() throws Exception {
Class clazz1 = Class.forName("cn.itcast.gz.reflect.Person");
// 1.获取非私用方法(包括父类继承的方法)
Method[] methods = clazz1.getMethods();
System.out.println(methods.length);
for (Method m : methods) {
// System.out.println(m.getName());
if ("eat".equals(m.getName())) {
m.invoke(clazz1.newInstance(), null);
}
}

}

/**
* 获取指定方法签名的方法
*
* @throws Exception
* */
private static void test4() throws Exception {
Class clazz1 = Class.forName("cn.itcast.gz.reflect.Person");
// 获取指定名称的函数
Method method1 = clazz1.getMethod("eat", null);
method1.invoke(new Person(), null);
}

/**
* 获取指定方法名且有参数的方法
*
* @throws Exception
* */
private static void test5() throws Exception {
Class clazz1 = Class.forName("cn.itcast.gz.reflect.Person");
Method method = clazz1.getMethod("eat", String.class);
method.invoke(new Person(), "包子");
}

/**
* 获取指定方法名,参数列表为空的方法.
*
* @throws Exception
* */
private static void test4() throws Exception {
Class clazz1 = Class.forName("cn.itcast.gz.reflect.Person");
// 获取指定名称的函数
Method method1 = clazz1.getMethod("eat", null);
method1.invoke(new Person(), null);
}

/**
* 反射静态方法
* @throws Exception
* */
private static void test7() throws Exception {
Class clazz1 = Class.forName("cn.itcast.gz.reflect.Person");
Method method = clazz1.getMethod("play", null);
method.invoke(null, null);
}

/**
* 访问私有方法 暴力反射
* @throws Exception
* */
private static void test6() throws Exception {
Class clazz1 = Class.forName("cn.itcast.gz.reflect.Person");
Method method = clazz1.getDeclaredMethod("movie", String.class);
method.setAccessible(true);
method.invoke(new Person(), "苍老师");
}

5.4通过Class类获取类型中的字段的信息
1.获取公共字段
Field[] getFields()
2.获取指定参数的公共字段
Field getField(String name)
3.获取所有的字段
Field[] getDeclaredFields()
4.获取指定参数的字段,包括私用
Field getDeclaredField(String name)

/**
* 获取公有的字段
* */
private static void test8() throws Exception {
Class clazz1 = Class.forName("cn.itcast.gz.reflect.Person");
Field[] fields = clazz1.getFields();
Person p = new Person();
System.out.println(fields.length);
for (Field f : fields) {
System.out.println(f.getName());
if ("name".equals(f.getName())) {
System.out.println(f.getType().getName());
f.set(p, "jack");
}
}
System.out.println(p.getName());

}

/**
* 获取私有的字段
* @throws Exception
* */
private static void test9() throws Exception {
Class clazz1 = Class.forName("cn.itcast.gz.reflect.Person");
Field field = clazz1.getDeclaredField("age");
System.out.println(field.getName());
field.setAccessible(true);
Person p = new Person();
field.set(p, 100);
System.out.println(p.getAge());
}

6.工厂模式
该模式将创建对象的过程放在了一个静态方法中来实现.在实际编程中,如果需要大量的创建对象,该模式是比较理想的.
package cn.itcast.factory;

import cn.itcast.reflect.Person;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;

/*
工厂设计模式就是用于产生对象 的。
*/
class Car {
}

class BMW extends Car {
}

class BSJ extends Car {
}

public class Demo1 {
public static void main(String[] args) throws Exception {
Person p = (Person) getInstance();
System.out.println(p);
}

//需求： 编写一个工厂方法根据配置文件返回对应的对象。
public static Object getInstance() throws Exception {
//读取配置文件
BufferedReader bufferedReader = new BufferedReader(new FileReader(
"info.txt"));

//读取第一行 : 读取类文件的信息
String className = bufferedReader.readLine();

//通过完整类名获取对应 的Class对象
Class clazz = Class.forName(className);

//获取到对应的构造方法
Constructor constructor = clazz.getDeclaredConstructor(null);
constructor.setAccessible(true);

Object o = constructor.newInstance(null);

//给对象设置对应的属性值
String line = null;

while ((line = bufferedReader.readLine()) != null) {
String[] datas = line.split("=");
Field field = 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]);
}
}

return o;
}
}