8.4java学习笔记

最新推荐文章于 2024-07-20 23:59:39 发布
最新推荐文章于 2024-07-20 23:59:39 发布
阅读量546 收藏
点赞数
分类专栏： Java 文章标签： 多线程 工厂模式 java 死锁
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/NiZhuanXingHeIT/article/details/47277539
版权

知识点

工厂模式

工厂模式可以减少代码的修改量

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Properties;

public class Factory {
    public static Person createPerson(){
        Person person = null;
        Properties p = new Properties();
        try {
            p.load(new FileInputStream("config.properties"));
            String clazzName = p.getProperty("person");
            Class clazz = Class.forName(clazzName);
            person = (Person)clazz.newInstance();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return person;
    }

}
public interface Person {
    public void sleep();
}
public class Teacher implements Person {

    @Override
    public void sleep() {
        System.out.println("老师睡觉");
    }

}
public class Worker implements Person {

    @Override
    public void sleep() {
        System.out.println("工人睡觉");
    }

}
public class Test {

    public static void main(String[] args) {
        Person person = Factory.createPerson();
        person.sleep();
    }

}
以下是需要解析的properties文件内容

person=com.chu.factoryModel.Teacher

反射

类Class概述

Class 类的实例表示正在运行的 Java 应用程序中的类和接口。枚举是一种类，注释是一种接口。每个数组属于被映射为 Class 对象的一个类，所有具有相同元素类型和维数的数组都共享该 Class 对象。基本的 Java 类型（boolean、byte、char、short、int、long、float 和 double）和关键字 void 也表示为 Class 对象。

Class 没有公共构造方法。Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的 defineClass 方法自动构造的。

    /*
    * 反射
     */
    Class<Student> clazz = Student.class;
    //Field[] fields = clazz.getFields();//以数组形式返回所有公共属性
    /*Field[] fields = clazz.getDeclaredFields();//以数组形式返回所有属性
    for(Field field:fields){
        System.out.println(field.getName());//返回属性名称
        System.out.println(field.getType());//返回属性的类型
        System.out.println(field.getType().getName());//返回属性的类型名称
        System.out.println(field.getModifiers());//返回属性访问修饰符的整数表示形式
    }*/
    Student zhangsan = new Student();
    try {
        Field age = clazz.getDeclaredField("age");//得到指定的属性age
        age.setAccessible(true);        //取消java访问修饰符检查
        age.set(zhangsan, 19);      //将对象zhangsan的age属性的值更改为19
        age.setAccessible(false);   //取消  取消java访问修饰符检查
        System.out.println(zhangsan.getAge());//输出对象zhangsan的age值
    } catch (NoSuchFieldException e) {
        e.printStackTrace();
    } catch (SecurityException e) {
        e.printStackTrace();
    } catch (IllegalArgumentException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    }
}
public class Student {
    private String name;
    private int age;
    public String no;
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }

}

注解

public class Teacher {
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }

}
建立一个注解类
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)//表示此注解的范围是可执行的
@Target(ElementType.FIELD)//表示此注解只能用到属性上
public @interface ClazzAnotation {
    String name();
    int age() default 24;//如果age在注解中没有声明则使用默认default值
}
public class Clazz {
    @ClazzAnotation(name="张三",age=27)
    private Teacher javaTeacher;
    @ClazzAnotation(name="李四",age=22)
    private Teacher englishTeacher;
    @ClazzAnotation(name="王五")
    private Teacher mathTeacher;

