import java.text.DecimalFormat;
public void changeColor(View view) {
        DecimalFormat decimalFormat = new DecimalFormat("000");
        //获取随机数对象，产生三个随机数值（RGB值）
        Random x = new Random();

        int red = x.nextInt(256);
        String sred = decimalFormat.format(red);
        txvR.setText("红："+sred);
        txvR.setTextColor(Color.rgb(red,0,0));

        int green = x.nextInt(256);
        String sgreen = decimalFormat.format(green);
        txvG.setText("绿："+sgreen);
        txvG.setTextColor(Color.rgb(0,green,0));

        int blue = x.nextInt(256);
        String sblue = decimalFormat.format(blue);
        txvB.setText("蓝："+sblue);
        txvB.setTextColor(Color.rgb(0,0,blue));

        //设置界面最上方的按钮 button 的文字颜色
        button.setTextColor(Color.rgb(red,green,blue));

        //设置界面最下方的空白 LinearLayout 的背景颜色
        colorBlock.setBackgroundColor(Color.rgb(red,green,blue));
    }

import java.text.DecimalFormat;

//如果数字1是字符串,如下处理：
String string="1";
DecimalFormat decimalFormat =new DecimalFormat("0000");
String string2=decimalFormat.format(Integer.parseInt(str1));
System.out.println(string2);

//如果数字1是整型,如下处理：
int string=1;
DecimalFormat decimalFormat =new DecimalFormat("0000");
String string2=decimalFormat.format(string);
System.out.println(string2);

//方法一
    function FillZero(p) {
        return new Array(3 - (p + '''').length + 1).join(''0'') + p;
    }
    FillZero(6);    //输出006
 
    //方法一扩展（C#中PadLeft、PadRight）
    String.prototype.PadLeft = function (len, charStr) {
        var s = this + '''';
        return new Array(len - s.length + 1).join(charStr,  '''') + s;
    }
    String.prototype.PadRight = function (len, charStr) {
        var s = this + '''';
        return s + new Array(len - s.length + 1).join(charStr,  '''');
    }
    var p = 6;
    p.toString().PadLeft(3, ''0'');    //输出006
    p.toString().PadRight(3, ''0'');  //输出600

<&#63;php
namespace Lio\Http\Controllers\Forum;
use Lio\Forum\Replies\ReplyRepository;
use Lio\Forum\Threads\ThreadCreator;
use Lio\Forum\Threads\ThreadCreatorListener;
use Lio\Forum\Threads\ThreadDeleterListener;
use Lio\Forum\Threads\ThreadForm;
use Lio\Forum\Threads\ThreadRepository;
use Lio\Forum\Threads\ThreadUpdaterListener;
use Lio\Http\Controllers\Controller;
use Lio\Tags\TagRepository;
class ForumThreadsController extends Controller implements ThreadCreatorListener, ThreadUpdaterListener, ThreadDeleterListener
{
 protected $threads;
 protected $tags;
 protected $currentSection;
 protected $threadCreator;
 public function __construct(
  ThreadRepository $threads,
  ReplyRepository $replies,
  TagRepository $tags,
  ThreadCreator $threadCreator
 ) {
  $this->threads = $threads;
  $this->tags = $tags;
  $this->threadCreator = $threadCreator;
  $this->replies = $replies;
 }
}

$constructor = $reflector->getConstructor();
dump($constructor);

public function build($concrete, array $parameters = [])
{
 // If the concrete type is actually a Closure, we will just execute it and
 // hand back the results of the functions, which allows functions to be
 // used as resolvers for more fine-tuned resolution of these objects.
 if ($concrete instanceof Closure) {
  return $concrete($this, $parameters);
 }
 $reflector = new ReflectionClass($concrete);
 // If the type is not instantiable, the developer is attempting to resolve
 // an abstract type such as an Interface of Abstract Class and there is
 // no binding registered for the abstractions so we need to bail out.
 if (! $reflector->isInstantiable()) {
  $message = "Target [$concrete] is not instantiable.";
  throw new BindingResolutionContractException($message);
 }
 $this->buildStack[] = $concrete;
 $constructor = $reflector->getConstructor();
 // If there are no constructors, that means there are no dependencies then
 // we can just resolve the instances of the objects right away, without
 // resolving any other types or dependencies out of these containers.
 if (is_null($constructor)) {
  array_pop($this->buildStack);
  return new $concrete;
 }
 $dependencies = $constructor->getParameters();
 // Once we have all the constructor''s parameters we can create each of the
 // dependency instances and then use the reflection instances to make a
 // new instance of this class, injecting the created dependencies in.
 $parameters = $this->keyParametersByArgument(
  $dependencies, $parameters
 );
 $instances = $this->getDependencies(
  $dependencies, $parameters
 );
 array_pop($this->buildStack);
 return $reflector->newInstanceArgs($instances);
}

protected function resolveClass(ReflectionParameter $parameter)
{
 try {
  return $this->make($parameter->getClass()->name);
 }
 // If we can not resolve the class instance, we will check to see if the value
 // is optional, and if it is we will return the optional parameter value as
 // the value of the dependency, similarly to how we do this with scalars.
 catch (BindingResolutionContractException $e) {
  if ($parameter->isOptional()) {
   return $parameter->getDefaultValue();
  }
  throw $e;
 }
}

<&#63;php
class kulou
{
 //
}
class junjun
{
 //
}
class tanteng
{
 private $kulou;
 private $junjun;
 public function __construct(kulou $kulou,junjun $junjun)
 {
  $this->kulou = $kulou;
  $this->junjun = $junjun;
 }
}
//$tanteng = new tanteng(new kulou(),new junjun());
$reflector = new ReflectionClass(''tanteng'');
$constructor = $reflector->getConstructor();
$dependencies = $constructor->getParameters();
print_r($dependencies);exit;