/**
 * 插件入口类
 */
class TestPlugin implements Plugin<Project> {
    @Override
    void apply(Project project) {
        //do something
    }
}
apply plugin: TestPlugin

apply plugin: 'groovy'
dependencies{
    //gradle sdk
    compile gradleApi()
    //groovy sdk
    compile localGroovy()
}
//以上配置比较固定
//以下内容主要用来上传插件
apply plugin: 'maven'
repositories {
    mavenCentral()
}
group = 'com.charles.plugin'
version = '1.0.0'
uploadArchives{
    repositories {
        mavenDeployer{
            repository(url: uri('./../repo'))
        }
    }
}

//插件是一个类 继承Plugin
class LintPlugin implements Plugin<Project> {
//重载 void apply(Project project)方法，这个方法将会传入使用这个插件的 project 的实例，这是一个重要的 context。
    @Override
    void apply(Project project) {
        /*project.task('lintOutputsTask') {
            doLast {
                println("lint outputs task start...")
            }
        }*/
        project.afterEvaluate {
            project.android.lintOptions.xmlOutput=new File(project.buildDir,"lintResult.xml")
        }
        project.tasks.create('cleanTest',CleanTestTask)
    }
}

implementation-class=com.charles.plugin.LintPlugin

apply plugin: 'com.charles.plugin'

buildscript {
    ext.kotlin_version = '1.2.30'
    repositories {
        google()
        jcenter()
        maven {
            url uri('./../repo')
        }
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:3.1.3'
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
        classpath 'com.charles.plugin:lintplugin:1.0.0'
        // NOTE: Do not place your application dependencies here; they belong
        // in the individual module build.gradle files
    }
}

强制使用该模式：-Xint

强制使用该模式：-Xint

//代码路径：
package retrofit2.adapter.rxjava2.CallExecuteObservable
@Override protected void subscribeActual(Observer<? super Response<T>> observer) {
   //省略逻辑
   ...
   
    try {
    //划重点了，这里没有贴代码，感兴趣自己调式execute方法 
      Response<T> response = call.execute();
      if (!disposable.isDisposed()) {
        observer.onNext(response);
      }
      if (!disposable.isDisposed()) {
        terminated = true;
        observer.onComplete();
      }
    } catch (Throwable t) {
    //划重点了，跟随优秀的开源框架一步步进去，你会发现它遵循了：
    //1.尽量捕获具体异常,不要捕获Throable或者Error //2.不生吞（swallow)异常
    //3.throw early
    //4.仅仅捕获必要代码块，try-catch会产生额外的性能开销
      Exceptions.throwIfFatal(t);
      if (terminated) {
        RxJavaPlugins.onError(t);
      } else if (!disposable.isDisposed()) {
        try {
          observer.onError(t);
        } catch (Throwable inner) {
          Exceptions.throwIfFatal(inner);
          RxJavaPlugins.onError(new CompositeException(t, inner));
        }
      }
    }
  }

//关键点 final 
public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    // The associated character storage is managed by the runtime. We only
    // keep track of the length here.
    //关键点final private
    // private final char value[];
    private final int count;

