使用Kotlin高效开发Android应用：Android Studio 3实战指南

需积分: 10 126 浏览量更新于2024-07-17 收藏 11.42MB PDF 举报

"Learn Android Studio 3 with Kotlin.pdf" 这本书《Learn Android Studio 3 with Kotlin: Efficient Android App Development》由Ted Hagos撰写，是2018年出版的Android开发指南，专注于使用Kotlin语言在Android Studio 3环境下构建高效的应用程序。这本书提供了清晰的文字版，带有详细的目录，方便读者查阅和学习。在Android开发领域，Kotlin是一种现代、类型安全的编程语言，它已经被Google官方指定为Android开发的首选语言。这本书旨在帮助开发者充分利用Kotlin和Android Studio 3的功能，提高开发效率，减少代码出错的可能性。在内容上，我们可以期待涵盖以下几个关键知识点： 1. **Kotlin基础知识**：书中会介绍Kotlin的基本语法，包括变量声明、函数、类、接口、扩展、高阶函数等，这些都是编写Kotlin代码的基础。 2. **Android Studio 3特性**：介绍Android Studio 3的新功能，如Gradle插件升级、Instant Run、布局编辑器、代码提示和自动完成等，这些工具能提升开发者的生产力。 3. **Android架构组件**：可能包含Android架构组件的使用，如ViewModel、LiveData、Repository和Data Binding，这些组件有助于构建更健壮、可测试的应用。 4. **Android Kotlin协程**：Kotlin引入了协程来解决Android应用中的异步处理问题，使得后台任务管理更为简单，避免主线程阻塞。 5. **Jetpack库**：讲解如何使用Android Jetpack组件，如Room数据库、Navigation、Paging库等，这些库可以帮助开发者更高效地实现特定功能。 6. **测试与调试**：介绍单元测试、集成测试以及Android Studio提供的调试工具，帮助开发者确保代码质量。 7. **发布与性能优化**：指导如何打包和发布应用，以及如何进行性能分析和优化，如内存管理、APK瘦身和UI流畅度提升。 8. **Material Design**：可能会讨论如何遵循Material Design指南创建用户友好的界面，以及使用Material Components库。 9. **Android最佳实践**：分享Android开发的最佳实践，如代码组织、依赖注入、模块化等，帮助开发者写出更高质量的代码。通过这本书，无论是初学者还是有经验的开发者，都能深入理解Kotlin在Android开发中的应用，并掌握构建高效、稳定应用的技巧。书中实例丰富，理论与实践相结合，将帮助读者快速提升Android应用开发能力。

xix

Introduction

Welcome to the Kotlin edition of Learn Android Studio 3, This book will help you get

started in your programming journey with the little green robot. You already bought

the book, so you don’t need to be convinced that programming for the mobile platform

offers a lot of opportunity for software developers. Thank you for buying it, by the way.

Who This Book Is For

The book is aimed at beginning Android programmers, but it isn’t for people who are

completely new to programming. Ideally, you already are a Java programmer trying to

get your feet wet in Android, and you wanna try the Kotlin language (coz all your dev

friends told you it was cool). But in case you’re not a Java developer or you don’t have

Android programming experience, don’t sweat it. The book is friendly enough—I tried

hard to write it that way—and approachable enough such that anyone with a passing

knowledge of either C#, JavaScript, C, or C++ will be able to follow the code samples and

the concepts presented in this book.

What’s Different intheKotlin Edition

All the code examples and the demo projects are mostly new. They’re not a plain Kotlin

port of the first edition’s examples. I’ve also added new chapters; here they are:

• Collections

• Generics

• Higher Order Functions

• Broadcast Receivers

Some chapters in the first edition have been split into two or more chapters. I

split them so that I can treat the subjects with more depth—for example, “Intents,”

“SharedPreferences,” “Internal Storage,” and “Fragments.”

Organization andTreatment

The book is divided into two major parts. Chapters 1 to 7 are all about the Kotlin

language, and Chapters 8 to 20 are about Android programming.

While you can use it as a reference book, I didn’t write it that way. It’s not meant as

a substitute for the docs in https://kotlinglang.org or the Android developer guides

