Java学习总结之反射

反射库提供了一个非常丰富且精心设计的工具集，以便能够动态编写能够操纵Java代码的程序。这项功能被大量应用于JavaBeans中，它是Java组件的体系结构。

1.什么是反射？

反射是可以让我们在运行时获取类的方法、属性、父类、接口等类的内部信息的机制，在编写一些通用性较高的代码或者框架的时候使用。也就是说，反射本质上是一个“反着来”的过程。我们通过new创建一个类的实例时，实际上是由Java虚拟机根据这个类的Class对象在运行时构建出来的，而反射是通过一个类的Class对象来获取它的定义信息，从而我们可以访问到它的属性、方法，知道这个类的父类、实现了哪些接口等信息。
　　要想理解反射的原理，首先要了解什么是类型信息。Java让我们识别对象和类的信息，主要有2种方式：一种是传统的RTTI，它假定我们在编译时已经知道了所有的类型信息；另一种是反射机制，它允许我们在运行时发现和使用类的信息。
　　程序中一般的对象的类型都是在编译期就确定下来的，而Java反射机制可以动态地创建对象并调用其属性，这样的对象的类型在编译期是未知的。所以我们可以通过反射机制直接创建对象，即使这个对象的类型在编译期是未知的。
　　反射的核心是JVM在运行时才动态加载类或调用方法/访问属性，它不需要事先（写代码的时候或编译期）知道运行对象是谁。

2.反射的作用

  • 在运行时获取任意一个类的父类、接口、构造器、属性、方法等；
  • 在运行时构造任意一个类的对象；
  • 在运行时调用任意一个对象的方法（通过反射甚至可以调用private方法）

3.Class类

我们知道使用javac能够将.java文件编译为.class文件，这个.class文件包含了我们对类的原始定义信息（父类、接口、构造器、属性、方法等）。Class 类的实例表示正在运行的 Java 应用程序中的类或接口。在 Java 中，每个 Class 都有一个相应的 Class 对象，即对于每一个类，.class文件在运行时会被ClassLoader加载到JVM中，当一个.class文件被加载后，JVM会为之生成一个Class对象，用于表示这个类的类型信息，我们在程序中通过new实例化的对象实际上是在运行时根据相应的Class对象构造出来的。确切的说，这个Class对象实际上是java.lang.Class类的一个实例，从中我们可以得出结论：万物皆对象，任何类型(包括基本类型，引用类型，void关键字等).class都是java.lang.Class的实例，简言之，class对象是Class泛型类的实例，它代表了一个类型。由于java.lang.Class类不存在公有构造器，它在每个类第一次被加载时由JVM自动调用，因此我们不能直接实例化这个类，我们可以通过以下方法获取一个Class对象。
　　在下面的讲解中，我们将以People类和Student类为例：

public class People {
    private String name;
    private int age;
    
