15/8/4反射，注解，工程设计模式，线程

反射注解

工厂设计模式

线程

反射例子

1.把所有的java文件抽象起来抽象到一个类中的方法就是反射

    public static void main(String[] args) {
//把所有的java文件抽象起来抽象到一个类中的方法就是反射
        Class<Student> clazz=Student.class;
//      Field[] field=clazz.getFields();//返回一个包含某些 Field 对象的数组，这些对象反映此 Class 对象所表示的类或接口的所有可访问公共字段
//      Field[] fields=clazz.getDeclaredFields();//以数组形式返回所有属性
//      for (Field field : fields) {
//          System.out.println(field.getName());//返回属性的名称
//          System.out.println(field.getModifiers());//返回修饰符的整数表示形式
//          System.out.println(field.getType().getName());//返回属性的类型名称
//      }
        Student zhangsan=new Student();//创建一个Student类对象zhangsan
        try {
            Field age=clazz.getDeclaredField("age");//得到指定名称的属性；
            age.setAccessible(true);//取消JAVA访问修饰符的检查
            age.set(zhangsan,18);//将对象张三的age属性的值更改为18
            age.setAccessible(false);//取消  取消检查
            System.out.println(zhangsan.getAge());//输出Student类对象zhangsan的age值
        } catch (NoSuchFieldException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

注解例子

@Target(ElementType.FIELD)//表示此注解只能用到属性上
@Retention(RetentionPolicy.RUNTIME)//表示此注解的范围是可执行的
public @interface TeacherAnnotation {
    int age() default 19;//如果注解中没有给出age的值，那么默认的值为19
    String name();
}

    @TeacherAnnotation(age=18,name="java")
    private  Teacher javaTeacher;
    @TeacherAnnotation(age=22,name="english")
    private  Teacher englishTeacher;
    @TeacherAnnotation(name="math")
    private  Teacher mathTeacher;
    public Clazz(){
        Class clazz=Clazz.class;//创建一个Class类的对象clazz
        Field[] fields=clazz.getDeclaredFields();//得到这个类中的所有属性
        for (Field field : fields) {
//          得到TeacherAnnotation的注解如果没有就返回Null
            TeacherAnnotation ta=field.getDeclaredAnnotation(TeacherAnnotation.class);
            if (ta==null) {
                continue;//跳出
            }else {
                int age=ta.age();//得到该注解的age值，如果没有就用默认值代替
                String name=ta.name();//得到该注解的name值
                Teacher teacher=new Teacher();//创建一个新的Teacher对象
                teacher.setAge(age);//将得到的age和name值放到该对象中
                teacher.setName(name);
                try {
                    field.setAccessible(true);//取消java修饰符访问
                    field.set(this, teacher);//将该Teacher对象放到此班级的对象中
                    field.setAccessible(false);//取消 取消访问
                } catch (IllegalArgumentException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }
    public Teacher getJavaTeacher() {
        return javaTeacher;
    }
    public void setJavaTeacher(Teacher javaTeacher) {
        this.javaTeacher = javaTeacher;
    }
    public Teacher getEnglishTeacher() {
        return englishTeacher;
    }
    public void setEnglishTeacher(Teacher englishTeacher) {
        this.englishTeacher = englishTeacher;
    }
    public Teacher getMathTeacher() {
        return mathTeacher;
    }
    public void setMathTeacher(Teacher mathTeacher) {
        this.mathTeacher = mathTeacher;
    }


    public static void main(String[] args) {
        Clazz clazz=new Clazz();
        System.out.println(clazz.getEnglishTeacher().getName());
        System.out.println(clazz.getMathTeacher().getAge());
    }

工厂化设计模式例子

    public static Person creatPerson(){//静态方法
        Person person=null;
        Properties p=new Properties();//创建一个无默认值的空属性列表
        try {
            p.load(new FileInputStream("config.properties"));//从输入流中读取属性列表（键和元素对）。
            String clazzName=p.getProperty("person");//用指定的键在此属性列表中搜索属性,返回属性列表中具有指定键值得值
            Class clazz=Class.forName(clazzName);//返回与带有给定字符串名的类或接口相关联的 Class 对象
            person=(Person) clazz.newInstance();//创建此 Class 对象所表示的类的一个新实例
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InstantiationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return person;
    }

    public static void main(String[] args) {
        Person person=Factory.creatPerson();
        person.sleep();
    }
public class Teacher extends Person{
    private int age;
    private String name;
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public void sleep() {
        System.out.println("老师睡觉");
    }
}

线程例子

    public static void main(String[] args) {
//      多个线程同时启动，同时运行相同数据
//      MyThread thread1=new MyThread("西西");
//      MyThread thread2=new MyThread("问问");
//      MyThread thread3=new MyThread("恩恩");
//      MyThread thread4=new MyThread("肉肉");
//      thread1.start();
//      thread2.start();
//      thread3.start();
//      thread4.start();
//      多个线程共用一个数据
//      MyRunnable runnable=new MyRunnable();
//      Thread t1=new Thread(runnable,"售票员one");
//      Thread t2=new Thread(runnable,"售票员two");
//      Thread t3=new Thread(runnable,"售票员three");
//      Thread t4=new Thread(runnable,"售票员four");
//      t1.start();
//      t2.start();
//      t3.start();
//      t4.start();
//      join用法
//      MyRunnable runnable=new MyRunnable();
//      Thread t1=new Thread(runnable,"售票员one");
//      t1.start();
//      try {
//          t1.join(1000);//直接调用join()指等待该线程结束 调用join(1000)指等待该线程执行1s
//      } catch (InterruptedException e) {
//          // TODO Auto-generated catch block
//          e.printStackTrace();
//      }
//      System.out.println("程序运行结束");
        MyCount runnable=new MyCount();
        Thread t1=new Thread(runnable,"售票员one");
        Thread t2=new Thread(runnable,"售票员two");
        Thread t3=new Thread(runnable,"售票员three");
        Thread t4=new Thread(runnable,"售票员four");
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
public class MyThread extends Thread{
    public MyThread(){

    }
    public MyThread(String name){
        super(name);
    }
    private int tickets=100;
    @Override
    public void run() {
        while(tickets>0){
            System.out.println(getName()+"售出了第"+tickets+"张票");
            tickets--;
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}
public class MyRunnable implements Runnable{
    private int i=100;
    private String s="new";
    @Override
    public void run() {
        while(i>0){
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            synchronized (s) {
                if (i>0) {

                    System.out.println(Thread.currentThread().getName()+"卖出了第"+i+"票");
                    i--;    
                }
            }
        }

    }

}
public class MyCount implements Runnable{
    private int count=1234; 
    String s="money";
    @Override
    public void run() {
        while(count>100){
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            synchronized (s) {
                if (count>100) {
                    count-=100;
                    System.out.println(Thread.currentThread().getName()+"取走了100还剩下"+count);
                }
            }
        }

    }

}

public class MyRunnable01 implements Runnable {

    @Override
    public void run() {
        String lock1 = "abc";
        String lock2 = "123";
        synchronized (lock1) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        System.out.println("我在等lock2");
        synchronized (lock2) {

        }


    }

}
public class MyRunnable02 implements Runnable{

    @Override
    public void run() {
        String lock1 = "abc";
        String lock2 = "123";
        synchronized (lock2) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        System.out.println("我在等lock1");
        synchronized (lock1) {

        }





    }

}
public class MyRunnableLockTest {
    public static void main(String[] args) {
        MyRunnable01 mr1=new MyRunnable01();
        MyRunnable02 mr2=new MyRunnable02();
        Thread t1=new Thread(mr1,"张三" );
        Thread t2=new Thread(mr2,"李四" );
        t1.start();
        t2.start();
    }
}