<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context="me.loshine.guidedemo.MainActivity">

    <android.support.v4.view.ViewPager
        android:id="@+id/view_pager"
        android:layout_width="match_parent"
        android:layout_height="match_parent"/>

</RelativeLayout>

处理滑动背景色

MainActivity.xml

public class MainActivity extends AppCompatActivity implements ViewPager.OnPageChangeListener {

    ViewPager mViewPager;

    private int[] colors;
    private int state = ViewPager.SCROLL_STATE_IDLE; // 初始位于停止滑动状态

    private ArgbEvaluator mArgbEvaluator;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        initColors();
        initViewPager();
    }

    /**
     * 初始化 ViewPager
     */
    private void initViewPager() {
        mViewPager = (ViewPager) findViewById(R.id.view_pager);
        if (mViewPager != null) {
            // 初始颜色
            mViewPager.setBackgroundColor(colors[0]);
            mViewPager.setAdapter(new FragmentStatePagerAdapter(getSupportFragmentManager()) {
                @Override
                public Fragment getItem(int position) {
                    return GuideBaseFragment.newInstance(position);
                }

                @Override
                public int getCount() {
                    return 4;
                }
            });

            mViewPager.addOnPageChangeListener(this);
        }
    }

    /**
     * 初始化颜色
     */
    private void initColors() {
        colors = new int[4];
        colors[0] = getResources().getColor(R.color.guideBackgroundColor1);
        colors[1] = getResources().getColor(R.color.guideBackgroundColor2);
        colors[2] = getResources().getColor(R.color.guideBackgroundColor3);
        colors[3] = getResources().getColor(R.color.guideBackgroundColor4);

        mArgbEvaluator = new ArgbEvaluator();
    }

    @Override
    public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) {
        // 只要不是滑动停止状态就计算颜色
        if (state != ViewPager.SCROLL_STATE_IDLE) {
            if (positionOffset > 0 && position < 4) {
                int evaluatePreColor = (int) mArgbEvaluator
                        .evaluate(positionOffset, colors[position], colors[position + 1]);
                mViewPager.setBackgroundColor(evaluatePreColor);
            } else if (positionOffset < 0 && position > 0) {
                int evaluateNextColor = (int) mArgbEvaluator
                        .evaluate(-positionOffset, colors[position], colors[position - 1]);
                mViewPager.setBackgroundColor(evaluateNextColor);
            }
        }
    }

    @Override
    public void onPageSelected(int position) {
    }

    @Override
    public void onPageScrollStateChanged(int state) {
        this.state = state;
    }
}

总结

其实实现方式并不复杂，监听 ViewPager 的滚动然后计算中间值即可，重要的是又学习到酷炫的新东西了。

2016-03-30发表技术8 分钟读完 (大约1237个字)

在Android开发中使用Lambda表达式

由于三体人对我们的科技封锁，我们无法在 Android 开发中启用 Java 1.8 的重要特性——Lambda 表达式。但现在我们可以通过一些工具启用它，然后使用 Lambda 表达式替换没有什么实际意义的单方法匿名内部类。

Lambda表达式

可能有些人还不太清楚到底什么是 Lambda 表达式，这里先对 Lambda 表达式进行一个简单的介绍。

Lambda 表达式是函数式编程语言的特性，它简单的说就是一个匿名函数。

我们先看一个 Groovy 的例子：

1	[1, 2, 3, 4, 5].asList().forEach { x -> println x }

在这个例子中，我们使用foreach来遍历一个List并打印每一个值。我们传入了一个 Lambda 表达式：{ x -> println x }，这个表达式就是我们对每一个值进行的操作，在本例中就是打印它们。

在这里 Lambda 表达式是一个映射函数，foreach接受了它作为参数，然后对List中的每一个值进行遍历。

在函数式编程语言中，函数是一等公民（first class）。它们也可以作为变量或者参数被传递而且它们也是一个类。

但在 Java 中函数并不是一等公民，如果我们需要传递一个方法，必须要有一个对象包含这个方法，然后把这个对象传递过去。

