Day03-Dart-基础语法二

总体概述

  • 运算符
  • 流程控制
  • 类和对象
  • 泛型
  • 库的使用

一、运算符

  • 1.1、Dart 所有的运算符

    描述 运算符
    一元后缀 expr++ expr--· () [] . ?.
    一元前缀 -expr !expr ~expr --expr
    乘法类型 * / % ~/
    加法类型 + -
    移动位运算 << >>
    与位运算 &
    异或位运算 ^
    或位运算 |
    关系和类型测试 >= <= > < as is is!
    等式 == !=
    逻辑与 &&
    逻辑或 ||
    条件 expr1 ? expr2 : expr3
    级联 ..
    赋值 = *= /= ~/= %= += -= <<= >>= &= ^= \= ??=

    提示：上表操作符的优先级由上到下逐个减小，上面行内的操作符优先级大于下面行内
    使用操作运算符时的顺序，如下

    // 使用括号来提高可读性
if ((n % I == 0) && (d % i == 0))
// 可读性较差
if (n % I == 0 && d % i == 0)

  • 1.2、除法、整除、取余运算

    var num = 7;
print(num / 3); // 除法操作, 结果2.3333..
print(num ~/ 3); // 整除操作取商, 结果2;
print(num % 3); // 取余操作, 结果1;

  • 1.3、??= 赋值操作
    当变量为 null 时，使用后面的内容进行赋值。
    当变量有值时，使用自己原来的值。

    main(List<String> args) {
     var name1 = 'Lily';
     print(name1);
     // var name2 = 'kobe';
     var name2 = null;
     name2 ??= 'James'; 
     // 当name2初始化为kobe时，结果为kobe，当初始化为null时，赋值了James
     print(name2); 
}

  • 1.4、条件运算符：

    • 第一种：Dart中包含一直比较特殊的条件运算符：expr1 ?? expr2
      如果expr1是null，则返回expr2的结果;
      如果expr1不是null，直接使用expr1的结果。

      var temp = 'why';
var temp = null;
var name = temp ?? 'kobe';
print(name);

    • 第二种：三元表达式，如果条件为真；则但会 expr1，否则返回 expr2的值

      condition  ? expr1 : expr2

  • 1.5、级联语法：..
    某些时候，我们希望对一个对象进行连续的操作，这个时候可以使用级联语法，类似于链式语法

    class Person {
   String name;

   void run() {
       print("${name} is running");
   }

   void eat() {
       print("${name} is eating");
   }

   void swim() {
       print("${name} is swimming");
   }
}

main(List<String> args) {
    final p1 = Person();
    p1.name = 'why';
    p1.run();
    p1.eat();
    p1.swim();

    final p2 = Person()
          ..name = "why"
          ..run()
          ..eat()
          ..swim();
}

    提示：级联的 双点 符号不是运算符，这只是 Dart 语法的一部分。

二、流程控制

  • 2.1. if 和 else
    和其他语言用法一样

    String today = 'Monday'
if (today == 'Monday') {
      print('今天是星期一');
} else {
      print('不知道今天是星期几')
}

    提示：这里有一个注意点：不支持非空即真或者非0即真，必须有明确的bool类型

    String name = '小王'
if (name) {
   // 这是错误的写法
}

  • 2.2. 循环操作
    基本的for循环

    for (var i = 0; i < 5; i++) {
    print(i);
}

    for in遍历List和Set类型

    var names = ['why', 'kobe', 'curry'];
for (var name in names) {
    print(name);
}

    while和do-while和其他语言一致
    break和continue用法也是一致

  • 2.3. switch-case
    普通的switch使用，注意：每一个case语句，默认情况下必须以一个break结尾

    main(List<String> args) {
    var direction = 'east';
    switch (direction) {
    case 'east':
        print('东面');
    break;
    case 'south':
        print('南面');
    break;
    case 'west':
        print('西面');
    break;
    case 'north':
        print('北面');
    break;
    default:
        print('其他方向');
    }
}

