Sobre Orientado a Objeto em PHP

[Williams Duarte 431]

Pra noobs não!! Bom achei que aqui não teria somente noobs... Mas como PHP sempre reúne noobs... eu tô caindo fora...

Só um conselho de um de meus Mister Minds, você só sai da sala quando você é o mais esperto da mesa, e sinto muito em dizer, mas você não é o cara mais experto aqui, vi em alguns posts o seu embasamento técnico e também sua arrogância.

 

Já vi diversos membros igual a você em dezenas de grupos de discussão que participo, que se acham um dos Deuses da programação como já foi dito "a você diretamente" em outro post, estes somem e volta com a mesma arrogância em nicks diferentes.

 

Aqui todos e sem exceção é noob em alguma coisa, ou posso estar enganado.

 

Senão todos estariam em um http://bit.ly/1qLtP2F ou http://bit.ly/1kyO9qd curtindo a vida, e não hora em hora ajudando outros membros, assim como você mesmo vem fazendo.

 

#FIKAADICA

[André Wielki 6]

Agora eu estou ajustando o código na estrutura que quero e voltou a dar erro. Olha só, sao dois arquivos um com cada classe., a classe da conexao e a classe da autenticacao, eu quero herdar na autenticacao o construct da abertura da conexao. Arquivo da classe autenticacao: pastebin.com/a7mfxSjU Arquivo da classe da conexao: pastebin.com/FmfCWDRC O erro é: Fatal error: Call to a member function query() on a non-object in C:\htdocs\NetBeansProjects\flptrevisan\classes\autenticacao.class.php on line 8 Sempre naquela linha.

 

A linha 8 é este código:

$sql = $this->conexao->query("SELECT * FROM usuarios WHERE email = '$email' AND senha = '$senha'");

 

 

Pra fazer isso eu li suas respostas e tambem estou me basenado neste codigo aqui: http://www.arquivodecodigos.net/arquivo/tutoriais/php/geral/poo1/heranca_construtores_parent.php

 

Alguem me ajuda a terminar ? Sei que está perto

[Gabriel Heming 766]

Já foi mencionado que não é correto herdar a classe de conexão e indicado que a injeção de dependência é o correto a se fazer.

 

A sua classe autenticação usa uma conexão, ela não é uma conexão.

 

Voltando ao erro, ele acontece por causa da declaração de visibilidade que você efetuou (private). Para poder acessar, teria que ser ao menos protected.

 

Mas reiterando, nesse exemplo, não é cabível o uso da herança.

O exemplo que você postou é coerente com herança, pois um cliente é uma pessoa (que pode ser tanto física como jurídica).

[André Wielki 6]

Mas desse jeito é a unica forma que entendi e estava conseguindo, alias, consegui e nao sei o qu emechi que deu errado, a minha logica era criar uma classe so para conexao, e fazer o conectar ser o cosntruct dela pra toda vez que for chamada, se conectar.

 

Ai eu pego e crio uma classe para qualquer outra coisa, e nessas classes novas eu herdo a conexao e chamo o construct que vai conectar primeiro, e depois eu faço as funcoes vinculadas ao banco de dados das novas classes assim todas novas funcoes vao estar conectadas ao banco sem precisar ficar se conectando manualmente.

 

Troquei para public agora e funcionou, obrigado.

Depois vou deixar protected isso se nao da para usar private como eu queria.

 

Eu pensei que o correto era mante-la como private por isso nao tentei trocar antes.

 

Vou dar mais uma lida para ver se entendo o que voce quer que eu faça, que eu sei que a autenticacao nao é conexao e usa conexao eu sei. O que eu nao quero é ficar passando $conexao toda hora nas funções como antes, o maximo que eu poderia fazer é criar uma funcao conectar e usar ela sempre antes de aplciar quallquer funcao que usa conexao, seria isso então outra forma correta?(era isso que e ufazia antes de esquecer) Basicamente é a mesma coisa que estou fazendo, a diferenca é que estou usando o construct pra deixar automatico, EU PENSO QUE É ISSO QUE ESTOU FAZENDO.

Na real eu to tentando fazer alguns testes pra deixar mais automatico essa conexao, por isso o uso do construct.

[Gabriel Heming 766]

Seguir os princípios SOLID é importante para ter um projeto com alta coesão e baixo acoplamento. Entender SRP (o S de SOLID) é um ensinamento básico para a programação orientada a objetos.

 

Ao usar herança, você viola LSP, pois uma autenticação não é uma conexão e tão pouco uma conexão pode ser considerada uma autenticação.

 

Além das desvantagens acima citadas, você terá estas:

- Cada instância criará uma nova conexão no banco de dados;

- Você não poderá alterar o meio de conexão sem alterar a classe conexão;

- A classe conexão não permite parametrização para acesso a bases distintas.

 

Veja que não me fixei apenas no problema da herança, mas também nos poblemas criados com as configurações fixas na classe conexão.

 

