Java基础加强——Junit、反射、注解

今日内容

1. Junit单元测试
2. 反射
3. 注解

Junit单元测试：

* 测试分类：
    1. 黑盒测试：不需要写代码，给输入值，看程序是否能够输出期望的值。
    2. 白盒测试：需要写代码的。关注程序具体的执行流程。

* Junit使用：白盒测试
    * 步骤：
        1. 定义一个测试类(测试用例)
            * 建议：
                * 测试类名：被测试的类名Test       CalculatorTest
                * 包名：xxx.xxx.xx.test        cn.itcast.test

        2. 定义测试方法：可以独立运行
            * 建议：
                * 方法名：test测试的方法名        testAdd()  
                * 返回值：void
                * 参数列表：空参

        3. 给方法加@Test
        4. 导入junit依赖环境

    * 判定结果：
        * 红色：失败
        * 绿色：成功
        * 一般我们会使用断言操作来处理结果
            * Assert.assertEquals(期望的结果,运算的结果);

    * 补充：
        * @Before:
            * 修饰的方法会在测试方法之前被自动执行
        * @After:
            * 修饰的方法会在测试方法执行之后自动被执行

/**
 * 计算器类
 *
 *  测试分类：
 *  1. 黑盒测试：不需要写代码，给输入值，看程序是否能够输出期望的值。
 *  2. 白盒测试：需要写代码的。关注程序具体的执行流程。更有技术含量
 *
 *  单元测试的使用步骤：
 *  * Junit使用：白盒测试
 *  * 步骤：
 *      1. 定义一个测试类(测试用例)
 *          * 建议：
 *              * 测试类名：被测试的类名Test       CalculatorTest
 *              * 包名：xxx.xxx.xx.test        cn.itcast.test
 *
 *      2. 定义测试方法：可以独立运行
 *          * 建议：
 *              * 方法名：test测试的方法名        testAdd()
 *              * 返回值：void
 *              * 参数列表：空参
 *
 *      3. 给方法加@Test
 *      4. 导入junit依赖环境
 *
 *  * 判定结果：
 *      * 红色：失败
 *      * 绿色：成功
 *      * 一般我们会使用断言操作来处理结果
 *          * Assert.assertEquals(期望的结果,运算的结果);
 *
 *  * 补充：（注意哪怕是程序出了错误，before和after都也会执行，而且执行顺序好像没有规律）
 *      * @Before:
 *          * 修饰的方法会在测试方法之前被自动执行
 *      * @After:
 *          * 修饰的方法会在测试方法执行之后自动被执行
 *
 */
public class CalculatorTest {

    @Before
    public void  init(){
        System.out.println("init....");
    }

    @After
    public void close0(){
        System.out.println("close0...");
    }
    @After
    public void close1(){
        System.out.println("close1...");
    }
    @After
    public void close2(){
        System.out.println("close2...");
    }

    @Test
    public void testAdd(){
        Calculator calculator = new Calculator();
        int result = calculator.add(1, 2);
        System.out.println(result);
    }

    @Test
    public void testSub(){
        Calculator calculator = new Calculator();
        int result = calculator.sub(3, 1);
        //System.out.println(result);
        Assert.assertEquals(2,result);
    }

}

反射：框架设计的灵魂

* 框架：半成品软件。可以在框架的基础上进行软件开发，简化编码
* 反射：将类的各个组成部分封装为其他对象，这就是反射机制
    * 好处：
        1. 可以在程序运行过程中，操作这些对象。
        2. 可以解耦，提高程序的可扩展性。

* 获取Class对象的方式：
    1. Class.forName("全类名")：将字节码文件加载进内存，返回Class对象
        * 多用于配置文件，将类名定义在配置文件中。读取文件，加载类
    2. 类名.class：通过类名的属性class获取
        * 多用于参数的传递
    3. 对象.getClass()：getClass()方法在Object类中定义着。
        * 多用于对象的获取字节码的方式

    * 结论：
        同一个字节码文件(*.class)在一次程序运行过程中，只会被加载一次，不论通过哪一种方式获取的Class对象都是同一个。