三、类和对象
Dart 作为高级语言支持买你洗那个对象的很多特性，并且支持基于 mixin 的继承方式。基于 mixin 的方式是指：一个类可以继承多个父类，相当于其他语言里的多继承。所有的类都有同一个基类 Object，这个特性类似于 Java 语言，Java所有类也都是继承自 Object，也就是说一切皆为对象。

  • 3.1. 类的定义
    在Dart中，定义类用class关键字。
    类通常有两部分组成：成员（member）和方法（method）。
    定义类的伪代码如下：

    class 类名 {
    类型 成员名;
    返回值类型 方法名(参数列表) {
        方法体
    }
}

    编写一个简单的Person类：

     class Person {
    String name;
    eat() {
        print('$name在吃东西');
    }
}

    提示：

    • 这里有一个注意点: 我们在方法中使用属性(成员/实例变量)时，并没有加this；
    • Dart的开发风格中，在方法中通常使用属性时，会省略this，但是有命名冲突时，this不能省略；

    我们来使用这个类，创建对应的对象，从Dart2开始，new关键字可以省略

    main(List<String> args) {
    // 1.创建类的对象
    var p = new Person(); // 直接使用Person()也可以创建

    // 2.给对象的属性赋值
    p.name = '小王';  // 相当于使用了 name 的 setter 方法

    // 3.调用对象的方法
    p.eat();
}

    提示：类定义中所有的变量都会隐式的定义 setter 方法，针对非空的变量会额外增加 getter 方法。

  • 3.2、构造函数

    • <1>、普通构造函数
      构造函数是用来构造当前类的函数，是一种特殊的函数，函数名称必须要和类名相同才行。如下代码为 User类添加了一个构造函数，函数里给User类的两个成员变量初始化了值：

      class  User {
    String name;
    int age;

    User(String name, int age) {
          this.name = name;
          this.age = age;
    }
}

      this 关键字指向了当前类的实例，上面的代码可以简化为

      class  User {
    String name;
    int age;

    User( this.name, this.age);

    @override
    String toString() {
       // TODO: implement toString
       return 'name=$name age=$age';
    }
}
      • 注意一：当有了自己的构造方法时，默认的构造方法将会失效，不能使用
        当然，你可能希望明确的写一个默认的构造方法，但是会和我们自定义的构造方法冲突；这是因为Dart本身不支持函数的重载（名称相同, 参数不同的方式）。
      • 注意二：这里我还实现了toString方法

    • <2>、 命名构造函数
      使用命名构造函数从一个类或现有的数据中快速实现构造函数，代码如下所示

      class Person {
   String name;
   int age;

   Person( this.name, this.age);

   // 命名构造方法
   Person.withArgments(String name, int age) {
         this.name = name;
         this.age = age;
   }

   @override
   String toString() {
        return 'name=$name age=$age';
   }
}

// 创建对象
var p1 = new Person();
print(p1);
var p2 = new Person.withArgments('why', 18);
print(p2);

      在之后的开发中, 我们也可以利用命名构造方法，提供更加便捷的创建对象方式,比如开发中，我们需要经常将一个Map转成对象，可以提供如下的构造方法

      // 新的构造方法
Person.fromMap(Map<String, Object> map) {
     this.name = map['name'];
     this.age = map['age'];
}

// 通过上面的构造方法创建对象
var p3 = new Person.fromMap({'name': 'kobe', 'age': 30});
print(p3);

    • <3>、构造函数初始化列表
      我们来重新定义一个类Point, 传入x/y，可以得到它们的距离distance:

      class Point {
    final num x;
    final num y;
    final num distance;

    // 错误写法
    // Point(this.x, this.y) {
    //   distance = sqrt(x * x + y * y);
    // }

    // 正确的写法
    Point(this.x, this.y) : distance = sqrt(x * x + y * y);
}

      上面这种初始化变量的方法, 我们称之为初始化列表(Initializer list)

    • <4>、重定向构造函数
      在某些情况下, 我们希望在一个构造方法中去调用另外一个构造方法, 这个时候可以使用重定向构造方法，在一个构造函数中，去调用另外一个构造函数（注意：是在冒号后面使用this调用）

      class Person {
   String name;
   int age;

   Person(this.name, this.age);
   Person.fromName(String name) : this(name, 0);
}

    • <5>、常量构造方法
      在某些情况下，传入相同值时，我们希望返回同一个对象，这个时候，可以使用常量构造方法.
      默认情况下，创建对象时，即使传入相同的参数，创建出来的也不是同一个对象，看下面代码:
      这里我们使用 identical(对象1, 对象2) 函数来判断两个对象是否是同一个对象:

      main(List<String> args) {
    var p1 = Person('why');
    var p2 = Person('why');
    print(identical(p1, p2)); // false
}

class Person {
   String name;
   Person(this.name);
}

      但是, 如果将构造方法前加const进行修饰，那么可以保证同一个参数，创建出来的对象是相同的，这样的构造方法就称之为常量构造方法。

      main(List<String> args) {
   var p1 = const Person('why');
   var p2 = const Person('why');
   print(identical(p1, p2)); // true
}

