Programando com Kotlin
Quem viu este produto , comprou
-
ocê obterá com o OpenSwing: Facilidade e Produtividade no desenvolvimento de aplicações Java desktop e para Web; Construa rapidamente aplicações ricas para Internet (RIA) em três camadas; Integração com vários frameworks: Hibernate, Spring, JPA/TopLink e outros; Trabalhe com sua IDE preferida: NetBeans, Eclipse, Jbuilder ou JDeveloper; Uma suíte de componentes gráficos avançados; você não precisará gastar tempo e esforço desenvolvendo novos componentes. ... Ler mais +
QUERO VER -
Persistência no Spring com Hibernate
Este livro não só ensinará as funcionalidades do Spring 3 e do Hibernate 3.5, mas também guiará você pelos passos essenciais da construção de uma aplicação real – atendendo a armadilhas e considerações comuns ao longo do caminho. Nós apresentaremos melhores práticas e truques que aprendemos ao longo de anos de experiência prática e que você também pode aplicar em seus próprios projetos. Como bônus, você também aprenderá sobre dois empolgantes projetos de estado da arte construídos sobre o Spring e o Hibernate: o Grails e o Roo. ... Ler mais +
QUERO VER -
OCA/OCP Java SE 7 Guia de Estudo do Programador I & II (Exames 1Z0-803 & 1Z0-804)
Prepare-se para os exames OCA/OCP Java SE 7 Programação I e II com esse guia exclusivo da Oracle Press. Os capítulos apresentam exercícios desafiadores, um resumo da certificação, uma área de recapitulação e uma avaliação para reforçar os tópicos apresentados. Este recurso autorizado lhe ajuda a passar nestes exames e também serve como uma referência essencial no trabalho. ... Ler mais +
QUERO VER -
Java Fundamental - Aprenda como programar na linguagem Java usando boas práticas
Neste livro o leitor entenderá o funcionamento dos mecanismos oferecidos da linguagem Java e também conseguirá visualizar e reproduzir os exemplos de códigos práticos, (os exemplos usados fazem parte de desenvolvimentos de sistemas reais que tive experiência no mundo Java), e será possível o leitor aplicar no cotidiano para os sistemas dos seus projetos. ... Ler mais +
QUERO VER -
Java na Web com JSF, Spring, Hibernate e Netbeans 6
Neste livro você vai encontrar o que há de mais atual e poderoso no mundo do desenvolvimento Java para a Web. Terá acesso a uma aplicação completa em JSF (criado visualmente com o novo Netbeans 6). Verá ainda como utilizar os padrões de projeto mais utilizados do mercado (Facades e DAOs) para a Web, e com exemplos do mundo real. ... Ler mais +
QUERO VER -
Aprendendo Java por meio de Conceitos e Exemplos
Esta obra foi desenvolvida para proporcionar ao leitor uma aprendizagem de desenvolvimento de software utilizando a linguagem JAVA. Este livro dedica-se, em sua maior parte, a fornecer ao leitor uma visão de como programar utilizando essa linguagem de programação, começando por uma introdução sobre a linguagem, comandos básicos e avançandos, realizando a introdução à linguagem orientada a objetos, por conceitos de classe, herança, polimorfismo, entre outros. ... Ler mais +
QUERO VER -
Sistemas Operacionais com Java - 8ª Edição
A obra continua a evoluir com as necessidades emergentes do curso, visando fornecer uma base teórica sólida para o entendimento de sistemas operacionais. A oitava edição foi atualizada para oferecer a cobertura dos temas e aplicativos mais atuais, melhor cobertura conceitual e conteúdo adicional para preencher a lacuna entre os conceitos e implementações reais. Ao final de cada capítulo, haverá exercícios, perguntas de revisão e exercícios de programação que ajudarão a reforçar conceitos importantes.Esta versão fornece exemplos e problemas em Java, uma linguagem que muitos estudantes estão mais confortáveis com que o C da versão regular. ... Ler mais +
QUERO VER -
Java + Primefaces + iReport: Desenvolvendo um CRUD para Web
Desenvolva passo a passo com excelência um cadastro para web com uma das linguagens mais poderosas e seguras do cenário da programação, o popular Java. São abordados procedimentos desde a criação do banco de dados até a parte de relatório da aplicação. ... Ler mais +
QUERO VER -
Este é o primeiro guia completo sobre teoria e prática de desenvolvimento de aplicações ricas para Internet (RIA), na plataforma Java, utilizando os fantásticos recursos do Framework ZK, através de um ambiente de desenvolvimento com recursos gráficos com Eclipse e o plugin Zk Studio. ... Ler mais +
QUERO VER -
Esteja você interessado em aprender sobre integração com AJAX2, desenvolvimento voltado a extensões (plug-ins), ou apenas em construir aplicativos web de qualidade, não consigo pensar em ninguém melhor que Ian para ser seu guia. ... Ler mais +
QUERO VER -
Projetando Web Services com a Plataforma J2EE 1.4 - tecnologia JAX , RPC , SOAP , e XML
Escrito por membros da equipe Java BluePrints da Sun Microsystems, Projetando Web Services com a Plataforma J2EE 1.4 é o guia autorizado para as melhores práticas de projeto e integração de Web services em nível empresarial usando a Plataforma Java 2, Enterprise Edition (J2EE) 1.4. Este livro fornece diretrizes, estratégias e exemplos realistas específicos que os arquitetos e desenvolvedores precisam para construir soluções portáveis mais robustas, escaláveis e interoperáveis. ... Ler mais +
QUERO VER -
POJOS em Ação - Como Desenvolver aplicações Corporativas com Frameworks Leves
Há uma concordância na comunidade Java de que EJBs sempre apresentam mais problemas do que resolvem. Atualmente há uma grande tendência na direção das tecnologias leves como Hibernate, Spring, JDO, iBATIS e outros, que permitem ao desenvolvedor trabalhar diretamente com os Plain Old Java Objects, ou POJOs, que são mais simples. Submetendo-se ao novo consenso, o EJB 3 agora também funciona com POJOs. POJOs em Ação descreve essas maneiras novas, mais simples e rápidas, de desenvolver aplicações corporativas Java. Mostra como tomar decisões básicas de projeto, incluindo como organizar e encapsular a lógica de domínio, acessar o banco de dados, gerenciar as transações e lidar com concorrência de bancos de dados. Escrito para desenvolvedores e projetistas, é um guia de desenvolvimento de aplicações Java da nova geração. Ele ajuda a construir aplicações leves, que são mais fáceis de desenvolver, testar e manter. O livro é bastante prático, com alternativas de projetos ilustradas através de diversos exemplos de código. ... Ler mais +
QUERO VER
Quem viu este produto , também se interessou
-
Esteja você interessado em aprender sobre integração com AJAX2, desenvolvimento voltado a extensões (plug-ins), ou apenas em construir aplicativos web de qualidade, não consigo pensar em ninguém melhor que Ian para ser seu guia. ... Ler mais +
QUERO VER -
Java RESTful na Prática com JAX -RS
Aprenda a implementar aplicações RESTful na plataforma Java de forma prática e direta. Os conceitos são aplicados a exemplos que simulam os desafios de integração de sistemas e disponibilizam informações por meio do protocolo de comunicação HTTP. Este livro guiará o leitor no caminho das melhores práticas de implementação de serviços REST usando a API JAX-RS em conjunto com as mais atuais ferramentas e frameworks existentes no mercado. Além disso, ensinará a construir aplicações e serviços capazes de liberar informações nos formatos JSON e XML de forma correta e segura, dessa forma garantindo que quaisquer aplicações do tipo web, desktop ou até mesmo aplicativos mobile sejam capazes de consumi-las. ... Ler mais +
QUERO VER -
Java na Web com JSF, Spring, Hibernate e Netbeans 6
Neste livro você vai encontrar o que há de mais atual e poderoso no mundo do desenvolvimento Java para a Web. Terá acesso a uma aplicação completa em JSF (criado visualmente com o novo Netbeans 6). Verá ainda como utilizar os padrões de projeto mais utilizados do mercado (Facades e DAOs) para a Web, e com exemplos do mundo real. ... Ler mais +
QUERO VER -
Este é o primeiro guia completo sobre teoria e prática de desenvolvimento de aplicações ricas para Internet (RIA), na plataforma Java, utilizando os fantásticos recursos do Framework ZK, através de um ambiente de desenvolvimento com recursos gráficos com Eclipse e o plugin Zk Studio. ... Ler mais +
QUERO VER -
Java + Primefaces + iReport: Desenvolvendo um CRUD para Web
Desenvolva passo a passo com excelência um cadastro para web com uma das linguagens mais poderosas e seguras do cenário da programação, o popular Java. São abordados procedimentos desde a criação do banco de dados até a parte de relatório da aplicação. ... Ler mais +
QUERO VER -
Java Persistence com Hibernate (Edição revisada e ampliada de Hibernate em Ação)
Java Persistence com Hibernate explora o Hibernate desenvolvendo uma aplicação que une centenas de exemplos individuais. O leitor irá imediatamente aprofundar-se no rico modelo de programação do Hibernate 3.2 e do Java Persistence, trabalhando bastante com consultas, estratégias de recuperação, cacheamento, transações, conversações e muito mais. Poderá também apreciar a bem-ilustrada discussão de boas práticas em projetos de bancos de dados, mapeamento objeto/relacional e técnicas de otimização. Nesta edição revisada do grande sucesso Hibernate em Ação, os autores Christian Bauer e Gavin King – fundador do projeto Hibernate – abordam o Hibernate 3.2 em detalhes junto com os padrões EJB 3.0 e Java Persistence. O livro finaliza em uma cobertura detalhada do JBoss Seam, um revolucionário framework de aplicação web para Java EE que se baseia nos conceitos EJB 3.0, JavaServer Faces e Hibernate. ... Ler mais +
QUERO VER -
Explorando Elasticsearch com Java - Introdução ao desenvolvimento para Big Data
Com a apresentação dos conceitos básicos e de um exemplo que permeia todas as suas páginas, este livro vem preencher uma lacuna na documentação de Elasticsearch em Português. A grande vantagem do Elasticsearch reside na sua arquitetura, projetada para ser altamente escalável e para gerenciar grandes quantidades de dados de forma simples e eficiente. Esses dados são disponibilizados por meio de uma interface baseada em comunicação RESTful, ou seja, que utiliza REST/HTTP, e permitem que clientes de distintas linguagens de programação indexem e busquem documentos baseados em JSON. Este livro coloca sua API Java em prática para atender a demanda por desenvolvimento de aplicações para Big Data, além disso, mostra como utilizar o Elasticsearh também com PHP e JavaScript. ... Ler mais +
QUERO VER -
Se estiver à procura de uma introdução rápida, leve e simples (ou uma reintrodução) ao Hibernate (versão 4.0), este é o livro que você quer. Por meio de exemplos claros do mundo real, você conhecerá o Hibernate e o mapeamento objeto-relacional desde o início, começando pelo básico. Em seguida, você mergulhará de cabeça nos componentes do framework para entender como eles funcionam quando estão em ação.
QUERO VER
Armazenar objetos Java em bancos de dados relacionais normalmente é uma tarefa desafiadora e complexa para qualquer desenvolvedor Java, seja ele experiente ou não. ... Ler mais + -
Desenvolvendo Aplicações Comerciais em Java com Java J2EE e UML
Desenvolvendo aplicações comerciais em Java com J2EE e UML aborda a melhor maneira de aproveitar essas tecnologias em conjunto. Explorando métodos concretos para completar um projeto de desenvolvimento bem-sucedido, os autores cobrem o uso da UML e do J2EE em detalhes. ... Ler mais +
QUERO VER -
Arquitetura de Sistemas para WEB com Java Utilizando Design Patterns e Frameworks
Esse livro apresenta os principais design patterns e frameworks utilizados no desenvolvimento de aplicações web na plataforma Java. Cada capítulo é estruturado com introdução, apresentação dos conceitos teóricos, exemplos práticos explicados passo a passo, resumo e lista de exercícios. ... Ler mais +
QUERO VER -
Projetando Web Services com a Plataforma J2EE 1.4 - tecnologia JAX , RPC , SOAP , e XML
Escrito por membros da equipe Java BluePrints da Sun Microsystems, Projetando Web Services com a Plataforma J2EE 1.4 é o guia autorizado para as melhores práticas de projeto e integração de Web services em nível empresarial usando a Plataforma Java 2, Enterprise Edition (J2EE) 1.4. Este livro fornece diretrizes, estratégias e exemplos realistas específicos que os arquitetos e desenvolvedores precisam para construir soluções portáveis mais robustas, escaláveis e interoperáveis. ... Ler mais +
QUERO VER
- DescriçãoProgramando com Kotlin
Kotlin tem causado sensação desde que foi disponibilizado como código aberto pela JetBrains em 2011. A linguagem foi elogiada por desenvolvedores no mundo todo e já está sendo adotada pelas empresas. Este livro apresenta uma introdução detalhada a Kotlin, mostrando todos os seus recursos, e possibilitará que você escreva código Kotlin para ambientes de produção.
Começaremos pelo básico: deixaremos você se familiarizar com a execução de código Kotlin, configurar ferramentas e apresentar instruções que poderão ser usadas para escrever programas básicos. Em seguida, discutiremos códigos orientados a objetos – funções, lambdas e propriedades –, tudo isso enquanto utilizamos os novos recursos de Kotlin.
Então, prosseguiremos discutindo aspectos sobre null safety (segurança de nulos) e parametrização de tipos. Mostraremos como desestruturar expressões e até mesmo escrever suas próprias expressões. Também abordaremos tópicos importantes, como testes, concorrência, microsserviços e muito mais. No final deste livro, você será capaz de compor diferentes serviços e construir suas próprias aplicações.
Você aprenderá a:
utilizar novos recursos para escrever código orientado a objetos estruturado e legível;
usar lambdas e funções de alta ordem para escrever um código limpo, reutilizável e simples;
escrever testes de unidade e integrar testes de Kotlin com código Java em uma base de código em transição;
escrever código de produção para o mundo real em Kotlin no estilo de microsserviços;
tirar proveito das extensões de Kotlin para usar a biblioteca de coleções de Java;
escrever código que evite erros de ponteiros nulos e ver como um código Java nullable pode ser integrado aos recursos de uma base de código Kotlin;
escrever funções em Kotlin, conhecer novos recursos disponíveis e estender as bibliotecas existentes. - Sobre o Autor
- Especificação
Características
Tipo de Livro Livro Físico Especificações
Sobre o Autor Stephen Samuel
Stephen Samuel é um desenvolvedor talentoso, com mais de 17 anos de experiência. Trabalhou com Java ao longo de sua carreira e, nos últimos cinco anos, concentrou-se em Scala. Tem paixão por concorrência e tecnologias de Big Data. Passou os últimos anos na área de investimentos bancários e, atualmente, trabalha com Kotlin em um grande projeto de Big Data. Stephen também é ativo na comunidade de código aberto e autor de diversas bibliotecas proeminentes de Scala e Kotlin.
Stefan Bocutiu
Stefan Bocutiu é consultor de Big Data, com mais de 13 anos de experiência em desenvolvimento de software. Gosta de programar em Scala e C# e tem paixão por tecnologias de processamento de streams. Com a equipe da DataMountaineer – uma empresa de consultoria que oferece soluções para plataformas de streaming/fast data –, Stefan tem como foco prover pipelines de dados escaláveis, unificados e em tempo real que permitam uma tomada de decisões reativa, análise de dados (analytics) e integração com Hadoop. Stefan é apaixonado por esportes automobilísticos; embora suas habilidades com corridas não sejam boas o suficiente para lhe permitir competir, procura comparecer ao máximo possível de corridas de MotoGP. Quando não está programando, Stefan pode ser encontrado na parede de escalada ou na academia. Ocasionalmente, fazer trilhas e montanhismo está em seu calendário e, durante o inverno, viagens para esquiar são obrigatórias para ele.Informações Técnicas Sumário
Prefácio .................................................................................................................................15
Capítulo 1 Introdução à linguagem Kotlin.............................................................................20
Usando a linha de comando para compilar e executar código Kotlin..........................21
Runtime de Kotlin................................................................................................... 23
REPL.......................................................................................................................24
Kotlin para scripting ................................................................................................24
Kotlin com Gradle................................................................................................... 25
Kotlin com Maven....................................................................................................28
IntelliJ e Kotlin.........................................................................................................32
Eclipse e Kotlin........................................................................................................36
Misturando Kotlin e Java em um projeto...................................................................37
Resumo .................................................................................................................. 44
Capítulo 2 Básico sobre Kotlin ..............................................................................................45
Vals e vars................................................................................................................45
Inferência de tipo .................................................................................................... 46
Tipos básicos...........................................................................................................47
Números ............................................................................................................47
Booleanos...........................................................................................................49
Chars .................................................................................................................49
Strings................................................................................................................49
Arrays ................................................................................................................50
Comentários............................................................................................................50
Pacotes ....................................................................................................................51
Importações.............................................................................................................51
Importações com caractere-curinga .....................................................................51
Renomeando na importação................................................................................52
Templates de string ..................................................................................................52
Intervalos.................................................................................................................53
Laços.......................................................................................................................54
Tratamento de exceções ...........................................................................................56
Instanciando classes.................................................................................................57
Igualdade referencial e igualdade estrutural ..............................................................57
Expressão this..........................................................................................................58
Escopo ...............................................................................................................58
Modificadores de visibilidade ...................................................................................59
Private ................................................................................................................59
Protected ........................................................................................................... 60
Internal ............................................................................................................. 60
Controle de fluxo como expressões.......................................................................... 60
Sintaxe de null .........................................................................................................61
Verificação de tipos e casting...............................................................................62
Casts inteligentes................................................................................................62
Casting explícito................................................................................................ 64
Expressão when...................................................................................................... 64
When (valor).......................................................................................................65
When sem argumento .........................................................................................67
Retorno de função...............................................................................................67
Hierarquia de tipos ..................................................................................................69
Resumo ...................................................................................................................70
Capítulo 3 Programação orientada a objetos em Kotlin.........................................................71
Classes ....................................................................................................................73
Níveis de acesso ..................................................................................................76
Classes aninhadas.............................................................................................. 77
Classes de dados.................................................................................................79
Classes enum..................................................................................................... 80
Métodos estáticos e objetos companheiros...........................................................81
Interfaces.................................................................................................................87
Herança...................................................................................................................91
Modificadores de visibilidade ...................................................................................94
Classes abstratas......................................................................................................96
Interface ou classe abstrata.......................................................................................97
Polimorfismo ...........................................................................................................98
Regras para sobrescrita ..........................................................................................104
Herança versus composição....................................................................................107
Delegação de classe ................................................................................................109
Classes seladas.......................................................................................................111
Resumo .................................................................................................................112
Capítulo 4 Funções em Kotlin ............................................................................................. 113
Definindo funções..................................................................................................113
Funções com uma única expressão ......................................................................... 114
Funções-membro ...................................................................................................115
Funções locais .......................................................................................................116
Funções de nível superior.......................................................................................119
Parâmetros nomeados ............................................................................................120
Parâmetros default .................................................................................................121
Funções de extensão ..............................................................................................123
Precedência para funções de extensão................................................................125
Funções de extensão em nulls............................................................................127
Funções-membro de extensão ...........................................................................127
Sobrescrevendo funções-membro de extensão....................................................128
Extensões em objetos companheiros..................................................................130
Múltiplos valores de retorno ..............................................................................131
Funções infixas.................................................................................................132
Operadores............................................................................................................134
Sobrecarga de operadores..................................................................................135
Operadores básicos...........................................................................................137
in/contains .......................................................................................................137
get/set...............................................................................................................138
Comparação .....................................................................................................140
Atribuição ........................................................................................................140
Interoperabilidade com Java .............................................................................. 141
Funções literais......................................................................................................142
Funções tail recursive.............................................................................................143
varargs...................................................................................................................145
Operador de spread...........................................................................................146
Funções da biblioteca-padrão .................................................................................146
apply ................................................................................................................146
let.....................................................................................................................147
with..................................................................................................................147
run...................................................................................................................148
lazy ..................................................................................................................148
use ...................................................................................................................149
repeat ...............................................................................................................149
require/assert/check..........................................................................................149
Funções genéricas..................................................................................................150
Funções puras........................................................................................................151
Java a partir de Kotlin ............................................................................................153
Getters e setters ................................................................................................153
Métodos abstratos únicos..................................................................................154
Escapando identificadores de Kotlin ..................................................................155
Exceções verificadas..........................................................................................155
Métodos void em Java .......................................................................................155
Kotlin a partir de Java ............................................................................................156
Funções de nível superior..................................................................................156
Parâmetros default ............................................................................................157
Objetos e métodos estáticos...............................................................................157
Nomes em caso de apagamento (erasure)...........................................................158
Captura de exceções verificadas ........................................................................159
Resumo .................................................................................................................159
Capítulo 5 Funções de ordem superior e programação funcional .........................................160
Funções de ordem superior.....................................................................................160
Devolvendo uma função....................................................................................162
Atribuição de função.........................................................................................163
Closures ................................................................................................................164
Funções anônimas .................................................................................................165
Referências a funções.............................................................................................166
Referências a funções de nível superior ..............................................................166
Referências a funções-membro e a funções de extensão......................................166
Referências vinculadas......................................................................................167
Receptores de funções literais.................................................................................168
Funções na JVM ....................................................................................................169
Bytecode...........................................................................................................169
Composição de funções..........................................................................................171
Funções inline .......................................................................................................173
Noinline ...........................................................................................................177
Currying e aplicação parcial ...................................................................................178
Currying em ação .............................................................................................179
Acrescentando suporte a currying .....................................................................180
Memoização ..........................................................................................................181
Implementando a memoização ..........................................................................183
Alias de tipo ..........................................................................................................184
Either ....................................................................................................................186
fold...................................................................................................................186
Projeção............................................................................................................187
Outras funções de projeção ...............................................................................189
Sumário 9
DSLs personalizadas..............................................................................................191
Funções infixas como palavras reservadas .........................................................192
Usando receptores de função em uma DSL ........................................................195
Validação e acúmulo de erros .................................................................................197
Resumo .................................................................................................................200
Capítulo 6 Propriedades.....................................................................................................201
Por que usar propriedades?.....................................................................................201
Sintaxe e variações.................................................................................................204
Visibilidade............................................................................................................207
Inicialização tardia.................................................................................................208
Propriedades delegadas ..........................................................................................209
Inicializações preguiçosas.......................................................................................216
lateinit versus lazy..................................................................................................221
Observáveis ...........................................................................................................222
Delegação de uma propriedade diferente de null......................................................223
Propriedades ou métodos?......................................................................................224
Resumo .................................................................................................................225
Capítulo 7 Null safety, reflexão e anotações........................................................................226
Tipos nullable ........................................................................................................227
Cast inteligente ......................................................................................................228
Acesso seguro de null.............................................................................................228
Operador force..................................................................................................230
Operador Elvis.......................................................................................................231
Casting seguro.......................................................................................................232
Opcionais..............................................................................................................232
Criando e devolvendo um Optional...................................................................233
Usando um Optional ........................................................................................233
Reflexão ................................................................................................................234
KClass..............................................................................................................235
Instanciação usando reflexão.............................................................................236
Construtores..........................................................................................................238
Instanciação com callBy ....................................................................................239
Objetos e companheiros.........................................................................................241
Propriedades úteis de KClass..................................................................................242
Funções e propriedades reflexivas...........................................................................243
Chamando uma função de modo reflexivo.........................................................245
Variantes declaradas e não declaradas................................................................245
10 Programando com Kotlin
Anotações..............................................................................................................246
Parâmetros de anotações...................................................................................247
Anotações-padrão..................................................................................................248
@JvmName......................................................................................................248
@JvmStatic.......................................................................................................249
@Throws .........................................................................................................249
@JvmOverloads................................................................................................251
Descoberta de anotações em tempo de execução.....................................................252
Resumo .................................................................................................................253
Capítulo 8 Genéricos..........................................................................................................254
Funções parametrizadas.........................................................................................254
Tipos parametrizados.............................................................................................256
Polimorfismo restrito..............................................................................................257
Limites superiores.............................................................................................257
Vários limites....................................................................................................258
Variância de tipos ..................................................................................................259
Invariância........................................................................................................259
Covariância ......................................................................................................261
Tipo de retorno covariante ................................................................................262
Contravariância ................................................................................................263
Visão geral sobre variância ................................................................................266
Tipo Nothing.........................................................................................................267
Projeção de tipos....................................................................................................268
Apagamento de tipo ...............................................................................................270
Reificação de tipos .................................................................................................274
Limites de tipos recursivos .....................................................................................276
Tipos de dados algébricos.......................................................................................279
Resumo .................................................................................................................284
Capítulo 9 Classes de dados................................................................................................285
Criação automática de getters e setters....................................................................287
Método copy..........................................................................................................288
toString automático................................................................................................293
Métodos hashCode e equals gerados para você .......................................................294
Declarações desestruturadas ..................................................................................297
Desestruturando tipos............................................................................................299
Regras para definição de classe de dados.................................................................300
Limitações.............................................................................................................303
Resumo .................................................................................................................3
Capítulo 10 Coleções..........................................................................................................304
Hierarquia de classes..............................................................................................304
Arrays....................................................................................................................313
Listas.....................................................................................................................323
Mapas ...................................................................................................................328
Conjuntos..............................................................................................................331
Visões somente de leitura .......................................................................................334
Acesso indexado ....................................................................................................335
Sequências.............................................................................................................336
Resumo .................................................................................................................341
Capítulo 11 Testes em Kotlin ..............................................................................................342
Introdução.............................................................................................................342
Selecionando uma spec ..........................................................................................343
Matchers................................................................................................................347
Matchers de string ............................................................................................347
Matchers de coleção..........................................................................................347
Matchers de ponto flutuante..............................................................................348
Esperando exceções..........................................................................................348
Combinando matchers......................................................................................349
Matchers personalizados...................................................................................350
Inspetores..............................................................................................................353
Interceptadores......................................................................................................355
Interceptador de caso de teste............................................................................355
Interceptador de spec ........................................................................................356
Config do projeto...................................................................................................357
Testes de propriedade.............................................................................................358
Especificando um gerador .................................................................................359
Testes orientados a tabela.......................................................................................360
Testando um código não determinístico.............................................................361
Tags, condições e config .........................................................................................363
Config ..............................................................................................................363
Condições ........................................................................................................364
Tags..................................................................................................................365
Recursos...........................................................................................................366
Resumo .................................................................................................................366
Capítulo 12 Microsserviços com Kotlin ................................................................................367
Definição...............................................................................................................368
Desvantagens.........................................................................................................372
Por que usar microsserviços? ..................................................................................373
12 Programando com Kotlin
Lagom ...................................................................................................................374
Definindo serviços .................................................................................................384
Implementando um serviço Lagom.........................................................................387
Resumo .................................................................................................................392
Capítulo 13 Concorrência ...................................................................................................393
Threads.................................................................................................................394
Bloqueio ...........................................................................................................395
Deadlocks e livelocks.............................................................................................401
O problema do jantar dos filósofos ....................................................................401
Executores.............................................................................................................403
Condições de concorrência.................................................................................... 404
Monitores........................................................................................................ 406
Locks .............................................................................................................. 408
Semáforos.........................................................................................................410
Coleções concorrentes....................................................................................... 414
Variáveis atômicas............................................................................................. 416
CountDownLatch............................................................................................. 417
Barreira cíclica ..................................................................................................419
E/S não bloqueante e programação assíncrona ...................................................421
Futures.............................................................................................................422
Resumo .................................................................................................................424Informações Técnicas
Nº de páginas: 424 Origem: Internacional Editora: Editora Novatec Idioma: Português Edição: 1ª Edição Ano: 2017 ISBN: 9788575226056 Encadernação: Brochura Autor: Stephen Samuel, Stefan Bocutiu - Informações
Avaliação técnica sobre o livro
