java--bat批处理、对象克隆、反射、观察者，工厂设计模式

最新推荐文章于 2021-05-26 10:46:01 发布

诺亚蜗牛_Snail

最新推荐文章于 2021-05-26 10:46:01 发布

阅读量220

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/qq_17503037/article/details/79979164

版权

java 专栏收录该内容

47 篇文章 0 订阅

订阅专栏

bat批处理文件

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

如何编写bat处理文件呢？

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

bat处理文件常用的命令：

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

对象的克隆

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

}
----------Address类
class Address implements Serializable{

String city;

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

对象的浅克隆

对象浅克隆要注意的细节：

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

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

结果：

=======构造方法调用了===
p1:编号：110 姓名：狗娃 地址：长沙
p2:编号：110 姓名：狗剩 地址：长沙

对象的深克隆

对象的深克隆：对象的深克隆就是利用对象的输入输出流把对象先写到文件上，然后再读取对象的
信息这个过程就称作为对象的深克隆。

//先要把对象写到文件上。
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();
}

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

}

结果：

=======构造方法调用了===
p1:编号：110 姓名：狗娃 地址：广州
p2:编号：110 姓名：狗娃 地址：长沙

懒汉单例设计模式(线程安全问题的解决方案):

//懒汉单例设计模式
class Single{

//  声明本类引用类型变量，但是不要创建对象。
private static Single s;

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

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

}

观察者设计模式

有时又被称为

    发布-订阅<Publish/Subscribe>模式、
    模型-视图<Model/View>模式、
    源-收听者<Source/Listener>模式
    或从属者<Dependents>模式）

Swing大量使用观察者模式，许多GUI框架也是如此。

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

观察者设计模式的步骤：

1. 当前目前对象发生指定的动作是，要通知另外一个对象做出相应的处理，这时候应该把对方的相应处理方法定义在接口上。
2. 在当前对象维护接口的引用，当当前对象发生指定的动作这时候即可调用接口中的方法了。

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

}

//订阅天气预报的接口
public interface Weather {


public void notifyWeather(String weather);

}

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

}

反射

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

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

Person p;

public static void main(String[] args) throws ClassNotFoundException {
    //Person p = new Person(110,"狗娃");

    //推荐使用： 获取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));


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

}

结果：

clazz1:class cn.itcast.reflect.Person
clazz1==clazz2?true
clazz2==clazz3?true

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

//获取到对应的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);

通过Class对象获取到对应的方法。

在反射技术中使用了Method类描述了方法的。

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 m = clazz.getMethod("eat", int.class);
    m.invoke(p, 3); //invoke 执行一个方法。 第一个参数：方法的调用对象。 第二参数： 方法所需要的参数。


    //执行私有的方法
    Method m =clazz.getDeclaredMethod("sleep",int.class);
    //设置访问权限允许访问
    m.setAccessible(true);
    m.invoke(null, 6);*/如果是静态方法第一个参数就传null

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

}

通过反射获取对应的成员变量

在反射技术中使用了Field类描述了成员变量的。

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 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;

}

Info.txt的内容：