前言

数据类是一种非常强大的类，它可以让你避免创建Java中的用于保存状态但又操作
非常简单的POJO的模版代码。它们通常只提供了用于访问它们属性的简单的getter
和setter。定义一个新的数据类非常简单：

data class Forecast(val date: Date, val temperature: Float, valdetails: String)

额外的函数

通过数据类，我们可以方便地得到很多有趣的函数，一部分是来自属性，我们之前
已经讲过（从编写getter和setter函数）：

• equals(): 它可以比较两个对象的属性来确保他们是相同的。
• hashCode(): 我们可以得到一个hash值，也是从属性中计算出来的。
• copy(): 你可以拷贝一个对象，可以根据你的需要去修改里面的属性。我们会在
  稍后的例子中看到。
• 一系列可以映射对象到变量中的函数。我也很快就会讲到这个。

复制一个数据类

如果我们使用不可修改的对象，就像我们之前讲过的，假如我们需要修改这个对象
状态，必须要创建一个新的一个或者多个属性被修改的实例。这个任务是非常重复
且不简洁的。

举个例子，如果我们需要修改 Forecast 中的 temperature （温度），我们可以
这么做：

val f1 = Forecast(Date(), 27.5f, "Shiny day")
val f2 = f1.copy(temperature = 30f)

如上，我们拷贝了第一个forecast对象然后只修改了 temperature 的属性而没有
修改这个对象的其它状态。

当你使用Java类时小心“不可修改性”

如果你决定使用不可修改来工作，你需要意识到Java不是根据这种思想来
设计的，在某些情况下，我们仍然可以修改这些状态。在上一个例子中，
你还是可以访问 Date 对象，然后改变它的值。有个简单（不安全）的方
法是记住所有需要修改状态的对象作为一个规则，然后必要的时候去拷贝
一份。
另外一个方法是封装这些类。你可以创建一个 ImmutableDate 类，它封
装了 Date 并且不允许去修改它们的状态。决定哪种方式取决于你。本书
中，我不会对不可修改性太限制，所以我不会去为一些危险的类去创建一
个封装类。

映射对象到变量中

映射对象的每一个属性到一个变量中，这个过程就是我们知道的多声明。这就是为
什么会有 componentX 函数被自动创建。使用上面的 Forecast 类举个例子：

val f1 = Forecast(Date(), 27.5f, "Shiny day")
val (date, temperature, details) = f1

上面这个多声明会被编译成下面的代码：

val date = f1.component1()
val temperature = f1.component2()
val details = f1.component3()

这个特性背后的逻辑是非常强大的，它可以在很多情况下帮助我们简化代码。举个
例子， Map 类含有一些扩展函数的实现，允许它在迭代时使用key和value：

for ((key, value) in map) {
    Log.d("map", "key:$key, value:$value")
}

转换json到数据类

我们现在知道怎么去创建一个数据类，那我们开始准备去解析数据。在 date 包
中，创建一个名为 ResponseClasses.kt 新的文件，如果你打开第8章中的url，你
可以看到json文件整个结构。它的基本组成包括一个城市，一个系列的天气预报，
这个城市有id，名字，所在的坐标。每一个天气预报有很多信息，比如日期，不同
的温度，和一个由描述和图标的id。

在我们当前的UI中，我们不会去使用所有的这些数据。我们会解析所有到类里面，
因为可能会在以后某些情况下会用到。以下就是我们需要使用到的类：

data class ForecastResult(val city: City, val list: List<Forecast>)

data class City(val id: Long, val name: String, val coord: Coordinates,val country: String, val population: Int)

data class Coordinates(val lon: Float, val lat: Float)

data class Forecast(val dt: Long, val temp: Temperature, val pressure: Float,val humidity: Int, val weather: List<Weather>,val speed: Float, valdeg: Int, val clouds:Int,val rain: Float)

data class Temperature(val day: Float, val min: Float, val max:Float,valnight: Float, val eve: Float, val morn: Float)

data class Weather(val id: Long, val main: String, val description:String,val icon: String)

当我们使用Gson来解析json到我们的类中，这些属性的名字必须要与json中的名字
一样，或者可以指定一个 serialised name （序列化名称）。一个好的实践是，
大部分的软件结构中会根据我们app中布局来解耦成不同的模型。所以我喜欢使用声明简化这些类，因为我会在app其它部分使用它之前解析这些类。属性名称与
json结果中的名字是完全一样的。

现在，为了返回被解析后的结果，我们的 Request 类需要进行一些修改。它将仍
然只接收一个城市的 zipcode 作为参数而不是一个完整的url，因此这样变得更加
具有可读性。现在，我会把这个静态的url放在一个 companion object （伴随对
象）中。如果我们之后还要对该API增加更多请求，我们需要提取它。

Companion objects

Kotlin允许我们去定义一些行为与静态对象一样的对象。尽管这些对象可以
用众所周知的模式来实现，比如容易实现的单例模式。
我们需要一个类里面有一些静态的属性、常量或者函数，我们可以使
用 companion object 。这个对象被这个类的所有对象所共享，就像
Java中的静态属性或者方法。

以下是最后的代码：

