Flutter学习笔记1.6 Dart基础（对象 类 构造函数 类的私有化 静态 类转换 继承 ）

Flutter学习笔记1.1 Dart基础（变量 常量 命名规则 基本类型
Flutter学习笔记1.2 Dart基础（运算符 条件判断 类型转换）
Flutter学习笔记1.3 Dart基础（循环语句 for,while, do...while, 多维列表循环,自增 自减 )
Flutter学习笔记1.4 Dart基础（List Set Map，属性，数据操作））
Flutter学习笔记1.5 Dart基础（函数 参数的多种定义方式 可选参数 默认参数 命名参数 箭头函数 匿名函数 递归 闭包））
Flutter学习笔记1.6 Dart基础（对象 类 构造函数 类的私有化 静态 类转换 继承 ））
Flutter学习笔记1.7 Dart基础（抽象类 多态 接口 mixins多重继承 泛型类 泛型方法 泛型接口 ）
Flutter学习笔记1.8 Dart基础（第三方库导入 使用 ， Async Await.dart 延迟加载）
Flutter学习笔记1.9 Dart基础（Dart 2.13之后的一些新特性 空类型声明符？,非空断言！,required 关键字）

面向对象编程(OOP)的三个基本特征是：封装、继承、多态
封装：封装是对象和类概念的主要特性。封装，把客观事物封装成抽象的类，并且把自己的部分属性和方法提供给其他对象调用, 而一部分属性和方法则隐藏。
继承：面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。
多态：允许将子类类型的指针赋值给父类类型的指针, 同一个函数调用会有不同的执行效果 。

Dart所有的东西都是对象，所有的对象都继承自Object类。
Dart是一门使用类和单继承的面向对象语言，所有的对象都是类的实例，并且所有的类都是Object的子类
一个类通常由属性和方法组成。

  Object a = 123;
  Object v = true;
  print(a);
  print(v);

类的定义

class Person {
  String name = "张三";
  int age = 23;

  void getInfo() {
    // print("$name----$age");
    print("${this.name}----${this.age}");
  }

  void setInfo(int age) {
    this.age = age;
  }
}

void main() {
  //实例化

  var p1 = new Person();
  print(p1.name);
  p1.getInfo();

  Person p2 = new Person();
  // print(p1.name);

  p2.setInfo(28);
  p2.getInfo();
}

构造函数

dart里面构造函数可以写多个

class Person {
//最新版本的dart中需要初始化不可为null的实例字段，如果不初始化的话需要在属性前面加上late
  late String name;
  late int age;

  //默认构造函数的简写
  Person(this.name, this.age);

  Person.now() {
    print('我是命名构造函数');
  }

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

  void printInfo() {
    print("${this.name}----${this.age}");
  }
}

//调用
void main() {
  var d=new DateTime.now();   //实例化DateTime调用它的命名构造函数
  /print(d);

 Person p1=new Person('张三', 20);   //默认实例化类的时候调用的是 默认构造函数

  Person p1=new Person.now();   //命名构造函数

  Person p1 = new Person.setInfo('李四', 30);
  p1.printInfo();
}

Dart中我们也可以在构造函数体运行之前初始化实例变量

class Rect{
  int height;
  int width;
  Rect():height=2,width=10{
    
    print("${this.height}---${this.width}");
  }
  getArea(){
    return this.height*this.width;
  } 
}

void main(){
  Rect r=new Rect();
  print(r.getArea()); 
   
}

类的私有化

Dart和其他面向对象语言不一样，Data中没有 public private protected这些访问修饰符合

但是我们可以使用_把一个属性或者方法定义成私有。

示例代码：

class Animal{
  late String _name;   //私有属性
  late int age; 
  //默认构造函数的简写
  Animal(this._name,this.age);

  void printInfo(){   
    print("${this._name}----${this.age}");
  }

  String getName(){ 
    return this._name;
  } 
  void _run(){
    print('这是一个私有方法');
  }

  execRun(){
    this._run();  //类里面方法的相互调用
  }
}

调用

import 'lib/Animal.dart';

void main(){
 Animal a=new Animal('小狗', 3);
 print(a.getName());
 a.execRun();   //间接的调用私有方法
}

静态成员

1、使用static 关键字来实现类级别的变量和函数

2、静态方法不能访问非静态成员，非静态方法可以访问静态成员

main(){
  print(Person.name);
  Person.show();

  print(Person.name);
  Person.show();


  Person p=new Person();
  p.printInfo();

  Person.printUserInfo();
}


class Person {
  static String name = '张三';
  int age=20;
  static void show() {
    print(name);
  }
  void printInfo(){  /*非静态方法可以访问静态成员以及非静态成员*/
    // print(name);  //访问静态属性
    // print(this.age);  //访问非静态属性
    show();   //调用静态方法
  }
  static void printUserInfo(){//静态方法
    print(name);   //静态属性
    show();        //静态方法

    // print(this.age);     //静态方法没法访问非静态的属性
    // this.printInfo();   //静态方法没法访问非静态的方法
    // printInfo();

  }

}

类型转换 as

class Person {
  String name;
  num age;

  Person(this.name, this.age);

  void printInfo() {
    print("${this.name}---${this.age}");
  }
}

//使用
  var p1;

  p1='';

  p1=new Person('张三1', 20);

  // p1.printInfo();
  (p1 as Person).printInfo();

类型判断 is

class Person {
  String name;
  num age;

  Person(this.name, this.age);

  void printInfo() {
    print("${this.name}---${this.age}");
  }
}

  Person p=new Person('张三', 20);
  if(p is Person){
      p.name="李四";
  }
  p.printInfo();
  print(p is Object);

级联操作 （连缀)

class Person {
  String name;
  num age;

  Person(this.name, this.age);

  void printInfo() {
    print("${this.name}---${this.age}");
  }
}

  Person p1 = new Person('张三1', 20);
  p1.printInfo();
  p1
    ..name = "李四"
    ..age = 30
    ..printInfo();

继承

1、子类使用extends关键词来继承父类
2、子类会继承父类里面可见的属性和方法 但是不会继承构造函数
3、子类能复写父类的方法 getter和setter

跟java类似，我们用几个例子演示，留意注释说明

示例1

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();
 
}

示例2

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


class Web extends Person{
//引用父类方法 super
  Web(String name, num age) : super(name, age){
    
  }  
}

main(){ 

  Person p=new Person('李四',20);
  p.printInfo();

  Person p1=new Person('张三',20);
  p1.printInfo();

  Web w=new Web('张三', 12);
  w.printInfo();


}

示例3

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

class Web extends Person{
  late String sex;
//继承父类的构造方法 参数
  Web(String name, num age,String sex) : super(name, age){
    this.sex=sex;
  }
  run(){
   print("${this.name}---${this.age}--${this.sex}");  
  }
  
}

main(){ 

  Person p=new Person('李四',20);
  p.printInfo();

 Person p1=new Person('张三',20);
 p1.printInfo();


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

  w.printInfo();

  w.run();

}

示例4

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();

  w.run();
 
}