* Class对象功能：
    * 获取功能：
        1. 获取成员变量们
            * Field[] getFields() ：获取所有public修饰的成员变量
            * Field getField(String name)   获取指定名称的 public修饰的成员变量

            * Field[] getDeclaredFields()  获取所有的成员变量，不考虑修饰符
            * Field getDeclaredField(String name)  
        2. 获取构造方法们
            * Constructor<?>[] getConstructors()  
            * Constructor<T> getConstructor(类<?>... parameterTypes)  

            * Constructor<T> getDeclaredConstructor(类<?>... parameterTypes)  
            * Constructor<?>[] getDeclaredConstructors()  
        3. 获取成员方法们：
            * Method[] getMethods()  
            * Method getMethod(String name, 类<?>... parameterTypes)  

            * Method[] getDeclaredMethods()  
            * Method getDeclaredMethod(String name, 类<?>... parameterTypes)  

        4. 获取全类名    
            * String getName()  

* Field：成员变量
    * 操作：
        1. 设置值
            * void set(Object obj, Object value)  
        2. 获取值
            * get(Object obj) 

        3. 忽略访问权限修饰符的安全检查
            * setAccessible(true):暴力反射

* Constructor:构造方法
    * 创建对象：
        * T newInstance(Object... initargs)  

        * 如果使用空参数构造方法创建对象，操作可以简化：Class对象的newInstance方法

* Method：方法对象
    * 执行方法：
        * Object invoke(Object obj, Object... args)  

    * 获取方法名称：
        * String getName:获取方法名

* 案例：
    * 需求：写一个"框架"，不能改变该类的任何代码的前提下，可以帮我们创建任意类的对象，并且执行其中任意方法
        * 实现：
            1. 配置文件
            2. 反射
        * 步骤：
            1. 将需要创建的对象的全类名和需要执行的方法定义在配置文件中
            2. 在程序中加载读取配置文件
            3. 使用反射技术来加载类文件进内存
            4. 创建对象
            5. 执行方法

/**
 * 反射的基本使用：
 * 反射：将类的各个组成部分封装为其他对象，这就是反射机制
 * Java代码在计算机中经历的三个阶段
 * 1. Source源码阶段（.java-->.class字节码）
 * 2. Class类对象阶段（类加载器加载到内存）
 * 3. Runtime运行时阶段 （创建对象）
 *
 * 获取Class对象的3种方式
 *  1. Class.forName("全类名")：将字节码文件加载进内存，返回Class对象
 *      * 多用于配置文件，将类名定义在配置文件中。读取文件，加载类
 *  2. 类名.class：通过类名的属性class获取
 *      * 多用于参数的传递
 *  3. 对象.getClass()：getClass()方法在Object类中定义着。
 *      * 多用于对象的获取字节码的方式
 *
 *  注意：同一个字节码文件(*.class)在一次程序运行过程中，只会被加载一次，不论通过哪一种方式获取的Class对象都是同一个。
 *
 */
public class ReflectDemo1 {
    public static void main(String[] args) throws ClassNotFoundException {
        // 获取Class对象的3种方式
        //1.Class.forName("");
        Class clz1 = Class.forName("com.ivyzh.reflect.domain.Person");
        System.out.println(clz1);

        //2.类名.class
        Class clz2 = Person.class;
        System.out.println(clz2);

        //3. 对象.getClass()
        Person person = new Person();
        Class clz3 = person.getClass();
        System.out.println(clz3);

        System.out.println(clz1 ==clz2);
        System.out.println(clz1 ==clz3);

        /**
         * 控制台輸出結果：
             class com.ivyzh.reflect.domain.Person
             class com.ivyzh.reflect.domain.Person
             class com.ivyzh.reflect.domain.Person
             true
             true

         */
    }
}



/**
 * 反射的功能使用：
 *  1. 获取成员变量们
 *      * Field[] getFields() ：获取所有public修饰的成员变量
 *      * Field getField(String name)   获取指定名称的 public修饰的成员变量
 *
 *      * Field[] getDeclaredFields()  获取所有的成员变量，不考虑修饰符
 *      * Field getDeclaredField(String name)
 *  2. 获取构造方法们
 *      * Constructor<?>[] getConstructors()
 *      * Constructor<T> getConstructor(类<?>... parameterTypes)
 *
 *      * Constructor<T> getDeclaredConstructor(类<?>... parameterTypes)
 *      * Constructor<?>[] getDeclaredConstructors()
 *  3. 获取成员方法们：
 *      * Method[] getMethods()
 *      * Method getMethod(String name, 类<?>... parameterTypes)
 *
 *      * Method[] getDeclaredMethods()
 *      * Method getDeclaredMethod(String name, 类<?>... parameterTypes)
 *
 *  4. 获取全类名
 *      * String getName()
 */
