精通Android Studio 3与Kotlin：高效应用开发指南

需积分: 0 127 浏览量更新于2024-07-18 收藏 12.65MB PDF 举报

"Apress.Learn.Android.Studio.3.with.Kotlin" 是一本由 Ted Hagos 编著的专业书籍，专注于教授如何利用最新版本的 Android Studio 3 和 Kotlin 进行高效的 Android 应用开发。这本书不仅涵盖了 Android Studio 3 的核心功能，还特别强调了 Kotlin 这一现代编程语言在 Android 开发中的重要性和优势。 Kotlin 是一种静态类型的、面向对象的编程语言，被 Google 官方推荐为 Android 开发的首选语言，其简洁、安全、互操作性强的特性使其在 Android 开发领域备受青睐。本书将引导读者学习如何利用 Kotlin 的强大功能来构建高效、易于维护的 Android 应用程序，包括但不限于函数式编程、空安全、类型推断以及与 Java 的无缝集成等关键概念。书中内容覆盖了 Android Studio 3 的各个方面，如项目设置、界面设计、架构模式、数据绑定、测试驱动开发、以及使用 Android Jetpack（一套官方提供的组件和库，旨在简化开发流程）的最佳实践。此外，作者还将分享实践经验，帮助读者避免常见的开发陷阱，提高开发效率。读者可以期待在阅读这本书时，不仅能够掌握 Android Studio 3 的最新工具和工作流程，还能深入理解如何通过 Kotlin 实现更优雅、可扩展的代码。该书还包括了 ISBN-13（纸质版：978-1-4842-3906-3，电子版：978-1-4842-3907-0）和 Library of Congress Control Number (2018962941) 等出版信息，并声明了版权，确保了知识的权威性和专业性。无论你是 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页未读，继续阅读

[道一]

粉丝: 0
资源: 60

精通Android Studio 3与Kotlin：高效应用开发指南

最新 ！！！ kotlin插件AndroidStudio适用

Android：Kotlin

帮我找一下可以写再javaweb毕设里的英文参考文献

关于springboot的英文文献

springboot框架外文参考文献列表

列举几个SpringBoot相关的技术文献,以文献引用的格式展示

spring boot项目英文文献

springboot的参考文献

javascript相关外文文献

springboot外文文献

最新资源

最新！！！ kotlin插件AndroidStudio适用