Java基础学习第三十二天（批处理文件、对象的克隆、懒汉单例设计模式的解决方案、观察者设计模式、反射、工厂设计模式）

一、批处理文件

1、bat处理文件：bat处理文件就是可以一次性执行多个命令的文件。

2、为什么要学bat处理文件， 快速运行一个软件我一般都会把软件打包一个jar包。而jar双击可以运行仅对于图形化界面的软件起作用，对于控制台的程序是不起作用的。对于控制台的程序我们可以使用bat处理文件快速启动一个项目。

3、如何编写bat处理文件呢？
步骤： 编写一个自定义的文本文件，然后把后缀名改成bat即可，然后把你所要执行的命令写在bat处理文件中即可。

java -classpath \test.zip; cn.itcast.bat.Demo32.1

4、bat处理文件常用的命令

命令	解释
echo	向控制台输出指定的内容
echo off	隐藏echo off后面执行过的命令
@	隐藏当前行执行的命令
title	改变当前控制台窗口的标题
color	指定控制台的背景颜色与前景颜色
%%	%注释的内容%
pause	让当前控制台停留
%1~%9	给bat处理文件传入参数，并且只能在控制台传参

二、对象的克隆 ##

1、对象的浅克隆
① 如果一个对象需要调用clone的方法克隆，那么该对象所属的类必须要实现Cloneable接口。
② Cloneable接口只不过是一个标识接口而已，没有任何方法。
③ 对象的浅克隆就是克隆一个对象的时候，如果被克隆的对象中维护了另外一个类的对象，这时候只是克隆另外一个对象的地址，而没有把另外一个对象也克隆一份
④ 对象的浅克隆也不会调用到构造方法的。

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();
    }
}

public class Demo32.2 {
    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、对象的深克隆
对象的深克隆就是利用对象的输入输出流把对象先写到文件上，然后再读取对象的
信息这个过程就称作为对象的深克隆。

public class Demo32.3{
    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 void writeObj(Person p) throws IOException{
        //建立一个文件的输出流对象
        FileOutputStream fileOutputStream  = new FileOutputStream("F:\\obj.txt");
        //建立对象的输出流
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
        //把对象写出
        objectOutputStream.writeObject(p);
        //关闭资源
        objectOutputStream.close(); 
    }
    //再从文件中读取对象的信息
    public static Person readObj() throws ClassNotFoundException, IOException{
        FileInputStream fileInputStream = new FileInputStream("F:\\obj.txt");
        //创建对象的输入流对象
        ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
        return (Person) objectInputStream.readObject();
    }   
}

三、懒汉单例设计模式的解决方案

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

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 Demo32.4 {
}

四、观察者设计模式

1、观察者设计模式：观察者设计模式解决的问题是当一个对象发生指定的动作时，要通过另外一个对象做出相应的处理。

2、观察者设计模式的步骤
① 当前目前对象发生指定的动作是，要通知另外一个对象做出相应的处理，这时候应该把对方的相应处理方法定义在接口上。
② 在当前对象维护接口的引用，当当前对象发生指定的动作这时候即可调用接口中的方法了。

3、需求： 编写一个气象站、一个工人两个类，当气象站更新天气的时候，要通知人做出相应的处理。

问题1： 气象站更新了多次天气，然后人才做一次的处理。
问题2： 目前气象站只能通知一个人而已。
问题3： 在现实生活中出了工人群体要关注天气，其他的群体也需要关注天气

//气象站
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; //
                    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);
    }
}

public class WeatherMain {
    public static void main(String[] args) throws Exception {
        //工人
        Emp e1 = new Emp("小明");
        Emp e2 = new Emp("如花"); 
        //学生
        Student s1 = new Student("狗娃");
        Student s2 = new Student("狗剩");

        WeatherStation station = new WeatherStation();
        station.addListener(e1);
        station.addListener(e2);
        station.addListener(s1);
        station.addListener(s2);
        station.startWork();    
    }
}

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 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+"戴着头盔过来上学!");
        }
    }   
}

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

五、反射

1、反射： 当一个字节码文件加载到内存的时候，jvm会对该字节码进行解剖，然后会创建一个对象的Class对象，把字节码文件的信息全部都存储到该Class对象中，我们只要获取到Class对象，我们就可以使用字节码对象设置对象的属性或者调用对象的方法等操作

2、注意： 在反射技术中一个类的任何成员都有对应的类进行描述。
比如成员变量（Field）方法 > Method类