public class ReflectDemo2 {
    public static void main(String[] args) throws Exception {
        // 获取Class对象的3种方式
        //1.Class.forName("");
        Class clzPerson = Class.forName("com.ivyzh.reflect.domain.Person2");
        System.out.println(clzPerson);

        // 1. 获取成员变量们
        Field[] fields = clzPerson.getFields();//获取所有public修饰的成员变量
        for (int i = 0; i < fields.length; i++) {
            Field field = fields[i];
            System.out.println("field-->"+field);
        }
        Field fielda1 = clzPerson.getField("a1");//获取指定名称的 public修饰的成员变量
        System.out.println("fielda1-->"+fielda1);
        System.out.println("---------------------------");
        Field[] declaredFields = clzPerson.getDeclaredFields();
        for (int i = 0; i < declaredFields.length; i++) {
            Field declaredField = declaredFields[i];
            System.out.println("declaredField-->"+declaredField);
        }
        Field declaredFieldd = clzPerson.getDeclaredField("d");
        System.out.println("declaredFieldd-->"+declaredFieldd);
        System.out.println("---------------------------");
        // 1.1 设置成员变量们
        Person2 person = new Person2();
        Field fieldaa = clzPerson.getField("a");
        fieldaa.set(person,10);
        Field fieldName = clzPerson.getDeclaredField("name");
        fieldName.setAccessible(true);//暴力反射,忽略访问权限修饰符的安全检查
        fieldName.set(person,"zhangsan");
        System.out.println("person:"+person);
        // 1.2 获取成员们的值
        Object nameValue = fieldName.get(person);
        System.out.println("nameValue:"+nameValue);
        System.out.println("---------------------------");

        // 2. 获取Constructor
        Constructor[] constructors = clzPerson.getConstructors();
        for (int i = 0; i < constructors.length; i++) {
            Constructor constructor = constructors[i];
            System.out.println("constructor-->"+constructor);
        }
        Constructor[] declaredConstructors = clzPerson.getDeclaredConstructors();
        for (int i = 0; i < declaredConstructors.length; i++) {
            Constructor declaredConstructor = declaredConstructors[i];
            System.out.println("declaredConstructor-->"+declaredConstructor);
        }
        System.out.println("---------------------------");
        // 使用构造器创建对象
        Constructor constructor = clzPerson.getConstructor();//无参数构造器
        Object p1 = constructor.newInstance();
        System.out.println("p1:"+p1);
        //Constructor declaredConstructor = clzPerson.getDeclaredConstructor(String.class,int.class);
        Constructor declaredConstructor = clzPerson.getDeclaredConstructor( int.class);
        declaredConstructor.setAccessible(true);
        //Object p2 = declaredConstructor.newInstance("lisi",20);
        Object p2 = declaredConstructor.newInstance( 20);
        System.out.println("p2:"+p2);
        System.out.println("---------------------------");

        // 3. 获取Method

        Method[] methods = clzPerson.getMethods();

        for (int i = 0; i < methods.length; i++) {
            Method method = methods[i];
            System.out.println("method-->"+method);//父类的方法也会被获取
        }
        Method[] declaredMethods = clzPerson.getDeclaredMethods();
        for (int i = 0; i < declaredMethods.length; i++) {
            Method declaredMethod = declaredMethods[i];
            System.out.println("declaredMethod-->"+declaredMethod);//父类的方法不会被获取
        }

        Method setName = clzPerson.getDeclaredMethod("setName", String.class);
        Person2 person2 = new Person2();
        setName.setAccessible(true);
        setName.invoke(person2,"wangwu");
        System.out.println("person2:"+person2);
    }
}


/**
 * 反射案例：
 * 需求：写一个"框架"，不能改变该类的任何代码的前提下，可以帮我们创建任意类的对象，并且执行其中任意方法
 *      * 实现：
 *          1. 配置文件
 *          2. 反射
 *      * 步骤：
 *          1. 将需要创建的对象的全类名和需要执行的方法定义在配置文件中
 *          2. 在程序中加载读取配置文件
 *          3. 使用反射技术来加载类文件进内存
 *          4. 创建对象
 *          5. 执行方法
 */
