paint-brush
Refactoring: Remove Setters #CodeSmellby@mcsee
251 reads

Refactoring: Remove Setters #CodeSmell

by Maximiliano ContieriNovember 22nd, 2021
Read on Terminal Reader
Read this story w/o Javascript
tldt arrow

Too Long; Didn't Read

Make your attributes private to favor immutability and add accidental coupling. Setters violate good naming policies since it does not exist on the [MAPPER] setXXX(). Remove the setXXX prefix. If you need to change an accidental property it is not a setter. Remove setXXX. Setter.setX(1); SetXXX(1) violates good naming policy. Setters should detect setters (unless they use meta-programming). Setters must also have good coverage if the car stores its new speed.

People Mentioned

Mention Thumbnail

Companies Mentioned

Mention Thumbnail
Mention Thumbnail
featured image - Refactoring: Remove Setters #CodeSmell
Maximiliano Contieri HackerNoon profile picture

Setters violate immutability and add accidental coupling

TL;DR: Make your attributes private to favor immutability

Problems Addressed

  • Mutability
  • setXXX() violates good naming policies since it does not exist on the MAPPER
  • Accidental coupling

Steps

  1. Locate the setters usage
  2. If you are setting essential properties move them to the constructor and remove the method
  3. If you need to change an accidental property it is not a setter. Remove the setXXX prefix

Sample Code

Before

public class Point {
   protected int x;
   protected int y;
  
   public Point() {
        this.x = 0;
        this.y = 0;        
   }
    
   public void setX(int x) {
	this.x = x;
   }
  
   public void setY(int y) {
        this.y = y;
  } 
}

Point location = new Point();
//At this momment, it is not clear which points represent
//It is coupled to constructor decision.
//Might be null or some other convention

location.setX(1);
//Now we have point(1,0)

location.setY(2);
//Now we have point(1,2)
public class Car {
   protected int speed;
  
   public Car() {     
   }
    
   public void setSpeed(Speed desiredSpeed) {
	this.speed = desiredSpeed;
   }   
}

Car tesla = new Car();
//We have no speed??

tesla.setSpeed(100 km/h);
//Now our car runs fast

After

//1. We locate setters usage
location.setX(1);

location.setY(2);

//2. If you are setting essential properties move 
//them to the constructor and remove the method
public class Point {
   public Point(int x, int y) {
        this.x = x;
        this.y = y;        
     //We remove the setters
   }

Point location = new Point(1, 2);
public class Car {
   protected int speed;
  
   public Car() {    
     this.speed = 0 km/h;
   }
    
   public void speed(Speed desiredSpeed) {
	    this.speed = desiredSpeed;
   }   
}


//1. Locate the setters usage
//3. If you need to change an accidental property
// it is not a setter. Remove the setXXX prefix


Car tesla = new Car();
//Our car is stopped

tesla.speed(100 km/h);
//We tell the desired speed. We don't set anything
//We don't care if the car stores its new speed.
//if it manages through the engine
//if the road is moving etc

Type

[ X ] Semi automatic


We should detect setters (unless they use meta programming) with our IDEs.

We can also remove them and see which tests fails if we have good coverage

Tags

  • Mutability
  • Remove Getters

  • Pass essential properties in the constructor

  • Initialize essential properties in the constructor