- Summary 更新時間：2021-07-02 21:51:00
- Launching the application
- Complete View
- Printing the result
- Background operations
- Forms
- Other layouts
- HBox layout
- VBox layout
- Layouts
- Views
- Controllers
- Configuring the client
- REST client
- Implementing the JSONModel interface
- Defining the Model
- Consuming the REST API
- Property delegate
- Dependency injection
- Type-safe CSS
- Application class
- Let's code!
- Project structure
- Creating the project
- Installing the TornadoFX plugin
- Prerequisites
- Setting up the IDE
- Features of our application
- Definition API
- Words API
- What we will build
- Let's build our dictionary application
- Other improvements
- Type-safe styling
- Creating a type-safe UI versus FXML
- TornadoFX special additions
- Java-based desktop frameworks
- Introducing TornadoFX
- Dictionary Desktop Application - TornadoFX
- Summary
- Creating a multiplatform project without an IDE
- Creating a multiplatform project with an IDE
- Setting up a multiplatform project
- Overview of the dependency structure
- Regular module
- Platform module
- Common module
- Project structure
- Multiplatform Kotlin
- Executing the program
- Compiling the program
- Understanding the dataset
- Running the program
- Complete code
- Printing the result
- Splitting strings
- Converting to Kotlin string
- Counting unique entries
- Reading the file contents
- Opening the file
- Reading command-line arguments
- Writing the main function
- Building our app
- Memory management
- Testing the installation
- Installing from binaries
- Installing from the source
- Installing Kotlin Native
- Multiplatform Kotlin
- Target platforms
- What is Kotlin Native?
- CSV Reader in Kotlin Native
- Summary
- Testing news sources using Postman
- Testing news sources using Postman
- Testing JSON using Postman
- Testing the index URL
- Testing the application
- Adding Gradle dependency
- Testing
- Path parameters
- Understanding route paths
- Modular routing
- Simple routing
- Installing routing
- Application main
- Application block
- Deployment block
- Application configuration
- Let's code!
- Completing Gradle script
- Blocking mode
- Asynchronous mode
- Quick sample
- Adding Gradle dependency
- What is Fuel?
- Adding Fuel
- Configuring logging
- Adding Ktor dependencies
- Adding Kotlin dependency
- Setting up the build script
- Deploying in IntelliJ IDEA
- Deploying
- Project structure
- Creating the project
- Prerequisites
- Setting up the IDE
- Architecture
- Features
- Preview
- Fetching news articles
- Fetching news sources
- News provider
- Let's build our news application
- Deploying the Ktor app
- Highly testable
- Asynchronous nature
- Understanding unopinionated applications
- Why Ktor?
- What is Ktor?
- What is REST?
- News Feed – REST API
- Summary
- Styling the page using CSS
- Disconnecting a socket
- Named parameter
- Using the let function
- Force unwraps
- Null safety
- Sending and receiving a message
- Iterating list
- Using the Pair class
- Using the data class
- Showing a list of online users
- Incrementing and decrementing operator overloading
- Emitting the event
- Listening to events
- Setting up Socket.IO
- Establishing a socket connection
- Registering a callback
- Smart cast
- Passing nickname to the server
- Reading the nickname
- Lambda functions
- Using kotlinx.html
- Using DSL
- Creating an index.ejs file
- Creating a login page
- Starting the node server
- Specifying the router
- Examining the compilation output
- Specifying the output files
- Setting up the Node.js server
- Creating a chat application
- Creating a project
- Installing the Node.js plugin
- Installing Node.js
- Choosing an IDE
- Creating our first Node.js app using Kotlin
- Chat Application with Server-Side JavaScript Generation
- Summary
- Interoperability with JavaScript
- Adding CSS
- Giving final touches
- Extension functions
- Named parameters
- Showing weather details
- Showing data to the user
- Data classes
- Reading data from input elements
- Calling a weather API
- Refactoring the HTML code using DSL
- Using Kotlinx.html
- What is DSL?
- Creating UI using Kotlin
- Simple HTML approach
- Creating a UI with dummy data
- Developing a weather forecast web app
- Running the project
- Creating a Main.kt file
- Creating an HTML page
- Creating a project
- Choosing an IDE
- Creating your first Kotlin and JavaScript project
- Weather App Using Kotlin for JavaScript
- Summary
- Anko layout
- Starting an activity made easy
- Displaying toast()
- Setting up Anko
- Anko - Kotlin's buddy for Android
- Setting up an item click on RecyclerView
- Dealing with Shared Preferences
- Delegated properties
- Object expressions and declarations
- Dealing with constants
- Fragment instantiation using companion objects
- Companion object
- The as operator
- The is and !is operators
- Smart casts
- Force unwrap (!!)
- Elvis operator (?:)
- Safe call operator (?.)
- Why Kotlin is called null-safe
- Null-Safety
- Android context
- Destructing declaration
- Named parameter
- Default parameter
- Default and named parameters
- Inline function
- Single-expression function
- Functions in Kotlin
- The let() function
- The apply() function
- The with() function
- The Standard.kt function
- Fragment LayoutInflater extension
- View extensions
- Ditching the findViewById() method
- Kotlin Android extension
- Interfaces
- Declaring a property
- Getters and setters
- The when() expression
- Control flow
- The lazy property
- lateinit
- lateinit versus lazy initialization
- Singletons
- Inheritance
- Data classes
- Constructors
- Classes
- String utility methods
- String interpolation
- Using datatypes and conversion
- Creating a social media aggregator
- Converting Java code to Kotlin code
- Getting started
- Setting up the Kotlin plugin for Android Studio
- Setting up Kotlin
- Social Media Aggregator Android App
- Summary
- What if I want to rewrite Java to Kotlin?
- Should I rewrite the existing Java code in Kotlin?
- Migrating to Kotlin
- Playing with the Java to Kotlin converter
- Spring starter
- All-open compiler plugin
- Pro-tips
- Test cases
- Gradle dependency
- Testing
- Extension functions
- Event broadcaster
- CrudRepository
- Repository
- Service/Controller
- Extras for geospatial support
- Exposed objects
- Exposed integration
- Data classes
- Application configuration
- Backend
- Application class
- Complete JavaScript
- Listening to message saved events
- Plotting messages on the map
- Rendering the map
- JavaScript
- CSS
- HTML
- Frontend
- Coding the application
- Completing the Gradle script
- Gradle dependency
- Object mapping
- Gradle dependency
- Installation
- Explaining PostGIS
- CRUD operations
- Connecting to the database
- Defining the table
- Gradle dependency
- Exposed library
- Adding Spring Boot dependencies
- Adding Kotlin dependency
- Setting up the build script
- Project structure
- Creating a project
- Setting up the IDE
- Architecture
- Features
- Preview
- Let's build our geospatial messenger
- Functional bean declaration DSL
- Leveraging Null safety
- Constructor injection
- Extension functions
- Leveraging Kotlin in Spring Boot applications
- Why Spring Boot?
- Geospatial Messenger – Spring Boot
- Summary
- Kotlin's winning strategy
- Go native strategy
- Kotlin is in the winning camp
- Beyond being a better Java
- Excellent IDE support from day one
- Enhanced robustness
- Concise yet expressive code
- Why Kotlin?
- Why not other languages?
- Kotlin – a better Java
- The Power of Kotlin
- Questions
- Piracy
- Errata
- Downloading the color images of this book
- Downloading the example code
- Customer support
- Reader feedback
- Conventions
- Who this book is for
- What you need for this book
- What this book covers
- Preface
- Customer Feedback
- Why subscribe?
- www.PacktPub.com
- About the Reviewer
- Acknowledgments
- About the Authors
- Credits
- 版權信息
- 封面
- 封面
- 版權信息
- Credits
- About the Authors
- Acknowledgments
- About the Reviewer
- www.PacktPub.com
- Why subscribe?
- Customer Feedback
- Preface
- What this book covers
- What you need for this book
- Who this book is for
- Conventions
- Reader feedback
- Customer support
- Downloading the example code
- Downloading the color images of this book
- Errata
- Piracy
- Questions
- The Power of Kotlin
- Kotlin – a better Java
- Why not other languages?
- Why Kotlin?
- Concise yet expressive code
- Enhanced robustness
- Excellent IDE support from day one
- Beyond being a better Java
- Kotlin is in the winning camp
- Go native strategy
- Kotlin's winning strategy
- Summary
- Geospatial Messenger – Spring Boot
- Why Spring Boot?
- Leveraging Kotlin in Spring Boot applications
- Extension functions
- Constructor injection
- Leveraging Null safety
- Functional bean declaration DSL
- Let's build our geospatial messenger
- Preview
- Features
- Architecture
- Setting up the IDE
- Creating a project
- Project structure
- Setting up the build script
- Adding Kotlin dependency
- Adding Spring Boot dependencies
- Exposed library
- Gradle dependency
- Defining the table
- Connecting to the database
- CRUD operations
- Explaining PostGIS
- Installation
- Gradle dependency
- Object mapping
- Gradle dependency
- Completing the Gradle script
- Coding the application
- Frontend
- HTML
- CSS
- JavaScript
- Rendering the map
- Plotting messages on the map
- Listening to message saved events
- Complete JavaScript
- Application class
- Backend
- Application configuration
- Data classes
- Exposed integration
- Exposed objects
- Extras for geospatial support
- Service/Controller
- Repository
- CrudRepository
- Event broadcaster
- Extension functions
- Testing
- Gradle dependency
- Test cases
- Pro-tips
- All-open compiler plugin
- Spring starter
- Playing with the Java to Kotlin converter
- Migrating to Kotlin
- Should I rewrite the existing Java code in Kotlin?
- What if I want to rewrite Java to Kotlin?
- Summary
- Social Media Aggregator Android App
- Setting up Kotlin
- Setting up the Kotlin plugin for Android Studio
- Getting started
- Converting Java code to Kotlin code
- Creating a social media aggregator
- Using datatypes and conversion
- String interpolation
- String utility methods
- Classes
- Constructors
- Data classes
- Inheritance
- Singletons
- lateinit versus lazy initialization
- lateinit
- The lazy property
- Control flow
- The when() expression
- Getters and setters
- Declaring a property
- Interfaces
- Kotlin Android extension
- Ditching the findViewById() method
- View extensions
- Fragment LayoutInflater extension
- The Standard.kt function
- The with() function
- The apply() function
- The let() function
- Functions in Kotlin
- Single-expression function
- Inline function
- Default and named parameters
- Default parameter
- Named parameter
- Destructing declaration
- Android context
- Null-Safety
- Why Kotlin is called null-safe
- Safe call operator (?.)
- Elvis operator (?:)
- Force unwrap (!!)
- Smart casts
- The is and !is operators
- The as operator
- Companion object
- Fragment instantiation using companion objects
- Dealing with constants
- Object expressions and declarations
- Delegated properties
- Dealing with Shared Preferences
- Setting up an item click on RecyclerView
- Anko - Kotlin's buddy for Android
- Setting up Anko
- Displaying toast()
- Starting an activity made easy
- Anko layout
- Summary
- Weather App Using Kotlin for JavaScript
- Creating your first Kotlin and JavaScript project
- Choosing an IDE
- Creating a project
- Creating an HTML page
- Creating a Main.kt file
- Running the project
- Developing a weather forecast web app
- Creating a UI with dummy data
- Simple HTML approach
- Creating UI using Kotlin
- What is DSL?
- Using Kotlinx.html
- Refactoring the HTML code using DSL
- Calling a weather API
- Reading data from input elements
- Data classes
- Showing data to the user
- Showing weather details
- Named parameters
- Extension functions
- Giving final touches
- Adding CSS
- Interoperability with JavaScript
- Summary
- Chat Application with Server-Side JavaScript Generation
- Creating our first Node.js app using Kotlin
- Choosing an IDE
- Installing Node.js
- Installing the Node.js plugin
- Creating a project
- Creating a chat application
- Setting up the Node.js server
- Specifying the output files
- Examining the compilation output
- Specifying the router
- Starting the node server
- Creating a login page
- Creating an index.ejs file
- Using DSL
- Using kotlinx.html
- Lambda functions
- Reading the nickname
- Passing nickname to the server
- Smart cast
- Registering a callback
- Establishing a socket connection
- Setting up Socket.IO
- Listening to events
- Emitting the event
- Incrementing and decrementing operator overloading
- Showing a list of online users
- Using the data class
- Using the Pair class
- Iterating list
- Sending and receiving a message
- Null safety
- Force unwraps
- Using the let function
- Named parameter
- Disconnecting a socket
- Styling the page using CSS
- Summary
- News Feed – REST API
- What is REST?
- What is Ktor?
- Why Ktor?
- Understanding unopinionated applications
- Asynchronous nature
- Highly testable
- Deploying the Ktor app
- Let's build our news application
- News provider
- Fetching news sources
- Fetching news articles
- Preview
- Features
- Architecture
- Setting up the IDE
- Prerequisites
- Creating the project
- Project structure
- Deploying
- Deploying in IntelliJ IDEA
- Setting up the build script
- Adding Kotlin dependency
- Adding Ktor dependencies
- Configuring logging
- Adding Fuel
- What is Fuel?
- Adding Gradle dependency
- Quick sample
- Asynchronous mode
- Blocking mode
- Completing Gradle script
- Let's code!
- Application configuration
- Deployment block
- Application block
- Application main
- Installing routing
- Simple routing
- Modular routing
- Understanding route paths
- Path parameters
- Testing
- Adding Gradle dependency
- Testing the application
- Testing the index URL
- Testing JSON using Postman
- Testing news sources using Postman
- Testing news sources using Postman
- Summary
- CSV Reader in Kotlin Native
- What is Kotlin Native?
- Target platforms
- Multiplatform Kotlin
- Installing Kotlin Native
- Installing from the source
- Installing from binaries
- Testing the installation
- Memory management
- Building our app
- Writing the main function
- Reading command-line arguments
- Opening the file
- Reading the file contents
- Counting unique entries
- Converting to Kotlin string
- Splitting strings
- Printing the result
- Complete code
- Running the program
- Understanding the dataset
- Compiling the program
- Executing the program
- Multiplatform Kotlin
- Project structure
- Common module
- Platform module
- Regular module
- Overview of the dependency structure
- Setting up a multiplatform project
- Creating a multiplatform project with an IDE
- Creating a multiplatform project without an IDE
- Summary
- Dictionary Desktop Application - TornadoFX
- Introducing TornadoFX
- Java-based desktop frameworks
- TornadoFX special additions
- Creating a type-safe UI versus FXML
- Type-safe styling
- Other improvements
- Let's build our dictionary application
- What we will build
- Words API
- Definition API
- Features of our application
- Setting up the IDE
- Prerequisites
- Installing the TornadoFX plugin
- Creating the project
- Project structure
- Let's code!
- Application class
- Type-safe CSS
- Dependency injection
- Property delegate
- Consuming the REST API
- Defining the Model
- Implementing the JSONModel interface
- REST client
- Configuring the client
- Controllers
- Views
- Layouts
- VBox layout
- HBox layout
- Other layouts
- Forms
- Background operations
- Printing the result
- Complete View
- Launching the application
- Summary 更新時間：2021-07-02 21:51:00