所以我们经常会见到类似这样的代码：

textView.setOnClickListener(new View.OnClickListener() {
	@Override
	public void onClick(View view) {
		// do what you want...
	}
});

但是实际上，我们需要的只是onClick这个方法里面的内容，其它的部分（new OnClickListener）实在是没有什么实际的意义，只是一个必须的语法而已。

所以 Java 1.8 也引入了部分函数式编程的特性——Lambda 表达式。

如果使用 Lambda 表达式，上面那个例子可以被简化为这样

1
2
3

textView.setOnClickListener(v -> {
	// do what you want...
});

如果只有一行代码我们还可以省略大括号

1	textView.setOnClickListener(v -> doSomething());

当啷啷~ 是不是省略了很多代码，有没有很爽的感觉。

有了 Lambda 表达式，从此我们的代码可以清爽简洁，而且看起来也很好理解：箭头的左边是形参，右边是函数体，整个 Lambda 表达式就是一个函数（就是数学中的函数）。

更多 Lambda 表达式的信息可以查看《Java 8新特性：lambda表达式》——廖雪峰。

如何使用

安利了这么多 Lambda 表达式的优点，但由于众所周知的某些原因，Android 中的 Java 版本被限定在了 1.6 以下，所以也就没办法使用那么好的 Lambda 表达式了。

但 Lambda 表达式这么好，你不让我用我就不用了么？我偏要用！

好的，有以下两种方式都可以为我们开启 Lambda 表达式，我们只需要任选其一就可以了。

RetroLambda

RetroLambda 的 Gradle 插件让我们可以在 Android 中使用 Lambda 表达式，那么我们看看如何使用它吧。

Project

我们需要在项目目录下的build.gradle中加入它的classpath

buildscript {
    repositories {
        jcenter()
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:2.1.0-alpha4'
     classpath 'me.tatarka:gradle-retrolambda:3.2.5'

        // NOTE: Do not place your application dependencies here; they belong
        // in the individual module build.gradle files
    }
}

在dependencies中加入classpath 'me.tatarka:gradle-retrolambda:3.2.5'

app module

编辑build.gradle启用插件，并把 Java 语法调整到 1.8

在顶部启用插件
1
apply plugin: 'me.tatarka.retrolambda'

在android中加入以下代码段启用 1.8 的语法

compileOptions {
    sourceCompatibility JavaVersion.VERSION_1_8
    targetCompatibility JavaVersion.VERSION_1_8
}

Enjoy it !~

jack

jack 是 Java Android Compile Kit 的缩写，它是 Google 为 Android 推出的一个编译工具包，它的原理在这里就不详述了。它有一个特点就是可以使用 Lambda 表达式，而且配置十分简单。

准备

使用 jack 我们必须要把buildTools升级到24以上，我已经升级到了24 RC。

使用

编辑 app 模块中的build.gradle，在defaultConfig中加一行 useJack true，然后在android中添加如下一段代码

compileOptions {
    sourceCompatibility JavaVersion.VERSION_1_8
    targetCompatibility JavaVersion.VERSION_1_8
}

然后就好了，是不是非常简单呢~

总结

在 Java 1.8 中的 Lambda 表达式实际上只是一个语法糖，它可以帮助我们简化代码，并且表述地更佳清晰。但 Java 目前来说并不是一门有函数式特性的编程语言，而且短期内不会加入函数式特性。如果你想使用一门拥有函数式特性的语言来写 Android Application 的话，可以考虑一下 Kotlin。

2015-08-25发表技术10 分钟读完 (大约1497个字)

Java中的模板方法模式

准备一个抽象类，将部分逻辑以具体方法以及具体构造子的形式实现，然后声明一些抽象方法来迫使子类实现剩余逻辑。不同的子类可以以不同的方式实现这些抽象方法，从而对剩余的逻辑有不同的实现。模版方法模式是基于继承的代码复用的基本技术。

结构

