精华内容
下载资源
问答
  • 一、 命名构造方法 二、 工厂构造方法 三、 命名工厂构造方法 四、 相关资源





    一、 命名构造方法



    命名构造方法 :

    • 定义格式 : 类名.方法名()
    Student.cover(Student student):super(student.name, student.age);
    
    • 父类构造函数 : 如果父类没有默认构造函数, 子类必须调用父类的构造函数 ;
    • 方法体 : 命名构造方法与普通构造函数一样 , 可以有方法体 , 也可以不写方法体 ;
      // 命名构造方法也可以有方法体
      Student.init(Student student):super(student.name, student.age){
        print("命名构造方法 : name : ${student.name}, age : ${student.age}");
      }
    

    代码示例 :

    // 定义 Dart 类
    // 与 Java 语言类似, 所有的类默认继承 Object 类
    class Person{
    
      // 定义变量
      String name;
      int age;
    
      // 标准构造方法, 下面的方法是常用的构造方法写法
      Person(this.name, this.age);
    
      // 重写父类的方法
      @override
      String toString() {
        return "$name : $age";
      }
    }
    
    // 继承
    class Student extends Person{
    
      // 命名构造方法
      // 定义格式 : 类名.方法名()
      // 父类构造函数 : 如果父类没有默认构造函数, 子类必须调用父类的构造函数
      Student.cover(Student student):super(student.name, student.age);
    
      // 命名构造方法也可以有方法体
      Student.init(Student student):super(student.name, student.age){
        print("命名构造方法 : name : ${student.name}, age : ${student.age}");
      }
    
    }
    




    二、 工厂构造方法



    工厂构造方法就是 单例模式 , 工厂构造方法作用是返回之前已经创建的对象 , 之前创建对象时需要缓存下来 ;

    工厂构造方法规则 : 在构造方法前添加 factory 关键字 ;


    定义了工厂构造方法的类 :

    // 使用工厂构造方法实现单例模式
    // 工厂构造方法就是单例模式
    // 工厂构造方法作用是返回之前已经创建的对象 , 之前创建对象时需要缓存下来 ;
    class Student2{
      // 静态成员
      static Student2 instace;
    
      // 工厂构造方法
      factory Student2(){
        if(instace == null){
          // 调用命名构造方法创建 Student2 对象
          instace = Student2.init();
        }
        // 返回单例对象
        return instace;
      }
    
      // 命名构造方法
      Student2.init();
    }
    

    测试工厂构造方法 :

      factoryConstructorDemo(){
        Student2 stu1 = Student2();
        print("stu1 创建完成 : ${stu1}");
        Student2 stu2 = Student2();
        print("stu2 创建完成 : ${stu2}");
    
        print("对比 stu1 与 stu2 : stu1 == stu2 : ${stu1 == stu2}");
      }
    

    执行结果 :

    I/flutter (32158): stu1 创建完成 : Instance of 'Student2'
    I/flutter (32158): stu2 创建完成 : Instance of 'Student2'
    I/flutter (32158): 对比 stu1 与 stu2 : stu1 == stu2 : true
    




    三、 命名工厂构造方法



    命名工厂构造方法格式 :

    factory 类名.方法名
    

    命名工厂构造方法可以有 返回值 ;

    如果类中有 final 修饰的成员 , 在命名构造方法中必须对其进行初始化 ;

    但是在命名工厂构造方法中 , 可以不初始化 final 类型成员


    命名工厂构造方法示例 :

    // 继承
    class Student extends Person{
    
      // 私有变量, 以下划线开始的变量是私有变量
      int _grade;
    
      String school;
      String city;
      String address;
    
      // 父类构造函数调用 : 如果父类有非空参数的构造函数, 子类必须实现相同参数的构造函数
      // 如果该类有父类 , 那么先调用父类的构造方法 , 完成父类的初始化
      // 然后才能完成自己的初始化
      //
      // this.school 指定自有参数
      // {this.school} 是可选参数, 可选参数必须在构造函数参数列表中最后一个
      //
      // 默认参数 : 可选参数中如果用户不初始化该可选参数 , 那么为其指定一个默认值
      // {this.city = "北京"} 指定了如果用户不初始化 city 变量, 那么为其初始化 "北京" 字符串值
      //
      // 初始化列表 : 冒号后面的内容就是初始化列表
      //            父类构造器也是初始化列表
      //            除了父类构造方法之外 , 还可以在子类构造方法体之前初始化示例变量
      //            不同的初始化实例变量之间使用逗号隔开
      //
      // 父类构造方法 : 如果父类没有默认构造方法 (无参构造方法) ,
      //              必须在初始化列表中调用父类构造函数 , super(name, age) ;
      //
      // 构造方法方法体 : 可以省略 ;
      Student(this._grade, String name, int age,
             {this.school, this.city = "北京"})
             : address = "北京市海淀区" ,
             super(name, age);
    
    
      // 命名构造方法
      // 定义格式 : 类名.方法名()
      // 父类构造函数 : 如果父类没有默认构造函数, 子类必须调用父类的构造函数
      Student.cover(Student student):super(student.name, student.age);
    
      // 命名构造方法也可以有方法体
      Student.init(Student student):super(student.name, student.age){
        print("命名构造方法 : name : ${student.name}, age : ${student.age}");
      }
    
      // 命名工厂构造方法 : factory 类名.方法名
      // 命名工厂构造方法可以有返回值
      // 如果类中有 final 修饰的成员 , 在命名构造方法中必须对其进行初始化
      //    但是在命名工厂构造方法中 , 可以不初始化 final 类型成员
      factory Student.init2(){
        return Student(1, "Tom", 18);
      }
    
    }
    




    四、 相关资源



    参考资料 :


    博客源码下载 :

    展开全文
  • 1.标准构造函数,可选参数,默认参数,初始化列表,命名构造函数,工厂构造函数,命名工厂构造函数,get,set,静态方法,抽象方法,抽象 //所有的都继承自Object class Person { String name; int age; Person(this....

    1.标准构造函数,可选参数,默认参数,初始化列表,命名构造函数,工厂构造函数,命名工厂构造函数,get,set,静态方法,抽象方法,抽象类 

    //所有的类都继承自Object
    class Person {
      String name;
      int age;
      Person(this.name, this.age); //标准构造方法
    
      @override
      String toString() {
        // 重写了父级的toString的方法
        return "name:$name,age:age";
      }
    }
    
    class Student extends Person {
      String _school; //_表示是私有变量
      String city; //城市
      String country; //国家
      String name;
    
      //如果继承的父类没有默认构造方法(无参数的),就要调用父类的构造方法
      //:后面的表示式就是初始化列表
      //this._school初始化自由参数
      //name,age交由父级初始化
      //{}里面的就是可选参数,或者用[]
      //=就是默认参数
      //初始化列表多个表示式的时候,用,隔开
      //构造方法有方法体的,用{}
      //这个事标准构造方法
      Student(this._school, name, int age, {this.city, this.country = '中国'})
          : name = "$country-$city",
            super(name, age) {
        print("构造方法体不是必须的");
      }
    
      //命名构造方法 [类名+.+方法名]
      //可以多个,但是标准构造方法只能一个
      //也可以有方法体
      Student.per(Student stu) : super(stu.name, stu.age);
    
      //命名工厂构造方法: factory [类名+.+方法名]
      //这种形式不需要把final的变量作为参数,比较灵活
      //如果事上面的模式,有final的变量,必须要初始化
      factory Student.fac(String school, String name, int age) {
        return Student(school, name, age);
      }
    
      //_school是私有属性,外部访问要公有
      //可以直接实例化的per.school访问
      String get school=>_school;
    
      //设置的时候,控制修改
      //实例化per.school="123";赋值的时候会调用
      set school(String val){
        _school=val;
      }
     
      //静态方法 方法前加static
      //调用的时候是用[类.方法名]
      static doPrint(String str){
        print("doPring$str");
      }
    }
    
    //工厂构造方法
    //也可以理解为单例模式
    class Logger {
      static Logger _logger;
    
      Logger._create();
    
      factory Logger() {
        if (_logger == null) {
          _logger = Logger._create(); //实例化一般用私有的命名构造方法实现
        }
        return _logger;
      }
    }
    
    //抽象类和抽象方法(没有实现的方法)
    //抽象类里面不一定一定要有抽象方法,但是有抽象方法的类必须是抽象类
    //继承抽象类,必须实现抽象方法
    abstract class Study{
      void flutterStydy();
    }
    
    class FlutterStudy extends Study{
      @override
      //实现抽象方法
      void flutterStydy() {
        print("flutterStydy");
      }
    
    }

    final变量没有初始化的错误:

    2.mixins 用with连接词

    //mixins 是一种重用代码的方式
    //with 后面添加名字,多个用 ,分割
    //只能继承自Object字类,不能有构造函数,不能调用super
    //下面就是一个mixins,可以类,也可以抽象类
    abstract class Studys{
      void flutterStydy();
    }
    
    class Member extends Person with Studys{
    
      Member(String name, int age) : super(name, age); //这是继承实现父级构造函数
    
      //这个是mixins的复用Studys的特性(必须实现抽象类的方法)
      //mixins就是继承类的特性
      @override
      void flutterStydy() {
        // TODO: implement flutterStydy
      }
    
    }

    3.泛型

    //泛型是解决类,接口,方法的复用性,以及对不特定数据类型的支持
    //提高复用性
    //T可以实任意类型
    
    class Cache<T> {
    
      static final Map<String, Object> _cache = Map();
    
      T getItem(String key){
        return _cache[key];
      }
    
      void setItem(String key, T value){
        _cache[key]=value;
      }
    }
    
    class TestCache{
      void start(){
        Cache<String> c1= Cache();
        Cache<int> c2=Cache();
        c1.setItem("name", "张三");  //值只能是String
        c2.setItem("age", 18); //值只能是int
      }
    }
    //泛型的类型约束
    
    class GenericMember<T extends Person> {
      T _person;
    
      GenericMember(this._person);
    
      String getName() {
        return "Name is ${_person.name}";
      }
    }
    
    class TestGenericMember {
      void start() {
        //Student是Person的子类,参考下面
        GenericMember<Student> gm = GenericMember(Student("学校", "名字", 18));
        print(gm.getName()); //Name is 名字
      }
    }
    
    //参考:
    //所有的类都继承自Object
    class Person {
      String name;
      int age;
      Person(this.name, this.age); //标准构造方法
    
      @override
      String toString() {
        // 重写了父级的toString的方法
        return "name:$name,age:age";
      }
    }
    
    class Student extends Person {
      String _school; //_表示是私有变量
      String city; //城市
      String country; //国家
      String name;
    
      //如果继承的父类没有默认构造方法(无参数的),就要调用父类的构造方法
      //:后面的表示式就是初始化列表
      //this._school初始化自由参数
      //name,age交由父级初始化
      //{}里面的就是可选参数,或者用[]
      //=就是默认参数
      //初始化列表多个表示式的时候,用,隔开
      //构造方法有方法体的,用{}
      //这个事标准构造方法
      Student(this._school, name, int age, {this.city, this.country = '中国'})
          : name = "$country-$city",
            super(name, age) {
        print("构造方法体不是必须的");
      }
    
      //命名构造方法 [类名+.+方法名]
      //可以多个,但是标准构造方法只能一个
      //也可以有方法体
      Student.per(Student stu) : super(stu.name, stu.age);
    
      //命名工厂构造方法: factory [类名+.+方法名]
      //这种形式不需要把final的变量作为参数,比较灵活
      //如果事上面的模式,有final的变量,必须要初始化
      factory Student.fac(String school, String name, int age) {
        return Student(school, name, age);
      }
    
      //_school是私有属性,外部访问要公有
      //可以直接实例化的per.school访问
      String get school => _school;
    
      //设置的时候,控制修改
      //实例化per.school="123";赋值的时候会调用
      set school(String val) {
        _school = val;
      }
    
      //静态方法 方法前加static
      //调用的时候是用[类.方法名]
      static doPrint(String str) {
        print("doPring$str");
      }
    }

     4.dart编程小技巧

    //封装,继承,多态
    //封装要大到类型的封装,类的封装和抽象,小到方法的封装
    //封装目的在于提高复用性和可维护性
    //不要在一个方法体里面写太多代码,小于100行
    //点点点习惯,1.点看类有哪些属性和方法 2.点看源码 3.点看源码里面的其他的引用,看究竟
    void skill(){
      // 1.安全的调用 ?.
      List list; //这个list不确定是否存在,你直接调用list.length就会抛异常
      print(list?.length); //这样就不会报错,存在才会访问length
    
      // 2.设置默认值
      print(list?.length??-1); //list不存在的时候,获取的是-1,存在就取list.length
    
      //条件判断0,'',null
      list.addAll([0,'',null]);
    
      //这样固然可以,但是太冗余
      if(list[0] == null || list[0] == 0 || list[0] == ''){
        print('list[0] is empty ');
      }
    
      //这样就简洁多了,多个也方便添加
      if([null,0,''].contains(list[0])){
        print('list[0] is empty ');
      }
    
    }

    也可以参考dart的最佳实践     http://dart.goodev.org/guides/language/effective-dart/usage#section

    展开全文
  • Java中静态工厂方法命名规则

    千次阅读 2018-06-03 17:54:47
    静态工厂方法常见的命名方式: valueOf——不太严格的讲,该方法返回的实例与它的参数具有相同的值。这样的静态工厂方法实际上是类型转换方法。 of——valueOf的一种更为简洁的替代,在EnumSet中使用并流行起来。 ...

    静态工厂方法常见的命名方式:

    1. valueOf——不太严格的讲,该方法返回的实例与它的参数具有相同的值。这样的静态工厂方法实际上是类型转换方法。
    2. of——valueOf的一种更为简洁的替代,在EnumSet中使用并流行起来。
    3. getInstance——返回的实例是通过方法的参数来描述的,但是不能够说与参数具有同样的值。对Singleton来说,该方法没有参数,并返回唯一的实例。
    4. newInstance——像getInstance一样,但newInstance能够确保返回的每个实例都与所有其他实例不同。
    5. getType——像getInstance一样,但是在工厂方法处于不同的类中的时候使用。Type表示工厂方法所返回的对象类型。
    6. newType——像newInstance一样,但是在工厂方法处于不同的类中的时候使用。Type表示工厂方法所返回的对象类型。
    展开全文
  • 静态工厂方法的主要缺点在于,如果不含有公有的或者受保护的构造器,就不能被子化。对于公有的静态工厂所返回的非公有,也同样如此。例如,要想将CollectionsFramework中的任何方便的实现子类化,这是不可能...

    静态工厂方法缺点

    静态工厂方法的主要缺点在于,类如果不含有公有的或者受保护的构造器,就不能被子类化。对于公有的静态工厂所返回的非公有类,也同样如此。例如,要想将CollectionsFramework中的任何方便的实现类子类化,这是不可能的。但是这样也许会因祸得福,因为它鼓励程序员使用复合(composition),而不是继承。

    静态工厂方法的第二个缺点在于,它们与其他的静态方法实际上没有任何区别。在API文档中,它们没有像构造器那样在API文档中明确标识出来,因此,对于提供了静态工厂方法而不是构造器的类来说,要想查明如何实例化一个类,这是非常困难的。同时,你通过在类或者接口注释中关注静态工厂,并遵守标准的命名习惯,也可以弥补这一劣势。下面是静态工厂方法的一些惯用名称:

    常用命名规则

    valueOf —— 不太严格地讲,该方法返回的实例与它的参数具有相同的值。这样的静态工厂方法实际上是类型转化方法。


    of —— valueOf 的一种更为简洁的替代,在 EnumSet (见第32条)中使用并流行起来。

    getInstance —— 返回的实例是通过方法的参数来描述的,但是不能够说与参数具有同样的值。对于 Singleton 来说,该方法没有参数,并返回唯一的实例。

    newInstance —— 像 getInstance 一样,但 newInstance 能够确保返回的每个实例都与所有其他实例不同。

    getType —— 像 getInstance 一样,但是在工厂方法处于不同的类中的时候使用。Type表示工厂方法所返回的对象类型。

    newType —— 像 newInstance 一样,但是在工厂方法处于不同的类中的时候使用。

    Type表示工厂方法所返回的对象类型。

    第1条:考虑用静态工厂方法代替构造器

    简而言之,静态工厂方法和公有构造器都各有用处,我们需要理解它们各自的长处。静态工厂通常更加合适,因此切忌第一反应就是提供公有的构造器,而不先考虑静态工厂。

     

    展开全文
  • namedspace工厂生成一个简单的,该封装了一个命名空间并提供了各种访问它的方法。 它受到namedtuple的启发(并无耻地复制了一些namedtuple代码),并受到我意识到自己经常滥用namedtuple的启发,将namedtuple...
  • 1.简单工厂模式: ...1) 工厂类角色:这是本模式的核心,含有一定的商业逻辑和判断逻辑。在java中它往往由 一个具体类实现。 2) 抽象产品角色:它一般是具体产品继承的父类或者实现的接口。在java中由接口或者
  • 图例参考: ...比如车辆类型族(运动型、舒适型),车辆品牌族(宝马、奔驰),族和族可以互相组合,所以抽象工厂中具体工厂可以以侧重点命名SportDriver和BusinessDriver,然后在Sport里面用方法createBe...
  • Java---设计模块(工厂方法)

    千次阅读 2016-04-03 23:07:26
    工厂类命名规范:***Factory 单例工厂方法命名规范:getInstance()工厂的本质是“选择实现”工厂、接口和实现类之间的技术边界:工厂只负责选择实现,实现类才做真正的实现,而接口是限定到底实现什么东西和...
  • 创建一个后,如果不声明构造方法,会默认声明一个与的修饰符相同修饰符的无参的构造方法。 不是应该声明一个public的无参构造方法吗? 不是。 工厂方法: 就是常见的getInstance、newInstance。 ...
  • 静态工厂方法

    千次阅读 2013-12-19 14:54:10
    静态工厂方法是什么静态工厂方法的声明方式静态工厂方法的优势静态工厂方法的劣势静态工厂方法的争议  静态工厂方法与构造器不同的第一大优势在于:他们有名 静态工厂方法与构造器不同的第二大优势在于:不必在...
  • Java 使用静态工厂方法替代构造方法

    千次阅读 2020-04-13 09:35:06
    一个可以提供一个公共静态工厂方法,它只是一个返回实例的静态方法。 下面是一个 Boolean 简单的例子(boolean 基本类型的包装)。 此方法将 boolean 基本类型转换为 Boolean 对象引用: public static...
  • 简单工厂工厂方法与抽象工厂大比拼

    千次阅读 热门讨论 2015-08-20 18:37:31
    简单工厂工厂方法和抽象工厂都属于设计模式创建型,严格意义上简单工厂不属于23设计模式之一(违背了开闭原则),本文为了完整描述三工厂演变过程,对三工厂进行了整体的总结和学习,并通过三者之间的特点比较总结...
  • 静态工厂方法的优缺点分析

    千次阅读 2016-06-20 23:59:15
    静态工厂方法的优缺点 本文参考Effective Java的观点,简单罗列下静态工厂方法的在创建对象时的优缺点。 先看一个Boolean(基本类型boolean的包装)的简单示例 public static Boolean valueOf(boolean b){ ...
  • 一、获取 命名空间 类名 方法名 using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Diagnostics; using System.Reflection; namespace GetMethodNameSpace { ...
  • c++实现工厂方法模式

    千次阅读 2018-04-16 21:32:39
    核心工厂类不再负责产品的创建,这样核心类成为一个抽象工厂角色,仅负责具体工厂子类必须实现的接口,这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。 工厂方法...
  • 直到前些时候才去了解工厂模式,其实工厂模式还是很常用的,参考大话设计模式和网上的若干博客,初步整理出四种版本的,简单工厂模式、工厂模式、改进的反射工厂模式、抽象工厂模式。  首先先大概了解下实际运用...
  • 工厂方法的称谓明显和一般意义上的工厂方法不同,从本质上来说,类方法可以独立于对象而执行,所以在其他的语言里面类方法有的时候被称为静态方法。 注意点一:类方法 1,类方法可以调用类方法。 2,类方法不可以...
  • Java 静态工厂方法

    千次阅读 2013-05-23 11:11:55
    静态工厂方法讲解 ...假如需要进一步封装创建自身实例的细节,并且控制自身实例的数目,那么可以提供静态工厂方法。  例如Class实例是Java虚拟机在加载一个时自动创建的,程序无法用new语句创
  • Dart中的——初始化列表、命名构造器、factory构造器、常量构造器、构造器私有化、get和set方法、枚举 1、调用成员变量——使用"."来调用成员变量或方法 var p = Point(2, 2); // Set the value of the instance ...
  • 设计模式【工厂方法模式】

    千次阅读 2014-09-23 22:34:27
    本文主要是分享自己在学习设计模式过程中的心得与记录,有什么不当之处,望各位有心关注的看官,给予指证...本文主要讲述【工厂方法模式】,望各位细细品读。【转载使用,请注明出处:http://blog.csdn.net/mahoking】
  • 本文主要介绍如何使用静态工厂方法已经在那种场合来使用这种方式代替构造...当然除了这种方法以外,我们还可以通过给提供一个public的静态工厂方法(static factory method)的方式来完成,让它返回一个的实例。
  • C#设计模式之1-工厂方法模式

    万次阅读 2018-07-20 22:24:50
    工厂方法模式属于创建型模式,定义一个创建对象的接口,让其子类自己决定实例化哪一个工厂类,工厂模式使其创建过程延迟到子类进行。 它提供了一种创建对象的最佳方式。在工厂模式中,我们在创建对象时不会对客户端...
  • 用静态工厂方法代替构造器

    千次阅读 2019-12-18 20:40:17
    参考于《Effective Java》 前言 对于而言,获得其实例最常见的...本质上就是的一个静态方法,返回值是的实例对象。 通过私有化构造器,无法直接new对象,而是通过运行静态工厂方法获取对象实例。 这么做既...
  • DAO工厂类的实现

    千次阅读 2008-12-04 23:06:00
    在刚开始的时候设计DAO模式的结构时,我们按 一个典型的 DAO 实现有以下组件: 一个 DAO 工厂类 一个 DAO 接口 一个实现了 DAO 接口的具体类 数据传输对象(有时称为值对象) 如何才能使系统通过一种更加灵活地方式来...
  • 从简单工厂工厂方法

    千次阅读 2007-07-13 09:20:00
    写在前面 最近一段时间在研究有关设计模式方面的文章,拜读了TerryLee以及吕震宇两位老师所写的设计模式方面的系列文章,收获颇丰,也让我对OOP,OOD有了新的理解和认识,不过在看到工厂方面的几篇文章时,却总有个...
  • 设计模式(3) 工厂方法(Factory Mehod)

    千次阅读 2014-01-06 18:59:07
    问题聚焦: 工厂方法与抽象工厂的区别 别名:虚构造器(Virtual Constructor)
  • 设计模式-工厂模式-3种-以手机制造工厂为例

    千次阅读 多人点赞 2019-07-19 16:05:18
    超级链接: Java常用设计模式的实例学习系列-绪论 参考:《HeadFirst设计模式》 ...工厂方法模式,全称多个工厂方法模式。 抽象工厂模式。 本文以`手机制造工厂生产手机为场景来学习工厂模式。 手机有两...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 74,832
精华内容 29,932
关键字:

命名工厂类方法