学无先后，达者为师

网站首页 编程语言 正文

dart总结(三.类,接口,继承,多态,mixins和枚举详解)

作者：庚中 更新时间： 2022-02-16 编程语言

Object类

Dart中所有的东西都是对象，所有的对象都继承自Object类.

普通类的声明

特点:用new关键字实例化

  class Class01{
    //变量
    int a;
    String b;
    var c=3;
    //函数
    void fun01(int d){
    }
    String fun2(){
      return b;
    }
  }
void main(){
//记住练习类要在main函数外面创建,里面会报错
  var class01= new Class01();
  print(class01.c);//3
  class01..a=1..b="b";//..级联操作符可以连续调用类的属性进行赋值
  print(class01.a);//1
  print(class01.b);//'b'
}

类属性和类方法(也叫静态属性和静态方法)

特点:使用static关键字来声明

main(List<String> args) {
  // static关键字声明的类属性和类方法不用实例直接可以使用类名点的方法来调用.
  Person.courseTime = "8:00";
  print(Person.courseTime); //8:00

  Person.gotoCourse();//去上课
}

class Person {
  // 成员变量
  String name;

  // 静态属性(类属性)
  static String courseTime;

  // 对象方法
  void eating() {
    print("eating");
  }

  // 静态方法(类方法)
  static void gotoCourse() {
    print("去上课");
  }
}

默认构造函数

class Class02{
  //变量
  int a =3;
  //未声明构造函数,有下面默认构造函数
  Class2(){}
}

void main (){
 var class02=new Class02();//正常实例化
 print(class02.a);//3
}

自定义构造函数

class Class03{
  int a;
  String b;
  // 自定义构造函数
  Class03(int a,String b){
    this.a=a;
    this.b=b;
  }
}

void main (){
 var class03=new Class03(1, "a");
 print(class03.a);//1
 print(class03.b);//a
}

上面简写

class Class03{
  int a;
  String b;
  // 自定义构造函数简写
  Class03(this.a,this.b);
}
void main (){
  var class03 =new Class03(1, "a");
  print(class03.a);//1
 print(class03.b);//a
}

命名构造函数

其实就是一种可以为类声明多个不同的构造函数.

class Class03{
  int a;
  String b;
  Class03(int a,String b){
    this.a=a;
    this.b=b;
  }
  Class03.fun1(int a){
    this.a=a;
  }
  Class03.fun2(String b){
    this.b=b;
  }
}

void main (){
  var class03=new Class03(4, "d");
  var class04=new Class03.fun1(5);
  var class05=new Class03.fun2('d');
  print(class04.a);//5
  print(class05.b);//'d'
}

静态构造函数(也叫常量构造函数)

特点:
1.用final关键字修饰变量,
2.用const修饰构造函数,
3.实例化使用的是const关键字(并不是new关键字)
4.可以创建相同的对象.

class Class04{
  // 用final修饰常量
  final int a;
  final String b;
  // 用const 修饰构造函数
  const Class04(this.a,this.b);
  //普通函数
  void fun01(){
    print("aa");
  }
}

void main (){
  var class04=const Class04(1, "a");
  print(class04.a);//1
  class04.fun01();//aa
}


main(List<String> args) {
  var p1 = const Person('why');//赋值时const关键字可以省略
  var p2 = const Person('why');
  print(identical(p1, p2)); // true
}

class Person {
  final String name;

  const Person(this.name);
}

重定向构造函数

class Class05{
  int a;
  String b;
  Class05(int a,String b){
    this.a=a;
    this.b=b;
  }
  Class05.fun1(int a){
    this.a=a;
  }
  // 重定向构造函数
  Class05.fun2(String b):this.fun1(33);//重定向到函数fun1
  Class05.fun3(String b):this(33,"ccc");//重定向到构造函数Class05
}

