Buscar
Minha Conta

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

PHP Programando com Orientação a Objetos - 4ª Edição

O PHP é uma das linguagens mais utilizadas no mundo. Sua popularidade se deve à flexibilidade da linguagem e a um conjunto abrangente de classes e funções que permitem desde a criação de simples portais até complexas aplicações de negócios corporativas. O PHP é usado por experientes programadores, que utilizam o que há de mais poderoso em termos de orientação a objetos, padrões de projeto e frameworks, mas também por iniciantes, que ainda usufruem de conceitos de programação estruturada e querem aprender mais.

VITRINE Os TOP de vendas !!

+-

Quem viu este produto , comprou

Quem viu este produto , também se interessou

  • Descrição
    PHP Programando com Orientação a Objetos - 4ª Edição

    O PHP é uma das linguagens mais utilizadas no mundo. Sua popularidade se deve à flexibilidade da linguagem e a um conjunto abrangente de classes e funções que permitem desde a criação de simples portais até complexas aplicações de negócios corporativas.

    O PHP é usado por experientes programadores, que utilizam o que há de mais poderoso em termos de orientação a objetos, padrões de projeto e frameworks, mas também por iniciantes, que ainda usufruem de conceitos de programação estruturada e querem aprender mais.

    Um dos principais objetivos deste livro é permitir que o desenvolvedor aprenda a criar uma aplicação totalmente orientada a objetos, mas que também compreenda os padrões de projeto envolvidos nos principais frameworks na atualidade.

    Com este livro, você aprenderá não somente os fundamentos da orientação a objetos, mas também a criar componentes que formarão um framework que será usado na construção de uma aplicação de negócios.

    Aprenderá também, por exemplo, como manipular o banco de dados de maneira orientada a objetos e como criar componentes de interface para ganhar produtividade na construção de formulários, datagrids, gráficos e relatórios. Ao final, será criada uma aplicação de vendas para consolidar o conhecimento desenvolvido ao longo do livro.

    Principais tópicos abordados no livro:

    Introdução ao PHP, Arrays, Strings, arquivos, bancos de dados
    Orientação a objetos, herança, associação, agregação, composição
    Abstração, polimorfismo, encapsulamento, interfaces
    Exceptions, XML, SPL, reflection, traits, PSR, namespaces, REST
    Design Patterns, MVC, injeção de dependência, Singleton, Facade, Adapter
    PDO, gateways, conexões, transações, Active Record, Repository
    Criação de componentes de interface e utilização de templates
    Criação de classes para manipulação de SQL, registro de logs
    Criação de componentes para formulários e listagens
    Criação de uma aplicação de vendas orientada a objetos
  • Sobre o Autor
  • Especificação

    Características

    Tipo de LivroLivro Físico

    Especificações

    Sobre o AutorPablo Dall´Oglio

    Pablo Dall’Oglio é graduado em Análise de Sistemas e mestre em Engenharia de Software pela Universidade do Vale do Rio dos Sinos (Unisinos). Autor dos livros PHP-GTK – Criando aplicações gráficas com PHP e Criando relatórios com PHP, tem grande experiência no desenvolvimento de sistemas para gestão de negócios e está constantemente envolvido com projeto e implementação de softwares orientados a objetos. Atualmente dedica-se à sua empresa, a Adianti Solutions (adianti.com.br), onde constrói ferramentas de produtividade como o Adianti Framework (adianti.com.br/framework) e o Adianti Reports (adianti.com.br/reports), além de prestar consultoria em projeto e desenvolvimento de sistemas orientados a objetos.
    Informações TécnicasSumário

    Sobre o autor ........................................................................................................... 15
    Agradecimentos....................................................................................................... 16
    Nota do autor........................................................................................................... 18
    Organização do livro................................................................................................. 21

    Capítulo 1 ¦ Introdução ao PHP.................................................................................22
    1.1 O que é o PHP?......................................................................................22
    1.2 Setup ....................................................................................................23
    1.2.1 Instalação .......................................................................................23
    1.2.2 Configuração .................................................................................25
    1.3 Um programa PHP ................................................................................26
    1.3.1 Estrutura do código-fonte................................................................26
    1.3.2 Comentários ..................................................................................27
    1.3.3 Comandos de saída (output)...........................................................27
    1.4 Variáveis................................................................................................28
    1.4.1 Tipo booleano................................................................................. 31
    1.4.2 Tipo numérico................................................................................32
    1.4.3 Tipo string......................................................................................32
    1.4.4 Tipo array.......................................................................................32
    1.4.5 Tipo objeto.....................................................................................32
    1.4.6 Tipo recurso ..................................................................................33
    1.4.7 Tipo misto......................................................................................33
    1.4.8 Tipo callback..................................................................................34
    1.4.9 Tipo NULL.....................................................................................34
    1.5 Declarações de tipo................................................................................34
    1.5.1 Tipagem estrita................................................................................37
    1.6 Superglobais..........................................................................................38
    1.7 Constantes ............................................................................................39
    1.8 Operadores ...........................................................................................40
    1.8.1 Atribuição.......................................................................................40
    1.8.2 Aritméticos ....................................................................................40
    1.8.3 Relacionais..................................................................................... 41
    1.8.4 Lógicos ..........................................................................................43
    1.9 Estruturas de controle ...........................................................................44
    1.9.1 IF....................................................................................................44
    1.9.2 WHILE ..........................................................................................47
    1.9.3 FOR ...............................................................................................48
    1.9.4 SWITCH ........................................................................................49
    1.9.5 FOREACH ..................................................................................... 51
    1.9.6 CONTINUE...................................................................................52
    1.9.7 BREAK...........................................................................................52
    1.10 Requisição de arquivos.........................................................................52
    1.11 Manipulação de funções .......................................................................53
    1.11.1 Criação..........................................................................................53
    1.11.2 Variáveis globais ............................................................................54
    1.11.3 Variáveis estáticas...........................................................................55
    1.11.4 Passagem de parâmetros.................................................................55
    1.11.5 Recursão .......................................................................................57
    1.11.6 Funções anônimas .........................................................................57
    1.12 Manipulação de arquivos e diretórios....................................................59
    1.13 Manipulação de strings.........................................................................64
    1.13.1 Declaração.....................................................................................64
    1.13.2 Concatenação................................................................................65
    1.13.3 Caracteres de escape ..................................................................... 66
    1.13.4 Funções para manipulação de strings ............................................ 66
    1.14 Manipulação de arrays..........................................................................69
    1.14.1 Criando um array ..........................................................................69
    1.14.2 Arrays associativos ........................................................................70
    1.14.3 Iterações........................................................................................70
    1.14.4 Acessando arrays ........................................................................... 71
    1.14.5 Arrays multidimensionais..............................................................72
    1.14.6 Funções para manipulação de arrays..............................................73
    1.15 Frameworks.........................................................................................79
    1.16 Ferramentas importantes......................................................................79

    Capítulo 2 ¦ Fundamentos de orientação a objetos....................................................81
    2.1 Programação procedural ........................................................................ 81
    2.2 Orientação a objetos..............................................................................84
    2.3 Classe .................................................................................................. 86
    Sumário 9
    2.4 Métodos............................................................................................... 88
    2.5 Métodos construtores e destrutores........................................................92
    2.6 Conversões de tipo ................................................................................95
    2.7 Relacionamentos entre objetos...............................................................97
    2.7.1 Associação ......................................................................................97
    2.7.2 Composição .................................................................................100
    2.7.3 Agregação..................................................................................... 102
    2.8 Herança .............................................................................................. 105
    2.9 Polimorfismo ......................................................................................108
    2.10 Abstração............................................................................................110
    2.10.1 Classes abstratas...........................................................................110
    2.10.2 Classes finais ............................................................................... 111
    2.10.3 Métodos abstratos........................................................................112
    2.10.4 Métodos finais .............................................................................113
    2.11 Encapsulamento..................................................................................114
    2.11.1 Public...........................................................................................115
    2.11.2 Private..........................................................................................116
    2.11.3 Protected ......................................................................................118
    2.12 Membros da classe ..............................................................................119
    2.12.1 Constantes .................................................................................. 120
    2.12.2 Atributos estáticos........................................................................121
    2.12.3 Métodos estáticos........................................................................ 122
    2.13 Funções para manipulação de objetos................................................. 123
    2.14 Interfaces ........................................................................................... 127
    2.15 Design patterns.................................................................................. 134
    2.15.1 Singleton ..................................................................................... 135
    2.15.2 Facade ........................................................................................ 139
    2.15.3 Adapter....................................................................................... 143

    Capítulo 3 ¦ Do estruturado à orientação a objetos.................................................. 149
    3.1 Introdução........................................................................................... 149
    3.2 Acesso à base de dados ........................................................................ 152
    3.2.1 Acesso nativo ................................................................................ 152
    3.2.2 Acesso orientado a objetos com PDO ............................................ 157
    3.3 Nível 1 – Procedural, um script por ação ............................................... 162
    3.3.1 Formulário de inserção.................................................................. 163
    3.3.2 Listagem de registros .................................................................... 167
    3.3.3 Edição de registros........................................................................ 169
    3.3.4 Exclusão de registros..................................................................... 172
    3.3.5 Problemas encontrados................................................................. 172
    3.4 Nível 2 – Agrupando ações comuns em scripts...................................... 173
    3.4.1 Listagem de registros......................................................................174
    3.4.2 Formulário de cadastro................................................................. 176
    3.5 Nível 3 – Separando o HTML com micro-templates.............................. 179
    3.5.1 Formulário de cadastros................................................................ 179
    3.5.2 Listagem de registros .................................................................... 183
    3.6 Nível 4 – Separando o acesso a dados com funções ............................... 185
    3.6.1 Funções de acesso à base ............................................................... 186
    3.6.2 Listagem de registros .................................................................... 188
    3.6.3 Formulário................................................................................... 189
    3.7 Nível 5 – Separando o acesso a dados com classes................................. 190
    3.7.1 Classe de acesso à base de dados.................................................... 190
    3.7.2 Listagem....................................................................................... 192
    3.7.3 Formulário ................................................................................... 193
    3.8 Nível 6 – Melhorando as conexões e a segurança .................................. 195
    3.9 Nível 7 – Transformando páginas em classes de controle ....................... 198
    3.9.1 Formulário de cadastro.................................................................. 198
    3.9.2 Index............................................................................................200
    3.9.3 A listagem.....................................................................................202

    Capítulo 4 ¦ Tópicos especiais em orientação a objetos ............................................ 205
    4.1 Tratamento de erros.............................................................................205
    4.1.1 Cenário proposto ..........................................................................205
    4.1.2 Função die().................................................................................208
    4.1.3 Retorno de flags............................................................................209
    4.1.4 Tratamento de exceções..................................................................211
    4.2 Métodos mágicos ................................................................................ 215
    4.2.1 Introdução aos métodos mágicos................................................... 215
    4.2.2 Método __get() ............................................................................ 216
    4.2.3 Método __set()............................................................................. 216
    4.2.4 Armazenando atributos em vetores.................................................217
    4.2.5 Métodos __isset() e __unset()....................................................... 218
    4.2.6 Método __toString().....................................................................220
    4.2.7 Exemplo de uso de __get() e __set().............................................. 221
    4.2.8 Método __clone().........................................................................223
    4.2.9 Método __call() ...........................................................................225
    4.3 Manipulação de XML com a SimpleXML .............................................227
    4.3.1 Classe SimpleXmlElement.............................................................227
    4.3.2 Acessando atributos......................................................................228
    4.3.3 Percorrendo elementos filhos ........................................................230
    4.3.4 Acessando elementos filhos...........................................................230
    4.3.5 Alterando o conteúdo do documento .............................................231
    4.3.6 Acessando elementos repetitivos.................................................... 233
    4.3.7 Acessando atributos de elemento...................................................234
    4.3.8 Percorrendo atributos de elementos...............................................236
    4.4 Manipulação de XML com DOM......................................................... 237
    4.4.1 Leitura de conteúdo...................................................................... 237
    4.4.2 Manipulação de conteúdo............................................................. 239
    4.5 SPL.....................................................................................................240
    4.5.1 Manipulação de arquivos ..............................................................240
    4.5.2 Manipulação de filas.....................................................................244
    4.5.3 Manipulação de pilhas..................................................................246
    4.5.4 Percorrendo diretórios .................................................................. 247
    4.5.5 Manipulando arrays..................................................................... 249
    4.6 Reflection............................................................................................250
    4.6.1 ReflectionClass ..............................................................................251
    4.6.2 ReflectionMethod......................................................................... 252
    4.6.3 ReflectionProperty........................................................................ 253
    4.6.4 Gerando documentação................................................................254
    4.7 Traits................................................................................................... 255
    4.8 Injeção de dependência........................................................................260
    4.9 PSR.....................................................................................................263
    4.10 Namespaces.......................................................................................264
    4.11 SPL Autoload......................................................................................273
    4.12 Composer.......................................................................................... 275

    Capítulo 5 ¦ Persistência......................................................................................... 278
    5.1 Introdução...........................................................................................278
    5.2 Gateways ............................................................................................280
    5.2.1 Table Data Gateway ......................................................................280
    5.2.2 Active Record ...............................................................................288
    5.2.3 Data Mapper................................................................................293
    5.3 Conexões e transações .........................................................................298
    5.3.1 Classe para conexões com Factory Method.....................................298
    5.3.2 Classe para transações ..................................................................303
    5.3.3 Registro de log e strategy pattern ................................................... 310
    5.4 Active Record e Layer Supertype........................................................... 316
    5.4.1 Definição da classe Active Record................................................... 325
    5.4.2 Novo objeto ................................................................................. 325
    5.4.3 Obter objeto................................................................................. 327
    5.4.4 Alterar objeto................................................................................ 328
    5.4.5 Clonar objeto ............................................................................... 329
    5.4.6 Excluir objeto...............................................................................330
    5.4.7 Encapsulamento............................................................................331
    5.5 Definição de critérios...................................................................... 333
    5.5.1 Query Object................................................................................ 335
    5.6 Manipulação de coleções de objetos................................................. 339
    5.6.1 Repository Pattern......................................................................... 339
    5.6.2 Preparação dos dados ...................................................................344
    5.6.3 Carregar coleção de objetos...........................................................345
    5.6.4 Alterar coleção de objetos.............................................................. 347
    5.6.5 Excluir coleção de objetos.............................................................348

    Capítulo 6 ¦ Apresentação e controle ...................................................................... 350
    6.1 Padrão MVC........................................................................................350
    6.2 Organização de namespaces e diretórios............................................... 352
    6.3 SPL Autoloaders...................................................................................356
    6.3.1 Library Loader..............................................................................356
    6.3.2 Application Loader ....................................................................... 357
    6.3.3 Exemplo de uso ............................................................................ 359
    6.4 Padrões de controle.............................................................................. 359
    6.4.1 Page Controller.............................................................................360
    6.4.2 Front Controller ...........................................................................363
    6.4.3 Remote Facade ............................................................................. 367
    6.5 Padrões de apresentação ...................................................................... 373
    6.5.1 Componentes ............................................................................... 374
    6.5.2 Template View .............................................................................. 378
    6.6 Criando componentes..........................................................................382
    6.6.1 Elementos HTML .........................................................................382
    6.6.2 Painéis.........................................................................................386
    6.6.3 Caixas..........................................................................................388
    6.6.4 Diálogo de mensagem e questionamento .......................................390
    6.6.5 Ações ...........................................................................................395
    6.7 Usando templates................................................................................399
    6.7.1 Substituições simples.....................................................................400
    6.7.2 Substituições com repetições ......................................................... 401

    Capítulo 7 ¦ Formulários e listagens........................................................................ 405
    7.1 Formulários.........................................................................................405
    7.1.1 Classe lógica para formulários........................................................407
    7.1.2 Classes para apresentação de formulários........................................411
    7.1.3 Classes para campos de formulários............................................... 415
    7.1.4 Exemplos...................................................................................... 435
    7.2 Listagens.............................................................................................447
    7.2.1 Classe lógica para Datagrids..........................................................448
    7.2.2 Classe para colunas da datagrid ....................................................450
    7.2.3 Classe para apresentação da datagrid ............................................ 452
    7.2.4 Exemplos .....................................................................................458

    Capítulo 8 ¦ Criando uma aplicação......................................................................... 474
    8.1 Visão geral da aplicação........................................................................ 474
    8.1.1 Index ............................................................................................ 475
    8.1.2 Template....................................................................................... 478
    8.1.3 Iniciando o projeto........................................................................480
    8.1.4 Modelo de classes ......................................................................... 481
    8.1.5 Modelo relacional.........................................................................482
    8.2 As classes de modelo ...........................................................................486
    8.2.1 Código-fonte das classes................................................................486
    8.2.2 Testando as classes de modelo.......................................................497
    8.3 Programa ............................................................................................504
    8.3.1 Cadastro de pessoas ......................................................................504
    8.3.2 Criando traits para ações comuns...................................................515
    8.3.3 Cadastro de produtos.....................................................................521
    8.3.4 Cadastro de cidades...................................................................... 529
    8.3.5 Manipulação de sessões................................................................ 534
    8.3.6 Registro de vendas........................................................................536
    8.3.7 Relatório de contas.......................................................................546
    8.3.8 Relatório de produtos ................................................................... 552
    8.3.9 Relatório de pessoas...................................................................... 555
    8.3.10 Gráfico de vendas por mês........................................................... 558
    8.3.11 Dashboard de vendas...................................................................562
    8.3.12 Controle de login ........................................................................563
    8.4 Considerações finais............................................................................568

    Informações Técnicas

    Nº de páginas:568
    Origem:Nacional
    Editora:Editora Novatec
    Idioma:Português
    Edição:4ª Edição
    Ano:2018
    ISBN:9788575226919
    Encadernação:Brochura
    Autor:Pablo Dall’Oglio
  • 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!