public class Demo32.5{
    Person p;
    public static void main(String[] args) throws ClassNotFoundException {
        //推荐使用：获取Class对象的方式一
        Class clazz1 = Class.forName("cn.itcast.reflect.Person");
        System.out.println("clazz1:"+ clazz1);

        //获取Class对象的方式二：通过类名获取
        Class clazz2 = Person.class;
        System.out.println("clazz1==clazz2?"+ (clazz1==clazz2));//true

        //获取Class对象的方式三：通过对象获取
        Class clazz3 = new Person(110,"狗娃").getClass();
        System.out.println("clazz2==clazz3?"+ (clazz2==clazz3));//true  
    }
}

public class Person {
    private int id;
    String name;
    public Person(int id,String name){
        this.id = id;
        this.name = name;
    }
    public Person(){}
    public void eat(int num){
        System.out.println(name+"吃很"+num+"斤饭");
    }
    private static void sleep(int num){
        System.out.println("明天睡上"+num+"小时");
    }
    public static void  sum(int[] arr){
        System.out.println("长度是："+ arr.length);
    }
    @Override
    public String toString() {
        return " 编号："+ this.id +" 姓名："+ this.name;
    }
}

2、如何通过Class对象获取构造方法。

public class Demo32.6 {
    public static void main(String[] args) throws Exception {
        //获取到对应的Class对象
        Class clazz = Class.forName("cn.itcast.reflect.Person");

        /**
        //通过Class对象获取对应的构造方法
        Constructor[] constructors = clazz.getConstructors();// getConstructors()获取一个类的所有公共的构造方法
        for(Constructor constructor:constructors){
            System.out.println(constructor);
        }   
        **/

        /**
        Constructor[] constructors =  clazz.getDeclaredConstructors(); //获取到一个类的所有构造方法，包括私有的
        for(Constructor constructor : constructors){
            System.out.println(constructor);
        }
        **/

        /**
        Constructor constructor = clazz.getConstructor(int.class,String.class); // getConstructor获取单个指定的构造方法    
        Person p  = (Person) constructor.newInstance(999,"小城"); // newInstance()创建一个对象
        System.out.println(p);
        **/

        //获取私有的构造函数
        Constructor constructor =  clazz.getDeclaredConstructor(null);
        //暴力反射
        constructor.setAccessible(true);
        Person p  =(Person) constructor.newInstance(null);
        System.out.println(p);  
    }
}

3、通过Class对象获取到对应的方法。在反射技术中使用了Method类描述了方法的。

public class Demo32.7 {
    public static void main(String[] args) throws Exception {
        //获取到对应的Class对象
        Class clazz = Class.forName("cn.itcast.reflect.Person");
        //获取到所有公共的方法

        /** 
        Method[] methods = clazz.getMethods(); // getMethods() 获取所有的公共方法 
        **/

        /** 
        Method[] methods = clazz.getDeclaredMethods(); //获取到所有的方法，但是不包含父类的方法
        for(Method method  : methods){
            System.out.println(method);
        }
        **/

        Person p = new Person(110,"狗娃");

        Method m1 = clazz.getMethod("eat", int.class);
        m1.invoke(p, 3); //invoke 执行一个方法，第一个参数：方法的调用对象。 第二参数：方法所需要的参数

        //执行私有的方法
        Method m2 =clazz.getDeclaredMethod("sleep",int.class);
        //设置访问权限允许访问
        m2.setAccessible(true);
        m2.invoke(null, 6);

        Method m3 = clazz.getMethod("sum", int[].class);
        m3.invoke(p,new int[]{12,5,9}); 
    }
}

4、通过反射获取对应的成员变量，在反射技术中使用了Field类描述了成员变量的。

public class Demo32.8{
    public static void main(String[] args) throws Exception {
        //获取到对应的Class对象
        Class clazz = Class.forName("cn.itcast.reflect.Person");

        /**
        //获取到所有的成员变量
        Field[] fields = clazz.getDeclaredFields();
        for(Field field  : fields){
            System.out.println(field);
        }
        **/

        Person p = new Person();
        Field field = clazz.getDeclaredField("id");
        //设置访问权限可以访问
        field.setAccessible(true);
        field.set(p, 110); //第一个参数设置该数据的成员变量，第二个参数设置该数据的属性值
        System.out.println(p);
    }   
}

六、工厂设计模式

工厂设计模式就是用于产生对象的。

class Car{}
class BMW extends Car{}
class BSJ extends Car{}

public class Demo32.9 {
    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;   
    }
}