Buscar
Minha Conta

Atendimento(21) 2262-3111 / (21) 2262-3111

Programando 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.

VITRINE Os TOP de vendas !!

+-

Quem viu este produto , comprou

Quem viu este produto , também se interessou

  • Descrição
    Programando 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 LivroLivro Físico

    Especificações

    Sobre o AutorStephen 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écnicasSumá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 .................................................................................................................424

    Informaçõ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

Não encontrou seu produto? Deixe aqui sua Sugestão para novos produtos!

Enviar sugestão

Políticas

Informações

Atendimento

(21) 2262-3111

(21) 2262-3111

Pague com

Visa, mastercard, Diners, Boleto, American Express , VisaElectron, Discover , Elo , Maestro

Segurança e certificados

© 2015 Livraria Ciência Moderna Ltda - Avenida Rio Branco 156 – subsolo 126 – Centro – RJ – Cep:20040-003 | Cnpj :33.412.271/0001-03 | Inscrição Estadual: 85.853.198 *Os preços e condições de pagamento podem ser exclusivos para compras via internet , o que quer dizer que podem variar das lojas físicas. Vendas Sujeitas á analise e confirmação de dados.
VTEXOriginal Media

Olá! Seja Bem Vindo (a)!

Eu sou o Moderninho , o Mascote da Ciência Moderna Online!
Além de bonito, o novo site tem Minhas Dicas :) #ficaadica

A 1ª Dica é -> Deixe aqui seu contato para receber nossas
NOVIDADES, PROMOÇÕES E CUPONS DE DESCONTOS ;)

Navegue SEM Moderação!