void main (){
 var class05 =new Class05(55, "fff");
 print(class05.a);//55
 var class06=new Class05.fun2("hhh");
 print(class06.a);//33,被重定向到了fun1
 var class07=new Class05.fun3("hhh");
 print(class07.a);//33,被重定向到了构造函数Class05
 print(class07.b);//ccc,被重定向到了构造函数Class05

工厂构造函数

特点:
1.使用facory关键字声明构造函数;
2.跟普通构造函数区别,在factory构造函数里需要手动return一个对象;

class Class06 {
  int a;
  static Class06 instance; //这里用static关键字创建一个单例
  factory Class06(int a) {
    //这里的构造函数用factory修饰，使用new时，不再是创建一个全新的实例了，而是通过函数体内return获取到实例
    if (instance == null) {
      instance = new Class06.fun1(a);
    }
    return instance;
  }
  Class06.fun1(this.a); //这里是实例化当前对象的构造方法
}

void main() {
  var class06 = new Class06(22);
  var class07 = new Class06(22);
  print(class06.a); //22
  print(identical(class06, class07)); //true,通过工厂构造函数创建出来的是同一个对象
}

工厂函数创建相同对象的案例:

main(List<String> args) {
  final p1 =
      Person.withName("why"); //依次打印:没对象创建一个null;{};name=why color=default
  final p2 = Person.withName("why");//打印:有对象后: {why: name=why color=default}
  print(identical(p1, p2)); //true
}

// 常量构造方法创建同一个对象的局限只能限定一个构造函数
// class Person {
//   final String name;
//   final String color = "red";

//   const Person(this.name);
//   const Person(this.color);
// }

// 而工厂函数创建同一个对象可以创建不同的构造函数
// 比如下面的需求:如果传入的name相同则返回相同的对象;如果传入的color相同,也可以返回相同的对象

// 普通的构造函数: 会自动返回创建出来的对象, 不能手动的返回
// 工厂构造函数最大的特点: 可以手动的返回一个对象
class Person {
  String name;
  String color;

  static final Map<String, Person> _nameCache = {};
  static final Map<String, Person> _colorCache = {};

  factory Person.withName(String name) {
    if (_nameCache.containsKey(name)) {
      print('有对象后: $_nameCache'); //{why: name=why color=default}
      return _nameCache[name];
    } else {
      final p = Person(name, "default");
      print('没对象创建一个${_nameCache[name]}'); //null
      print(_nameCache); //{}
      print(p); //实质是对象,打印name=why color=default
      _nameCache[name] = p;
      return p;
    }
  }
  @override
  String toString() {
    return 'name=$name color=$color';
  }

  factory Person.withColor(String color) {
    if (_colorCache.containsKey(color)) {
      return _colorCache[color];
    } else {
      final p = Person("default", color);
      _colorCache[color] = p;
      return p;
    }
  }

  Person(this.name, this.color);
}

get 和 set 修饰词的应用

class Rect{
  num height;
  num width; 
  
  Rect(this.height,this.width);
  get area{//注意get这里是类
    return this.height*this.width;
  }
  set areaHeight(value){//set是设置方法
    this.height=value;
  }
}

void main(){
  Rect r=new Rect(10,4);
  print("面积:${r.area}");  //10*4=40,所以输出40.注意调用直接通过访问属性的方式访问area,如果调用括号会报错
  r.areaHeight=6;//注意设置也是直接通过实例.方法名的方式设置

  print(r.area);//输出24

}

可以用箭头函数简写:

main(List<String> args) {
  final p = Person();
  // 通过getter和setter访问
  p.setName = "lilei";
  print(p.getName);
}

class Person {
  String name;
  // 常规set和get写法
  // set setName(String name) {
  //   this.name = name;
  // }

  // get getName {
  //   //记住这里是大括号
  //   return name;
  // }

// 箭头函数简写

  set setName(String name) => this.name = name;
  String get getName => name;
}

抽象方法

特点:

  • 1、抽象类通过abstract 关键字来定义

  • 2、Dart中的抽象方法不能用abstract声明，Dart中没有方法体的方法我们称为抽象方法。

  • 3、如果子类继承抽象类必须得实现里面的抽象方法

  • 4、如果把抽象类当做接口实现的话必须得实现抽象类里面定义的所有属性和方法。

  • 5、抽象类不能被实例化，只有继承它的子类可以

//定义抽象类,使用abstract修饰

abstract class Class09{
  void fun01();//这里是定义抽象方法
}
//继承抽象类
class Class10 extends Class09 {
  @override
  void fun01(){//这里是实现抽象方法
    print("定义自己的抽象方法");
  }
}

void main(){
  var class10=new Class10();
  class10.fun01();//打印:定义自己的抽象方法
}

案例：
定义一个Animal 类要求它的子类必须包含eat方法

abstract class Animal{
  eat();   //抽象方法
  run();  //抽象方法  
  printInfo(){
    print('我是一个抽象类里面的普通方法');
  }
}

class Dog extends Animal{
  @override
  eat() {
     print('小狗在吃骨头');
  }

  @override
  run() {
    // TODO: implement run
    print('小狗在跑');
  }  
}
class Cat extends Animal{
  @override
  eat() {
    // TODO: implement eat
    print('小猫在吃老鼠');
  }

  @override
  run() {
    // TODO: implement run
    print('小猫在跑');
  }

}

main(){

  Dog d=new Dog();
  d.eat();//小狗在吃骨头
  d.printInfo();//我是一个抽象类里面的普通方法

   Cat c=new Cat();
  c.eat();//小猫在吃老鼠
  c.printInfo();//我是一个抽象类里面的普通方法


  // Animal a=new Animal();   //报错,抽象类没法直接被实例化

}

接口

特点:使用implements关键字

/*
定义一个DB库 支持 mysql  mssql  

mysql  mssql  两个类里面都有同样的方法

*/


abstract class Db{   //当做接口   接口：就是约定 、规范
    String uri;      //数据库的链接地址
    add(String data);
    save();
    delete();
}

class Mysql implements Db{
  
  @override
  String uri;

  Mysql(this.uri);

  @override
  add(data) {
    // TODO: implement add
    print('这是mysql的add方法'+data);
  }

  @override
  delete() {
    // TODO: implement delete
    return null;
  }

  @override
  save() {
    // TODO: implement save
    return null;
  }

  remove(){
      
  }

  
}

class MsSql implements Db{
  @override
  String uri;
  MsSql(this.uri);
  @override
  add(String data) {
    print('这是mssql的add方法'+data);
  }

  @override
  delete() {
    // TODO: implement delete
    return null;
  }

  @override
  save() {
    // TODO: implement save
    return null;
  }


}

main() {

  Mysql mysql=new Mysql('xxxxxx');

  mysql.add('1243214');//这是mysql的add方法1243214


  MsSql mssql=new MsSql('xxxxxx');

  mssql.add('1243214');//这是mssql的add方法1243214

  


  
}

案例2
特点:
比如下面 Impostor 实现了类Person ，那么Impostor 中必须重写Person 中所有的属性和函数。

// person 类。 隐式接口里面包含了 greet() 方法声明。
class Person {
  // 包含在接口里，但只在当前库中可见。
  final _name;

  // 不包含在接口里，因为这是一个构造函数。
  Person(this._name);

  // 包含在接口里。
  String greet(String who) => 'Hello, $who. I am $_name.';
}

// person 接口的实现。
class Impostor implements Person {
  @override
  get _name => '';
  
  @override
  String greet(String who) => 'Hi $who. Do you know who I am?';
}

//声明greetBob函数
String greetBob(Person person) => person.greet('Bob');

void main() {
  print(greetBob(Person('Kathy')));//Hello, Bob. I am Kathy.
  print(greetBob(Impostor()));//Hi Bob. Do you know who I am?
}

extends抽象类 和 接口implements 的区别：

  • 1、如果要复用抽象类里面的方法，并且要用抽象方法约束子类的话我们就用extends继承抽象类

  • 2、如果只是把抽象类当做标准的话我们就用接口implements实现抽象类.

接口案例:

// Dart中没有哪一个关键字是来定义接口的, 没有这些关键字interface/protocol
// 默认情况下所有的类都是隐式接口
// Dart支持单继承
// 当将一个类当做接口使用时, 那么实现这个接口的类, 必须实现这个接口中所有方法(即里面都要重写接口里的方法)

class Runner {
void running() {

}
}


class Flyer {
void flying() {

}
}

class Animal {
void eating() {
  print("动物次东西");
}

void running() {
  print("running");
}
}
// 在接口里要必须重新实现接口里的方法
class SuperMan extends Animal implements Runner, Flyer {//这里不但继承Animal类,因为已经有running方法了,所以接口里面可以不用写running了,

@override
void eating() {
  super.eating();
}

@override
void flying() {
}
}

多态(实际是抽象类)

特点:

  • 用abstract关键字
  • 子类的实例赋值给父类的引用。
  • 多态就是父类定义一个方法不去实现，让继承他的子类去实现，每个子类有不同的表现。
abstract class Animal{
 eat();   //抽象方法 
}

class Dog extends Animal{
 @override
 eat() {
    print('小狗在吃骨头');
 }
 run(){
   print('小狗run');
 }
}
class Cat extends Animal{
 @override
 eat() {   
   print('小猫在吃老鼠');
 }
 run(){
   print('小猫run');
 }
}

main(){
 //普通实例化和调用 

 // Dog d=new Dog();
 // d.eat();//小狗在吃骨头
 // d.run();//小狗run


 // Cat c=new Cat();
 // c.eat();//小猫在吃老鼠
 // c.run();//小猫run


//多态的使用:子类的实例赋值给父类的引用;多态就是父类定义一个方法不去实现，让继承他的子类去实现

 Animal d=new Dog();
 d.eat();//小狗在吃骨头



 Animal c=new Cat();
 c.eat();//小猫在吃老鼠




}

静态变量和静态函数的使用

class Class11{
  static int a=3;//静态变量
  int b=4;//实例变量

  static void fun01(int c){//静态方法
    print(c);
  }
  void fun02(){//实例方法
    print(this.b);
  }
}

void main (){
  var class11=new Class11();
  print(class11.b);//4,实例变量
  print(Class11.a);//3,静态变量
  class11.fun02();//4 ,实例函数调用
  Class11.fun01(44);//44 静态函数调用
}

枚举类型
特点:使用enum修饰类,每个枚举值都有一个唯一值,不用实例化,直接枚举名点values获取所有枚举值.

//定义枚举
enum Week { Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday }
void main() {
  List<Week> list = Week.values; //values属性获取所有枚举值
  print(
      list); //[Week.Monday, Week.Tuesday, Week.Wednesday, Week.Thursday, Week.Friday, Week.Saturday, Week.Sunday]

  list.forEach((e) {
    print(e); //依次如下打印
    //     Week.Monday
    //     Week.Tuesday
    //     Week.Wednesday
    //     Week.Thursday
    //     Week.Friday
    //     Week.Saturday
    //     Week.Sunday
    print(e.index);//依次如下打印
    //     0
    //     1
    //     2
    //     3
    //     4
    //     5
    //     6
  });

}

类实例化对象的操作符

?     条件运算符 （了解）
as    类型转换
is    类型判断
..    级联操作 （连缀）  (很常见)

class Person {
String name;
num age;
Person(this.name, this.age);
void printInfo() {
 print("${this.name}---${this.age}");
}
}

void main() {
// ?运算符
Person p;
print(p); //null
p?.printInfo(); //没执行后面方法.这是条件运算符判断,如果?前面是空,则不会执行后面操作

Person p = new Person("张三", 18);
p?.printInfo(); //张三---18

// is运算符
Person p = new Person("张三", 18);
if (p is Person) {
 //is判断是否是后面的类型
 p.name = "李四";
}
p.printInfo(); //李四---18

Person p = new Person("张三", 18);
print(p is Object); //true

// ..运算符
Person p = new Person("张三", 18);

// 等同于
p
 ..name = "李四"
 ..age = 30
 ..printInfo(); //李四---30
}

继承

简单继承

class Person {
  String name='张三';
  num age=20; 
  void printInfo() {
    print("${this.name},${this.age}");  
  } 
}
class Web extends Person{

}

main(){   

  Web w=new Web();
  print(w.name);//张三
  w.printInfo();//张三,20
 
}

super关键字的使用

子类给父类传参

class Person {
  String name;
  num age; 
  Person(this.name,this.age);
  void printInfo() {
    print("${this.name}---${this.age}");  
  }
}


class Web extends Person{
  // Web(String name, num age) : super(name, age){//这里是子类给父类传参

  // }
  // 可以简写
   Web(String name, num age) : super(name, age);
  
}

main(){ 
  Web w=new Web('张三', 12);

  w.printInfo();//张三---12


}

给子类添加自己的属性

class Person {
  String name;
  num age; 
  Person(this.name,this.age);
  void printInfo() {
    print("${this.name}---${this.age}");  
  }
}


class Web extends Person{
  String sex;
  Web(String name, num age,String sex) : super(name, age){
    this.sex=sex;
  }
  run(){
   print("${this.name}---${this.age}--${this.sex}");  
  }
  
}

main(){ 

  Web w=new Web('张三', 12,"男");

  w.printInfo();//张三---12

  w.run();//张三---12--男

}

子类给父类命名构造函数传参

class Person {
  String name;
  num age; 
  Person(this.name,this.age);
  Person.xxx(this.name,this.age);
  void printInfo() {
    print("${this.name}---${this.age}");  
  }
}


class Web extends Person{
  String sex;
  Web(String name, num age,String sex) : super.xxx(name, age){
    this.sex=sex;
  }
  run(){
   print("${this.name}---${this.age}--${this.sex}");  
  }
  
}

main(){ 

  Web w=new Web('张三', 12,"男");

  w.printInfo();//张三---12

  w.run();//张三---12--男

}

子类覆写父类的方法

class Person {
  String name;
  num age; 
  Person(this.name,this.age);
  void printInfo() {
    print("${this.name}---${this.age}");  
  }
  work(){
    print("${this.name}在工作...");
  }
}

class Web extends Person{
  Web(String name, num age) : super(name, age);

  run(){
    print('run');
  }
  //覆写父类的方法
  @override       //可以写也可以不写  建议在覆写父类方法的时候加上 @override 
  void printInfo(){
     print("姓名：${this.name}---年龄：${this.age}"); 
  }
  @override
  work(){
    print("${this.name}的工作是写代码");
  }

}





main(){ 

  Web w=new Web('李四',20);

  w.printInfo();//姓名：李四---年龄：20

  w.work();//李四的工作是写代码
 
}

子类里面调用父类的方法

class Person {
  String name;
  num age; 
  Person(this.name,this.age);
  void printInfo() {
    print("${this.name}---${this.age}");  
  }
  work(){
    print("${this.name}在工作...");
  }
}

class Web extends Person{
  Web(String name, num age) : super(name, age);

  run(){
    print('run');
    super.work();  //自类调用父类的方法
  }
  //覆写父类的方法
  @override       //可以写也可以不写  建议在覆写父类方法的时候加上 @override 
  void printInfo(){
     print("姓名：${this.name}---年龄：${this.age}"); 
  }
  

}


main(){ 

  Web w=new Web('李四',20);

  w.printInfo();//姓名：李四---年龄：20

  w.run();//run 李四在工作...
 
}

继承案例:

main(List<String> args) {
  var p = new Person('why', 18);

  print(p); //打印:name=why, age=18
  p.run(); //打印:why在奔跑ing
}

class Animal {
  int age;

  Animal(this.age);

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

class Person extends Animal {
  String name;

  Person(String name, int age)
      : this.name = name, //这里是将传递过来的name赋值给name,this可以省略,后面使用逗号
        super(age);

  @override
  run() {
    print('$name在奔跑ing');
  }

//  重写Person的toString方法
  @override
  String toString() {
    return 'name=$name, age=$age';
  }
}

mixins多类继承

如果继承已经写好的多接口方法不想重写的话,直接用mixin混入就不用每个方法重写一遍了.
特点:
1.用mixin/class关键字来声明类接口规范;
2.用with关键字来混入引用;
3.混入的类中可以不用重写mixin中的方法;

案例1

main(List<String> args) {
  final sm = SuperMan();
  sm.running(); //SuperMan running
  sm.flying(); //flying
}

mixin Runner {
  //这里不使用class关键字,使用mixin代替class
  void running() {
    print("runner running");
  }
}

mixin Flyer {
  void flying() {
    print("flying");
  }
}

class Animal {
  void eating() {
    print("动物次东西");
  }

  void running() {
    print("animal running");
  }
}

class SuperMan extends Animal with Runner, Flyer {//使用with混入已经写好的Runner Flyer类
  @override
  void eating() {
    super.eating();
  }

  void running() {
    print("SuperMan running");
  }
}

调用顺序总结:自己有的方法直接调用自己的,然后再找继承的,再没有的会找混入的mixin方法.
案例2

class With1 {//用mixin关键字来代替class也是一样的
  String getName() => 'With1';//三个类都有该方法
  String getAge()=> "With1   10" ;//该类独有
}

class With2 {用mixin关键字来代替class也是一样的
  String getName() => 'With2';//三个类都有该方法
  String getColor() => "With2   red";//该类独有
  int getNum()=> 6;//该类和OtherClass都有
  String getFruit()=>"With2   banana";
}

class OtherClass {
  String getName() => 'OtherClass';//三个类都有该方法
  int getNum() => 3; //该类和With2都有
  int getDesk() => 333;//该类独有

  String getPhone()=>"OtherClass   huawei";//该类和子类
  String getFruit()=>"OtherClass   apple";

}

class Child1 extends OtherClass with With1 ,With2 {
  //重写父类
  @override
  String getPhone() {
    return "Child1   iphone";
  }
  @override
  String getFruit() {
    return "Child1  oriange";
  }
}
class Child2 extends OtherClass with With2, With1 {}
void main(){
    print("class Child1 extends OtherClass with With1 ,With2 {}");
    Child1 c1 = Child1();
    print(c1.getPhone());//Child1   iphone     重写了函数，调用时用的是自身的函数
    print(c1.getFruit());//Child1  oriange     重写了函数，调用时用的是自身的函数
    print(c1.getDesk());//333      调用的是OtherClass的函数  With1 With2中没有同名函数
    print(c1.getNum());//6       调用的是With2中的函数
    print(c1.getAge());//With1   10        调用的是With1中的函数
    print(c1.getColor());//With2   red       调用的是With2中的函数
    print(c1.getName());//With2          调用的是With2中的函数    With2在声明顺序中更靠后

    print("-----------------------");
    print("class Child2 extends OtherClass with With2, With1 {}");
    Child2 c2 = Child2();
    print(c2.getPhone());//OtherClass   huawei     没有重写函数，调用时用的是OtherClass的函数
    print(c2.getFruit());//With2   banana    没有重写函数，调用时用的是With2的函数，虽然OtherClass也有，但With2在声明顺序中更靠后
    print(c2.getDesk());//333     调用的是OtherClass的函数  With1 With2中没有同名函数
    print(c2.getNum());//6     调用的是With2中的函数
    print(c2.getAge());//With1   10       调用的是With1中的函数
    print(c2.getColor());//With2   red      调用的是With2中的函数
    print(c2.getName());//With1      调用的是With1中的函数    With1在声明顺序中更靠后
}

解释说明:

  • A extends B with C,D{}。

  • A 继承了B 并拥有了C和D所有的属性和函数，可以用A的实例直接调用CD的属性方法。

  • 如果B有函数fun1，A重写了这个函数 那么以后A的实例调用的fun1，都是A重写后的方法。

  • 如果B有函数fun1，CD中也有函数fun1，A重写了这个函数 那么以后A的实例调用的fun1，都是A重写后的方法。

  • 如果B有函数fun1，CD中也有函数fun1，A没有重写这个函数 那么以后A的实例调用的fun1，是声明方法时最后的那个类的函数，比如“A extends B with C,D”，那么就是D中的fun1，如果是“A extends B with D,C”，那么就是C中的fun1。也就是说优先级是从后向前的（前提是子类没有重写函数）。

枚举

枚举是一种特殊的类, 通常用于表示固定数量的常量值.
特点:
1.使用enum关键字来进行定义类;
2.不能拿来实例化;

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

enum Colors { red, green, blue }

枚举中两个常见的属性:

  • index: 用于表示每个枚举常量的索引, 从0开始.

  • values: 包含每个枚举值的List;

main(List<String> args) {
  // 属性index
  print(Colors.red.index);//0
  print(Colors.green.index);//1
  print(Colors.blue.index);//2
  // 属性values
  print(Colors.values);//打印:[Colors.red, Colors.green, Colors.blue]
}

常见枚举的用法:

// 枚举用法
main(List<String> args) {
  final color = Colors.red;

  switch (color) {
    case Colors.red:
    //todo
      print("红色");
      break;
    case Colors.blue:
      print("蓝色");
      break;
    case Colors.green:
      print("绿色");
      break;
  }
}

enum Colors {
  red,
  blue,
  green
}

原文链接：https://blog.csdn.net/xiaodi520520/article/details/107521198

相关推荐

栏目分类
最近更新
Copyright © 2025   AB教程网    免责声明
本站部分资源收集于互联网、用户投稿，其版权归原作者所有，内容以共享、参考、学习为主，不存在任何商业目的。如有侵权请与本站联系，情况属实将予以删除!
本站由    提供CDN加速