class Person {
   final String name;
   const Person(this.name);
}

      提示：常量构造方法有一些注意点:

      • 注意一：拥有常量构造方法的类中，所有的成员变量必须是 final 修饰的.
      • 注意二: 为了可以通过常量构造方法，创建出相同的对象，不再使用 new 关键字，而是使用 const 关键字
      • 如果是将结果赋值给 const 修饰的标识符时，const 可以省略.

    • <6>、工厂构造方法
      Dart提供了 factory 关键字, 用于通过工厂去获取对象

      main(List<String> args) {
    var p1 = Person('why');
    var p2 = Person('why');
    print(identical(p1, p2)); // true
}

class Person {
    String name;
    static final Map<String, Person> _cache = <String, Person>{};
    factory Person(String name) {
        if (_cache.containsKey(name)) {
            return _cache[name];
        } else {
            final p = Person._internal(name);
            _cache[name] = p;
            return p;
        }
    }
    Person._internal(this.name);
}

      提示

      • 普通的构造函数：会自动返回创阿金出来的对象，不能手动返回
      • 工厂构造函数的最大特点：可以手动返回一个对象

    • <7>、setter和getter
      默认情况下，Dart中类定义的属性是可以直接被外界访问的。
      但是某些情况下，我们希望监控这个类的属性被访问的过程，这个时候就可以使用 setter 和 getter 了

      main(List<String> args) {
    final d = Dog("黄色");
    d.setColor = "黑色";
    print(d.getColor);
}

class Dog {
    String color;

    String get getColor {
        return color;
    }
    set setColor(String color) {
        this.color = color;
    }
    Dog(this.color);
}

      也可以如下：使用箭头

      class Dog {
   String color;
   Dog(this.color);
   String get getColor => color;
   set setColor(String color) => this.color = color;
}

  • 3.3、 类的继承
    继承是面向对象编程技术的一块基石，因为它允许创建分等级层次的类。继承就是子类继承父类的特征和行为。使得子类对象(实例)具有父类的实例域和方法；或子类从父类继承方法，使得子类具有父类相同的行为。
    面向对象的其中一大特性就是继承，继承不仅仅可以减少我们的代码量，也是多态的使用前提。
    Dart中的继承使用extends关键字，子类中使用super来访问父类。
    父类中的所有成员变量和方法都会被继承,，但是构造方法除外。

    class Animal {
    int age;

    Animal(this.age);

    run() {
       print('在奔跑ing');
    }
}

class Person extends Animal {
    String name;

    Person(String name, int age) : name=name, super(age);
    // 重写父类的方法
    @override
    run() {
       print('$name在奔跑ing');
    }

    @override
    String toString() {
       return 'name=$name, age=$age';
    }
}

    提示：子类中可以调用父类的构造方法，对某些属性进行初始化：

    • 子类的构造方法在执行前，将隐含调用父类的无参默认构造方法（没有参数且与类同名的构造方法）。
    • 如果父类没有无参默认构造方法，则子类的构造方法必须在初始化列表中通过super显式调用父类的某个构造方法。

  • 3.4、抽象类
    父类本身可能并不需要对某些方法进行具体的实现，所以父类中定义的方法,，我们可以定义为抽象方法。
    什么是 抽象方法? 在Dart中没有具体实现的方法(没有方法体)，就是抽象方法。也就是定义了方法，可以不用实现。
    抽象方法，必须存在于抽象类中。
    抽象类是使用abstract声明的类。
    下面的代码中, Shape类就是一个抽象类, 其中包含一个抽象方法.

    // 抽象类不能实例化
abstract class Shape {
    getArea();
}

class Circle extends Shape {
    double r;

    Circle(this.r);

    @override
    getArea() {
        return r * r * 3.14;
    }
}
// 注意：继承抽象类后，必须实现抽象类的抽象方法，不比如我们必须实现 Shape 的 getArea()
class Reactangle extends Shape {
    double w;
    double h;

    Reactangle(this.w, this.h);

    @override
    getArea() {
        return w * h;
    }
}

    提示：

    • 注意一：抽象类不能实例化。如果我们想实例化，那么可以如下
    • 注意二：抽象类中的抽象方法必须被子类实现, 抽象类中的已经被实现方法, 可以不被子类重写。

  • 3.5、隐式接口
    Dart中的接口比较特殊, 没有一个专门的关键字来声明接口。
    默认情况下，定义的每个类都相当于默认也声明了一个接口，可以由其他的类来实现(因为Dart不支持多继承)
    在开发中，我们通常将用于给别人实现的类声明为抽象类:

    abstract class Runner {
    run();
}