public class ReflectDemo3 {
    public static void main(String[] args) throws Exception {

        Properties properties = new Properties();
        ClassLoader classLoader = ReflectDemo3.class.getClassLoader();
        InputStream is = classLoader.getResourceAsStream("pro.properties");
        properties.load(is);
        String className = properties.getProperty("className");
        String methodName = properties.getProperty("methodName");
        Class<?> clz = Class.forName(className);
        Object instance = clz.newInstance();
        Method declaredMethod = clz.getDeclaredMethod(methodName);
        declaredMethod.setAccessible(true);
        declaredMethod.invoke(instance);

    }
}

pro.properties文件

className=com.ivyzh.reflect.domain.BenzCar
methodName=fix

注解：

* 概念：说明程序的。给计算机看的
* 注释：用文字描述程序的。给程序员看的

* 定义：注解（Annotation），也叫元数据。一种代码级别的说明。它是JDK1.5及以后版本引入的一个特性，与类、接口、枚举是在同一个层次。它可以声明在包、类、字段、方法、局部变量、方法参数等的前面，用来对这些元素进行说明，注释。
* 概念描述：
    * JDK1.5之后的新特性
    * 说明程序的
    * 使用注解：@注解名称

​

* 作用分类：
    ①编写文档：通过代码里标识的注解生成文档【生成文档doc文档】
    ②代码分析：通过代码里标识的注解对代码进行分析【使用反射】
    ③编译检查：通过代码里标识的注解让编译器能够实现基本的编译检查【Override】

* JDK中预定义的一些注解
    * @Override ：检测被该注解标注的方法是否是继承自父类(接口)的
    * @Deprecated：该注解标注的内容，表示已过时
    * @SuppressWarnings：压制警告
        * 一般传递参数all  @SuppressWarnings("all")

* 自定义注解
    * 格式：
        元注解
        public @interface 注解名称{
            属性列表;
        }

    * 本质：注解本质上就是一个接口，该接口默认继承Annotation接口
        * public interface MyAnno extends java.lang.annotation.Annotation {}

    * 属性：接口中的抽象方法
        * 要求：
            1. 属性的返回值类型有下列取值
                * 基本数据类型
                * String
                * 枚举
                * 注解
                * 以上类型的数组

            2. 定义了属性，在使用时需要给属性赋值
                1. 如果定义属性时，使用default关键字给属性默认初始化值，则使用注解时，可以不进行属性的赋值。
                2. 如果只有一个属性需要赋值，并且属性的名称是value，则value可以省略，直接定义值即可。
                3. 数组赋值时，值使用{}包裹。如果数组中只有一个值，则{}可以省略
    
    * 元注解：用于描述注解的注解
        * @Target：描述注解能够作用的位置
            * ElementType取值：
                * TYPE：可以作用于类上
                * METHOD：可以作用于方法上
                * FIELD：可以作用于成员变量上
        * @Retention：描述注解被保留的阶段
            * @Retention(RetentionPolicy.RUNTIME)：当前被描述的注解，会保留到class字节码文件中，并被JVM读取到
        * @Documented：描述注解是否被抽取到api文档中
        * @Inherited：描述注解是否被子类继承

* 在程序使用(解析)注解：获取注解中定义的属性值
    1. 获取注解定义的位置的对象  （Class，Method,Field）
    2. 获取指定的注解
        * getAnnotation(Class)
        //其实就是在内存中生成了一个该注解接口的子类实现对象

                public class ProImpl implements Pro{
                    public String className(){
                        return "cn.itcast.annotation.Demo1";
                    }
                    public String methodName(){
                        return "show";
                    }
                }
    3. 调用注解中的抽象方法获取配置的属性值

* 案例：简单的测试框架
* 小结：
    1. 以后大多数时候，我们会使用注解，而不是自定义注解
    2. 注解给谁用？
        1. 编译器
        2. 给解析程序用
    3. 注解不是程序的一部分，可以理解为注解就是一个标签