    public People(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public int getAge() {
        return age;
    }

    public String getName() {
        return name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void setName(String name) {
        this.name = name;
    }
    
    public void speak() {
        System.out.println(getName() + " " + getAge());
    }
}

public class Student extends People {
    private int grade;
    
    public Student(String name, int age) {
        super(name, age);
    }
    
    public Student(String name, int age, int grade) {
        super(name, age);
        this.grade = grade;
    }
    
    public int getGrade() {
        return grade;
    }

    public void setGrade(int grade) {
        this.grade = grade;
    }
  
    private void learn(String course) {
        System.out.println(name + " learn " + course);
    }
 }

获取class对象有以下三种:

  1. 可以通过类名.class得到相应类的Class对象，如:
  Class peopleClass = People.class;
  1. 如果已知类的全限定名称(包含包名)，可以通过Class的forName静态方法得到类的Class对象，如：
Class peopleClass = Class.forName("cn.habitdiary.People");
//假设People类在cn.habitdiary包中

在使用forName时必须要保证传入的字符串是一个类名或接口名，否则会抛出一个ClassNotFoundException,这是一个必检异常，所以我们在使用该方法时必须提供一个异常处理器,例如：

try{
    String name = "xxx";
    Class c1 = Class.forName(name);
    }
    catch(Exception e){
    e.printStackTrace();
    }

在JDBC开发中常用此方法加载数据库驱动

  1. 可以通过类的实例对象.getClass()得到相应类的Class对象，如:
People people = new People("Steven"， 20);
Class peopleClass = people.getClass();

实例对象.getClass().getName() 可以获取当前对象的类的全限定名称(包含包名)
实例对象.getClass().getCanonicalName()大部分情况和getName()相同，但在表示数组或内部类时有所区别，比如对于String数组，getName返回的是[Ljava.lang.String之类的表现形式，而getCanonicalName返回的就是跟我们声明类似的形式。
实例对象.getClass().getSimpleName()只是去掉getCanonicalName()返回结果前面的包部分
　　但在类加载的时候需要的是getName得到的那样的名字，而在根据类名字创建文件的时候最好使用getCanonicalName()
具体分析见：源码解析getCanonicalName(), getName(), getSimpleName()的不同

对于基本数据类型的封装类，还可以采用.TYPE来获取相对应的基本数据类型的 Class 实例

三种方式的比较：
1.调用Class.forName()方法，如果类没有加载就加载，加载时执行static语句，找不到就抛出异常，也可以理解为手动加载类的一种方法，它会自动初始化Class对象。

2.getClass()方法，在已经持有该类的对象时来获取Class引用。其Class对象已经被初始化。

3..class方式创建Class对象引用时，不会自动初始化Class对象。主要进行下面的步骤：
1)加载，类加载器查找字节码（classpath）创建Class对象；
2)链接，为静态域分配存储空间；
3)初始化，其被延迟到静态方法或非常数静态域首次引用时。

总结：Java获得Class对象的引用的方法中，Class.forName()方法会自动初始化Class对象，而.class方法不会，.class的初始化被延迟到静态方法或非常数静态域的首次引用。

注意：
　　1.一个Class对象实际上表现的是一个类型，而这个类型未必一定是一种类。例如，int不是类，但int.class是一个Class对象。
　　2.Class类实际上是一个泛型类。 Class c = T.class实际上是Class<T> c = T.class。Class c = x.getClass()实际上是Class<? extends T> c = x.getClass()(T的x的声明类型，x.getClass()获得的是x的实际类型的Class对象)。但有时候我们不能提前确定class对象的类型,如Class c = Class.forName("T")实际上是Class<?> c = Class.forName("T")。
　　3.虚拟机为每个类型管理一个Class对象，可以用 == 运算符实现两个类对象比较的操作，这可以用来判断两个对象属不属于同一个类。
　　4.getClass()方法返回的是对象实际类型的class对象，而不是声明类型的class对象。
　　5.newInstance()方法可以返回一个Class对象对应类的新实例(返回值类型是Object)，前提要有无参的构造方法，newInstance()方法是通过调用无参构造方法来创建对象的。比如:

String s = "java.util.Random";
Object m = Class.forName(s).newInstance();

如果希望给构造器提供参数，就不能使用这种写法，必须先获取指定的Constructor对象，再调用Constructor对象的newInstance()方法来创建实例。这种方法可以用指定的构造器构造类的实例：

//获取String所对应的Class对象
Class<?> c = String.class;
//获取String类带一个String参数的构造器
Constructor constructor = c.getConstructor(String.class);
//根据构造器创建实例
Object obj = constructor.newInstance("23333");
System.out.println(obj);

类的静态加载和动态加载
静态加载：在编译时就需要加载所有可能用到的类，比如new关键字就是静态加载类。
动态加载：在运行时加载类。
静态加载类的缺点是：比如用new创建了多个类的对象，其中某一个类不存在，则整个程序无法通过编译。而如果动态加载类，只要不使用不存在的类，其他类还可以正常使用。

比如

