Programming Kotlin Applications

Name: Programming Kotlin Applications | Building Mobile and Server-Side Applications with Kotlin
Brand: Jossey-Bass
Price: 28.99 EUR
Availability: OnlineOnly

Building Mobile and Server-Side Applications with Kotlin

Brett McLaughlin(Autor*in)

Jossey-Bass (Verlag)

1. Auflage

Erschienen am 4. Dezember 2020

384 Seiten

E-Book

PDF mit Adobe-DRM

Systemvoraussetzungen

978-1-119-69616-2 (ISBN)

28,99 €inkl. 7% MwSt.

Systemvoraussetzungen

für PDF mit Adobe-DRM

E-Book Einzellizenz

Als Download verfügbar

Beschreibung

Weitere Details

Weitere Ausgaben

Person

Inhalt

Cover
Title Page
Copyright
About the Author
About the Technical Editor
Acknowledgments
Contents
Introduction
Chapter 1 Objects All the Way Down
Kotlin: A New Programming Language
What is Kotlin?
What Does Kotlin Add to Java?
Kotlin is Object-Oriented
Interlude: Set Up Your Kotlin Environment
Install Kotlin (and an IDE)
Install IntelliJ
Create Your Kotlin Program
Compile and Run Your Kotlin Program
Fix Any Errors as They Appear
Install Kotlin (and Use the Command Line)
Command-Line Kotlin on Windows
Command-Line Kotlin on Mac OS X
Command-Line Kotlin on UNIX-Based Systems
Verify Your Command-Line Installation
Creating Useful Objects
Pass In Values to an Object Using Its Constructor
Print an Object with toString()
Terminology Update: Functions and Methods
Print an Object (and Do It with Shorthand)
Override the toString() Method
All Data Is Not a Property Value
Initialize an Object and Change a Variable
Kotlin Auto-Generates Getters and Setters
Terminology Update: Getters, Setters, Mutators, Accessors
Constants Can't Change (Sort of)
Chapter 2 It's Hard to Break Kotlin
Upgrade Your Kotlin Class Game
Name a File According to Its Class
Organize Your Classes with Packages
Put Person in a Package
Classes: The Ultimate Type in Kotlin
Kotlin Has a Large Number of Types
Numbers in Kotlin
Letters and Things
Truth or Fiction
Types Aren't Interchangeable (Part 1)
You Must Initialize Your Properties
Types Aren't Interchangeable (Part 2)
You Can Explicitly Tell Kotlin What Type to Use
Try to Anticipate How Types Will Be Used
It's Easy to Break Kotlin (Sort of)
Overriding Property Accessors and Mutators
Custom-Set Properties Can't Be in a Primary Constructor
Move Properties Out of Your Primary Constructors
Initialize Properties Immediately
Try to Avoid Overusing Names
Override Mutators for Certain Properties
Classes Can Have Custom Behavior
Define a Custom Method on Your Class
Every Property Must Be Initialized
Assign an Uninitialized Property a Dummy Value
Tell Kotlin You'll Initialize a Property Later
Assign Your Property the Return Value from a Function
Sometimes You Don't Need a Property!
Type Safety Changes Everything
Writing Code Is Rarely Linear
Chapter 3 Kotlin Is Extremely Classy
Objects, Classes, and Kotlin
All Classes Need an equals(x) Method
Equals(x) Is Used to Compare Two Objects
Override equals(x) to Make It Meaningful
Every Object Is a Particular Type
A Brief Introduction to Null
Every Object Instance Needs a Unique hashCode()
All Classes Inherit from Any
Always Override hashCode() and equals(x)
Default Hash Codes Are Based on Memory Location
Use Hash Codes to Come Up with Hash Codes
Searching (and Other Things) Depend on Useful and Fast equals(x) and hashCode()
Multiple Properties to Differentiate Them in hashCode()
Use == over equals(x) for Speed
A Quick Speed Check on hashCode()
Basic Class Methods Are Really Important
Chapter 4 Inheritance Matters
Good Classes Are Not Always Complex Classes
Keep It Simple, Stupid
Keep It Flexible, Stupid
Classes Can Define Default Values for Properties
Constructors Can Accept Default Values
Kotlin Expects Arguments in Order
Specify Arguments by Name
Change the Order of Arguments (If You Need)
Secondary Constructors Provide Additional Construction Options
Secondary Constructors Come Second
Secondary Constructors Can Assign Property Values
You Can Assign null to a Property . . . Sometimes
null Properties Can Cause Problems
Handle Dependent Values With Custom Mutators
Set Dependent Values in a Custom Mutator
All Property Assignments Use the Property's Mutator
Nullable Values Can Be Set to null!
Limit Access to Dependent Values
When Possible, Calculate Dependent Values
You Can Avoid Parentheses with a Read-Only Property
Need Specifics? Consider A Subclass
Any Is the Base Class for Everything in Kotlin
{ . . . } Is Shorthand for Collapsed Code
A Class Must Be Open for Subclassing
Terminology: Subclass, Inherit, Base Class, and More
A Subclass Must Follow Its Superclass's Rules
A Subclass Gets Behavior from All of Its Superclasses
Your Subclass Should Be Different Than Your Superclass
Subclass Constructors Often Add Arguments
Don't Make Mutable What Isn't Mutable
Sometimes Objects Don't Exactly Map to the Real World
Generally, Objects Should Map to the Real World
Chapter 5 Lists and Sets and Maps, Oh My!
Lists Are Just a Collection of Things
Kotlin Lists: One Type of Collection
Collection Is a Factory for Collection Objects
Collection Is Automatically Available to Your Code
Mutating a Mutable List
Getting Properties from a Mutable List
Lists (and Collections) Can Be Typed
Give Your Lists Types
Iterate over Your Lists
Kotlin Tries to Figure Out What You Mean
Lists Are Ordered and Can Repeat
Order Gives You Ordered Access
Lists Can Contain Duplicate Items
Sets: Unordered but Unique
In Sets, Ordering Is Not Guaranteed
When Does Order Matter?
Sort Lists (and Sets) on the Fly
Sets: No Duplicates, No Matter What
Sets "Swallow Up" Duplicates
Sets Use equals(x) to Determine Existing Membership
Iterators Aren't (Always) Mutable
Maps: When a Single Value Isn't Enough
Maps Are Created by Factories
Use Keys to Find Values
How Do You Want Your Value?
Filter a Collection by . . . Anything
Filter Based on a Certain Criterion
Filter Has a Number of Useful Variations
Collections: For Primitive and Custom Types
Add a Collection to Person
Allow Collections to Be Added to Collection Properties
Sets and MutableSets Aren't the Same
Collection Properties Are Just Collections
Chapter 6 The Future (in Kotlin) Is Generic
Generics Allow Deferring of a Type
Collections Are Generic
Parameterized Types Are Available Throughout a Class
Generic: What Exactly Does It Refer To?
Generics Try to Infer a Type When Possible
Kotlin Looks for Matching Types
Kotlin Looks for the Narrowest Type
Sometimes Type Inference Is Wrong
Don't Assume You Know Object Intent
Kotlin Doesn't Tell You the Generic Type
Just Tell Kotlin What You Want!
Covariance: A Study in Types and Assignment
What about Generic Types?
Some Languages Take Extra Work to Be Covariant
Kotlin Actually Takes Extra Work to Be Covariant, Too
Sometimes You Have to Make Explicit What Is Obvious
Covariant Types Limit the Input Type as Well as the Output Type
Covariance Is Really about Making Inheritance Work the Way You Expect
Contravariance: Building Consumers from Generic Types
Contravariance: Limiting What Comes Out Rather Than What Comes In
Contravariance Works from a Base Class Down to a Subclass
Contravariant Classes Can't Return a Generic Type
Does Any of This Really Matter?
Unsafevariance: Learning The Rules, then Breaking Them
Typeprojection Lets You Deal with Base Classes
Variance Can Affect Functions, Not Just Classes
Type Projection Tells Kotlin to Allow Subclasses as Input for a Base Class
Producers Can't Consume and Consumers Can't Produce
Variance Can't Solve Every Problem
Chapter 7 Flying through Control Structures
Control Structures are The Bread and Butter of Programming
If and Else: The Great Decision Point
!! Ensures Non-Nullable Values
Control Structures Affect the Flow of Your Code
if and else Follow a Basic Structure
Expressions and if Statements
Use the Results of an if Statement Directly
Kotlin Has No Ternary Operator
A Block Evaluates to the Last Statement in That Block
if Statements That Are Assigned Must Have else Blocks
When Is Kotlin's Version of Switch
Each Comparison or Condition Is a Code Block
Handle Everything Else with an else Block
Each Branch Can Support a Range
Each Branch Usually Has a Partial Expression
Branch Conditions Are Checked Sequentially
Branch Conditions Are Just Expressions
When Can Be Evaluated as a Statement, Too
For Is for Looping
For in Kotlin Requires an Iterator
You Do Less, Kotlin Does More
For Has Requirements for Iteration
You Can Grab Indices Instead of Objects with for
Use While to Execute until a Condition Is False
While Is All about a Boolean Condition
A Wrinkle in while: Multiple Operators, One Variable
Combine Control Structures for More Interesting Solutions
Do . . . While Always Runs Once
Every do . . . while Loop Can Be Written as a while Loop
If Something Must Happen, Use do . . . while
do . . . while Can Be a Performance Consideration
Get out of a Loop Immediately with Break
Break Skips What's Left in a Loop
You Can Use a Label with break
Go to the Next Iteration Immediately with Continue
Continue Works with Labels as Well
If versus continue: Mostly Style over Substance
Return Returns
Chapter 8 Data Classes
Classes in the Real World are Varied But Well Explored
Many Classes Share Common Characteristics
Common Characteristics Result in Common Usage
A Data Class Takes the Work Out of a Class Focused on Data
Data Classes Handle the Basics of Data for You
The Basics of Data Includes hashCode() and equals(x)
Destructuring Data through Declarations
Grab the Property Values from a Class Instance
Destructuring Declarations Aren't Particularly Clever
Kotlin Is Using componentN() Methods to Make Declarations Work
You Can Add componentN() Methods to Any Class
If You Can Use a Data Class, You Should
You Can "Copy" an Object or Make a Copy of an Object
Using = Doesn't Actually Make a Copy
If You Want a Real Copy, Use copy()
Data Classes Require Several Things From You
Data Classes Require Parameters and val or var
Data Classes Cannot Be Abstract, Open, Sealed, or Inner
Data Classes Add Special Behavior to Generated Code
You Can Override Compiler-Generated Versions of Many Standard Methods
Supertype Class Functions Take Precedence
Data Classes Only Generate Code for Constructor Parameters
Only Constructor Parameters Are Used in equals()
Data Classes are Best Left Alone
Chapter 9 Enums and Sealed, More Specialty Classes
Strings Are Terrible as Static Type Representations
Strings Are Terrible Type Representations
Capitalization Creates Comparison Problems
This Problem Occurs All the Time
String Constants Can Help . . . Some
Companion Objects Are Single Instance
Constants Must Be Singular
Companion Objects Are Singletons
Companion Objects Are Still Objects
You Can Use Companion Objects without Their Names
Using a Companion Object's Name Is Optional
Using a Companion Object's Name Is Stylistic
Companion Object Names Are Hard
You Can Skip the Companion Object Name Altogether
Enums Define Constants and Provide Type Safety
Enums Classes Provide Type-Safe Values
Enums Classes Are Still Classes
Enums Give You the Name and Position of Constants
Each Constant in an enum Is an Object
Each Constant Can Override Class-Level Behavior
Sealed Classes Are Type-Safe Class Hierarchies
Enums and Class Hierarchies Work for Shared Behavior
Sealed Classes Address Fixed Options and Non-Shared Behavior
Sealed Classes Don't Have Shared Behavior
Sealed Classes Have a Fixed Number of Subclasses
Subclasses of a Sealed Class Don't Always Define Behavior
when Requires All Sealed Subclasses to Be Handled
when Expressions Must Be Exhaustive for Sealed Classes
else Clauses Usually Don't Work for Sealed Classes
else Clauses Hide Unimplemented Subclass Behavior
Chapter 10 Functions and Functions and Functions
Revisiting the Syntax of a Function
Functions Follow a Basic Formula
Function Arguments Also Have a Pattern
Default Values in Constructors Are Inherited
Default Values in Functions Are Inherited
Default Values in Functions Cannot Be Overridden
Default Values Can Affect Calling Functions
Calling Functions Using Named Arguments Is Flexible
Function Arguments Can't Be Null Unless You Say So
Functions Follow Flexible Rules
Functions Actually Return Unit by Default
Functions Can Be Single Expressions
Single-Expression Functions Don't Have Curly Braces
Single-Expression Functions Don't Use the return Keyword
Single-Expression Functions Can Infer a Return Type
Type Widening Results in the Widest Type Being Returned
Functions Can Take Variable Numbers of Arguments
A vararg Argument Can Be Treated Like an Array
Functions in Kotlin Have Scope
Local Functions Are Functions Inside Functions
Member Functions Are Defined in a Class
Extension Functions Extend Existing Behavior without Inheritance
Extend an Existing Closed Class Using Dot Notation
this Gives You Access to the Extension Class
Function Literals: Lambdas and Anonymous Functions
Anonymous Functions Don't Have Names
You Can Assign a Function to a Variable
Executable Code Makes for an "Executable" Variable
Higher-Order Functions Accept Functions as Arguments
The Result of a Function Is Not a Function
Function Notation Focuses on Input and Output
You Can Define a Function Inline
Lambda Expressions Are Functions with Less Syntax
You Can Omit Parameters Altogether
Lambda Expressions Use it for Single Parameters
it Makes Lambdas Work More Smoothly
Lambda Expressions Return the Last Execution Result
Trailing Functions as Arguments to Other Functions
Lots of Functions, Lots of Room for Problems
Chapter 11 Speaking Idiomatic Kotlin
Scope Functions Provide Context to Code
Use Let to Provide Immediate Access to an Instance
let Gives You it to Access an Instance
The Scoped Code Blocks Are Actually Lambdas
let and Other Scope functions Are Largely about Convenience
You Can Chain Scoped Function Calls
An Outer it "Hides" an Inner it
Chaining Scope Functions and Nesting Scope Functions Are Not the Same
Nesting Scope Functions Requires Care in Naming
Chaining Scope Functions Is Simpler and Cleaner
Prefer Chaining over Nesting
Many Chained Functions Start with a Nested Function
You Can Scope Functions to Non-Null Results
Accepting null Values Isn't a Great Idea
Scope Functions Give You Null Options
Scope Functions Work on Other Functions . . . in Very Particular Ways
With Is a Scope Function for Processing an Instance
with Uses this as Its Object Reference
A this Reference Is Always Available
with Returns the Result of the Lambda
Run Is a Code Runner and Scope Function
Choosing a Scope Function Is a Matter of Style and Preference
run Doesn't Have to Operate on an Object Instance
Apply Has a Context Object But No Return Value
apply Operates upon an Instance
apply Returns the Context Object, Not the Lambda Result
?: Is Kotlin's Elvis Operator
Also Gives You an Instance . . . but Operates on the Instance First
also Is Just Another Scope Function
also Executes before Assignment
Scope Functions Summary
Chapter 12 Inheritance, One More Time, with Feeling
Abstract Classes Require a Later Implementation
Abstract Classes Cannot Be Instantiated
Abstract Classes Define a Contract with Subclasses
Abstract Classes Can Define Concrete Properties and Functions
Subclasses Fulfill the Contract Written by an Abstract Class
Subclasses Should Vary Behavior
The Contract Allows for Uniform Treatment of Subclasses
Interfaces Define Behavior but Have No Body
Interfaces and Abstract Classes Are Similar
Interfaces Cannot Maintain State
A Class's State Is the Values of Its Properties
An Interface Can Have Fixed Values
Interfaces Can Define Function Bodies
Interfaces Allow Multiple Forms of Implementation
A Class Can Implement Multiple Interfaces
Interface Property Names Can Get Confusing
Interfaces Can Decorate a Class
Delegation Offers Another Option for Extending Behavior
Abstract Classes Move from Generic to Specific
More Specificity Means More Inheritance
Delegating to a Property
Delegation Occurs at Instantiation
Inheritance Requires Forethought and Afterthought
Chapter 13 Kotlin: The Next Step
Programming Kotlin for Android
Kotlin for Android Is Still Just Kotlin
Move from Concept to Example
Kotlin and Java are Great Companions
Your IDE Is a Key Component
Kotlin Is Compiled to Bytecode for the Java Virtual Machine
Gradle Gives You Project Build Capabilities
When Kotlin Questions Still Exist
Use the Internet to Supplement Your Own Needs and Learning Style
Now What?
Index
EULA

Systemvoraussetzungen

Als PDF speichern Als Link merken