每天laravel-20160812| Container -15

    /**
     * Resolve the given type from the container.
     *
     * @param  string  $abstract
     * @param  array   $parameters
     * @return mixed
     */
     // get the given type from the container
    public function make($abstract, array $parameters = [])
    {// this function name "make" like compile c file to binary file in the linux
        $abstract = $this->getAlias($this->normalize($abstract));
        // first get the alias as the new name

        // If an instance of the type is currently being managed as a singleton we'll
        // just return an existing instance instead of instantiating new instances
        // so the developer can keep using the same objects instance every time.
        if (isset($this->instances[$abstract])) {
            return $this->instances[$abstract];
        }// like normal method
        // if it is exist ,we will return it, that ok;

        $concrete = $this->getConcrete($abstract);// concrete like create it done

        // We're ready to instantiate an instance of the concrete type registered for
        // the binding. This will instantiate the types, as well as resolve any of
        // its "nested" dependencies recursively until all have gotten resolved.
        if ($this->isBuildable($concrete, $abstract)) {// isBuildable
            $object = $this->build($concrete, $parameters);// check it is can be Builda
        } else {
            $object = $this->make($concrete, $parameters);
        }

        // If we defined any extenders for this type, we'll need to spin through them
        // and apply them to the object being built. This allows for the extension
        // of services, such as changing configuration or decorating the object.
        foreach ($this->getExtenders($abstract) as $extender) {
            $object = $extender($object, $this);
        }// to though , a extender done is too trouble

        // If the requested type is registered as a singleton we'll want to cache off
        // the instances in "memory" so we can return it later without creating an
        // entirely new instance of an object on each subsequent request for it.
        if ($this->isShared($abstract)) {
            $this->instances[$abstract] = $object;
        }// get the instance from the "memory"

        $this->fireResolvingCallbacks($abstract, $object);

        $this->resolved[$abstract] = true;

        return $object;
    }// in the last we will found it is a compatible way to get you want object.

    /**
     * Get the concrete type for a given abstract.
     *
     * @param  string  $abstract
     * @return mixed   $concrete
     */
    protected function getConcrete($abstract)
    {// get a Concrete type for a abstract
        if (! is_null($concrete = $this->getContextualConcrete($abstract))) {
            return $concrete;
        }// if you can get it ,then return it
        // otherwise see next

        // If we don't have a registered resolver or concrete for the type, we'll just
        // assume each type is a concrete name and will attempt to resolve it as is
        // since the container should be able to resolve concretes automatically.
        if (! isset($this->bindings[$abstract])) {
            return $abstract;
        }// return it back

        return $this->bindings[$abstract]['concrete'];
    }//last we will binding it