Nesse caso, em específico, não deve fugir do básico:

- uma classe de conexão, com atributos parametrizáveis;

- injetar a conexão no objeto que necessitar.

 

Você nem precisa criar uma classe de conexão, pode usar a PDO. Basta injetá-la aonde for necessário.

[Vinicius Rangel 208]

Ai eu pego e crio uma classe para qualquer outra coisa, e nessas classes novas eu herdo a conexao e chamo o construct que vai conectar primeiro

 

ERRADO.

 

É UMA CONEXÃO É DIFERENTE DE USAR UMA CONEXÃO

[André Wielki 6]

Hum, pra evitar o multipla instancia de conexao eu penso em usar um destruct, ja me resolveria esse problema pelo menos ? Seria uma maneira automatica de fechar a conexao sem precisar ficar dando o close.

 

Ta eu sei que ainda estou sendo cabeça dura ignorando o resntate que voce falou, mas eu vou estudar isso que voce falou ai pra tentar melhorar é que agora eu nao tenho o conhecimento para por em pratica ele.

 

Me diz se o destruct resolveria o problema de varias intancias de conexao aberta?

 

ERRADO.

 

É UMA CONEXÃO É DIFERENTE DE USAR UMA CONEXÃO

hummmmm entendendo aos poucos isso ai

[criatividade zero 17]

O X da questão é instanciar APENAS 1 unica vez e aproveitar a instancia sempre que for preciso.

 

Para fechar a conexão, é preciso destruir o objeto, garantindo que todas as referências restantes para ele são excluídos - você faz isso através da atribuição de NULL para a variável que contém o objeto. Se você não fizer isso explicitamente, o PHP irá fechar automaticamente a conexão quando o script termina.

 

O destructor não é necessário, o PHP faz isso automaticamente.

[André Wielki 6]

hummmmmmm

[Gabriel Jacinto 74]

namespace Your\Namespace\Db\Connection;

interface ConnectorInterface
{
    /**
     * @return object
    */
    public function getConnection();
}

namespace Your\Namespace\Db\Connection;

use Your\Namespace\Db\Connection\ConnectorInterface;
use \PDO;

class PDOConnector implements ConnectorInterface
{
    /**
     * PDO instance
     *
     * @var \PDO
    */
    private $pdo;

    /**
     * @param string  $dsn
     * @param string  $user
     * @param string  $pass
     * @param integer $port
    */
    public function __construct($dsn, $user, $pass, $port = null)
    {
        $this->pdo = new PDO($dsn, $user, $pass, $port);
    }

    /**
     * @return \PDO
    */
    public function getConnection()
    {
        return $this->pdo;
    }
}

namespace Your\Namespace\Db\Storage;

interface StorageInterface
{
    /**
     * @param string       $table
     * @param array|string $where
    */
    public function remove($table, $where);

    /**
     * @param string $table
     * @param array  $values
    */
    public function create($table, array $values);

    /**
     * @param string       $table
     * @param array        $dataSet
     * @param string|array $where
    */
    public function update($table, array $dataSet, $where);

    /**
     * @param string       $table
     * @param string|array $data
     * @param string|array $where
    */
    public function read($table, $data = '*', $where);
}

namespace Your\Namespace\Db\Storage;

use Your\Namespace\Db\Connection\ConnectorInterface;
use Your\Namespace\Db\Storage\StorageInterface;

class Storage implements StorageInterface
{
    /**
     * @param \Your\Namespace\Db\Connection\ConnectorInterface $connection
    */
    public function __construct(ConnectorInterface $connection)
    {
        $this->db = $connection;
    }

    /**
     * @param string       $table
     * @param array|string $where
    */
    public function remove($table, $where)
    {
        //...
    }

    /**
     * @param string $table
     * @param array  $values
    */
    public function create($table, array $values)
    {
        //...
    }

    /**
     * @param string       $table
     * @param array        $dataSet
     * @param string|array $where
    */
    public function update($table, array $dataSet, $where)
    {
        //...
    }

    /**
     * @param string       $table
     * @param string|array $data
     * @param string|array $where
    */
    public function read($table, $data = '*', $where)
    {
        //...
    }
}

namespace Your\Namespace\Controller;

use Your\Namespace\Db\Storage\StorageInterface;

class UserController
{
    /**
     * @var \Your\Namespace\Db\Storage\StorageInterface;
    */
    private $storage;

    /**
     * @param \Your\Namespace\Db\Storage\StorageInterface $storage
    */
    public function __construct(StorageInterface $storage)
    {
        $this->storage = $storage;
    }

    /**
     * @param string $name
     * @param string $email
     * @param string $pass
     * @param ?      $kPost
     * @param ?      $k
     * @param string $ip
    */
    public function singUp($name, $email, $pass, $kPost, $k, $ip)
    {
        //...
    }
}

Isso é só um exemplo do que você pode fazer.