abstract class Flyer {
    fly();
}

class SuperMan implements Runner, Flyer {
     @override
     run() {
        print('超人在奔跑');
     }

     @override
     fly() {
        print('超人在飞');
     }
}

    提示： implements 后面跟 当做接口使用的类，那么该类必须实现 implements 后面所有类的方法

  • 3.6、Mixin混入

    • Mixin(混入功能) 相当于多继承，也就是说可以继承多个类。

    • 在通过implements实现某个类时，类中所有的方法都必须被重新实现(无论这个类原来是否已经实现过该方法)。

    • 但是某些情况下，一个类可能希望直接复用之前类的原有实现方案，怎么做呢?

    • 使用继承吗？但是Dart只支持单继承，那么意味着你只能复用一个类的实现。

    • Dart提供了另外一种方案: Mixin混入的方式

      • 除了可以通过class定义类之外，也可以通过mixin关键字来定义一个类。
      • 只是通过mixin定义的类用于被其他类混入使用，通过with关键字来进行混入。

    • 使用 with 关键字来实现 Mixin功能，实例代码如下所示：

      main(List<String> args) {
    var superMan = SuperMain();
    superMan.run();
    superMan.fly();
}

mixin Runner {
    run() {
      print('在奔跑');
    }
}

mixin Flyer {
    fly() {
       print('在飞翔');
    }
}

// implements的方式要求必须对其中的方法进行重新实现
// class SuperMan implements Runner, Flyer {}

class SuperMain with Runner, Flyer {

}

      提示：上面定义一个类并不是一定要用 mixin, 我们可以使用 calss

  • 3.7、类成员和方法
    前面我们在类中定义的成员和方法都属于对象级别的, 在开发中, 我们有时候也需要定义类级别的成员和方法
    在Dart中我们使用static关键字来定义:

    main(List<String> args) {
     var stu = Student();
     stu.name = 'why';
     stu.sno = 110;
     stu.study();

     Student.time = '早上8点';
     // stu.time = '早上9点'; 错误做法, 实例对象不能访问类成员  
     Student.attendClass();  // stu.attendClass(); 错误做法, 实现对象不能访问类方法
}

class Student {
    String name;
    int sno;

    static String time;

    study() {
       print('$name在学习');
    }

    static attendClass() {
       print('去上课');
    }
}

    提示：static 是静态方法，也是类方法，如果学过Swift的话就会知道

  • 3.8、枚举类型
    枚举在开发中也非常常见, 枚举也是一种特殊的类, 通常用于表示固定数量的常量值。

    • <1>、枚举的定义
      枚举使用 enum 关键字来进行定义:

      main(List<String> args) {
    print(Colors.red);
}

enum Colors {
   red,
   green,
   blue
}

    • <2>、枚举的属性
      枚举类型中有两个比较常见的属性:
      index: 用于表示每个枚举常量的索引, 从0开始.
      values: 包含每个枚举值的List.

      main(List<String> args) {
   print(Colors.red.index);
   print(Colors.green.index);
   print(Colors.blue.index);

   print(Colors.values);
}

enum Colors {
   red,
   green,
   blue
}

      提示：枚举类型的注意事项:

      • 注意一: 不能子类化、混合或实现枚举。

      • 注意二: 不能显式实例化一个枚举，如下代码是错误的

        final color = Colors();

四、泛型

  • 4.1、泛型的含义
    泛型通常是为了类型的安全而设计的，适当地指定泛型的类型会生成更好的代码，可以使用泛型来减少代码重复。Dart中使用 <T> 的方式来定义泛型。例如，如果想要 List 只包含字符串，我们可以将其声明为 list<String>。如下所示

    var names = new List<String>();
name.addAll(['张三', '李四', '王五'])

  • 4.2. List和Map的泛型
    List使用时的泛型写法:

    // 创建List的方式
var names1 = ['why', 'kobe', 'james', 111];
print(names1.runtimeType); // List<Object>

// 限制类型
var names2 = <String>['why', 'kobe', 'james', 111]; // 最后一个报错
List<String> names3 = ['why', 'kobe', 'james', 111]; // 最后一个报错

    Map使用时的泛型写法:

    // 创建Map的方式