https://developer.android.com. It’s also not meant to be a “Definitive Guide” type of

book where you can spend hours or days exploring every nook and cranny. Quite the

contrary—I wanted it to be a “get started quick” type of book, like a recipe book, but

without losing our grasp on the fundamental concepts.

Android and Kotlin are big subjects; I don’t think there exists a “single best way” to

present the materials for either of these two. So, I made certain bets on the instructional

design. Here they are:

• Bite-sized concepts. The troublesome topics are broken down into

a series of small steps so that you can solve them in isolation. When

you can solve small problems, it gives you confidence to solve bigger

ones. This approach helps a beginning programmer to grow in the

direction of skill.

• Conciseness. I tried to keep each chapter as short as possible, so you

can nish it in one sitting. Originally, I wanted each chapter to be a

“20-minute read”; that was too ambitious, so, I gave up on it—but

still, the chapters are short.

• Multiple Learning Curves. e book is about three topics: Android

Studio, Android Programming, and Kotlin. Although Kotlin and

Android programming may seem to have dedicated chapters for

them, techniques on how to use Android Studio (and IntelliJ) are

scattered throughout the book.

• Balance between concept and code. Admittedly, the treatment is

biased (just a little bit) toward code. Programming is not a spectator

sport; we learn by doing. Nonetheless, in every chapter, I tried to

explain what the fundamental concepts are, what we’re trying to

do, what problems are we trying to solve, how we might solve those

problems, and what does the solution look like—in code. Almost all

of the chapters have one or more demo projects in them.

inTRoduCTion

xxi

• Verbose and complete code presentations. Sometimes (most of

the time actually), I presented the full source example, but only

one or two lines of it are relevant. I erred on the side of caution

(and verbosity) because it’s easier for a beginner to understand the

relevant codes if he can see it in relation to the whole program. So,

you don’t have to worry about, “Where do I put this code? Does this

go inside function main or inside a class?”

• Immediacy and coherence. Like I said, I wanted this to be a “get

started quick” or a “recipe” kind of book. So, instead of covering

everything, including the kitchen sink, I chose to cover some topics

and ignore others. I chose use-cases whose complexities are easy or

moderate and covered topics that are only relevant for those use-

cases. For example, in the BroadcastReceiver and Intent chapters,

I didn’t cover LocalBroadcastManager and PendingIntent. Cool as

these topics are, they weren’t relevant for the use-cases I chose. If I

added more use-cases or demo-projects, that would have stretched

the length of the chapter. It’s a balancing act, you see.

• Independent demo projects. I designed them as such so that the

demo project could be started (and followed) from scratch. There is

no “putting it all together” project in the end. This way, the book can

be conveniently used as a reference. If you pick a topic, it’s almost

self-contained, including the demo project.

In the end, I can only hope that the bets I made will pay off and that you will walk

away as a slightly better programmer after reading the book.

Chapter Overviews

Chapter 1: “Getting into Kotlin” introduces the language. It tells you how to setup Kotlin

in various ways on the three major platforms: macOS, Linux, and Windows. It also

contains instructions on how to create, configure, and run a project in IntelliJ—this is the

IDE I used to create all the Kotlin code samples for Chapters 1 through 7.

Chapter 2: “Kotlin Basics” dives into the language fundamentals of Kotlin. You’ll

learn the basic building blocks of a Kotlin program (e.g., Strings, control structures,

inTRoduCTion

xxii

exception handling, basic data types). You’ll also see some of Kotlin’s features that are

very different from Java, like its treatment of nullable and non-nullable types.

Chapter 3: “Functions.” There’s a whole chapter dedicated to functions because

Kotlin’s functions have something new up their sleeves. It has all the trimmings of a

modern language like default and named parameters, infix functions, and operators;

and with Kotlin, we can also create extension functions. Extension functions lets you add

behavior to an existing class, without inheriting from it and without changing its source.

Chapter 4: “Working with Types.” This chapter deals with object-oriented topics.

You’ll learn how Kotlin treats interfaces, classes, and access modifiers. We’ll also learn

about the new data classes in Kotlin. It also talks about object declarations—it’s the

replacement for Java’s static keyword.