//AbstractStringBuilder 没有加final 也没private修饰
abstract class AbstractStringBuilder implements Appendable, CharSequence {
    char[] value;
    int count;
    private static final int MAX_ARRAY_SIZE = 2147483639;
    AbstractStringBuilder() {
    }

//StringBuilder截取部分源码
static final long serialVersionUID = 4383685877147921099L;
    public StringBuilder() {
        super(16);
    }
    public StringBuilder(int var1) {
        super(var1);
    }
    public StringBuilder(String var1) {
        super(var1.length() + 16);
        this.append(var1);
    }
    public StringBuilder(CharSequence var1) {
        this(var1.length() + 16);
        this.append(var1);
    }
    public StringBuilder append(Object var1) {
        return this.append(String.valueOf(var1));
    }
    public StringBuilder append(String var1) {
        super.append(var1);
        return this;
    }
    public StringBuilder append(StringBuffer var1) {
        super.append(var1);
        return this;
    }
    public StringBuilder append(CharSequence var1) {
        super.append(var1);
        return this;
    }
    public StringBuilder append(CharSequence var1, int var2, int var3) {
        super.append(var1, var2, var3);
        return this;
    }

//StringBuffer部分源码 多了synchronized
public StringBuffer(CharSequence seq) {
        this(seq.length() + 16);
        append(seq);
    }
    public synchronized int length() {
        return count;
    }
    public synchronized int capacity() {
        return value.length;
    }
    public synchronized void ensureCapacity(int minimumCapacity) {
        if (minimumCapacity > value.length) {
            expandCapacity(minimumCapacity);
        }
    }

public static final int DEVICE_NOT_AVAILABLE_ERROR_CODE = 390004;// 设备未启用或者被锁住

/**
     * 获取POST请求的base url
     *
     * @param requestHolder
     * @return
     * @throws AlipayApiException
     */
    private String getRequestUrl(RequestParametersHolder requestHolder) throws AlipayApiException {
        StringBuffer urlSb = new StringBuffer(serverUrl);
        try {
            String sysMustQuery = WebUtils.buildQuery(requestHolder.getProtocalMustParams(),
                    charset);
            String sysOptQuery = WebUtils.buildQuery(requestHolder.getProtocalOptParams(), charset);
            urlSb.append("?");
            urlSb.append(sysMustQuery);
            if (sysOptQuery != null & sysOptQuery.length() > 0) {
                urlSb.append("&");
                urlSb.append(sysOptQuery);
            }
        } catch (IOException e) {
            throw new AlipayApiException(e);
        }
        return urlSb.toString();
    }

/**
         * Extracts absolute path form a given URI. E.g., passing
         * <code>http://google.com:80/execute?query=cat#top</code>
         * will result in <code>/execute?query=cat#top</code>.
         *
         * @param uri URI which absolute path has to be extracted,
         * @return the absolute path of the URI,
         */
        private String getAbsolutePathFromAbsoluteURI(URI uri) {
            String rawPath = uri.getRawPath();
            String rawQuery = uri.getRawQuery();
            String rawFragment = uri.getRawFragment();
            StringBuilder absolutePath = new StringBuilder();
            if (rawPath != null) {
                absolutePath.append(rawPath);
            } else {
                absolutePath.append("/");
            }
            if (rawQuery != null) {
                absolutePath.append("?").append(rawQuery);
            }
            if (rawFragment != null) {
                absolutePath.append("#").append(rawFragment);
            }
            return absolutePath.toString();
        }

compileOptions {
    sourceCompatibility JavaVersion.VERSION_1_8
    targetCompatibility JavaVersion.VERSION_1_8
}

//try-catch异常退出、不被执行
try{
    system.exit(1)
}finally{
    println("会被执行吗？")
}

//try-catch无线循环，不被执行
try{
    while(true){
        println("do something")
    }finally{
        println("会被执行吗？")
    }
}

/**
 * 作者：huangchen on 2018/8/7 21:48
 * 邮箱：huangcftt@gmail.com
 */
//java实现
public class PayManager {
    private static PayManager payManager = new PayManager();
    public static PayManager getPayManager() {
        return payManager;
    }
    private PayManager(){
    }
}

/**
 * 作者：huangchen on 2018/8/7 21:55
 * 邮箱：huangcftt@gmail.com
 */
//Kotlin实现
object PayServiceManager

@Metadata(
   mv = {1, 1, 9},
   bv = {1, 0, 2},
   k = 1,
   d1 = {"\u0000\f\n\u0002\u0018\u0002\n\u0002\u0010\u0000\n\u0002\b\u0002\bÆ\u0002\u0018\u00002\u00020\u0001B\u0007\b\u0002¢\u0006\u0002\u0010\u0002¨\u0006\u0003"},
   d2 = {"Lcn/yonghui/shop/shopapplication/pay/config/PayServiceManager;", "", "()V", "production sources for module app"}
)
public final class PayServiceManager {
   public static final PayServiceManager INSTANCE;
   static {
      PayServiceManager var0 = new PayServiceManager();
      INSTANCE = var0;
   }
}

//java 代码
 private PayManager(){
   }
   private  volatile static PayManager payManager;
    public static  PayManager getPayManager() {
        if(payManager == null){
            synchronized (PayManager.class){
                if(payManager == null){
                    payManager = new PayManager()
                }
            }
        }
        return payManager;
    }

//kotlin实现
class PayServiceManager private constructor() {
    companion object {
        val instance: PayServiceManager by lazy {
            PayServiceManager()
        }
    }
}

//Java实现
private PayManager(){
   }
   private static class PayManagerHolder{
       private static PayManager payManager = new PayManager();
   }
   public static PayManager getPayManager(){
       return PayManagerHolder.payManager;
   }

//kotlin实现
class PayServiceManager private constructor() {
    companion object {
        val instance =PayServiceManagerHolder.payServiceManager
    }
    private object PayServiceManagerHolder {
        val payServiceManager = PayServiceManager()
    }
}

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), defaultHandler);
    }

/**
     * Creates a thread pool that creates new threads as needed, but
     * will reuse previously constructed threads when they are
     * available.  These pools will typically improve the performance
     * of programs that execute many short-lived asynchronous tasks.
     * Calls to {@code execute} will reuse previously constructed
     * threads if available. If no existing thread is available, a new
     * thread will be created and added to the pool. Threads that have
     * not been used for sixty seconds are terminated and removed from
     * the cache. Thus, a pool that remains idle for long enough will
     * not consume any resources. Note that pools with similar
     * properties but different details (for example, timeout parameters)
     * may be created using {@link ThreadPoolExecutor} constructors.
     *
     * @return the newly created thread pool
     */
    public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

