精华内容
下载资源
问答
  • 链式编程

    2021-03-18 11:09:28
    链式编程 函数式编程 响应式编程 前几天看Masonry 框架框架,虽然常常用 .语法很方便,但是一直都没去看看怎么实现的。 链式编程:通过高阶函数以点为连接将多个函数连接在一起完成参数传递和复杂的操作! iOS中...

      常见的编程方式有:

    • 链式编程
    • 函数式编程
    • 响应式编程

     前几天看Masonry 框架框架,虽然常常用 .语法很方便,但是一直都没去看看怎么实现的。

    链式编程: 通过高阶函数以点为连接将多个函数连接在一起完成参数传递和复杂的操作!

    iOS中是通过getter方法来实现各方法之间的链式调用,特点:每个方法必须有返回值(本身对象),把函数或者Block当做参数,block参数(需要操作的值)block返回值(操作结果)。jAVA 链式编程的原理就是返回一个this对象,就是返回本身,达到链式效果。

    下面举个🌰吧:

    #import <Foundation/Foundation.h>
    
    NS_ASSUME_NONNULL_BEGIN
    
    @interface Cat : NSObject
    
    -(Cat* (^)(NSString *foodName))eat;
    -(Cat* (^)(NSInteger hour))sleep;
    
    
    -(Cat*)hehe;
    -(Cat*)haha;
    
    -(Cat*)aa;
    -(Cat*)bb;
    
    -(void)cc;
    -(void)dd;
    
    @end
    
    NS_ASSUME_NONNULL_END
    
    
    =============.m=================
    
    #import "Cat.h"
    
    @implementation Cat
    
    
    -(Cat* (^)(NSString *))eat{
        Cat * (^eatBlock)(NSString*) =  ^(NSString *foodName){
            NSLog(@"---------吃:%@",foodName);
            return self;
        };
        return eatBlock;
        
    }
    
    -(Cat* (^)(NSInteger hour))sleep{
        
        return  ^(NSInteger hour){
            NSLog(@"睡了%ld小时",hour);
            return self;
        };
    }
    
    -(Cat*)hehe{
        NSLog(@"------呵呵呵---");
        return self;
    }
    -(Cat*)haha{
        NSLog(@"----哈哈哈哈------");
        return self;
    }
    
    -(Cat*)aa{
        NSLog(@"-----aaa----" );
        return [[Cat alloc]init];
    }
    -(Cat*)bb{
        NSLog(@"-----bbb----" );
        return [[Cat alloc]init];
    }
    
    -(void)cc{
        NSLog(@"-----ccc---" );
    }
    
    -(void)dd{
        NSLog(@"-----ddd---" );
    }
    
    @end
    
    =================调用====================
     Cat *cat = [[Cat alloc]init];
        [cat cc];
        [cat dd];
        
      [[cat hehe]haha];
        
       [[cat aa]bb];
    
      cat.eat(@"奥特曼").sleep(100);
      cat.eat(@"奥特曼").sleep(100);
      [cat aa].eat(@"迪迦奥特曼");
    

    可以发现其实实现起来也不难,就是通过get方法将单个方法串联起来; 

    1  常用方法

      [cat cc];

       [cat dd];

    2    [[cat aa]bb];

    3 cat.eat(@"奥特曼").sleep(100);

    下面就来实战一下吧,封装一个lable:

    #import <UIKit/UIKit.h>
    
    NS_ASSUME_NONNULL_BEGIN
    
    @interface UILabel (Custom)
    
    
    
    +(UILabel*(^)(CGRect frame))label;
    
    - (UILabel *(^)(NSString *title))title;
    - (UILabel *(^)(UIColor *titleColor))titleColor;
    -(UILabel *(^)(NSInteger font))customfont;
    
    
    @end
    
    NS_ASSUME_NONNULL_END
    
    ===============================
    #import "UILabel+Custom.h"
    
    @implementation UILabel (Custom)
    
    + (UILabel * _Nonnull (^)(CGRect))label {
        return ^(CGRect frame) {
            return [[UILabel alloc] initWithFrame:frame];
        };
    }
    
    - (UILabel * _Nonnull (^)(NSString * _Nonnull))title {
        return ^(NSString *title) {
            self.text = title;
            return self;
        };
    }
    
    - (UILabel * _Nonnull (^)(UIColor * _Nonnull))titleColor {
        return ^(UIColor *titleColor) {
            self.textColor = titleColor;
            return self;
        };
    }
    
    -(UILabel *(^)(NSInteger font))customfont{
       
        return  ^(NSInteger font){
            self.font = [UIFont systemFontOfSize:font];
            return self;
        };
    }
    
    @end
    
    //调用
    UILabel *la = UILabel.label(CGRectMake(100, 200, 180, 100)).title(@"链式编程").titleColor([UIColor redColor]).customfont(80);
      [self.view addSubview: la];

    链式编程的特点:

    1. 方法的返回值是block。

    2. 这个block必须有返回值,并且这个返回值就是对象本身;block也有输入参数。

    总体看来链式编程还是很不错的可读性强,调用方便,封装之后可以很方便的调用,就是在封装时需要多点时间。缺点:封装时得写一堆blok,不熟容易各种报错。

    暂时就写这么多吧。可以动手试试~

    展开全文
  • Java 链式编程 和 lombok 实现链式编程

    万次阅读 多人点赞 2018-10-28 21:52:53
    接着我来说下链式编程 链式编程的原理就是返回一个this对象,就是返回本身,达到链式效果。 我们经常用的 StringBuffer 就是 实现了链式的写法。 StringBuffer builder = new StringBu...

    一、什么是链式编程

    1、链式编程定义

    链式编程的原理就是返回一个this对象,就是返回本身,达到链式效果。

    我们经常用的 StringBuffer 就是 实现了链式的写法。

    StringBuffer builder = new StringBuffer();
    builder.append("blake").append("bob").append("alice").append("linese").append("eve");
    

    是不是很方便呢!

    怎么实现呢,其实就是在设置的 返回当前的对象

    2、查看 jdk 中 StringBuffer 源码:

    public final class StringBuilder  extends ... {
    
        // ...省略代码...
        
        public StringBuilder append(String str) {
            super.append(str);
            return this;             // 返回this
        }
      
        private StringBuilder append(StringBuilder sb) {
            if (sb == null)
                return append("null");
            int len = sb.length();
            int newcount = count + len;
            if (newcount > value.length)
                expandCapacity(newcount);
            sb.getChars(0, len, value, count);
            count = newcount;
            return this;           // 返回this
        }
      
        public StringBuilder append(StringBuffer sb) {
            super.append(sb);
            return this;			// 返回this
        }
     
        public StringBuilder delete(int start, int end) {
            super.delete(start, end);
            return this;			// 返回this
        }
     
        public StringBuilder deleteCharAt(int index) {
            super.deleteCharAt(index);
            return this;			// 返回this
        }
      
        public StringBuilder replace(int start, int end, String str) {
            super.replace(start, end, str);
            return this;			// 返回this
        }   
        
        public StringBuilder insert(int offset, String str) {
            super.insert(offset, str);
            return this;			// 返回this
        }
      
        public int indexOf(String str) {
            return indexOf(str, 0);			// 返回this
        }   
       
        public int lastIndexOf(String str) {
            return lastIndexOf(str, count);		// 返回this
        }
       
        public StringBuilder reverse() {
            super.reverse();
            return this;						// 返回this
        }
    
        public String toString() {      
            return new String(value, 0, count);			// 返回this
        }
    }
    

    3、按照上面的方法写一个例子:

    public class StudentBean {
    	private String name;
    	private int age;
    
    	public String getName() {
    		return name;
    	}
    
    	public StudentBean setName(String name) {
    		this.name = name;
    		return this;		// 返回this
    	}
    
    	public int getAge() {
    		return age;
    	}
    
    	public StudentBean setAge(int age) {
    		this.age = age;
    		return this;		// 返回this
    	}
    }
    
    

    测试:

    public class Main {
    
    	public static void main(String[] args) {
    		
    		StudentBean studentBean = new StudentBean().setAge(22).setName("ly");
    		System.out.println(studentBean.getAge());
    		System.out.println(studentBean.getName());
    	}
    }
    

    二、 lombok 链式编程

    lombok 能通过注解的方式,在编译时自动为属性生成构造器、getter/setter、equals、hashcode、toString方法。

    2.1、依赖

    <dependency>
    	<groupId>org.projectlombok</groupId>
    	<artifactId>lombok</artifactId>
    	<version>1.16.14</version>
    	<scope>provided</scope>
    </dependency>
    

    2.2、lombok 实现静态的链式编程

    我们把这个 bean 改成 lombok 实现只需要加上一个 @Accessors(chain = true) 即可。

    import lombok.*;
    import lombok.experimental.Accessors;
    
    @Accessors(chain = true)
    @Data
    public class StudentBean {
    	private String name;	
    	private int age;
    	
    }
    

    这样代码简洁多了 ,而且实现了链式编程。
    在这里插入图片描述

    测试代码与上面的代码完全一样。

    三、静态的链式编程

    静态的链式编程 比 普通的链式编程 的好处:

    • 创建对象更简洁;
    • 可以在静态方法、静态代码块等中使用;
    • 对于必输字段,可以强制要求。

    对比:

    特点 静态的链式编程 普通的链式编程
    创建对象更简洁 对象.静态方法() new 对象()
    可以在静态方法、静态代码块等中使用
    对于必输字段,可以强制要求。 对象.静态方法(param) if( xxx ){ ...}

    3.1、lombok 实现静态的链式编程

    比如,创建 StudentBean 对象时,有时会要求一些必输字段,比如name字段必须有值。

    1)如果自己编写代码实现静态的链式编程。

    代码如下:

    import lombok.NonNull;
    
    public class StudentBean {
     
    	private String name;  
    	private int age;
    	
    	
    	private StudentBean(String name) {   //默认构造方法置为 private
    	  	this.name = name;
    	}
    	
    	public static StudentBean getInstance(String name) {  //唯一的 public 构造方法,name 不能为空
    	 	if (name == null)
    	    	throw new NullPointerException("name is not null"); 
    	  	return new StudentBean(name);
    	}  
    	
    	//------------  getter/setter  --------------
    	public StudentBean setName(String name) { 
    	  	this.name = name;
    	  	return this;   // 返回this
    	}
    	
    	public StudentBean setAge(int age) {
    	 	this.age = age;
    	  	return this;   // 返回this
    	}  
    	
    	public String getName() {
    	  	return this.name;
    	} 
    	
    	public int getAge() {
    	  	return this.age;
    	}  
    	
    	public String toString() {
    	  	return "StudentBean(name=" + getName() + ", age=" + getAge() + ")";
    	}
    }
    

    上面是自己编写静态的链式编程。 如果使用 lombok 注解,则代码更加简洁。

    2) 使用 lombok 注解 实现静态的链式编程

    代码如下:

    import lombok.*;
    import lombok.experimental.Accessors;
    
    @Accessors(chain = true)
    @Data
    @RequiredArgsConstructor(staticName = "getInstance")   //指定构造方法 
    public class StudentBean {
    
    	@NonNull
    	private String name;
    	
    	private int age;
    }
    

    3) 探究 lombok 注解的原理

    @RequiredArgsConstructor 究竟做了什么,我们通过 StudentBean.class 反编译(整理后)可以看到 :

    import lombok.NonNull;
    
    public class StudentBean {
    
    	  @NonNull
    	  private String name;  
    	  private int age;
    	  
    	   // 默认构造方法置为 private
    	  private StudentBean(@NonNull String name) { 
    		    if (name == null)
    		      	throw new NullPointerException("name"); 
    		    this.name = name;
    	  }
    	  
    	   //唯一的 public 构造方法,name 不能为空
    	  public static StudentBean getInstance(@NonNull String name) { 
    	    	return new StudentBean(name);
    	  }
    	  	
    
    	  //------------  getter/setter  --------------
    	   public StudentBean setName(@NonNull String name) {
    		   if (name == null)
    		      throw new NullPointerException("name"); 
    		   this.name = name;
    		   return this;         // 返回this
    	  }  
    	  
    	  public StudentBean setAge(int age) {
    		  this.age = age;
    		  return this;         // 返回this
    	  }
    	  
    	  @NonNull
    	  public String getName() {
    	   	 return this.name;
    	  }
    	  
    	  public int getAge() {
    	  	  return this.age;
    	  }
    
    	 public String toString() {
    	    return "StudentBean(name=" + getName() + ", age=" + getAge() + ")";
    	 }
    
      	 // -- 省略 equals,canEqual ,hashCode--- 	
    }
    
    • 默认构造方法置为 private ;
    • 唯一的、指定为public的 getInstance 构造方法,要求 name 不能为空。

    4)测试方法:

    public class Main {	
    	public static void main(String[] args) {		
    		StudentBean studentBean = StudentBean.getInstance("zhangsan").setAge(22);
    		System.out.println(studentBean.getAge());
    		System.out.println(studentBean.getName());
    	}
    }
    

    这样不仅实现了链式编程,还实现了静态创建。

    四、builder模式的链式Bean

    4.1、自定义 builder模式的链式Bean

    build模式实现原理为在bean里面创建一个 静态builder方法 和一个 静态内部Builder类 ,通过调用静态builder方法来创建 Builder类,然后通过 builder类 中的 build方法直接创建一个Bean,具体如下:

    public class StudentBean {
    	private String name;
    	
    	private int age;
     
    	public String getName() {
    		return name;
    	} 
    	public void setName(String name) {
    		this.name = name;
    	} 
    	public int getAge() {
    		return age;
    	} 
    	public void setAge(int age) {
    		this.age = age;
    	}
    		
    	public static Builder builder() {
    		return new Builder();
    	}
    	
    	public static class Builder{
    		private String name;
    		
    		private int age;
     
    		public Builder name(String name) {
    			this.name = name;
    			return this;
    		}
     
    		public Builder age(int age) {
    			this.age = age;
    			return this;
    		}
    		
    		public StudentBean build() {
    			StudentBean studentBean = new StudentBean();
    			studentBean.setName(name);
    			studentBean.setAge(age);
    			return studentBean;
    		}
    	}
    }
    

    测试方法:

    StudentBean studentBean = StudentBean.builder().name("zhangsan").age(11).build();
    

    4.2、lombok 实现 builder模式的链式bean

    这样就实现了一个builder模式的链式bean。其实用lombok就一个注解的事情,调用与上面同样

    import lombok.*;
    
    @Builder
    @Data
    public class StudentBean {
    	private String name;
    	
    	private int age;
    }
    
    展开全文
  • 一、什么是链式编程 1、链式编程定义 2、jdk 中 StringBuffer 源码: 3、按照上面的方法写一个例子: 二、lombok链式编程 2.1、依赖 2.2、lombok实现静态的链式编程 三、静态的链式编程 3.1、lombok实现静态...

    目录

    一、什么是链式编程

    1、链式编程定义

    2、jdk 中 StringBuffer 源码:

    3、按照上面的方法写一个例子:

    二、 lombok 链式编程

    2.1、依赖

    2.2、lombok 实现静态的链式编程

    三、静态的链式编程

    3.1、lombok 实现静态的链式编程

    四、builder模式的链式Bean

    4.1、自定义 builder模式的链式Bean


    一、什么是链式编程

    1、链式编程定义

    链式编程的原理就是返回一个this对象,就是返回本身,达到链式效果。

    我们经常用的 StringBuffer 就是 实现了链式的写法。

    StringBuffer builder = new StringBuffer();
    builder.append("blake").append("bob").append("alice").append("linese").append("eve");
    

    是不是很方便呢!

    怎么实现呢,其实就是在设置的 返回当前的对象 。

    2、jdk 中 StringBuffer 源码:

    @Override
    public StringBuilder append(String str) {
        super.append(str);
        return this;
    }
    

    3、按照上面的方法写一个例子:

    public class StudentBean {
    	private String name;
    	private int age;
    
    	public String getName() {
    		return name;
    	}
    
    	public StudentBean setName(String name) {
    		this.name = name;
    		return this;
    	}
    
    	public int getAge() {
    		return age;
    	}
    
    	public StudentBean setAge(int age) {
    		this.age = age;
    		return this;
    	}
    }
    
    

    测试:

    public class Main {
    
    	public static void main(String[] args) {
    		
    		StudentBean studentBean = new StudentBean().setAge(22).setName("ly");
    		System.out.println(studentBean.getAge());
    		System.out.println(studentBean.getName());
    	}
    }
    

    二、 lombok 链式编程

    2.1、依赖

    <dependency>
    	<groupId>org.projectlombok</groupId>
    	<artifactId>lombok</artifactId>
    	<version>1.16.14</version>
    	<scope>provided</scope>
    </dependency>
    

    2.2、lombok 实现静态的链式编程

    其实,lombok 已经提供该 style,我们把这个bean 改成 lombok 实现只需要加上一个 @Accessors(chain = true) 即可。

    import lombok.*;
    import lombok.experimental.Accessors;
    
    @Accessors(chain = true)
    @Data
    public class StudentBean {
    	private String name;	
    	private int age;
    	
    }
    

    这样代码简洁多了 ,而且实现了链式编程。

    在这里插入图片描述

    测试代码与上面的代码完全一样。

    三、静态的链式编程

    静态的链式编程 比 普通的链式编程 的好处:

    • 创建对象更简洁;
    • 可以在静态方法、静态代码块等中使用;
    • 对于必输字段,可以强制要求。

    3.1、lombok 实现静态的链式编程

    写 StudentBean 这个bean的时亿会有一些必输字段,比如name字段必须有值。使用 lombok 的写法如下:

    import lombok.*;
    import lombok.experimental.Accessors;
    
    @Accessors(chain = true)
    @Data
    @RequiredArgsConstructor(staticName = "of")
    public class StudentBean {
    
    	@NonNull
    	private String name;
    	
    	private int age;
    }
    

    测试方法:

    public class Main {	
    	public static void main(String[] args) {		
    		StudentBean studentBean = StudentBean.of("zhangsan").setAge(22);
    		System.out.println(studentBean.getAge());
    		System.out.println(studentBean.getName());
    	}
    }
    

    这样不仅实现了链式编程,还实现了静态创建。

    四、builder模式的链式Bean

    4.1、自定义 builder模式的链式Bean

    build模式实现原理为在bean里面创建一个 静态builder方法 和一个 静态内部Builder类 ,通过调用静态builder方法来创建 Builder类,然后通过 builder类 中的 build方法直接创建一个Bean,具体如下:

    public class StudentBean {
    	private String name;
    	
    	private int age;
     
    	public String getName() {
    		return name;
    	} 
    	public void setName(String name) {
    		this.name = name;
    	} 
    	public int getAge() {
    		return age;
    	} 
    	public void setAge(int age) {
    		this.age = age;
    	}
    		
    	public static Builder builder() {
    		return new Builder();
    	}
    	
    	public static class Builder{
    		private String name;
    		
    		private int age;
     
    		public Builder name(String name) {
    			this.name = name;
    			return this;
    		}
     
    		public Builder age(int age) {
    			this.age = age;
    			return this;
    		}
    		
    		public StudentBean build() {
    			StudentBean studentBean = new StudentBean();
    			studentBean.setName(name);
    			studentBean.setAge(age);
    			return studentBean;
    		}
    	}
    }
    

    测试方法:

    StudentBean studentBean = StudentBean.builder().name("zhangsan").age(11).build();
    

    4.2、lombok 实现 builder模式的链式bean

    这样就实现了一个builder模式的链式bean。其实用lombok就一个注解的事情,调用与上面同样

    import lombok.*;
    
    @Builder
    @Data
    public class StudentBean {
    	private String name;
    	
    	private int age;
    }
    
    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 53,749
精华内容 21,499
关键字:

链式编程