Chapter 5: “Lambdas and Higher Order Functions.” Now we go to Kotlins’s

functional programming capabilities. It discusses how to create and use higher-order

functions, lambdas, and closures.

Chapter 6: “Collections” walks through the classic collection classes of Java and how

to use them in Kotlin.

Chapter 7: “Generics.” Using generics in Kotlin isn’t that much different from Java.

If generics is old hat for you, then most of this chapter will be a review. But try to read

through it still because it talks about reified generics, which Java doesn’t have.

Chapter 8: “Android Studio Introduction and Setup.” This chapter talks a bit about

Android’s history, its technical make-up, and the OS.It also walks you through the

installation and setup of Android Studio.

Chapter 9: “Getting Started” gets you grounded on the fundamental concepts about

Android programming. It talks about components, what they are, how they are organized,

and how they come together in an Android app. In this chapter, you’ll learn how the basic

workflow of an Android project—how to create a project and run it on an emulator

Chapter 10: “Activities and Layouts.” Here, we’ll learn how to build a UI.Activity,

Layout, and View objects are the building blocks for an Android UI.

Chapter 11: “Event Handling.” You’ll learn how to react to user-generated events like

clicks and longclicks. We’ll use some concepts that we learned in Chapters 4 and 5 (inner

objects and lambdas) to help us write more compact and succinct event-handling code.

Chapter 12: “Intents.” This chapter reviews some fundamental concepts on Android

programming, specifically the concept of components, which dovetails to the topic of

Intents. You’ll learn how to use Intents to launch another Activity and pass data in-and-

around Activities.

inTRoduCTion

xxiii

Chapter 13: “Themes and Menus.” This is a short chapter. You’ll learn how to add

styles/themes to your app. We’ll also work with some menus and the ActionBar.

Chapter 14: “Fragments.” You’ll learn how to use Android Fragments as a more

granular composition unit for UI.We’ll also see how to use Fragments to address

changes in device orientation.

Chapter 15: “Running in the Background.” Any non-trivial app will do something

substantial like read from a file, write to a file, download something from the network,

etc. These activities will likely take more than 16 ms to execute (you’ll learn why 16 ms

should be the upper limit and why you should not exceed it). When that happens, the

user will see and feel “jank.” This chapter discusses the various ways on how to run our

code in a background thread.

Chapter 16: “Debugging” shows some of the things you can do to debug your apps

in Android Studio 3. It goes through a list of the kinds of errors you might encounter

while coding and what you can do in Android Studio to respond them.

Chapter 17: “SharedPreferences.” When you need to save simple data, you can use

the SharedPreferences API.This chapter walks you through detailed examples on how to

do that.

Chapter 18: “Internal Storage.” Just like in SharedPreferences, you can also store data

using the Internal Storage API of Android. This chapter discusses internal and external

storage.

Chapter 19: “BroadcastReceivers.” Android has a way to make highly decoupled

components talk to each other. This chapter talks about how BroadcastReceivers can

facilitate messaging for Android components.

Chapter 20: “App Distribution.” When you’re ready to distribute your app, you’ll

need to sign it and list it in a marketplace like Google Play. This chapter walks you

through the steps on how to do it.

How toGet theMost FromThis Book

I designed it like a workbook; it’s best to use it like that. Most chapters have a “Demo

Project” section. There are details on how to create a project—for example, what name

should you use for the project, the minimum SDK to target, etc. The reason I included

this information is so you can follow the coding exercise.

inTRoduCTion

剩余479页未读，继续阅读

no1hero

粉丝: 3
资源: 45

使用Kotlin高效开发Android应用：Android Studio 3实战指南

Apress.Learn.Android.Studio.3.with.Kotlin

Learn Android Studio 3 with Kotlin.epub

mastering-android-development-kotlin.pdf

花瓣 · Nico (陶丰平) Programming Android With Kotlin .pdf

Packt.Android.Development.with.Kotlin.2017

Packt.Mastering.Android.Development.with.Kotlin.2017

Pro Android with Kotlin.zip

kotlin.pdf

android-mvp-kotlin.zip

Kotlin.for.Android.Developers.2016英文高清.pdf版

最新资源