Para alterar o documento padrão, edite o arquivo “blank.fb2” manualmente.
Prefácio 13
Java SE5 e SE6 14
Obrigado 14
Capítulo 1: Introdução aos Objetos 17
Desenvolvimento de abstração 18
O objeto tem interface 20
A instalação presta serviços 22
Implementação oculta 23
Reutilização de implementação 24
Herança 25
Objetos intercambiáveis e polimorfismo 29
Hierarquia de raiz única 33
Recipientes 33
Tipos parametrizados 35
Criação, uso de objetos e seu tempo de vida 36
Tratamento de Exceções: Lidando com Erros 38
Execução paralela 38
Java e a Internet 39
Capítulo 2. Tudo é um objeto 48
Todos os objetos devem ser criados explicitamente 49
Os objetos nunca precisam ser excluídos 53
Criando Novos Tipos de Dados 54
Métodos, argumentos e valores de retorno 56
Criando um programa Java 58
Palavra-chave estática 60
Nosso primeiro programa Java 61
Comentários e documentação integrada 64
Estilo de design do programa 70
Capítulo 3. Operadores 71
Comandos de impressão simples 71
Operadores Java 72
Literais 82
Java não possui sizeof() 92
Currículo 100
Capítulo 4. Estruturas de controle 101
Sintaxe foreach 105
quebrar e continuar 108
Comando goto 109 ruim
Resumo 115
Capítulo 5: Inicialização e Encerramento 116
O construtor garante a inicialização 116
Sobrecarga de Método 118
Limpeza: finalização e coleta de lixo 130
Inicializando Membros da Classe 137
Inicialização pelo construtor 140
Inicializando matrizes 146
Resumo 151
Capítulo 6. Controle de Acesso 152
Pacote como um módulo de biblioteca 153
Especificadores de acesso Java 159
Interface e implementação 163
Acesso a 164 aulas
Resumo 167
Capítulo 7: Reutilizando Classes 169
Sintaxe de Composição 170
Sintaxe de Herança 172
Delegação 176
Combinando Composição e Herança 178
Composição versus herança 184
Conversão de tipo ascendente 186
Palavra-chave final 188
Resumo 197
Capítulo 8. Polimorfismo 198
Novamente sobre transformação ascendente. . . > 199
Recursos 201
Construtores e polimorfismo 208
Covariância do tipo de retorno 216
Desenvolvimento com Herança 217
Currículo 220
Capítulo 9. Interfaces 221
Classes e métodos abstratos 221
Interfaces 224
Separando a Interface da Implementação 227
Estendendo uma Interface por meio de Herança 233
Interfaces como meio de adaptação 236
Interfaces Aninhadas 239
Interfaces e fábricas 242
Currículo 244
Capítulo 10. Classes Internas 245
Criando Classes Internas 245
Comunicação com classe externa 246
Construções.esta e.nova 248
Classes Internas e Conversão Ascendente 249
Classes internas sem nome 253
Classes internas: por quê? 261
Herança de classes internas 272
É possível substituir uma classe interna? 272
Aulas internas locais 274
Currículo 276
Capítulo 11. Coleções de Objetos 277
Contêineres parametrizados e digitados 277
Conceitos Básicos 280
Adicionando grupos de elementos 281
Iteradores 288
Conjunto 294
Fila 298
Fila de Prioridade 299
Coleção e Iterador 301
Idioma do adaptador de método 306
Resumo 309
Capítulo 12. Tratamento de Erros e Exceções 310
Principais exceções 310
Capturando exceções 312
Criando suas próprias exceções 314
Especificações de Exceção 319
Capturando exceções arbitrárias 320
Exceções padrão do Java 328
Terminando com finalmente 330
Usando finalmente com retorno 334
Limitações ao usar exceções 336
Construtores 339
Identificando exceções 343
Soluções alternativas 344
Currículo 351
Capítulo 13 Informações de Tipo 352
A necessidade de inferência de tipo dinâmico (RTTI) 352
Cadastro de fábricas 372
Reflexão: Informações de Classe Dinâmica 376
Intermediários Dinâmicos 380
Objetos com estado indefinido 384
Interfaces e informações de tipo 390
Currículo 394
Capítulo 14. Parametrização 397
Parametrização simples 398
Interfaces 404 parametrizadas
Métodos Parametrizados 407
Construindo modelos complexos 419
Restrições 437
Metacaracteres 440
Currículo 452
Capítulo 15. Matrizes 454
Recursos de matrizes 454
Matriz como objeto 456
Matriz de retorno 458
Matrizes multidimensionais 460
Matrizes e parametrização 463
Criando Dados de Teste 465
Criando matrizes usando geradores 470
Kit de ferramentas de suporte do Arrays 474
Currículo 482
Capítulo 16: Sistema de E/S Java 483
Arquivo de Classe 484
Entrada e saída 489
Adicionando atributos e interfaces 491
Classes de Leitor e Escritor 494
RandomAccessFile: sozinho 497
Uso Típico de Fluxos de E/S 498
Leitores e gravadores de arquivos 505
E/S padrão 507
Nova E/S (nio) 510
Compressão de dados 531
Serialização de Objeto 536
Preferências 553
Currículo 555
Capítulo 17. Execução Paralela 557
Classe do tópico 559
Artistas 561
Compartilhando recursos 578
Comunicação entre threads 598
Impasse 602
Novos componentes de biblioteca 607
Trava de contagem regressiva 607
Barreira Cíclica 609
PriorityBlockingQueue 614
Semáforos 619
Modelagem 624
Currículo 629
Índice alfabético 631
Introdução aos objetos
Dissecamos a natureza, transformamo-la em conceitos e atribuímos-lhes significado da mesma forma que o fazemos de muitas maneiras, porque todos somos partes num acordo que é válido numa sociedade vinculada pela fala e que está consagrado na estrutura da linguagem. Não podemos comunicar de forma alguma, exceto concordando com a organização e classificação dos dados estabelecida por este acordo.
Benjamin Lee Worf (1897-1941)
Devemos o surgimento da revolução do computador à máquina. Portanto, nossas linguagens de programação tentam estar mais próximas desta máquina.
Mas, ao mesmo tempo, os computadores não são tanto mecanismos, mas meios de amplificar pensamentos (“bicicletas para a mente”, como Steve Jobe gosta de dizer), e outro meio de autoexpressão. Como resultado, as ferramentas de programação estão menos voltadas para as máquinas e mais para as nossas mentes, bem como para outras formas de expressão das aspirações humanas, como a literatura, a pintura, a escultura, a animação e o cinema. A programação orientada a objetos (OOP) faz parte de tornar o computador um meio de autoexpressão.
Este capítulo apresentará os fundamentos da OOP, incluindo uma discussão sobre técnicas básicas de desenvolvimento de programas. Ele, e o livro em geral, pressupõem que você tenha experiência em programação em uma linguagem processual, não necessariamente C. Se você acha que antes de ler este livro não tem conhecimento de programação e sintaxe C, aproveite o seminário multimídia Pensando em C. que pode ser baixado do site
Muito provavelmente, não me enganarei ao supor que a maioria dos que estudaram Java começaram a fazer isso com a ajuda do famoso livro de Bruce Eckel: "Pensando em Java", conhecido na edição russa como "Filosofia Java". Infelizmente, a versão eletrônica mais difundida (em russo) é a 2ª edição deste livro, baseada na versão Java 1.1, que há muito perdeu sua relevância. As inovações que surgiram nas sucessivas versões do Java (e especialmente no Java SE5) foram muito significativas, o que levou a uma grande revisão do livro em sua quarta edição (cuja tradução foi publicada em russo). No entanto, em formato eletrônico fácil de ler (e o mais importante - para pesquisa rápida), a versão russa desta publicação não existia. Portanto, decidi preencher esta lacuna e produzir uma versão completa deste popular livro no formato Wikibook. Acredito que esta informação será interessante e útil não só para estudantes de línguas, mas também para todos que trabalham em Java devido ao grande número de excelentes exemplos que ilustram quase todos os aspectos da programação nesta linguagem. Especialmente quando se trata de recursos Java raramente usados.
Wikilivros "Filosofia Java" localizado em:
"Primavera em Ação"
Livros da série "..... em ação"(geralmente em formato PDF e geralmente em inglês) são merecidamente populares em certos círculos :) Entre eles também existem Talmuds amplos, como "JSTL em Ação"(fácil de ler e com conhecimento moderado de inglês, mas adequado para o papel de um bom livro de referência sobre o tema), e artesanato mais modesto, como "Suportes em Ação"("nem tudo é ouro..."). Livro "Primavera em Ação" nesta lista ainda pertence à categoria de “pesos pesados”, e em todos os sentidos da palavra. Provavelmente não é fácil lê-lo sem um inglês fluente. E a questão provavelmente não está na complexidade do material apresentado (não é complicado), mas no fato de que acabou sendo excessivamente “artístico-inglês” ou algo assim... Cheio de digressões líricas, bordões, trocadilhos e outros blá, blá, blá, autores de idiomas, rapidamente transformam a leitura deste livro de referência (no idioma original) em um processo tedioso. Mas, por outro lado, permite descobrir o que é a palavra "empate"(geralmente “desenhar”) pode ser usado no sentido de “extrair de” (lit. - “puxar, arrastar”). Como resultado (levando em conta o estilo geral de apresentação adotado no livro) compreender significado exato frases como: "...Primavera sorteia esses dados...", pode ser difícil e extremamente necessário ao mesmo tempo. Portanto, os leitores dos capítulos que não traduzi terão que decidir por si próprios ao longo do caminho o que os autores queriam nesses casos: expressar-se poeticamente sobre a criação (gravação) do arquivo, ou falar de forma lúdica sobre sua leitura.
Este livro foi convertido por mim de PDF para Wikibook como uma referência rápida para uso pessoal. Portanto, a tradução não é total, mas apenas em locais onde houve entusiasmo suficiente. Os capítulos restantes foram apresentados de forma simples e conveniente para uma pesquisa rápida. É publicado, TUDO na forma - “como está”, e não há necessidade de culpar a qualidade do texto russo... Não sou tradutor profissional e não tive editor literário. Talvez eu decepcione alguém porque não traduzi alguns trechos e capítulos do livro (e nem pretendo traduzi-los), mas tive que deixar isso como legado para as gerações futuras
Wikilivros "Primavera em ação " localizado em:Em março do ano passado, candidatei-me a uma filial de uma grande empresa internacional em Samara (sim, tive muita arrogância e ambição desde a infância). Naquela época eu conhecia html, css, java, javascript (básico), pascal, visualbasic6, consultas mysql, php, apresentação geral: c++. Eu não conhecia Java. Ofereceram-me um emprego como designer de layout, mas recusei. Apenas um programador! Então eles deram a lista:
Bruce Eckel Thinking in Java (tradução russa da 2ª edição ou original da 4ª - leia ambas)
-Steve McConnell – código perfeito.
-Gangue dos Quatro - Design de padrão. (este é quase o ABC da OOP)
-ter a compreensão mais clara possível da diferença entre j2se e j2ee.
em dezembro surgiu a necessidade de trabalho. consegui um emprego em um pequeno estúdio web de Samara. Ficou imediatamente claro que se tratava de golpistas, mas eu precisava de qualquer trabalho que pudesse mostrar aos futuros empregadores. Eles não pagaram (mesmo sendo todos ouvidos nas promessas), mas elevaram o código aos padrões de design e, o mais importante, nos ensinaram onde procurar e o que procurar em caso de erros, quais são as pequenas coisas fácil de perder.
Além da literatura acima, fiz o curso intuitivo (agora entendo que é ridículo em sua abrangência, mas em princípio o básico está aí)
No final de fevereiro, reenviei meu currículo e recebi um convite para uma entrevista. Foram 6 entrevistas no total e duraram 1,5 meses. Duas delas aconteceram via videoconferência com Moscou. A imagem toda lembrava o filme "Come Tomorrow". Mas no final recebi uma oferta de emprego. O contrato foi celebrado para trabalho a tempo parcial, porque... Naquela época eu não tinha diploma. No mês passado recebi meu diploma e o contrato foi renovado para trabalho em tempo integral.
Cargo atual: Engenheiro Soft. O salário é mais que satisfatório. Ontem, no âmbito da transição para o trabalho a tempo inteiro, aumentaram 30%.
Mesmo naquele escritório torto pediam exemplos de trabalho. Apresentei o trabalho que realizei como freelancer. Mesmo trabalhos em outras línguas são sempre muito melhores do que nenhum trabalho.
Ps: Diploma azul em FÍSICA. Sou totalmente autodidata, então está tudo em suas mãos. Só tenho inglês da escola gratuita (7 horas por semana). embora o americano que nos procurou durante sua viagem ao redor do mundo não o conheça bem. Eu mal entendi metade por causa do sotaque dele. mas isso não é tão crítico no meu departamento. Toda a documentação está em inglês - você aprenderá mesmo que não saiba)))))
Agradecimentos especiais a este fórum. Na verdade eu estudei aqui- todos os dias estudei todos os tópicos que encontrei)
BIBLIOTECA DO PROGRAMADOR
Bruce Eckel
4ª edição
(^PPTER
Moscou - São Petersburgo - Nizhny Novgorod - Voronezh Rostov-on-Don - Ecaterimburgo - Samara - Novosibirsk Kiev - Kharkov - Minsk
BBK 32.973 2-018.1
Eckel B.
E38 Filosofia Java. Biblioteca do programador. 4ª edição. - São Petersburgo: Peter, 2009. - 640 e.: III. - (Série “Biblioteca do Programador”).
ISBN 978-5-388-00003-3
Java não pode ser entendido olhando-o apenas como um conjunto de algumas características – é necessário entender as tarefas desta linguagem como tarefas específicas da programação como um todo. O livro r3ia é sobre problemas de programação: por que eles se tornaram problemas e qual abordagem Java usa para resolvê-los. Portanto, as características da linguagem discutidas em cada capítulo estão inextricavelmente ligadas à forma como são usadas para resolver problemas específicos.
Este livro, que já passou por mais de uma reimpressão no original, é considerado um dos melhores livros didáticos para programadores Java, graças à sua apresentação profunda e verdadeiramente filosófica dos meandros da linguagem.
BBK 32.973.2-018.1 UDC 004.3
Os direitos de publicação foram obtidos sob um acordo com a Prentice Hall PTR.
Todos os direitos reservados. Nenhuma parte deste livro pode ser reproduzida de qualquer forma sem a permissão por escrito dos detentores dos direitos autorais.
As informações contidas neste livro foram obtidas de fontes consideradas confiáveis pela editora. No entanto, tendo em conta possíveis erros humanos ou técnicos, a editora não pode garantir a absoluta exatidão e integralidade da informação disponibilizada e não se responsabiliza por possíveis erros associados à utilização do livro.
ISBN 978-0131872486 (Inglês) © Prentice Hall PTR, 2006
ISBN 978-5-388-00003-3 © Tradução para o russo por Peter Press LLC, 2009
© Edição em russo, desenhada por Peter Press LLC, 2009
Prefácio...................................13
Java SE5 e SE6...................................14
Agradecimentos...................................14
Capítulo 1: Introdução aos Objetos...................................17
Desenvolvimento da abstração...................................18
O objeto tem uma interface.........................20
A instalação fornece serviços........................22
Implementação oculta...................................23
Reutilização de implementação...................................24
Herança...................................25
Objetos intercambiáveis e polimorfismo......29
Hierarquia de raiz única...................................33
Recipientes.................................33
Tipos parametrizados........................35
Criação, uso de objetos e seu tempo de vida................................36
Tratamento de Exceções: Lidando com Erros.................................38
Execução paralela...................................38
Java e a Internet.................................39
Resumo...................................47
Capítulo 2. Tudo é um objeto.................48
Todos os objetos devem ser criados explicitamente...................49
Os objetos nunca precisam ser excluídos......53
Criando Novos Tipos de Dados........................54
Métodos, argumentos e valores de retorno......56
Criando um programa Java........................58
Palavra-chave estática........................60
Nosso primeiro programa Java......61
Comentários e documentação integrada................................64
Estilo de design do programa........................70
Resumo.................................70
Capítulo 3. Operadores........................71
Comandos de impressão simples...................................71
Operadores Java.................................72
Literais.................................82
Java não possui sizeof().................................92
Resumo.................................100
Capítulo 4. Estruturas de controle................101
Sintaxe foreach...................................105
retornar, ....................107
interromper e continuar........................108
Comando goto incorreto........................109
Resumo.................................115
Capítulo 5. Inicialização e encerramento..................................116
O construtor garante a inicialização......116
Sobrecarga de método...................................118
Limpeza: Finalização e Coleta de Lixo......130
Inicializando membros da classe.........................137
Inicialização pelo construtor...................................140
Inicializando matrizes........................146
Resumo...................................151
Capítulo 6. Controle de Acesso......152
Pacote como um módulo de biblioteca.................................153
Especificadores de acesso Java............159
Interface e implementação........................163
Acesso às aulas.........................164
Resumo...................................167
Capítulo 7. Reutilizando Classes......169
Sintaxe de composição.........................170
Sintaxe de herança...................................172
Delegação.................................176
Combinação de composição e herança......178
Composição versus herança.................................184
protegido...................................185
Conversão de tipo ascendente...................................186
Final da palavra-chave...................................188
Resumo...................................197
Capítulo 8. Polimorfismo....................198
Novamente sobre transformação ascendente. . . >............199
Recursos...................................201
Construtores e polimorfismo.................................208
Covariância do tipo de retorno......216
Projetando com Herança........................217
Resumo.................................220
Capítulo 9. Interfaces...................................221
Classes e métodos abstratos...................................221
Interfaces.................................224
Separando a Interface da Implementação......227
Estendendo uma interface por meio de herança......233
Interfaces como meio de adaptação.........236
Interfaces aninhadas..................239
Interfaces e fábricas........................242
Resumo.................................244
Capítulo 10. Classes Internas.................245
Criando Classes Internas...................................245
Comunicação com uma classe externa....................246
Construções.estas e.novas........................248
Classes internas e conversão upstream......249
Classes Internas Sem Nome...................................253
Classes internas: por quê?........................261
Herança de classes internas.................272
É possível substituir uma classe interna?......272
Classes Internas Locais.................................274
Resumo.................................276
Capítulo 11. Coleções de Objetos.....................277
Contêineres parametrizados e digitados........................277
Conceitos Básicos.................................280
Adicionando Grupos de Elementos........................281
Lista.................................285
Iteradores.................................288
Lista Vinculada.................................291
Pilha.................................292
Muitos...................................294
Mapa.................................296
Fila.................................298
FilaPrioridade.................................299
Coleção e Iterador........................301
A linguagem do “adaptador de método”........................306
Resumo.................................309
Capítulo 12. Tratamento de Erros e Exceções......310
Principais exceções.................................310
Capturando exceções........................312
Criando suas próprias exceções.........314
Especificações de Exceção...................................319
Capturando exceções arbitrárias...................................320
Exceções Java padrão......................328
Concluindo com finalmente.................................330
Usando finalmente com retorno.........................334
Limitações ao usar exceções......336
Projetistas........................339
Identificando exceções.........................343
Soluções alternativas........................344
Resumo.................................351
Capítulo 13. Informações de tipo.................................352
A necessidade de inferência de tipo dinâmico (RTTI).....352
Registro de fábricas........................372
Reflexão: Informações Dinâmicas em Sala de Aula......376
Intermediários dinâmicos........................380
Objetos com estado indeterminado......384
Interfaces e informações de tipo...................................390
Resumo.................................394
Capítulo 14. Parametrização.................................397
Parametrização simples.........................398
Interfaces parametrizadas...................................404
Métodos parametrizados........................407
Construindo modelos complexos...................................419
Limitações.................................437
Metacaracteres.................................440
Resumo...................................452
Capítulo 15. Matrizes........................454
Recursos de matrizes........................454
Matriz como um objeto........................456
Retornando uma matriz........................458
Matrizes multidimensionais........................460
Matrizes e parametrização............463
Criando dados de teste............465
Criando matrizes usando geradores......470
Ferramentas auxiliares de matrizes................................474
Resumo...................................482
Capítulo 16. Sistema de E/S Java....483
Classe de arquivo.................................484
Entrada e saída................................489
Adicionando Atributos e Interfaces......491
Classes de Leitor e Escritor........................494
RandomAccessFile: por conta própria...................................497
Uso típico de fluxos de E/S......498
Leitores e Gravadores de Arquivos...................................505