class Office{
    public static void main(String[] args){
        //静态加载类
        if("Word".equals(args[0])){
            Word w = new Word();
            w.start();
         }
         if("Excel".equals(args[0]){
            Excel e = new Excel();
            e.start();
         }
 }

上面的程序通过new关键字创建对象，是静态加载类，所以如果Word类和Excel类中缺少一个，另一个类即使存在也无法通过编译。

如果通过反射动态加载类可以解决这个问题，如下：

class OfficeBetter{
    public static void main(String[] args){
        try{
            //动态加载类,在运行时刻加载
            Class c = Class.forName(args[0]);
            /*通过类类型,创建该类的对象,此时需要强制转换为Excel和Word的公有类型，
            所以可以定义OfficeAble接口，让Excel和Word实现这个接口*/
            OfficeAble oa = (OfficeAble)c.newInstance();
            oa.start();
            }
            catch(Exception e){
            e.printStackTrace();
            }
 }

由于是动态加载类，新增其他实现OfficeAble接口的类不必重新编译OfficeBetter类。

4.在运行时分析类的能力

下面简要介绍一下反射机制最重要的内容 —— 检查类的结构。
Java中为了支持反射机制主要提供了以下的类：
java.lang.Class
java.lang.reflect.Field
java.lang.reflect.Constructor
java.lang.reflect.Method
java.lang.reflect.Modifier

图解.png

java.lang.Class类的常用API如下：

  • Field[] getFields()
  • Field[] getDeclaredFields()
  • Method[] getMethods()
  • Method[] getDeclaredMethods()
  • Constructor< ? >[] getConstructors()
  • Constructor< ? >[] getDeclaredConstructors()
  • Class< ? > getSupperClass()
  • Class< ? >[] getInterfaces()

提示：getFields、getMethods和getConstructors方法将分别返回类提供的public域、方法和构造器数组，其中包括超类的公有成员;而getDeclaredFields、getDeclaredMethods和getDeclaredConstructors方法将分别返回类中声明的全部域、方法和构造器，不论访问权限，但不包括超类的成员。getSupperClass()返回class对象对应类的超类的class对象，没有显式继承的类的超类是Object。getInterfaces返回class对象对应类的所有接口的class对象

其中java.lang.reflect包中的三个类Field、Constructor和Method分别用于描述类的域、构造器、方法。
这三个类的常用API如下：

  • String getName() 返回一个用于描述域名、构造器或方法的字符串
  • Class< ? > getDeclaringClass() 返回一个用于描述类中定义的域、构造器或方法的Class对象
  • Class< ? >[] getExceptionTypes() (在Constuctor和Method类中)
    返回一个用于描述方法抛出异常类型的Class对象数组
  • int getModifiers() 返回一个描述域、构造器或方法的修饰符的整型数值。使用Modifier的toString静态方法可以分析这个返回值
  • Class< ? >[] getParameterTypes() (在Constructor和Method类中) 返回一个用于描述参数类型的Class对象数组
  • Class< ? > getReturnType() (在Method类中) 返回一个用于描述返回类型的Class对象

java.lang.reflect.Modifier类的常用API如下

  • static String toString(int modifiers)
    返回修饰符对应的字符串描述
  • static boolean isAbstract(int modifiers)
  • static boolean isFinal(int modifiers)
  • static boolean isInterface(int modifiers)
  • static boolean isNative(int modifiers)
  • static boolean isPrivate(int modifiers)
  • static boolean isProtected(int modifiers)
  • static boolean isPublic(int modifiers)
  • static boolean isStatic(int modifiers)
  • static boolean isStrict(int modifiers)
  • static boolean isSynchronized(int modifiers)
  • static boolean isVolatile(int modifiers)

上述方法检测修饰符是否是某一特定修饰符
java.lang.reflect.Modifier类一般和Field、Constructor、Method类的getModifiers()方法配套使用，用于解析该方法返回的整型数值的含义

下面是一个检测类内部结构的例子

import java.lang.reflect.*;
import java.lang.Class;
import java.util.Scanner;

public class ReflectionTest {

    public static void main(String[] args) {
        String name;
        if(args.length > 0) 
            name = args[0];
        else {
            Scanner in = new Scanner(System.in);
            System.out.println("Enter class name (e.g. java.util.Date)");
            name = in.next();
        }
        
        try {
            Class<?> c1 = Class.forName(name);
            Class<?> superc1 = c1.getSuperclass();
            String modifiers = Modifier.toString(c1.getModifiers());
            if (modifiers.length() > 0) 
                System.out.print(modifiers + " " );
            System.out.print("class " + name);
            if(superc1 != null && superc1 != Object.class)
                System.out.print("  extends "  +  superc1.getSimpleName());
            System.out.print("\n{\n");
            printFields(c1);
            System.out.println();
            printConstructors(c1);
            System.out.println();
            printMethods(c1);
            System.out.println("}");
                
        }
        catch(ClassNotFoundException e)
        {
            e.printStackTrace();
        }
        System.exit(0);
    }
    
    public static void printConstructors(Class<?> c1) {
        Constructor<?>[] constructors = c1.getDeclaredConstructors();
        
        for(Constructor<?> c : constructors) {
            String name = c.getName();
            System.out.print("     ");
            String modifiers = Modifier.toString(c.getModifiers());
            if(modifiers.length() > 0)
                System.out.print(modifiers + " ");
            System.out.print(name + "(");
            Class<?>[] paramTypes = c.getParameterTypes();
            for(int j = 0;j < paramTypes.length;j++) {
                if(j > 0)
                    System.out.print(", ");
                System.out.print(paramTypes[j].getSimpleName());
            }
            System.out.println(");");
            
        }
    }
    
    public static void printMethods(Class<?> c1)
    {
        Method[] methods = c1.getDeclaredMethods();
        
        for(Method m :methods) {
            Class<?> retType = m.getReturnType();
            String name = m.getName();
            
            System.out.print("     ");
            String modifiers = Modifier.toString(m.getModifiers());
            if(modifiers.length() > 0)
                System.out.print(modifiers + " ");
            System.out.print(retType.getSimpleName() + " " + name + "(");
            Class<?>[] paramTypes = m.getParameterTypes();
            for(int j = 0;j < paramTypes.length;j++) {
                if(j > 0)
                    System.out.print(", ");
                System.out.print(paramTypes[j].getSimpleName());
            }
            System.out.println(");");
        }
        
        
        }
    public static void printFields(Class<?>  c1)
    {
        Field[] Fields = c1.getDeclaredFields();
        
        for(Field f : Fields) {
            Class<?> type = f.getType();
            String name = f.getName();
            System.out.print("     ");
            String modifiers = Modifier.toString(f.getModifiers());
            if(modifiers.length() > 0)
                System.out.print(modifiers + "  ");
            System.out.println(type.getSimpleName() + " " + name + ";");
            }
    }

}

补充：instanceof运算符、Class的isInstance( )与isAssignableFrom()的区别

5.在运行时使用反射分析对象

反射不仅可以查看类的域、构造器、方法等，还可以进一步查看某个对象指定数据域的值。
　　查看对象域的关键方法是Field类中的get方法。如果f是一个Field类型的对象(例如，通过getDeclaredFields得到的对象)，obj是某个包含f域的类的对象，f.get(obj)将返回一个Object对象，其值为obj域的当前值。比如：

Employee harry = new Empolyee("Harry Hacker",35000,10,1,1989);
Class<Employee> c1 = harry.getClass();
Field f = c1.getDeclaredField("name"); //返回某一个特定域
f.setAccessible(true); //由于name是私有域，必须先设置为可访问
Object v = f.get(harry);

上述的String可以作为Object返回，但如果某个域是基本数据类型，比如double，可以使用Field类的getDouble方法返回double类型数值，也可以使用get方法，反射机制会将其自动装箱成Double类型对象。f.set(obj,value) 可以把obj对象的f域设置为value

下面是一些相关API
在java.lang.reflect.Field中：

  • Object get(Object obj)
    返回obj对象中用Field对象表示的域值
  • xxx getXxx(Object obj)
    返回obj对象的基本类型的域的值
  • void set(Object obj,Object newValue)
    用一个新值设置obj对象中Field对象表示的域

在java.lang.Class中：

  • Field getField(String name)
    返回指定名称的公有域
  • Field getDeclaredField(String name)
  • 返回指定名称的声明的域

在java.lang.reflect.AccessibleObject中：

  • void setAccessible(boolean flag)
    为反射对象设置可访问标志，flag为true表明屏蔽Java语言的访问检查，使得对象的私有属性也可以被查询和设置
  • boolean isAccessible()
    返回反射对象的可访问标志的值
  • static void setAccessible(AccessibleObject[] array,boolean flag)
    批量设置AccessibleObject(是Field、Constructor、Method的公共超类)数组的所有元素的可访问标志

6.使用反射编写泛型数组代码

java.lang.reflect包中的Array类允许动态地创建数组。例如，在Arrays类中有copyOf方法，可以扩展已经填满的数组。

Employee[] a = new Employee[100];
a = Arrays.copyOf(a,2 * a.length);

我们想要编写一个适用于所有数组类型的copyOf方法，下面是第一次尝试:

public static Object[] badCopyOf(Object[] a,int newLength){
    Object[] newArray = new Object[newLength];
    System.arraycopy(a,0,newArray,0,Math.min(a.length,newLength);
    return newArray;
}

上述代码存在一个错误，即使用了new Object[newLength]创建数组，这样会在运行时抛出ClassCastException,将一个Employee[]临时转换成Object[]，再把它转回来是可以的，但从一开始就是Object[]的数组永远不能转换成Employee[]数组。
为了解决这个问题，下面提供java.lang.reflect.Array中的API

  • static Object get(Object array,int index)
    返回对象数组某个位置上的元素
  • static xxx getXxx(Object array,int index)
    (xxx是基本数据类型)返回基本类型数组某个位置上的值
  • static void set(Object array,int index,Object newValue)
    设置对象数组某个位置上的元素
  • static void setXxx(Object array,int index,xxx newValue)
    (xxx是基本数据类型)设置基本类型数组某个位置上的值
  • static int getLength(Object array)
    返回数组的长度
  • static Object newInstance(Class componentType,int length)
  • static Object newInstance(Class componentType,int[] length)
    返回一个具有给定类型、给定维数的新数组

下面给出正确的代码实现：

 public static Object goodCopyOf(Object a,int newLength){
 {
    Class c1 = a.getClass();//获取a数组的类对象
     if(!c1.isArray()) return null;//确认是一个数组
     Class componentType = c1.getComponentType();
     //获取数组类型
     int length = Array.getLength(a);
     Object newArray = Array.newInstance(componentType,newLength);
     System.arraycopy(a,0,newArray,0,Math.min(length,newLength));
     return newArray;   
 }

这个CopyOf方法可以扩展任意类型的数组，不仅仅是对象数组使用示例:

int[] a = {1,2,3,4,5};
a = (int[]) goodCopyOf(a,10);

为了实现上述操作，应该将goodCopyOf的参数声明为Object类型，而不要声明为Object[],因为整数数组类型可以被转换为Object，但不能转换成Object[]类型

7.调用任意方法

通过反射还可以调用任意方法，这是通过Method类的invoke方法实现的，方法签名是:Object invoke(Object obj,Object... args),Object obj表示调用方法的对象，Object...args表示方法的参数列表。
如果方法是静态方法，将第一个参数设置为null;如果方法是非静态无参方法，第二个参数列表可以忽略。
　　例如：String n = (String)m1.invoke(harry);(m1表示Employee类的getName方法)。如果方法m1的返回值是void，则invoke方法返回null，否则返回具体类型。如果返回值是基本类型，invoke方法会返回其包装器类型,可以利用自动开箱将其还原为基本数据类型。例如:double s = (Double)m2.invoke(harry);(m2表示Employee类的getSalary方法)
getMethods方法和getDeclaredMethods会返回一个Method对象列表，如果要得到特定的Method对象，可以调用Class类的getMethod方法，其签名是Method getMethod(String Methodname,Class...parameterTypes)。
例如：

Method m1 = Employee.class.getMethod("getName");  
Method m2 = Employee.class.getMethod("raiseSalary",double.class);

下面给出一个调用任意方法打印函数表的程序(以自定义的square和Math.sqrt方法为例)：

import java.lang.reflect.*;
public class MethodTableTest
{
   public static void main(String[] args)
   {
Method square =                     MethodTableTest.class.getMethod("square",double.class);
    Method sqrt = Math.class.getMethod("sqrt",double.class);
    
    printTable(1,10,10,square);
    printTable(1,10,10,sqrt);
    }
    
    public static double square(double x)
    {
    return x * x;
    }
    
    public static void printTable(double from,double to,int n,Method f)
    {
    System.out.println(f);
    double dx = (to - from) / (n - 1);
    
    for(double x = from;x <= to;x += dx)
    {
      try
      {
         double y = (Double)f.invoke(null,x);
         System.out.printf("%10.4f | %10/4f\n",x,y);
      }
      catch(Exception e)
      {
         e.printStackTrace();
      }
    }

invoke方法如果提供了错误的参数，会抛出一个异常，所以要提供一个异常处理器
建议在有必要的时候才使用invoke方法，有如下原因:
1.invoke方法的参数和返回值必须是Object类型，意味着必须进行多次类型转换，这样会使编译器错过检查代码的机会，等到测试阶段才发现错误，找到并改正会更加困难
2.通过反射调用方法比直接调用方法要明显慢一些

特别重申：建议Java开发者不要使用Method对象的回调功能，使用接口进行回调会使代码的执行速度更快，更易于维护。

8.通过反射了解泛型本质

来看下面一段代码：

ArrayList list = new ArrayList();
ArrayList<String> list1 = new ArrayList<String>();
Class c1 = list.getClass();
Class c2 = list1.getClass();
System.out.println(c1 == c2); //true
/*反射的操作都是编译之后的操作，编译之后会发生类型擦除，即ArrayList<String>被擦除为ArrayList，所以c1 == c2结果为true*/

Java中集合的泛型，是防止错误输入的，只在编译阶段有效，编译之后就会发生类型擦除，所以绕过编译泛型就无效了

验证：我们可以通过方法的反射来操作，绕过编译

    try {
    Method m = c2.getMethod("add", Object.class);
    m.invoke(list1, 20);//绕过编译操作就绕过了泛型
    System.out.println(list1.size());
    System.out.println(list1);
    } catch (Exception e) {
          e.printStackTrace();
    }

推荐博客：

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

推荐阅读更多精彩内容

  • Java初级面试题
    1. Java基础部分 基础部分的顺序：基本语法，类相关的语法，内部类的语法，继承相关的语法，异常的语法，线程的语...
    子非鱼_t_阅读 31,587评论 18赞 399
  • java编程学习之反射技术及其应用
    Java是一种可以撰写跨平台应用软件的面向对象的程序设计语言。Java 技术具有卓越的通用性、高效性、平台移植性和...
    Java小辰阅读 694评论 1赞 2
  • Spring Cloud
    Spring Cloud为开发人员提供了快速构建分布式系统中一些常见模式的工具（例如配置管理，服务发现，断路器，智...
    卡卡罗2017阅读 134,601评论 18赞 139
  • 致呱儿子的一封信
    我的宝贝呱呱： 呱呱啊，首先我忍不住想要吐槽一下啊，你娘勤俭节约这么多个日夜，终于给你买了个幸运铃，你敢不敢给娘带...
    胡木桃阅读 186评论 0赞 2
  • 苏醒的文
    就像那夹缝中的野草 肆无忌惮的飞扬吧 久违的简书 久未提笔的自己偶然翻翻手机便签 看见下面的这几句上礼拜爬山...
    琼笔茗阅读 403评论 0赞 2