模板方法模式需要开发抽象类和具体子类的设计师之间的协作。一个设计师负责给出一个算法的轮廓和骨架，另一些设计师则负责给出这个算法的各个逻辑步骤。代表这些具体逻辑步骤的方法称做基本方法(primitive method)；而将这些基本方法汇总起来的方法叫做模板方法(template method)，这个设计模式的名字就是从此而来。

模板方法所代表的行为称为顶级行为，其逻辑称为顶级逻辑。模板方法模式的静态结构图如下所示：

template

这里涉及到两个角色：

抽象模板(Abstract Template)角色：

定义了一个或多个抽象操作，以便让子类实现。这些抽象操作叫做基本操作，它们是一个顶级逻辑的组成步骤。
定义并实现了一个模板方法。这个模板方法一般是一个具体方法，它给出了一个顶级逻辑的骨架，而逻辑的组成步骤在相应的抽象操作中，推迟到子类实现。顶级逻辑也有可能调用一些具体方法。

具体模板(Concrete Template)角色：

实现父类所定义的一个或多个抽象方法，它们是一个顶级逻辑的组成步骤。
每一个抽象模板角色都可以有任意多个具体模板角色与之对应，而每一个具体模板角色都可以给出这些抽象方法（也就是顶级逻辑的组成步骤）的不同实现，从而使得顶级逻辑的实现各不相同。

示例代码

抽象模板角色类，abstractMethod()、doHookMethod()等基本方法是顶级逻辑的组成步骤，这个顶级逻辑由templateMethod()方法代表。

public abstract class AbstractTemplate {
    
    /**
     * 模板方法
     */
    public void templateMethod(){
        // 调用基本方法
        abstractMethod();
        doHookMethod();
        concreteMethod();
    }
    
    /**
     * 抽象方法，子类必须实现的方法
     */
    protected abstract void abstractMethod();
    
    /**
     * 钩子方法，子类可选择是否实现。注意钩子方法一般以 do 开头
     */
    protected void doHookMethod(){}
    
    /**
     * 具体方法，由父类实现，子类无法 override
     */
    private final void concreteMethod(){
        // 业务相关的代码
    }
}

具体模板角色类，实现了父类所声明的基本方法，abstractMethod()方法所代表的就是强制子类实现的剩余逻辑，而doHookMethod()方法是可选择实现的逻辑，不是必须实现的。

public class ConcreteTemplate extends AbstractTemplate {
    
    // 基本方法的实现
    @Override
    public void abstractMethod() {
        // 业务相关的代码
    }
    
    // 重写父类的方法
    @Override
    public void hookMethod() {
        // 业务相关的代码
    }
}

模板方法模式的关键：子类可以置换掉父类的可变部分，但是子类却不可以改变模板方法所代表的顶级逻辑。

每当定义一个新的子类时，不要按照控制流程的思路去想，而应当按照责任的思路去想。换言之，应当考虑哪些操作是必须置换掉的，哪些操作是可以置换掉的，以及哪些操作是不可以置换掉的。使用模板模式可以使这些责任变得清晰。

在Servlet中的应用

使用过Servlet的人都清楚，除了要在web.xml做相应的配置外，还需继承一个叫HttpServlet的抽象类。HttpService类提供了一个service()方法，这个方法调用七个do方法中的一个或几个，完成对客户端调用的响应。这些do方法需要由HttpServlet的具体子类提供，因此这是典型的模板方法模式。下面是service()方法的源代码：