    public Clazz() {
        Class clazz = this.getClass();
        Field[] fields = clazz.getDeclaredFields();//得到clazz的所有属性
        for(Field field:fields){
            ClazzAnotation ca = field.getAnnotation(ClazzAnotation.class);//得到clazzAnotation的注解，如果没有返回null
            if(ca==null){
                continue;//如果为null跳出
            }else{
                int age = ca.age();//得到该注解的age值，如果没有则赋默认值
                String name = ca.name();//得到该注解的name值
                Teacher teacher = new Teacher();
                teacher.setAge(age);
                teacher.setName(name);//根据注解的值创建新的对象
                try {
                    field.setAccessible(true);
                    field.set(this,teacher);//将这个teacher对象赋值clazz对象的该属性
                    field.setAccessible(false);
                } catch (IllegalArgumentException e) {
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    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 class Test {

    public static void main(String[] args) {
        Teacher teacher = new Clazz().getEnglishTeacher();
        Teacher teacher2 = new Clazz().getJavaTeacher();
        System.out.println(teacher.getName()+teacher.getAge());
        System.out.println(teacher2.getName()+teacher2.getAge());
    }
}

多线程

Thread()
public class MyThread extends Thread{
    private static int ticketNum = 50;
    private String lock = "lock";
    public MyThread() {

    }
    public MyThread(String name) {
        super(name);
    }
    @Override
    public void run() {
        while (ticketNum>0) {
            try {
                sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized(lock){//线程锁
                System.out.println(this.getName()+"卖出第"+(ticketNum--)+"张票");
            }
        }
    }
}
public static void main(String[] args) {
    new MyThread("张三").start();
    new MyThread("李四").start();
    new MyThread("王五").start();
    new MyThread("赵六").start();
}

运行结果：
多线程

runnable方式
public class Myrunnable implements Runnable{
    private int ticketNum = 50;
    private String lock = "lock";
    public void run() {
        while (ticketNum>0) {
            while (ticketNum>0) {
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //运行结果的最后会出现卖出负数张票，是因为当ticketNum=0时，还有线程还在线程锁处等候，直至它们全部执行完，倒置票数仍在减少
                synchronized(lock){
                    System.out.println(Thread.currentThread().getName()+"卖出第"+(ticketNum--)+"张票");
                }
            }
        }
    }
}
setPriority()与join两种方法

概述：
public final void join()
throws InterruptedException等待该线程终止。

抛出：
InterruptedException - 如果任何线程中断了当前线程。当抛出该异常时，当前线程的中断状态 被清除
若带参数：
等待该线程终止的时间最长为 millis 毫秒 + nanos 纳秒。
参数：
millis - 以毫秒为单位的等待时间。
nanos - 要等待的 0-999999 附加纳秒

    new MyThread("张三").start();
    Myrunnable myrunnable = new Myrunnable();
    Thread t1 = new Thread(myrunnable,"张三");
    Thread t2 = new Thread(myrunnable,"李四");
    Thread t3 = new Thread(myrunnable,"王五");
    Thread t4 = new Thread(myrunnable,"赵六");
    t1.start();
    t2.setPriority(10);//setPriority()方法用于设置优先级，参数越大优先级越高，优先级范围：1~10
    try {
        t1.join();//join()是指知道调用该方法的线程执行完再往下执行主线程，如果里面带参数，则是指执行多少毫秒后再往下执行
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("运行结束");
死锁的写法
public class MyRunnable1 implements Runnable{
    private String key1 = "key1";
    private String key2 = "key2";
    @Override
    public void run() {
        synchronized (key1) {
            System.out.println(Thread.currentThread().getName()+"进了room1，持有第一把钥匙");
            try {
                System.out.println(Thread.currentThread().getName()+"要睡觉了");
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"醒了，他需要第二把钥匙");
            synchronized(key2){
                System.out.println(Thread.currentThread().getName()+"进了room2，持有第二把钥匙");
            }
        }
    }
}
public class MyRunnable2 implements Runnable{
    private String key1 = "key1";
    private String key2 = "key2";
    @Override
    public void run() {
        synchronized (key2) {
            System.out.println(Thread.currentThread().getName()+"进了room2，持有第一把钥匙");
            try {
                System.out.println(Thread.currentThread().getName()+"要睡觉了");
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"醒了，他需要第一把钥匙");
            synchronized(key1){
                System.out.println(Thread.currentThread().getName()+"进了room1，持有第二把钥匙");
            }
        }
    }
}
public class Test {

    public static void main(String[] args) {
        MyRunnable1 myRunnable1 = new MyRunnable1();
        MyRunnable2 myRunnable2 = new MyRunnable2();
        new Thread(myRunnable1, "张三").start();
        new Thread(myRunnable2, "李四").start();
    }

}

运行结果：
死锁

逆转星河
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java学习笔记
VanMonday的博客
05-12 1015
兰智数加Java学习笔记
java学习笔记4
hanq2016的博客
04-19 619
java学习笔记，持续更新，非常完整
Java学习笔记8.4
weixin_37047553的博客
08-05 72
IO流相关
java8学习笔记
weixin_45484128的博客
09-24 227
本文内容编辑主要是对lambda表达式、函数式接口、引用、stream api的学习记录等，后续会逐渐更新，作者本人是在其他平台编译，拷贝过来的
java学习笔记 初学者必读
05-08
8.4. 捕捉多个异常 8-38 8.5. finally 声明 8-38 8.6. 异常调用栈 8-39 8.7. 异常层次 8-39 8.8. 一些未检查的异常 8-39 8.9. 写你自己的异常 8-39 8.10. 抛出你自己的异常 8-40 9. 八•图形用户接口 9-40 10. 九•...
Go 语言编程 + Go 学习笔记
06-04
Go 语言编程 + Go 学习笔记, 第 部分 语 第 1 章 类型 1.1 变量 1.2 常量 1.3 基本类型 1.4 引 类型 1.5 类型转换 1.6 字符串 1.7 指针 1.8 定义类型 第 2 章 表达式 2.1 保留字 2.2 运算符 2.3 初始化 2.4 控制流 ...
Go学习笔记（第四版）.zip
07-02
Go 学习笔记, 第 4 版 4.4 Struct 47 第 5 章 ⽅法 53 5.1 ⽅法定义 53 5.2 匿名字段 54 5.3 ⽅法集 56 5.4 表达式 56 第 6 章 接⼝ 60 6.1 接⼝定义 60 6.2 执⾏机制 62 6.3 接⼝转换 63 6.4 接⼝技巧 65 第 7 章 ...
华为Datacom HCIA学习笔记
09-19
【华为Datacom HCIA学习笔记】是一份详细记录基础网络技术知识的学习资料，涵盖了从数据通信的基本概念到网络协议、华为VRP系统、IP路由、OSPF、以太网交换、VLAN、ACL访问控制列表以及NAT网络地址转换等多个核心...
8.3java学习笔记
NiZhuanXingHeIT的博客
08-03 696
知识点URL打印一个网址的信息try { URL url = new URL("http://www.baidu.com"); InputStream is = url.openStream(); BufferedReader br = new BufferedReader(new InputStreamReader(is)); Str
8.5-Learning Java
NiZhuanXingHeIT的博客
08-05 667
知识点：多线程（续）消费者与生产者(一般方法)概述：生产者没生产一个产品，就休眠一段时间让消费者消费此产品，当消费者消费完该产品后，唤醒生产者继续生产者。在程序中，消费者与生产者的共享对象是产品，故以产品作为程序锁。Productorpublic class Productor implements Runnable{ private Production production; pub
8.10 mysql
NiZhuanXingHeIT的博客
08-10 630
知识点1.MySQL的基本语法：1、说明：创建数据库 CREATE DATABASE database-name 2、说明：删除数据库 drop database dbname 3、说明：备份sql server — 创建 备份数据的 device USE master EXEC sp_addumpdevice ‘disk’, ‘testBack’, ‘c:\mssql7backup\
8.12java学习篇
NiZhuanXingHeIT的博客
08-12 622
概况还是关于服务器和客户端的数据解析，今天用的是HttpClient。实现的机理是，客户端与服务器交互，服务器与数据库交互。知识点doGet 直接连在url后边,是显示的 doPost 是隐式的，比doGet安全服务器serverlet/** * Servlet implementation class MyServerlet */ @WebServlet("/MyServerlet")
8.2学习笔记
NiZhuanXingHeIT的博客
08-02 551
知识点1.TCP/IP服务器serverpublic class MyServer { public static void main(String[] args) { try { ServerSocket server = new ServerSocket(8080); System.out.println("服务器启动");
8.11java学习篇
NiZhuanXingHeIT的博客
08-11 532
概况mvc设计模式、mySQL的事务、serverlet知识点1.mvc设计模式所谓mvc设计模式，就是将集中的代码放到不同的类的方法中，没个模块不必实现太多功能，如：一个聊天程序中，登录界面类只完成登录功能，网络连接类只完成网络连接的功能，聊天窗口类只写与聊天功能相关的方法，避免冗余。2.事务即一组不可拆分的操作。代码1： Connection conn = SQLManager.newIn
单例模式深度分析
NiZhuanXingHeIT的博客
04-04 500
概述 单例模式，它能保证我们始终如一的使用同一个对象，我们平时经常会去用它，因为可以避免重复制造对象，减少内存隐患，我们也都可以写个常见的单例出来。 这里要讲下单例到底应该怎么写，既能避免线程不安全，也能保证性能。 内容 1、一个最简单的单例模式 public class GirlFriend { //静态变量记录唯一实例 private static Gi...
观察者模式深度分析
NiZhuanXingHeIT的博客
04-16 492
概述 观察者模式是一种很常用的设计模式，Android中的广播（Broadcast）就是用观察者模式设计的，再往大一步，诸如微博这种社交平台也是用的观察者模式，观察者模式亦被称作发布-订阅模式。观察者模式包含两个要素：目标对象、观察者对象。其中，当目标对象的状态发生改变时，它所依赖的观察者将立即得到通知，通知携带的数据将在消息中心得到处理。 内容 1、使用观察者模式的场景 当一个对...
在eclipse中导入本地的jar包配置Junit环境步骤（包含Junit中的方法一直标红的解决方法）
最新发布
weixin_70987470的博客
07-20 205
从本地导入Junit
TIBCORendezvous Java官方8.4版参考文档
TIBCORendezvous® Java Reference文档是TIBCO公司官方发布的一份技术指南，针对RV（Rendezvous）软件的Java接口进行了详细介绍，适用于TIBCO Software Release 8.4版本，发行日期为2012年2月。这份文档对于开发人员...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值