var infos1 = {1: 'one', 'name': 'why', 'age': 18}; 
print(infos1.runtimeType); // _InternalLinkedHashMap<Object, Object>

// 对类型进行显示
Map<String, String> infos2 = {'name': 'why', 'age': 18}; // 18不能放在value中
var infos3 = <String, String>{'name': 'why', 'age': 18}; // 18不能放在value中

  • 4.3. 类定义的泛型
    如果我们需要定义一个类, 用于存储位置信息Location, 但是并不确定使用者希望使用的是int类型,还是double类型, 甚至是一个字符串, 这个时候如何定义呢?

    • 一种方案是使用Object类型, 但是在之后使用时, 非常不方便
    • 另一种方案就是使用泛型.

    Location类的定义: Object方式

    main(List<String> args) {
    Location l1 = Location(10, 20);
    print(l1.x.runtimeType); // Object
}

class Location {
    Object x;
    Object y;

    Location(this.x, this.y);
}

    Location类的定义: 泛型方式

    main(List<String> args) {
    Location l2 = Location<int>(10, 20);
    print(l2.x.runtimeType); // int 

    Location l3 = Location<String>('aaa', 'bbb');
    print(l3.x.runtimeType); // String
}
class Location<T> {
    T x;
    T y;

    Location(this.x, this.y);
}

    如果我们希望类型只能是num类型, 怎么做呢?

    main(List<String> args) {
    Location l2 = Location<int>(10, 20);
    print(l2.x.runtimeType);

     // 错误的写法, 类型必须继承自num
    Location l3 = Location<String>('aaa', 'bbb');
    print(l3.x.runtimeType);
}

class Location<T extends num> {
    T x;
    T y;

    Location(this.x, this.y);
}

    提示：T extends num 也就是只能传入 num 类型

  • 4.4、泛型方法的定义
    最初，Dart仅仅在类中支持泛型。后来一种称为泛型方法的新语法允许在方法和函数中使用类型参数。

    main(List<String> args) {
    var names = ['why', 'kobe'];
    var first = getFirst(names);
    print('$first ${first.runtimeType}'); // why String
}
// 返回 list 的第一个元素
T getFirst<T>(List<T> ts) {
    return ts[0];
}

五、库的使用
在Dart中，你可以导入一个库来使用它所提供的功能。
库的使用可以使代码的重用性得到提高，并且可以更好的组合代码。
Dart中任何一个dart文件都是一个库，即使你没有用关键字library声明

  • 5.1、引用库

    • <1>、引用自己写的库
      下图是在项目文件下建立了一个 Utils 文件夹，里面一个一些 dart 文件, Utils.dart 是专门用来放头文件的, 其他我自己写的工具文件，在其他文件使用的时候我们只需要导入 Utils.dart 文件，如： import 'Utils/utils.dart';

      61588387053_.pic_hd.jpg

      提示，当自己写的工具文件和其他库有冲突的时候，我们那可以给文件起别名，如上面的日期文件 date.utils.dart，我们可以如下，在调用 日期里面的方法的时候我们就可以 newDate. 了

      import 'utils/date.utils.dart ' as newDate

      库文件中内容的显示和隐藏

      • 如果希望只导入库中某些内容，或者刻意隐藏库里面某些内容，可以使用show和hide关键字

        • show关键字：可以显示某个成员（屏蔽其他）

        • hide关键字：可以隐藏某个成员（显示其他）

          import 'lib/student/student.dart' show Student, Person;
import 'lib/student/student.dart' hide Person;

    • <2>、引用系统的库
      来自dart标准版，比如dart:io、dart:html、dart:math、dart:core(但是这个可以省略)

      //dart:前缀表示Dart的标准库，如dart:io、dart:html、dart:math
import 'dart:io';

    • <3>、引用第三方的库，在 pub.dev 搜索第三方库，下面我们以 使用 http 为例

      WechatIMG7.jpeg

      • 我们需要在我们的项目里面建立一个文件 pubspec.yaml,里里有一些固定的格式

        name: wc
description: a dart
dependencies: 
      http: ^0.12.1

        提示：

        • name: 名字
        • description：描述
        • dependencies: 第三方库

      • 上面写好后我们需要在终端进入项目，执行下面的指令

        pub get

        提示，在执行完 pub get 后会生成其他几个文件，如：.packages、.dart_tool、pubspec.lock

      • http 的使用，导入头文件

        import 'package:http/http.dart' as http;

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