public class ForecastRequest(val zipCode: String) {
    companion object {
        private val APP_ID = "15646a06818f61f7b8d7823ca833e1ce"
        private val URL = "http://api.openweathermap.org/data/2.5/" +"forecast/daily?mode=json&units=metric&cnt=7"
        private val COMPLETE_URL = "$URL&APPID=$APP_ID&q="
}

    fun execute(): ForecastResult {
        val forecastJsonStr = URL(COMPLETE_URL + zipCode).readText()
        return Gson().fromJson(forecastJsonStr, ForecastResult::class.java)
    }
}

记得在 build.gradle 中增加你需要的Gson依赖：

compile "com.google.code.gson:gson:2.8.2" 

构建domain层

我们现在创建一个新的包作为 domain 层。这一层中会包含一些 Commands 的实
现来为app执行任务。

首先，必须要定义一个 Command ：

public interface Command<T> {
    fun execute(): T
}

这个command会执行一个操作并且返回某种类型的对象，这个类型可以通过范型被
指定。你需要知道一个有趣的概念，一切kotlin函数都会返回一个值。如果没有指
定，它就默认返回一个 Unit 类。所以如果我们想让Command不返回数据，我们
可以指定它的类型为Unit。

Kotlin中的接口比Java（Java 8以前）中的强大多了，因为它们可以包含代码。但
是我们现在不需要更多的代码，以后的章节中会仔细讲这个话题。

第一个command需要去请求天气预报结构然后转换结果为domain类。下面这些类
会在domain类中被定义：

data class ForecastList(val city: String, val country: String,val dailyForecast:List<Forecast>)

data class Forecast(val date: String, val description: String, val high: Int,val low: Int)

当更多的功能被增加，这些类可能会需要在以后被审查。但是现在这些类对我们来
说已经足够了。

这些类必须从数据映射到我们的domain类，所以我接下来需要创建一
个 DataMapper ：

public class ForecastDataMapper {
    fun convertFromDataModel(forecast: ForecastResult): ForecastList {
        return ForecastList(forecast.city.name, forecast.city.country,convertForecastListToDomain(forecast.list))
    }
    
    private fun convertForecastListToDomain(list: List<Forecast>):List<ModelForecast> {
        return list.map { convertForecastItemToDomain(it) 
    }


    private fun convertForecastItemToDomain(forecast: Forecast):ModelForecast {
        return ModelForecast(convertDate(forecast.dt),forecast.weather[0].description, forecast.temp.max.toInt(),forecast.temp.min.toInt())
    }

    private fun convertDate(date: Long): String {
        val df = DateFormat.getDateInstance(DateFormat.MEDIUM, Locale.getDefault())
        return df.format(date * 1000)
    }
}

当我们使用了两个相同名字的类，我们可以给其中一个指定一个别名，这样我们就
不需要写完整的包名了：

import com.antonioleiva.weatherapp.domain.model.Forecast as ModelForecast

这些代码中另一个有趣的是我们从一个forecast list中转换为domain model的方法：

return list.map { convertForecastItemToDomain(it) }

这一条语句，我们就可以循环这个集合并且返回一个转换后的新的List。Kotlin在
List中提供了很多不错的函数操作符，它们可以在这个List的每个item中应用这个操
作并且任何方式转换它们。对比Java 7，这是Kotlin其中一个强大的功能。我们很
快就会查看所有不同的操作符。知道它们的存在是很重要的，因为它们要方便得
多，并可以节省很多时间和模版。

现在，编写命令前的准备就绪：

class RequestForecastCommand(val zipCode: String) :Command<ForecastList> {
    override fun execute(): ForecastList {
        val forecastRequest = ForecastRequest(zipCode)
        return ForecastDataMapper().convertFromDataModel(forecastRequest.execute())
    }
}

在UI中绘制数据

MainActivity 中的代码有些小的改动，因为现在有真实的数据需要填充到
adapter中。异步调用需要被重写成：

async() {
    val result = RequestForecastCommand("94043").execute()
    uiThread{
        forecastList.adapter = ForecastListAdapter(result)
    }
}

Adapter也需要被修改：

class ForecastListAdapter(val weekForecast: ForecastList) :RecyclerView.Adapter<ForecastListAdapter.ViewHolder>() {
    override fun onCreateViewHolder(parent: ViewGroup, viewType:Int):ViewHolder? {
        return ViewHolder(TextView(parent.getContext()))
    }
    
    override fun onBindViewHolder(holder: ViewHolder,position: Int) {
        with(weekForecast.dailyForecast[position]) {
            holder.textView.text = "$date - $description - $high/$low"
        }
    }
    
    override fun getItemCount(): Int = weekForecast.dailyForecast.size
    
    class ViewHolder(val textView: TextView) : RecyclerView.ViewHolder(textView)
}

with函数

with是一个非常有用的函数，它包含在Kotlin的标准库中。它接收一个对象
和一个扩展函数作为它的参数，然后使这个对象扩展这个函数。这表示所
有我们在括号中编写的代码都是作为对象（第一个参数）的一个扩展函
数，我们可以就像作为this一样使用所有它的public方法和属性。当我们针
对同一个对象做很多操作的时候这个非常有利于简化代码。