Why I should use dependency injection in Drupal 8? Why is this 

__construct(MyService $my_service ) {
   $this-&gt;my_service = $my_service;
}

create (ContainerInterface $container) {
  return new static(
      $container-&gt;get('my.service'));
}


better than

__construct() {
    $this-&gt;my_service = new MyService();
}


?
From Services and dependency injection in Drupal 8:


  ... is best practice to access any of the services provided by Drupal via
  the service container to ensure the decoupled nature of these systems
  is respected.


A clear example can be found in Drupal 8 Dependency Injection, Service Container And All That Jazz:


  Take the following simple class:

class Car {

  protected $engine;

  public function __construct() {
    $this-&gt;engine = new Engine();
  }

  /* ... */

}

  
  When you instantiate a new class Car you go like this:

$car = new Car();

  
  And now you have an object handler ($car) that has an $engine property
  containing the handler of another object. But what if this car class
  needs to work with another engine? You'd have to extend the class and
  overwrite its constructor for each new car with a different engine.
  Does that make sense? No.
  
  Now consider the following:

class Car {

  protected $engine;

  public function __construct($engine) {
    $this-&gt;engine = $engine;
  }

  /* ... */

}

  
  To instantiate an object of this class, you go like this:

$engine = new Engine();
$car = new Car($engine);

  
  Much better. So now if you need to create another car using another
  engine, you can do so easily without caring about the Car class too
  much since it is supposedly equipped to work with all the engines in
  your application.

$turbo = new TurboEngine();
$car2 = new Car($turbo);

  
  And that is dependency injection. The Car class depends on an engine
  to run (dooh), so we inject one into its constructor which then does
  what it needs to do. Rather than hardcoding the engine into the Car
  class which would not make the engine swappable. Such constructor
  injections are the most common but you'll also find other types such
  as the setter injection by which we would pass in the engine through a
  setter method.
  
  So there you go. Dependency injection is a very simple concept that
  has to do with the practice of decoupling functionality between
  classes. By passing dependencies to objects we can isolate their
  purpose and easily swap them with others. Additionally, it make is
  much easier to unit test the classes individually by passing mock
  objects.