protected void service(HttpServletRequest req, HttpServletResponse resp)
    throws ServletException, IOException {
 
    String method = req.getMethod();
 
    if (method.equals(METHOD_GET)) {
        long lastModified = getLastModified(req);
        if (lastModified == -1) {
            // servlet doesn't support if-modified-since, no reason
            // to go through further expensive logic
            doGet(req, resp);
        } else {
            long ifModifiedSince = req.getDateHeader(HEADER_IFMODSINCE);
            if (ifModifiedSince < (lastModified / 1000 * 1000)) {
                // If the servlet mod time is later, call doGet()
                // Round down to the nearest second for a proper compare
                // A ifModifiedSince of -1 will always be less
                maybeSetLastModified(resp, lastModified);
                doGet(req, resp);
            } else {
                resp.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
            }
        }
 
    } else if (method.equals(METHOD_HEAD)) {
        long lastModified = getLastModified(req);
        maybeSetLastModified(resp, lastModified);
        doHead(req, resp);
 
    } else if (method.equals(METHOD_POST)) {
        doPost(req, resp);
 
    } else if (method.equals(METHOD_PUT)) {
        doPut(req, resp);       
 
    } else if (method.equals(METHOD_DELETE)) {
        doDelete(req, resp);
 
    } else if (method.equals(METHOD_OPTIONS)) {
        doOptions(req,resp);
 
    } else if (method.equals(METHOD_TRACE)) {
        doTrace(req,resp);
 
    } else {
        //
        // Note that this means NO servlet supports whatever
        // method was requested, anywhere on this server.
        //
 
        String errMsg = lStrings.getString("http.method_not_implemented");
        Object[] errArgs = new Object[1];
        errArgs[0] = method;
        errMsg = MessageFormat.format(errMsg, errArgs);
 
        resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED, errMsg);
    }
}

当然，这个service()方法也可以被子类置换掉。

下面给出一个简单的 Servlet 例子：

TestServlet 类是 HttpServlet 类的子类，并且置换掉了父类的两个方法：doGet()和doPost()：

public class TestServlet extends HttpServlet {
 
    public void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
 
        System.out.println("using the GET method");
 
    }
 
    public void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
 
        System.out.println("using the POST method");
    }
 
}

从上面的例子可以看出这是一个典型的模板方法模式。

HttpServlet 担任抽象模板角色

模板方法：由service()方法担任。
基本方法：由doPost()、doGet()等方法担任。

TestServlet 担任具体模板角色

TestServlet 置换掉了父类 HttpServlet 中七个基本方法中的其中两个，分别是doGet()和doPost()。

2015-08-18发表技术3 分钟读完 (大约509个字)

Java中的单例设计模式

单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例。

特点

单例模式有以下特点：

单例类只能有一个实例
单例类必须自己创建自己的唯一实例
单例类必须给所有其他对象提供这一实例

实现

饿汉式

饿汉式在类创建的同时就已经创建好一个静态的对象供系统使用，以后不再改变，所以天生是线程安全的。

public class Singleton {

    // 饿汉式，开始就建立一个对象
    private static final Singleton single = new Singleton();
    
    // 将构造函数私有，禁止在其它类中创建对象
    private Singleton() {}
    
    public static Singleton getInstance() {
        return single;
    }
}

懒汉式

懒汉式则是在调用获取实例对象的方法时检查，若没有对象则创建对象，如果单例对象已经存在则不创建对象直接返回已存在的对象。

public class Singleton {
    // 懒汉式，刚开始不创建对象
    private static Singleton single=null;

    // 将构造函数私有，禁止在其它类中创建对象
    private Singleton() {}
    
    // 静态工厂方法
    public static Singleton getInstance() {
         if (single == null) {
             single = new Singleton();
         }
        return single;  
    }
}

这种懒汉式实现是非线程安全的，并发环境下很可能出现多个Singleton实例。若要保证线程安全，我们可以使用如下几种方式

同步getInstance()方法

public static synchronized Singleton getInstance() {
    if (single == null) {
        single = new Singleton();
    }    
    return single;
}

代码块加锁和双重检查

public static Singleton getInstance() {
    if (singleton == null) {
        synchronized (Singleton.class) {
            if (singleton == null) {
            singleton = new Singleton();
            }
        }
    }
    return singleton;
}

静态内部类

public class Singleton {
    
    // 用于封装单例实例的内部类
    private static class LazyHolder {
        private static final Singleton INSTANCE = new Singleton();
    }
    
    // 私有构造
    private Singleton() {}
    
    // 获取单例实例的方法
    public static final Singleton getInstance() {
        return LazyHolder.INSTANCE;
    }    
}

其中第三种实现方式最好，避免了加锁的效率问题。但实际开发中饿汉式使用较多。

使用什么实现

关键 API

具体实现

布局