/**
    * Creates a thread pool that reuses a fixed number of threads
    * operating off a shared unbounded queue.  At any point, at most
    * {@code nThreads} threads will be active processing tasks.
    * If additional tasks are submitted when all threads are active,
    * they will wait in the queue until a thread is available.
    * If any thread terminates due to a failure during execution
    * prior to shutdown, a new one will take its place if needed to
    * execute subsequent tasks.  The threads in the pool will exist
    * until it is explicitly {@link ExecutorService#shutdown shutdown}.
    *
    * @param nThreads the number of threads in the pool
    * @return the newly created thread pool
    * @throws IllegalArgumentException if {@code nThreads <= 0}
    */
   public static ExecutorService newFixedThreadPool(int nThreads) {
       return new ThreadPoolExecutor(nThreads, nThreads,
                                     0L, TimeUnit.MILLISECONDS,
                                     new LinkedBlockingQueue<Runnable>());
   }

/**
     * Creates an Executor that uses a single worker thread operating
     * off an unbounded queue. (Note however that if this single
     * thread terminates due to a failure during execution prior to
     * shutdown, a new one will take its place if needed to execute
     * subsequent tasks.)  Tasks are guaranteed to execute
     * sequentially, and no more than one task will be active at any
     * given time. Unlike the otherwise equivalent
     * {@code newFixedThreadPool(1)} the returned executor is
     * guaranteed not to be reconfigurable to use additional threads.
     *
     * @return the newly created single-threaded Executor
     */
    public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

/**
     * Creates a thread pool that can schedule commands to run after a
     * given delay, or to execute periodically.
     * @param corePoolSize the number of threads to keep in the pool,
     * even if they are idle
     * @return a newly created scheduled thread pool
     * @throws IllegalArgumentException if {@code corePoolSize < 0}
     */
    public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }

/**
     * Creates a thread pool that maintains enough threads to support
     * the given parallelism level, and may use multiple queues to
     * reduce contention. The parallelism level corresponds to the
     * maximum number of threads actively engaged in, or available to
     * engage in, task processing. The actual number of threads may
     * grow and shrink dynamically. A work-stealing pool makes no
     * guarantees about the order in which submitted tasks are
     * executed.
     *
     * @param parallelism the targeted parallelism level
     * @return the newly created thread pool
     * @throws IllegalArgumentException if {@code parallelism <= 0}
     * @since 1.8
     */
    public static ExecutorService newWorkStealingPool(int parallelism) {
        return new ForkJoinPool
            (parallelism,
             ForkJoinPool.defaultForkJoinWorkerThreadFactory,
             null, true);
    }

String a="test";
String b="test";
System.out.println(a==b);
System.out.println(System.idntityHashCode(a));
System.out.println(System.identityHashCode(b));
输出：true
851664923
851664923
    
//为什么有觉得可变呢？    
String a="test";
a="test1"

package yonghui.cn.firstthread.flyweight;
/**
 * 作者：huangchen on 2018/7/26 20:57
 * 邮箱：huangchen@yonghui.cn
 */
public interface IBike {
    void biliing(int  time);
}

package yonghui.cn.firstthread.flyweight;
/**
 * 作者：huangchen on 2018/7/26 20:58
 * 邮箱：huangchen@yonghui.cn
 */
public class ShareBike implements IBike {
    private int price;//单价
    private int total;//总价
    @Override
    public void biliing(int time) {
        System.out.println("total price is" + price * time);
    }
}

package yonghui.cn.firstthread.flyweight;
import java.util.HashMap;
/**
 * 作者：huangchen on 2018/7/26 20:11
 * 邮箱：huangchen@yonghui.cn
 */
public class FlyWeightFactory {
    private HashMap<String, IBike> map = new HashMap<>();
    public IBike getIBike(String name) {
        IBike iBike;
        if (map.containsKey(name)) {
            System.out.println("押金已经交过了" + name);
            iBike = map.get(name);
            return iBike;
        } else {
            System.out.println("押金没有交，开始交押金299元");
            iBike = new ShareBike();
            map.put(name, iBike);
            return iBike;
        }
    }
}

package yonghui.cn.firstthread.flyweight;
/**
 * 作者：huangchen on 2018/7/26 20:16
 * 邮箱：huangchen@yonghui.cn
 */
public class Client {
    public void test(){
        FlyWeightFactory flyWeightFactory = new FlyWeightFactory();
        IBike ofo = flyWeightFactory.getIBike("ofo");
        ofo.biliing(2);
        IBike mobike = flyWeightFactory.getIBike("mobike");
        mobike.biliing(1);
        IBike ofo1 = flyWeightFactory.getIBike("ofo");
        ofo1.biliing(3);
    }
}

//Integer部分源码
//Immutable private final
/**
     * The value of the {@code Integer}.
     *
     * @serial
     */
    private final int value;
 /**
     * Returns an {@code Integer} instance representing the specified
     * {@code int} value.  If a new {@code Integer} instance is not
     * required, this method should generally be used in preference to
     * the constructor {@link #Integer(int)}, as this method is likely
     * to yield significantly better space and time performance by
     * caching frequently requested values.
     *
     * This method will always cache values in the range -128 to 127,
     * inclusive, and may cache other values outside of this range.
     *
     * @param  i an {@code int} value.
     * @return an {@code Integer} instance representing {@code i}.
     * @since  1.5
     */
    public static Integer valueOf(int i) {
        assert IntegerCache.high >= 127;
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }