Android development with Kotlin learn android application development with the extensive features of Kotlin
Learn how to make Android development much faster using a variety of Kotlin features, from basics to advanced, to write better quality code. About This Book Leverage specific features of Kotlin to ease Android application development Write code based on both object oriented and functional programmin...
| Otros Autores: | , |
|---|---|
| Formato: | Libro electrónico |
| Idioma: | Inglés |
| Publicado: |
Birmingham, [England] ; Mumbai, [India] :
Packt Publishing
2017.
|
| Edición: | 1st edition |
| Materias: | |
| Ver en Biblioteca Universitat Ramon Llull: | https://discovery.url.edu/permalink/34CSUC_URL/1im36ta/alma991009630745706719 |
Tabla de Contenidos:
- Cover
- Copyrights
- Credits
- About the Authors
- About the Reviewers
- www.PacktPub.com
- Customer Feedback
- Table of Contents
- Preface
- Chapter 1: Beginning Your Kotlin Adventure
- Say hello to Kotlin
- Awesome Kotlin examples
- Dealing with Kotlin code
- Kotlin Playground
- Android Studio
- Configuring Kotlin for the project
- Using Kotlin in a new Android project
- Java to Kotlin converter (J2K)
- Alternative ways to run Kotlin code
- Kotlin under the hood
- The Kotlin standard library
- More reasons to use Kotlin
- Summary
- Chapter 2: Laying a Foundation
- Variables
- Type inference
- Strict null safety
- Safe call
- Elvis operator
- Not-null assertion
- The let function
- Nullability and Java
- Casts
- Safe/unsafe cast operator
- Smart casts
- Type smart casts
- Non-nullable smart cast
- Primitive data types
- Numbers
- Char
- Arrays
- The Boolean type
- Composite data types
- Strings
- String templates
- Ranges
- Collections
- Statements versus expressions
- Control flow
- The if statement
- The when expression
- Loops
- The for loop
- The while loop
- Other iterations
- Break and continue
- Exceptions
- The try... catch block
- Compile-time constants
- Delegates
- Summary
- Chapter 3: Playing with Functions
- Basic function declaration and usage
- Parameters
- Returning functions
- Vararg parameter
- Single-expression functions
- Tail-recursive functions
- Different ways of calling a function
- Default argument values
- Named arguments syntax
- Top-level functions
- Top-level functions under the hood
- Local functions
- Nothing return type
- Summary
- Chapter 4: Classes and Objects
- Classes
- Class declaration
- Properties
- Read-write versus read-only
- Property access syntax between Kotlin and Java
- Increment and decrement operators.
- Custom getters/setters
- The getter versus property default value
- Late-initialized properties
- Annotating properties
- Inline properties
- Constructors
- Properties versus constructor parameters
- Constructors with default arguments
- Patterns
- Inheritance
- The JvmOverloads annotation
- Interfaces
- Data classes
- The equals and hashCode methods
- The toString method
- The copy method
- Destructing declarations
- Operator overloading
- Object declaration
- Object expression
- Companion objects
- Companion object instantiation
- Enum classes
- Infix calls for named methods
- Visibility modifiers
- The internal modifier and Java bytecode
- Sealed classes
- Nested classes
- Import aliases
- Summary
- Chapter 5: Functions as First-Class Citizens
- Function types
- What is function type under the hood?
- Anonymous functions
- Lambda expressions
- The implicit name of a single parameter
- Higher-order functions
- Providing operations to functions
- Observer (Listener) pattern
- A callback after a threaded operation
- Combination of named arguments and lambda expressions
- The last lambda in an argument convention
- Named code surrounding
- Processing data structures using LINQ style
- Java SAM support in Kotlin
- Named Kotlin function types
- Named parameters in function types
- Type alias
- Underscore for unused variables
- Destructuring in lambda expressions
- Inline functions
- The noinline modifier
- Non-local returns
- Labeled returns in lambda expressions
- Crossinline modifier
- Inline properties
- Function references
- Summary
- Chapter 6: Generics Are Your Friends
- Generics
- The need for generics
- Type parameters versus type arguments
- Generic constraints
- Nullability
- Variance
- Variance modifiers
- Use-site variance versus declaration-site variance.
- Collection variance
- Variance producer/consumer limitation
- Invariant constructor
- Type erasure
- Reified type parameters
- The startActivity method
- Star-projections
- Type parameter naming convention
- Summary
- Chapter 7: Extension Functions and Properties
- Extension functions
- Extension functions under the hood
- No method overriding
- Access to receiver elements
- Extensions are resolved statically
- Companion object extensions
- Operator overloading using extension functions
- Where should top-level extension functions be used?
- Extension properties
- Where should extension properties be used?
- Member extension functions and properties
- Types of receivers
- Member extension functions and properties under the hood
- Generic extension functions
- Collection processing
- The Kotlin collection type hierarchy
- The map, filter, and flatMap functions
- The forEach and onEach functions
- The withIndex and indexed variants
- The sum, count, min, max, and sorted functions
- Other stream processing functions
- Examples of stream collection processing
- Sequence
- Function literals with a receiver
- Kotlin standard library functions
- The let function
- Using the apply function for initialization
- The also function
- The run and with functions
- The to function
- Domain-specific language
- Anko
- Summary
- Chapter 8: Delegates
- Class delegation
- The Delegation pattern
- Decorator pattern
- Property delegation
- What are delegated properties?
- Predefined delegates
- The lazy function
- The notNull function
- The observable delegate
- The vetoable delegate
- Property delegation to the Map type
- Custom delegates
- View binging
- Preference binding
- Providing a delegate
- Summary
- Chapter 9: Making Your Marvel Gallery Application
- Marvel Gallery
- How to use this chapter.
- Making an empty project
- Character gallery
- View implementation
- Network definition
- Business logic implementation
- Putting it all together
- Character search
- Character profile display
- Summary
- Index.