/**
 * * 概念：说明程序的。给计算机看的
 * * 注释：用文字描述程序的。给程序员看的
 *
 * * 定义：注解（Annotation），也叫元数据。一种代码级别的说明。它是JDK1.5及以后版本引入的一个特性，与类、接口、枚举是在同一个层次。
 *   它可以声明在包、类、字段、方法、局部变量、方法参数等的前面，用来对这些元素进行说明，注释。
 * * 概念描述：
 *  * JDK1.5之后的新特性
 *  * 说明程序的
 *  * 使用注解：@注解名称
 *
 * * 作用分类：
 *  ①编写文档：通过代码里标识的注解生成文档【生成文档doc文档】
 *  ②代码分析：通过代码里标识的注解对代码进行分析【使用反射】
 *  ③编译检查：通过代码里标识的注解让编译器能够实现基本的编译检查【Override】
 *  * 注解的定义
 * * JDK中预定义的一些注解
 * * 自定义注解
 * * 在程序使用(解析)注解：获取注解中定义的属性值
 *
 *
 * * JDK中预定义的一些注解
 *  * @Override ：检测被该注解标注的方法是否是继承自父类(接口)的
 *  * @Deprecated：该注解标注的内容，表示已过时
 *  * @SuppressWarnings：压制警告
 *      * 一般传递参数all  @SuppressWarnings("all")
 */
public @interface AnnoDemo1 {

    //1. 属性的返回值类型有
    int show1();// 基本数据类
    String show2();//String
    MyAnno show3();//注解
    MyEnum show6();//枚举
    int[]  show4();//以上类型的数组
    MyAnno[] show5();//以上类型的数组

    //2. 定义了属性，在使用时需要给属性赋值

    String name() default "zhangsan";// 如果定义属性时，使用default关键字给属性默认初始化值，则使用注解时，可以不进行属性的赋值

}


/**
 ** 元注解：用于描述注解的注解
 *  * @Target：描述注解能够作用的位置
 *      * ElementType取值：
 *          * TYPE：可以作用于类上
 *          * METHOD：可以作用于方法上
 *          * FIELD：可以作用于成员变量上
 *  * @Retention：描述注解被保留的阶段
 *      * @Retention(RetentionPolicy.RUNTIME)：当前被描述的注解，会保留到class字节码文件中，并被JVM读取到
 *      * @Retention(RetentionPolicy.CLASS)：当前被描述的注解，会保留到class字节码文件中，但不会被JVM读取到
 *      * @Retention(RetentionPolicy.SOURCE)：当前被描述的注解，不会保留到class字节码文件中，但不会被JVM读取到
 * （三个阶段：source、class、runtime）
 *  * @Documented：描述注解是否被抽取到api文档中
 *  * @Inherited：描述注解是否被子类继承

 */
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface AnnoDemo3 {
  int value();
}

/**
 * * 概念：说明程序的。给计算机看的
 * * 注释：用文字描述程序的。给程序员看的
 *
 * * 定义：注解（Annotation），也叫元数据。一种代码级别的说明。它是JDK1.5及以后版本引入的一个特性，与类、接口、枚举是在同一个层次。
 *   它可以声明在包、类、字段、方法、局部变量、方法参数等的前面，用来对这些元素进行说明，注释。
 * * 概念描述：
 *  * JDK1.5之后的新特性
 *  * 说明程序的
 *  * 使用注解：@注解名称
 *
 * * 作用分类：
 *  ①编写文档：通过代码里标识的注解生成文档【生成文档doc文档】
 *  ②代码分析：通过代码里标识的注解对代码进行分析【使用反射】
 *  ③编译检查：通过代码里标识的注解让编译器能够实现基本的编译检查【Override】
 *  * 注解的定义
 * * JDK中预定义的一些注解
 * * 自定义注解
 * * 在程序使用(解析)注解：获取注解中定义的属性值
 *
 *
 * * JDK中预定义的一些注解
 *  * @Override ：检测被该注解标注的方法是否是继承自父类(接口)的
 *  * @Deprecated：该注解标注的内容，表示已过时
 *  * @SuppressWarnings：压制警告
 *      * 一般传递参数all  @SuppressWarnings("all")
 */
public @interface MyAnno {


}

/**
 * 获取指定的注解
 *      * getAnnotation(Class)
 */
