Kotlin em ação
VITRINE Os Livros mais Vendidos !
De: R$ 79,99Por: R$ 79,90ou X de
Preço a vista: R$ 79,90
Economia de R$ 0,09Quem viu este produto , comprou
-
E-BOOK Aprendendo Java por meio de Conceitos e Exemplos (envio por e-mail)
*** ATENÇÃO ***
QUERO VER
PRODUTO DIGITAL PARA DOWNLOAD. RECEBERÁ O LINK E AS INSTRUÇÕES VIA E-MAIL EM ATÉ 2 DIAS ÚTEIS APÓS A CONFIRMAÇÃO DA COMPRA.
NÃO REALIZAMOS DEVOLUÇÕES DESTE PRODUTO.
ANTES DE COMPRAR VERIFIQUE SE SEU PC OU DISPOSITIVO ESTÁ APTO À BAIXAR O ARQUIVO. VEJA MAIS EM INFORMAÇÕES ABAIXO.
*CASO TENHA ESCOLHIDO JUNTO AO E-BOOK UM PRODUTO FÍSICO, O MESMO APARECERÁ NO CARRINHO COM O PRAZO DE ENTREGA E O CUSTO DO FRETE
NESTE CASO, A OPÇÃO ENVIO POR EMAIL DESAPARECERÁ , POREM NÃO SE PREOCUPE, POIS SEU E-BOOK SERÁ ENVIADO EM ATÉ 2 DIAS ÚTEIS PARA O SEU EMAIL .
... Ler mais + -
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: A Referência Completa 8ª edição
Em Java: A referência Completa, tradução da otitava edição, o autor best-seller de livros de programação Herb Schildt mostra o necessário para desenvolver, compilar, depurar e executar programas Java. Atualizado para a Plataforma Java, Edição Padrão 7 (Java SE7), o guia detalhado abrange toda linguagem Java, incluindo sua sintaxe, palavras-chave e princípios fundamentais da programação. Também serão encontradas no livro informações sobre elementos-chave da biblioteca Java API. JavaBeans, servlets, applets e Swing são estudados e exemplos reais demonstram o Java em ação.. Além disso, as novas funções do Java SE 7, como o try-with-resources, strings em switch, inferência de tipo com o operador diamante, NIO.2, e os Frameworks Fork/Join são discutidos em detalhes. ... 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 -
Prezado leitor, Escrevemos este livro para servir como recurso definitivo que lhe ajude a pôr-se pronto com a plataforma JavaFX™, usando a liberação 1.2 final. Cada um de nós é apaixonado pelo JavaFX, porque ele desempenha um papel chave na promessa longamente esperada da onipresente tecnologia Java™ de cliente rico, que ajudará a restaurar a sanidade ao desenvolvimento de aplicações de Internet. Também estamos empolgados com a produtividade melhorada do desenvolvedor que advém da sintaxe declarativa, das poderosas ligações, da programação funcional, e dos fantásticos gráficos de cena, no JavaFX. ... Ler mais +
QUERO VER -
O leitor encontrará neste livro uma abordagem detalhada do que é a Linguagem Java e como funciona o processo de definição e criação de objetos, tendo como foco principal os conceitos da Linguagem. Para acompanhar este livro, é necessário somente um editor de textos simples. Será abordado também o que é e quais são as plataformas Java existentes e tendências de uso da Linguagem no mercado comercial. Cada explicação será acompanhada por um exemplo para melhor assimilação e todos os conceitos serão abordados obedecendo uma ordem lógica que o autor considerou ser a melhor para o aprendizado dos leitores, baseado em suas experiências em sala de aula. ... Ler mais +
QUERO VER -
Java Fundamental - Aprenda como programar na linguagem Java usando boas práticas
VITRINE Os Livros mais Vendidos !
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 -
Ant em Ação - 2ª Edição de Java Development com Ant
Este livro é sobre o Ant, a ferramenta premiada de construção de Java. O Ant se tornou a peça central de tantos processos de construção de projetos por ser fácil de se usar, ser independente de plataforma e objetivar as necessidades dos projetos atuais de automação de testes e de distribuição. Desde seus primórdios, como aplicação auxiliar à compilação do Tomcat, o servidor web Java do Apache cresceu até se tornar uma ferramenta isolada, adotada pela comunidade Java e, ao fazê-lo, mudou as expectativas das pessoas com relação as suas ferramentas de desenvolvimento. ... Ler mais +
QUERO VER -
Idealizado com o intuito de oferecer os subsídios necessários para uma formação qualificada, esta obra aborda aspectos e funcionalidades da linguagem de programação Java, apresentando desde conceitos básicos da programação orientada a objetos, passando por análise e modelagem, até implementações de estruturas mais complexas como EJBs e Web Services. ... 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 -
Web Services SOAP em Java - 2ª Edição - Guia prático para o desenvolvimento de web services em Java
Este livro mostra como desenvolver web services SOAP de uma forma extremamente prática com o uso da linguagem de programação Java, por meio de exercícios passo a passo.
QUERO VER
O livro aborda tanto a criação de web services como a de seus consumidores, ou seja, web service clients. programação Java, por meio de exercícios passo a passo.
Com a leitura deste livro você: programação Java, por meio de exercícios passo a passo.
-Aprenderá a utilizar diversos recursos que auxiliam no desenvolvimento de web services, tais como o framework Apache Axis2 e as annotations Java, @WebService, @WebMethod e @WebParam.programação Java, por meio de exercícios passo a passo.
... Ler mais + -
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 -
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 -
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 -
*** ATENÇÃO ***
QUERO VER
PRODUTO DIGITAL PARA DOWNLOAD. RECEBERÁ O LINK E AS INSTRUÇÕES VIA E-MAIL EM ATÉ 2 DIAS ÚTEIS APÓS A CONFIRMAÇÃO DA COMPRA.
NÃO REALIZAMOS DEVOLUÇÕES DESTE PRODUTO.
ANTES DE COMPRAR VERIFIQUE SE SEU PC OU DISPOSITIVO ESTÁ APTO À BAIXAR O ARQUIVO. VEJA MAIS EM INFORMAÇÕES ABAIXO.
*CASO TENHA ESCOLHIDO JUNTO AO E-BOOK UM PRODUTO FÍSICO, O MESMO APARECERÁ NO CARRINHO COM O PRAZO DE ENTREGA E O CUSTO DO FRETE
NESTE CASO, A OPÇÃO ENVIO POR EMAIL DESAPARECERÁ , POREM NÃO SE PREOCUPE, POIS SEU E-BOOK SERÁ ENVIADO EM ATÉ 2 DIAS ÚTEIS PARA O SEU EMAIL .
... Ler mais + -
Programação Funcional para Desenvolvedores Java
O desenvolvimento de software atualmente está encampando a programação funcional (FP - Functional Programming), seja para escrever programas concorrentes, seja para gerenciar grandes volumes de dados. Onde isso deixa os desenvolvedores Java? Este livro conciso oferece uma introdução pragmática e acessível a FP para desenvolvedores Java ou qualquer pessoa que use uma linguagem orientada a objetos. ... 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 -
VITRINE Os Livros mais Vendidos !
Os desenvolvedores querem que seu trabalho seja feito – e quanto menos complicações houver, melhor. Programar com Kotlin significa ter menos complicações. A linguagem de programação Kotlin oferece uma sintaxe expressiva, um sistema de tipos robusto e intuitivo e o suporte de um ótimo conjunto de ferramentas, juntamente com uma interoperabilidade natural com códigos, bibliotecas e frameworks Java. A linguagem Kotlin pode ser compilada para bytecode Java, portanto você pode usá-la em todos os lugares em que Java é utilizada, inclusive no Android. Com um compilador eficiente e uma pequena biblioteca-padrão, Kotlin praticamente não impõe nenhum overhead em tempo de execução. ... Ler mais +
QUERO VER -
E-BOOK Java RESTful na Prática com JAX -RS (envio por e-mail)
*** ATENÇÃO ***
QUERO VER
PRODUTO DIGITAL PARA DOWNLOAD. RECEBERÁ O LINK E AS INSTRUÇÕES VIA E-MAIL EM ATÉ 2 DIAS ÚTEIS APÓS A CONFIRMAÇÃO DA COMPRA.
NÃO REALIZAMOS DEVOLUÇÕES DESTE PRODUTO.
ANTES DE COMPRAR VERIFIQUE SE SEU PC OU DISPOSITIVO ESTÁ APTO À BAIXAR O ARQUIVO. VEJA MAIS EM INFORMAÇÕES ABAIXO.
*CASO TENHA ESCOLHIDO JUNTO AO E-BOOK UM PRODUTO FÍSICO, O MESMO APARECERÁ NO CARRINHO COM O PRAZO DE ENTREGA E O CUSTO DO FRETE
NESTE CASO, A OPÇÃO ENVIO POR EMAIL DESAPARECERÁ , POREM NÃO SE PREOCUPE, POIS SEU E-BOOK SERÁ ENVIADO EM ATÉ 2 DIAS ÚTEIS PARA O SEU EMAIL .
... Ler mais +
Quem viu este produto , também se interessou
-
VITRINE Os Livros mais Vendidos !
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. ... Ler mais +
QUERO VER -
Independência Financeira: O guia para a libertação - Série Pai Rico
Independência Financeira desafia os paradigmas tradicionais de que a verdadeira segurança econômica está em um emprego estável. Na verdade, mostra como esta mentalidade é a causa de problemas, oscilações e insucessos financeiros. A grande questão não envolve seu pagamento garantido no final do mês, mas a proveniência de sua renda, ou seja, em que lado do quadrante CASHFLOW você está. Esta posição acarreta, também, uma forma de encarar a gestão de suas finanças e a aplicabilidade em sua vida pessoal; assim, não diz respeito apenas à correta administração de seu fluxo de caixa, mas a seus valores, sonhos e aspirações, e, em última instância, a quem você realmente é. ... Ler mais +
QUERO VER -
Competências Globais de RH - Agregando Valor Competitivo de Fora para Dentro
O pensamento do guru do RH Dave Ulrich – autor de RH de Dentro para Fora, Por que Trabalhamos e A Transformação do RH, todos publicados pela Bookman no Brasil – está de volta e traz consigo o melhor da discussão internacional sobre o assunto. Este livro aborda as melhores práticas de grandes empresas de todos os continentes, em um grande mosaico que projeta realidades regionais e universais. ... Ler mais +
QUERO VER -
Consultoria: Uma opção de vida e carreira
VITRINE Os Livros mais Vendidos !
A Consultoria como a arte de influenciar quem (corajosa e humildemente) se abre (e paga) para ser influenciado é uma definição que esclarece a dimensão das responsabilidades e exigências intelectuais, técnicas e morais imprescindíveis ao seu exercício. Por isso, falar, escrever e mesmo exercer, de fato e direito, o papel de consultor é prerrogativa outorgada a poucos, dentre os quais, meu mestre Luiz Concistré com méritos se inclui ... Ler mais +
QUERO VER -
Este livro vai lhe dar capacidades tremendas ao seu site Joomla! mesmo tendo algum treinamento relacionado a desenvolvimento ou não. Eu vou envolver tudo, desde a implantação de um servidor avançado até o uso de extensões sofisticadas para a criação de templates de primeira classe. Se você já tem alguma experiência anterior relacionada a desenvolvimento, a informação e os códigos-fonte citados aqui irão dar a você um entendimento avançado sobre como o sistema Joomla! opera de um nível de estrutura subindo até os seus recursos mais interessantes ... Ler mais +
QUERO VER -
Serviços de Redes em Servidores Linux
VITRINE Os Livros mais Vendidos !
O livro Serviços de Redes em Servidores Linux traz roteiros com o passo a passo detalhado de como instalar e configurar os principais serviços empregados em redes de computadores mediante o uso de servidores Linux baseados no Debian GNU/Linux e Ubuntu Server. Esse formato didático de apresentar conteúdo prático de maneira objetiva, sem tentar reinventar aquilo que já está consolidado em outras literaturas focadas na teoria, é característico do autor em suas publicações (livros e blog) e nas salas de aula. ... Ler mais +
QUERO VER -
Empresas Fora de Série: Gestão da mudança para criar valor, inovação e crescimento
VITRINE Os Livros mais Vendidos !
Esta obra oferece uma notável investigação das empresas do futuro e das habilidades de gestão necessárias para criar uma sinergia ímpar entre dois lados aparentemente díspares: o desempenho financeiro e a atenção à comunidade e às necessidades sociais. IBM, Banco Real, P & G, Cemex, Omron e outras companhias relatam como fizeram para progredir com a rapidez e a criatividade de empreendimentos menores, gerando resultados ao mesmo tempo em que contribuem para a esfera social. ... Ler mais +
QUERO VER -
Desenvolvendo aplicações com Xamarin
VITRINE Os Livros mais Vendidos !
Com uma abordagem bastante didática, este livro oferece ao leitor o conhecimento necessário para o desenvolvimento de aplicações móveis para Android, iOS e Windows Mobile utilizando o Xamarin e o Visual Studio 2017. ... Ler mais +
QUERO VER -
O Poder da Educação Financeira: Lições sobre dinheiro que não se aprendem na escola - Série Pai Rico
Este livro é sobre o poder que uma sólida educação financeira pode trazer a qualquer um, pobre ou rico, inteligente ou nem tanto, que viva em um país rico ou pobre. Com a internet, qualquer um, onde quer que esteja, pode lucrar com a imensa riqueza da economia mundial. Tudo que você precisa fazer é adotar novas ideias, levar realmente a sério sua educação financeira e entrar em ação. ... Ler mais +
QUERO VER -
Introdução ao HTML5 e CSS3: A Evolução da Web é destinado a qualquer um que tenha conhecimento básico de HTML e CSS. Se você só se aventurou há pouco tempo no mundo do HTML ou do CSS, ou se já tem desenvolvido sites há anos, sempre haverá coisas interessantes para você. ... Ler mais +
QUERO VER -
Cabo Apple 30 pinos para USB - MA591BZ/C
Este cabo USB 2.0 conecta seu iPod, iPhone ou iPad (diretamente ou usando o dock) à porta USB do computador para carregá-lo e sincronizá-lo de forma eficiente ou ao Carregador USB da Apple para um carregamento prático na tomada elétrica. ... Ler mais +
QUERO VER -
VITRINE Os Livros mais Vendidos !
Adquira todas as habilidades necessárias para o Exame MCTS 70-643. Em sua 2ª edição, atualizada para o Windows Server 2008 R2, este kit de treinamento oficial da Microsoft permite que você aprenda no seu próprio ritmo com diversas lições e resumos que cobrem inteiramente cada objetivo do exame. ... Ler mais +
QUERO VER -
Ciência da Computação - Uma Visão Abrangente - 11ª Edição
VITRINE Os Livros mais Vendidos !
Conhecido por oferecer uma cobertura ampla e uma clara exposição do vasto e dinâmico campo da ciência da computação, o livro mais conhecido da área chega à décima primeira edição atualizado e ampliado para incluir as tecnologias mais atuais ... Ler mais +
QUERO VER -
Desenvolvimento de aplicativos móveis com Xamarin é um guia prático de Xamarin.Forms e uma referência multiplataforma para a construção de aplicativos nativos do Android, iOS e Windows Phone com o uso da linguagem C# e do ambiente .NET. Este livro explica como usar o Xamarin.Forms, o Xamarin.Android e o Xamarin.iOS na construção de aplicativos empresariais para seus clientes e de aplicativos comerciais para o Google Play e a iTunes App Store.
QUERO VER
Aprenda como se beneficiar do Xamarin.Forms no desenvolvimento multiplataforma usando páginas, leiautes, visões, controles e padrões de design comuns nas UI. Combine-os com UIs específicas de plataformas para criar uma experiência de usuário móvel visualmente surpreendente e altamente interativa. ... Ler mais + -
O Guia de Investimentos: Aprenda a ganhar dinheiro investindo como os ricos - Série Pai Rico
VITRINE Os Livros mais Vendidos !
Em O Guia de Investimentos você verá como lidar com as questões de insuficiência de dinheiro, como ganhá-lo e aprender a investir. ... Ler mais +
QUERO VER -
Criando Vídeos para o Youtube Para Leigos
VITRINE Os Livros mais Vendidos !
Olá, futuros youtubers! Bem-vindos ao Fazendo Vídeos do YouTube — o livro que cumpre exatamente o que informa na capa. Você deseja ser a próxima estrela do YouTube? Sempre que assiste a vídeos no YouTube você pensa: “Eu poderia fazer isso!” ou “Quero muito fazer isso!” Bem, você escolheu o livro certo. Milhões de pessoas estão carregando seus vídeos no YouTube — e tem muito espaço para você também. Você só precisa transformar suas ideias criativas em vídeos. Vai ser muito divertido e irei guiá-lo em cada etapa. Este livro mostra como fazer vídeos que você pode compartilhar online. Grave com um telefone ou câmera, edite seus clipes, adicione efeitos e comece a ganhar seus fãs. ... Ler mais +
QUERO VER -
VITRINE Os Livros mais Vendidos !
Aplicações web têm um histórico extenso de vulnerabilidades, que têm sido exploradas pelos hackers. A lista de ataques conhecidos é extensa, envolvendo Cross-site Scripting, SQL Injection, unrestricted file upload, Code Injection, Command Injecion, Remote/Local File Inclusion e Cross-site Request Forgery, somente para citar alguns. ... Ler mais +
QUERO VER -
Android - Do Básico ao Avançado
A plataforma de desenvolvimento Android, apesar de relativamente nova, mostra-se robusta e estável para o desenvolvimento dos mais diversos tipos de aplicações móveis. Este livro apresenta os principais recursos utilizados no desenvolvimento de aplicações Android, desde o processo básico de preparação do ambiente e desenvolvimento do primeiro aplicativo, abordando também os principais componentes visuais da plataforma e seu modelo de tratamento de eventos, avançando para a persistência de dados, utilizando o tradicional SQLite e os métodos alternativos de persistência (arquivos, SharedPreference, entre outros). ... Ler mais +
QUERO VER -
VITRINE Os Livros mais Vendidos !
O Android é o sistema operacional móvel mais utilizado no mundo, e o objetivo deste livro é apresentar ao leitor os conceitos essenciais do desenvolvimento de aplicativos para Android utilizando a linguagem de programação Kotlin, por meio de uma explicação simples e prática. ... Ler mais +
QUERO VER -
Carregador Portátil Universal Essential 2500mAh Branco - Geonav ES25W
O Carregador Portátil Universal Geonav Essential 2500mAh é ideal para levar no dia a dia, viagens e assim recarregar o seu smartphone quando precisar. Por ser extremamente compacto e leve permite levá-lo no bolso. Pode ser utilizado enquanto você está na rua, na academia, no parque ou até curtindo um happy hour. Características: Autonomia: Até 1 recarga por ciclo (considerando como base smartphone com bateria de até 1500mAh) Vida útil: 300 ciclos podendo reduzir sua autonomia ao longo da vida. Conectividade: Entrada micro USB e saída USB. Capacidade Total 2500mAh. ... Ler mais +
QUERO VER -
Desenho para Arquitetos - 2ª Edição
VITRINE Os Livros mais Vendidos !
Destinado a arquitetos e projetistas, desenhistas, artistas em geral, ilustradores, professores e estudantes, Desenho para Arquitetos é uma ferramenta e? caz e de valor inestimável, demonstrando conceitos e técnicas por meio de um formato visualmente estimulante. ... Ler mais +
QUERO VER -
Microsserviços prontos para a produção
VITRINE Os Livros mais Vendidos !
Um dos maiores desafios para as empresas que adotaram a arquitetura de microsserviços é a falta de padronização de arquitetura – operacional e organizacional. Depois de dividir uma aplicação monolítica ou construir um ecossistema de microsserviços a partir do zero, muitos engenheiros se perguntam o que vem a seguir. Neste livro prático, a autora Susan Fowler apresenta com profundidade um conjunto de padrões de microsserviço, aproveitando sua experiência de padronização de mais de mil microsserviços do Uber. Você aprenderá a projetar microsserviços que são estáveis, confiáveis, escaláveis, tolerantes a falhas, de alto desempenho, monitorados, documentados e preparados para qualquer catástrofe. ... Ler mais +
QUERO VER
- DescriçãoKotlin em ação
Os desenvolvedores querem que seu trabalho seja feito – e quanto menos complicações houver, melhor. Programar com Kotlin significa ter menos complicações. A linguagem de programação Kotlin oferece uma sintaxe expressiva, um sistema de tipos robusto e intuitivo e o suporte de um ótimo conjunto de ferramentas, juntamente com uma interoperabilidade natural com códigos, bibliotecas e frameworks Java. A linguagem Kotlin pode ser compilada para bytecode Java, portanto você pode usá-la em todos os lugares em que Java é utilizada, inclusive no Android. Com um compilador eficiente e uma pequena biblioteca-padrão, Kotlin praticamente não impõe nenhum overhead em tempo de execução.
Kotlin em ação ensina você a usar a linguagem Kotlin em aplicações com qualidade compatível para ambientes de produção. Escrito para desenvolvedores com experiência em Java, este livro repleto de exemplos vai além da maioria dos livros sobre linguagens de programação, incluindo tópicos interessantes como construção de DSLs com sintaxe de linguagem natural. Os autores são desenvolvedores do núcleo de Kotlin, portanto você poderá estar certo de que mesmo os detalhes mais intrincados serão apresentados com extrema precisão.
O que o livro contém:
programação funcional na JVM;
como escrever um código claro e idiomático;
como combinar Kotlin e Java;
linguagens de domínio específico. - Sobre o Autor
- Especificação
Características
Tipo de Livro Livro Físico Especificações
Sobre o Autor Dmitry Jemerov
Dmitry Jemerov trabalha na JetBrains desde 2003 e participou do desenvolvimento de muitos produtos, inclusive IntelliJ IDEA, PyCharm e WebStorm. Foi um dos primeiros colaboradores de Kotlin e criou a versão inicial do gerador de bytecode JVM para Kotlin, além de ter feito diversas apresentações sobre Kotlin em eventos pelo mundo. Atualmente ele lidera a equipe que trabalha no plugin do IntelliJ IDEA para Kotlin.
Svetlana Isakova
Svetlana Isakova faz parte da equipe de Kotlin desde 2011. Trabalhou nos subsistemas de inferência de tipos e resolução de sobrecargas do compilador. Atualmente é evangelista técnica e faz palestras sobre Kotlin em conferências, além de trabalhar no curso online de Kotlin.Informações Técnicas Sumário
Apresentação........................................................................................................................... 13
Prefácio ................................................................................................................................... 15
Agradecimentos....................................................................................................................... 17
Sobre este livro ........................................................................................................................ 19
Sobre os autores.......................................................................................................................23
Sobre a ilustração da capa........................................................................................................24
Parte I Introdução à Kotlin.......................................................................... 25
Capítulo 1 Kotlin: o que é e por quê........................................................................................26
1.1 Uma amostra de Kotlin............................................................................................ 26
1.2 Principais características de Kotlin........................................................................... 28
1.2.1 Plataformas visadas: lado do servidor, Android, qualquer lugar em que Java seja
executada........................................................................................................... 28
1.2.2 Tipagem estática ............................................................................................. 29
1.2.3 Programação funcional e orientada a objetos.................................................... 30
1.2.4 Código gratuito e aberto.................................................................................. 32
1.3 Aplicações Kotlin .................................................................................................... 32
1.3.1 Kotlin do lado do servidor ............................................................................... 32
1.3.2 Kotlin no Android........................................................................................... 34
1.4 Filosofia de Kotlin ................................................................................................... 36
1.4.1 Pragmática ...................................................................................................... 36
1.4.2 Concisa........................................................................................................... 37
1.4.3 Segura............................................................................................................. 38
1.4.4 Possibilita interoperabilidade............................................................................ 39
1.5 Usando as ferramentas de Kotlin.............................................................................. 40
1.5.1 Compilando código Kotlin............................................................................... 41
6 Kotlin em Ação
1.5.2 Plug-in para IntelliJ IDEA e Android Studio ..................................................... 42
1.5.3 Shell interativo ................................................................................................ 42
1.5.4 Plug-in para Eclipse ......................................................................................... 42
1.5.5 Playground online ........................................................................................... 42
1.5.6 Conversor de Java para Kotlin.......................................................................... 43
1.6 Resumo................................................................................................................... 43
Capítulo 2 Básico sobre Kotlin ................................................................................................45
2.1 Elementos básicos: funções e variáveis ..................................................................... 45
2.1.1 Hello, world! ................................................................................................... 46
2.1.3. Variáveis ........................................................................................................ 49
2.1.4 Formatação de strings simplificada: templates de string .................................... 51
2.2 Classes e propriedades ............................................................................................ 52
2.2.1 Propriedades................................................................................................... 53
2.2.2 Métodos de acesso personalizados................................................................... 55
2.2.3 Layout do código-fonte de Kotlin: diretórios e pacotes ..................................... 56
2.3 Representando e tratando opções: enums e “when”.................................................. 59
2.3.1 Declarando classes enum................................................................................. 59
2.3.2 Usando “when” para lidar com classes enum ................................................... 60
2.3.3 Usando when com objetos arbitrários.............................................................. 62
2.3.4 Usando “when” sem argumentos ..................................................................... 63
2.3.Casts inteligentes: combinando verificações de tipo e casts.................................. 64
2.3.6 Refatoração: substituindo if por when.............................................................. 66
2.3.7 Blocos como ramos de if e de when.................................................................. 68
2.4 Iterando por itens: laços while e for.......................................................................... 69
2.4.1 Laço while....................................................................................................... 69
2.4.2 Iterando por números: intervalos e progressões ................................................ 69
2.4.3 Iterando por mapas ......................................................................................... 71
2.4.4 Usando in para verificar a pertinência a uma coleção ou um intervalo............... 73
2.5 Exceções em Kotlin................................................................................................. 75
2.5.1 try, catch e finally ............................................................................................ 76
2.5.2 try como uma expressão.................................................................................. 77
2.6 Resumo .................................................................................................................. 79
Capítulo 3 Definindo e chamando funções..............................................................................80
3.1 Criando coleções em Kotlin ..................................................................................... 80
3.2 Facilitando a chamada de funções............................................................................ 82
3.2.1 Argumentos nomeados.................................................................................... 83
3.2.2 Valores default de parâmetros.......................................................................... 84
3.2.3 Livrando-se das classes utilitárias estáticas: funções de nível superior e propriedades. 86
3.3 Adicionando métodos às classes de outras pessoas: funções de extensão e propriedades...89
3.3.1 Importações e funções de extensão .................................................................. 91
3.3.2 Chamando funções de extensão a partir de Java............................................... 92
3.3.3 Funções utilitárias como extensões.................................................................. 92
3.3.4 Sem sobrescritas para funções de extensão....................................................... 93
3.3.5 Propriedades de extensão ................................................................................ 95
3.4 Trabalhando com coleções: varargs, chamadas infixas e suporte de biblioteca ........... 97
3.4.1 Estendendo a API de coleções de Java............................................................... 97
3.4.2 Varargs: funções que aceitam um número arbitrário de argumentos.................. 98
3.4.3 Trabalhando com pares: chamadas infixas e declarações desestruturantes........ 99
3.5 Trabalhando com strings e expressões regulares......................................................101
3.5.1 Separando strings...........................................................................................101
3.5.2 Expressões regulares e strings com aspas triplas.................................................. 102
3.5.3 Strings multilinha com aspas triplas............................................................... 104
3.6 Deixando seu código organizado: funções locais e extensões.................................. 106
3.7 Resumo................................................................................................................. 109
Capítulo 4 Classes, objetos e interfaces................................................................................. 110
4.1 Definindo hierarquias de classes .............................................................................111
4.1.1 Interfaces em Kotlin........................................................................................111
4.1.2 Modificadores open, final e abstract: final por padrão......................................114
4.1.3 Modificadores de visibilidade: public por padrão.............................................117
4.1.4 Classes internas e aninhadas: aninhadas por padrão....................................... 120
4.1.5 Classes seladas: definindo hierarquias de classe restritas................................. 122
4.2 Declarando uma classe com construtores ou propriedades não triviais.................... 124
4.2.1 Inicializando classes: construtor primário e blocos de inicialização................. 124
4.2.2 Construtores secundários: inicializando a superclasse de modos diferentes..... 128
4.2.3 Implementando propriedades declaradas em interfaces .................................. 130
4.2.4 Acessando um backing field a partir de um getter ou de um setter................... 132
4.2.5 Alterando a visibilidade de um método de acesso ........................................... 134
4.3 Métodos gerados pelo compilador: classes de dados e delegação de classe ............... 135
4.3.1 Métodos universais de objetos ....................................................................... 136
4.3.2 Classes de dados: implementações de métodos universais gerados automaticamente 139
4.3.3 Delegação de classe: usando a palavra reservada “by” .....................................141
4.4 A palavra reservada “object”: declarando uma classe e criando uma instância ao mesmo
tempo.............................................................................................................. 144
4.4.1 Declarações de objetos: simplificando os singletons........................................ 144
4.4.2 Objetos companheiros: um local para métodos de fábrica e membros estáticos.147
4.4.3 Objetos companheiros como objetos comuns................................................. 150
4.4.4 Expressões de objeto: uma nova versão das classes internas anônimas............. 153
4.5 Resumo................................................................................................................. 155
Capítulo 5 Programação com lambdas.................................................................................. 156
5.1 Expressões lambda e referências a membros........................................................... 156
5.1.1 Introdução às lambdas: blocos de código como parâmetros de função............. 157
5.1.2 Lambdas e coleções....................................................................................... 158
5.1.3 Sintaxe das expressões lambda ...................................................................... 160
5.1.4 Acessando variáveis no escopo ....................................................................... 164
5.1.5 Referências a membros .................................................................................. 167
5.2 APIs funcionais para coleções.................................................................................169
5.2.1 Funções essenciais: filter e map.......................................................................169
5.2.2 all, any, count e find: aplicando um predicado a uma coleção ..........................172
5.2.3 groupBy: convertendo uma lista em um mapa de grupos.................................173
5.2.4 flatMap e flatten: processando elementos em coleções aninhadas.....................174
5.3 Operação lazy em coleções: sequências...................................................................176
5.3.1 Executando operações em sequências: operações intermediárias e terminais....178
5.3.2 Criando sequências........................................................................................181
5.4 Usando interfaces funcionais de Java...................................................................... 182
5.4.1 Passando uma lambda como parâmetro a um método Java ............................. 183
5.4.2 Construtores SAM: conversão explícita de lambdas em interfaces funcionais.. 186
5.5 Lambdas com receptores: “with” e “apply” ............................................................ 188
5.5.1 Função “with”............................................................................................... 188
5.5.2 Função apply................................................................................................. 191
5.6 Resumo................................................................................................................. 193
Capítulo 6 Sistema de tipos de Kotlin.................................................................................... 194
6.1 Nulidade ............................................................................................................... 194
6.1.1 Tipos nullable................................................................................................ 195
6.1.2 O significado de tipos.................................................................................... 197
6.1.3 Operador de chamada segura: “?.” ................................................................. 199
6.1.4 O operador Elvis: “?:” .................................................................................... 201
6.1.5 Casts seguros: “as?”....................................................................................... 203
6.1.6 Asserções de não null: “!!” ............................................................................. 204
6.1.7 A função “let” ............................................................................................... 207
6.1.8 Propriedades iniciadas tardiamente................................................................ 209
6.1.9 Extensões para tipos nullable..........................................................................210
6.1.10 Nulidade em parâmetros de tipo .................................................................. 213
6.1.11 Nulidade e Java.............................................................................................214
6.2 Tipos primitivos e outros tipos básicos................................................................... 219
6.2.1 Tipos primitivos: Int, Boolean e outros .......................................................... 219
6.2.2 Tipos primitivos nullable: Int?, Boolean? e outros........................................... 221
6.2.3 Conversões de números................................................................................. 222
6.2.4 Any e Any?: os tipos raiz................................................................................ 224
6.2.5 O tipo Unit: o “void” de Kotlin...................................................................... 225
6.2.6 Tipo Nothing: “Essa função jamais retorna” .................................................. 227
6.3 Coleções e arrays................................................................................................... 228
6.3.1 Nulidade e coleções....................................................................................... 228
6.3.2 Coleções somente para leitura e coleções mutáveis ......................................... 231
6.3.3 Coleções de Kotlin e Java............................................................................... 233
6.3.4 Coleções como tipos de plataforma................................................................ 236
6.3.5 Arrays de objetos e de tipos primitivos........................................................... 238
6.4 Resumo..................................................................................................................241
Parte II Adotando Kotlin ........................................................................... 243
Capítulo 7 Sobrecarga de operadores e outras convenções....................................................244
7.1 Sobrecarregando operadores aritméticos..................................................................245
7.1.1 Sobrecarregando operações aritméticas binárias ..............................................245
7.1.2 Sobrecarregando operadores de atribuição compostos..................................... 249
7.1.3 Sobrecarregando operadores unários.............................................................. 251
7.2 Sobrecarregando operadores de comparação........................................................... 252
7.2.1 Operadores de igualdade: “equals”................................................................. 252
7.2.2 Operadores de ordenação: compareTo............................................................ 254
7.3 Convenções usadas em coleções e intervalos........................................................... 256
7.3.1 Acessando elementos pelo índice: “get” e “set” ............................................... 256
7.3.2 A convenção “in”........................................................................................... 258
7.3.3 Convenção rangeTo ....................................................................................... 259
7.3.4 Convenção iterator para o laço for.................................................................. 260
7.4 Declarações desestruturantes e funções componentes............................................. 262
7.4.1 Declarações desestruturantes e laços .............................................................. 264
7.5 Reutilizando a lógica dos métodos de acesso às propriedades: propriedades delegadas 265
7.5.1 Propriedades delegadas: o básico.................................................................... 265
7.5.2 Usando propriedades delegadas: inicialização lazy e “by lazy()”...................... 267
7.5.3 Implementando propriedades delegadas......................................................... 268
7.5.4 Regras para tradução de propriedades delegadas............................................. 273
7.5.5 Armazenando valores de propriedades em um mapa........................................274
7.5.6 Propriedades delegadas em frameworks...........................................................276
7.6 Resumo................................................................................................................. 278
Capítulo 8 Funções de alta ordem: lambdas como parâmetros e valores de retorno................ 279
8.1 Declarando funções de alta ordem ......................................................................... 279
8.1.1 Tipos função ................................................................................................. 280
8.1.2 Chamando funções passadas como argumentos............................................. 282
8.1.3 Usando tipos função a partir de Java.............................................................. 284
8.1.4 Valores default e null para parâmetros com tipos função................................. 285
10 Kotlin em Ação
8.1.5 Devolvendo funções a partir de funções......................................................... 288
8.1.6 Removendo duplicações usando lambdas....................................................... 291
8.2 Funções inline: eliminando o overhead das lambdas .............................................. 293
8.2.1 Como o inline funciona................................................................................. 294
8.2.2 Restrições para funções inline ....................................................................... 296
8.2.3 Usando operações de coleção como inline...................................................... 297
8.2.4 Decidindo quando as funções devem ser declaradas como inline .................... 299
8.2.5 Usando lambdas inline para gerenciamento de recursos................................. 300
8.3 Fluxo de controle em funções de alta ordem........................................................... 302
8.3.1 Instruções return em lambdas: retornando de uma função que a engloba........ 302
8.3.2 Retornando de lambdas: return com um rótulo.............................................. 303
8.3.3 Funções anônimas: retornos locais por padrão............................................... 305
8.4 Resumo................................................................................................................. 307
Capítulo 9 Genéricos............................................................................................................ 308
9.1 Parâmetros de tipo para genéricos.......................................................................... 309
9.1.1 Funções e propriedades genéricas....................................................................310
9.1.2 Declarando classes genéricas...........................................................................312
9.1.3 Restrições para parâmetros de tipo..................................................................313
9.1.4 Fazendo com que os parâmetros de tipo sejam não null ...................................315
9.2 Genéricos em tempo de execução: parâmetros de tipo apagados e reificados.............317
9.2.1 Genéricos em tempo de execução: verificações de tipo e casts..........................317
9.2.2 Declarando funções com parâmetros de tipo reificados .................................. 320
9.2.3 Substituindo referências a classes por parâmetros de tipo reificados................ 323
9.2.4 Restrições para os parâmetros de tipo reificados..............................................324
9.3 Variância: genéricos e subtipagem.......................................................................... 325
9.3.1 Por que a variância existe: passando um argumento para uma função ............. 326
9.3.2 Classes, tipos e subtipos................................................................................ 327
9.3.3 Covariância: relação de subtipagem preservada .............................................. 329
9.3.4 Contravariância: relação inversa de subtipagem.............................................. 334
9.3.5 Variância no local de uso: especificando a variância nas ocorrências dos tipos 337
9.3.6 Projeção com asterisco: usando * no lugar de um argumento de tipo ................341
9.4 Resumo................................................................................................................. 346
Capítulo 10 Anotações e reflexão..........................................................................................348
10.1 Declarando e aplicando anotações........................................................................ 349
10.1.1 Aplicando anotações.................................................................................... 349
10.1.2 Alvos das anotações..................................................................................... 350
10.1.3 Usando anotações para personalizar a serialização de JSON ......................... 353
10.1.4 Declarando anotações.................................................................................. 356
10.1.5 Meta-anotações: controlando o processamento de uma anotação .................. 357
10.1.6 Classes como parâmetros de anotações ........................................................ 358
10.1.7 Classes genéricas como parâmetros de anotações.......................................... 360
10.2 Reflexão: introspecção de objetos Kotlin em tempo de execução ........................... 361
10.2.1 A API de reflexão Kotlin: KClass, KCallable, KFunction e KProperty ............ 362
10.2.2 Implementando a serialização de objetos usando reflexão............................. 366
10.2.3 Personalizando a serialização com anotações ............................................... 368
10.2.4 Parsing de JSON e desserialização de objetos................................................ 372
10.2.5 Último passo da desserialização: callBy() e a criação de objetos usando reflexão. 377
10.3 Resumo............................................................................................................... 382
Capítulo 11 Construção de DSLs............................................................................................ 383
11.1 De APIs a DSLs.................................................................................................... 383
11.1.1 O conceito de linguagens de domínio específico............................................ 385
11.1.2 DSLs internas.............................................................................................. 387
11.1.3 Estrutura das DSLs...................................................................................... 388
11.1.4 Construindo HTML com uma DSL interna .................................................. 389
11.2 Construindo APIs estruturadas: lambdas com receptores em DSLs........................391
11.2.1 Lambdas com receptores e tipos função de extensão......................................391
11.2.2 Usando lambdas com receptores em builders de HTML ............................... 396
11.2.3 Builders de Kotlin: possibilitando abstração e reutilização ............................ 401
11.3 Blocos aninhados de modo mais flexível usando a convenção “invoke” ................. 404
11.3.1 A convenção “invoke”: objetos callable como funções................................... 404
11.3.2 A convenção “invoke” e os tipos funcionais.................................................. 405
11.3.3 A convenção “invoke” em DSLs: declarando dependências no Gradle ........... 407
11.4 DSLs em Kotlin na prática.................................................................................... 409
11.4.1 Encadeando chamadas infixas: “should” em frameworks de teste.................. 409
11.4.2 Definindo extensões em tipos primitivos: tratando datas ...............................412
11.4.3 Funções de extensão membros: DSL interna para SQL...................................413
11.4.4 Anko: criando UIs para Android dinamicamente ...........................................417
11.5 Resumo................................................................................................................419
Apêndice A Construindo projetos em Kotlin .......................................................................... 420
A.1 Construção de código Kotlin com o Gradle ........................................................... 420
A.1.1 Construindo aplicações Android em Kotlin com o Gradle ...............................421
A.1.2 Construindo projetos que usam processamento de anotações......................... 422
A.2 Construção de projetos Kotlin com o Maven ......................................................... 423
A.3 Construção de código Kotlin com o Ant................................................................ 423
Apêndice B Documentação de código Kotlin ......................................................................... 425
B.1 Escrevendo comentários para documentação de Kotlin........................................... 425
B.2 Gerando a documentação da API........................................................................... 427
12 Kotlin em Ação
Apêndice C Ecossistema de Kotlin ......................................................................................... 429
C.1 Testes................................................................................................................... 429
C.2 Injeção de dependências ....................................................................................... 430
C.3 Serialização de JSON............................................................................................ 430
C.4 Clientes HTTP ..................................................................................................... 430
C.5 Aplicações web......................................................................................................431
C.6 Acesso a banco de dados........................................................................................431
C.7 Utilitários e estruturas de dados............................................................................ 432
C.8 Programação para desktop.................................................................................... 432Informações Técnicas
Nº de páginas: 432 Origem: Internacional Editora: Editora Novatec Idioma: Português Edição: 1ª Edição Ano: 2017 ISBN: 9788575226100 Encadernação: Brochura Autor: Dmitry Jemerov, Svetlana Isakova - Informações
Avaliação técnica sobre o livro