@Pro(className = "com.ivyzh.reflect.domain.BMWCar",methodName = "run")
public class ReflectTest {
    public static void main(String[] args) throws  Exception {

        Pro annotation = ReflectTest.class.getAnnotation(Pro.class);
        String className = annotation.className();
        String methodName = annotation.methodName();
        System.out.println(className);
        System.out.println(methodName);

        Class<?> clz = Class.forName(className);
        Object car = clz.newInstance();
        Method declaredMethod = clz.getDeclaredMethod(methodName);
        declaredMethod.setAccessible(true);
        declaredMethod.invoke(car);
    }
}

Calulator

/**
 * 计算器类
 */
public class Calculator {
    @Check(a=5,b=3)
    public int add(int a,int b){
        return a+b;
    }
    @Check
    public int sub(int a,int b){
        return a+b;
    }
    @Check
    public int mul(int a,int b){
        return a*b;
    }
    @Check(a=10,b=0)
    public int div(int a,int b){
        return a/b;
    }

    public void show(){
        System.out.println("show...");
    }
}

CalulatorTest

/**
 * 案例：简单的测试框架
 * 1.
 * 2.
 */

public class CaculatorTest {
    public static void main(String[] args) throws  Exception {

        Calculator calculator = new Calculator();
        Method[] declaredMethods = calculator.getClass().getDeclaredMethods();

        int bugNum = 0;
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("bug.txt"));


        for (int i = 0; i < declaredMethods.length; i++) {
            Method declaredMethod = declaredMethods[i];
            if(declaredMethod.isAnnotationPresent(Check.class)){
                Check annotation = declaredMethod.getAnnotation(Check.class);
                int a = annotation.a();
                int b = annotation.b();
                try {
                    Object result =  declaredMethod.invoke(calculator,a,b);
                    System.out.println(a+" "+declaredMethod.getName()+" "+b+" result:"+result);
                }catch (Exception e){
                    e.printStackTrace();
                    bugNum++;
                    bufferedWriter.write(declaredMethod.getName()+" 出现异常了");
                    bufferedWriter.newLine();
                    bufferedWriter.write("异常名称："+e.getCause().getClass().getSimpleName());
                    bufferedWriter.newLine();
                    bufferedWriter.write("异常原因："+e.getCause().getMessage());
                    bufferedWriter.newLine();
                    bufferedWriter.write("----------------------");
                    bufferedWriter.newLine();
                }

            }

        }

        bufferedWriter.write("本次运行一共出现 "+bugNum+" 次异常");
        bufferedWriter.flush();
        bufferedWriter.close();

    }
}

Check

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Check {
    int a() default 5;
    int b() default 3;
}

END.

©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 206,839评论 6赞 482
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 88,543评论 2赞 382
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 153,116评论 0赞 344
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 55,371评论 1赞 279
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 64,384评论 5赞 374
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 49,111评论 1赞 285
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 38,416评论 3赞 400
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 37,053评论 0赞 259
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 43,558评论 1赞 300
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 36,007评论 2赞 325
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 38,117评论 1赞 334
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,756评论 4赞 324
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 39,324评论 3赞 307
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,315评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,539评论 1赞 262
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 45,578评论 2赞 355
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,877评论 2赞 345

推荐阅读更多精彩内容

  • Java基础 - 注解
    文章开头先引入一处图片。 这处图片引自老罗的博客。为了避免不必要的麻烦，首先声明我个人比较尊敬老罗的。至于为什么放...
    小乖心塞阅读 351评论 1赞 0
  • JAVA 注解
    看到这边解释注解的博客非常好。放一下原版链接。进行了一些简化。 Annotation 中文译过来就是注解、标释的意...
    春天的蜜蜂阅读 899评论 0赞 0
  • JAVA注解
    转自https://blog.csdn.net/briblue/article/details/73824058#...
    扎Zn了老Fe阅读 850评论 0赞 4
  • 亲爱的自己，你要适应孤独
    适应孤独，学会爱自己！ 2017年7月22日 星期六 外面下着雨 广州 大学四年很快很快就过...
    HU托克拉克阅读 291评论 0赞 3
  • 百宝箱
    自定义 Model 网址 方案一：网址ID+数字 在model中定义 to_param 函数 方案二: 乱数 ID...
    bigbug_阅读 413评论 0赞 0