[Resolvido] Sobre orientação a objetos...

Classe é classe, objeto é objeto. A instância de uma classe é chamada de objeto.

Imagine a classe como a planta de uma casa e o objeto como a casa.

Espero que tenha entendido. Você está no caminho certo.

Um abraço e bons estudos.

Um objeto não é uma classe.

Um objeto é uma "instancia" dela. Você pode ter varias instancias de uma classe.

"No contexto da orientação ao objeto, instância significa a concretização de uma classe" Wikipédia

É através de uma classe que você concretiza um objeto.

/* CLASSE
* o que seria uma classe bom uma classe seria um molde para um objeto do mundo real exemplo
* uma pessoa do mundo real vem a fazer um cadastro em uma loja
*
*
*/
outro exemplo carro sera nossa classe e
tera os atributos como cor,motor,num portas etc ,
e as funçoes como andar ,parar,e etc
agora depois de definir nossos stributos e funções criaremos o objeto desse carro pois nosso molde ja esta pronto entendeu.

Classes são como moldes, elas definem quais atributos e funcionalidades os objetos de seu tipo terão.

/* METODOS = FUNÇOES
ATRIBUTOS
* os metodos sao as funções de uma classe e os atributos sao os dados de uma clase exermplo uma pessoa ao fazer um cadastro presisara informar seus
* atributos como nome,sobrenome,rg,cpf etc....
*

*/

/* OBJETO
* Objeto seria a instancia da nossa classe ue como assim bom como ja falei uma classe é um molde nao
* concretizado ou so sera finalizado quando o objeto for instanciado = criado
*
*
*/

/*Em termos mais simples, em programação orientada a objetos a palavra instanciar seria o mesmo que criar.
* Quando falamos em instanciar um objeto, criamos fisicamente uma representação concreta da classe.
*/
espero que ajude tenho um tutorial aqui

>
Um objeto não é uma classe.

Um objeto é uma "instancia" dela. Você pode ter varias instancias de uma classe.

"No contexto da orientação ao objeto, instância significa a concretização de uma classe" Wikipédia

É através de uma classe que você concretiza um objeto.

Que bacana essa explicação, acho que estou começando a entender... Vamos ver:

Se o objeto é a instância de uma classe então é correto:

$meu_objeto = new MinhaClasse();
O trecho acima quer dizer que a variável $meu_objeto irá receber uma instância de MinhaClasse e a partir desse momento será criado o objeto na memória chamado $meu_objeto que conterá toda a estrutura da classe instanciada?

Estou querendo entender melhor como a coisa acontece rsrs...

Sim, perfeitamente. Apenas a nível de ilustração intelectual, basta ter em mente que um objeto pertence à uma classe. Mas os termos técnicos são esses mesmos, um objeto é uma instância de uma classe definida.

uma duvida .. um metodo estatico sera oque ?

ULogin::AuthenticationAdmin(Registry::get('Database'));

Como assim? Ele será um método estático :)

um método estático faz referência às modificações na classe e não às instâncias do objeto

http://www.php.net/manual/pt_BR/language.oop5.static.php

hmm.. interessante.. mas nao intendi direito .. como "modificações" ?

Ah ta, com sua resposta entendi a pergunta :)

Tudo que é estático é da classe. Ponto final.

class ConectaBanco {

 private static $hostname;
 private static $username;
 private static $password;
 private static $database;

 public static function __callStatic($name, $params){
 if(substr($name,0,4)) == 'set_') {
 $prop = substr($name,3);
 if(isset(self::$$prop)) self::$$prop = $params[0];
 }
 else trigger_error("Undeclared method <b>ConectaBanco::{$name}</b>",E_USER_WARNING);
 }

 public function query($query){
 $conn = mysql_connect(ConectaBanco::$hostname,ConectaBanco::$username,ConectaBanco::$password) or die(mysql_error());
 mysql_select_db(ConectaBanco::$database,$conn) or die(mysql_error());
 $resource = mysql_query($query,$conn);
 mysql_close($conn);
 return $resource;
 }
}

ConectaBanco::set_hostname('localhost');
ConectaBanco::set_username('root');
ConectaBanco::set_password('');
ConectaBanco::set_database('teste');
$sql = new ConectaBanco();
$sql->query('SELECT * FROM `teste`');

Edit Acho que não fui muito claro, rs.

Vou tentar de outra forma:

class A {

 private static $b = 0;

 public static getB(){
 return self::$b;
 }

 public static setB($bValue){
 self::$b = (int)$bValue;
 }
}

$a1 = new A();
$a2 = new A();

$a2::setB(4);
echo $a1::getB(); // 4

$a1::setB(9);
echo $a2::getB(); // 9

ta mas entao utilizar metodo estaticos para deixa-los "independente" é errado ?

por exemplo

ULogin::AuthenticationAdmin(Registry::get('Database'));
ULogin é a classe que vem propor a resolução dos problemas relacionados a login como autentificacao

dentro dela tem o metodo AuthenticationAdmin que propoen resolver o problema de autentificacao para sessoes restritas a administradores..

Mas dentro dela ha varios outros metodos para propor a resolucao de diferentes problemas.

Dentro de uma pagina eu preciso autentificar para isso vou utilizar a AuthenticationAdmin, se nao fosse estatico teria que instanciar a classe intera so pra utilizar 1 metodo ?

valww galerin

se nao fosse estatico teria que instanciar a classe intera so pra utilizar 1 metodo ?

sim. =]

O propósito de criar instâncias de uma classe é ter objetos que se comportam de maneira semelhante ou igual, mas trabalham informações diferentes. Se for a mesma informação o tempo inteiro, trabalhe estaticamente e poupe memória.

Estático em PHP é um pouco diferente e pode ter efeitos inesperados. Por exemplo, o que você acha que vai ser exibido a partir deste script:

<?php
class Instancia
{
function hello()
{

	Estatica::hello();
}
}

class Estatica
{
function hello()
{

	var_dump($this);
}
}

$instancia = new Instancia;
$instancia->hello();
?>

Então nesse caso essa forma de atribuir...

ConectaBanco::set_hostname('localhost');
ConectaBanco::set_username('root');
ConectaBanco::set_password('');
ConectaBanco::set_database('teste');

...só é possível por causa desse método mágico?

public static function __callStatic($name, $params)
{
if(substr($name,0,4)) == 'set_')
{

 $prop = substr($name,3);
 if(isset(self::$$prop)) {self::$$prop = $params[0];}
 }else {
 trigger_error("Undeclared method <b>ConectaBanco::{$name}</b>",E_USER_WARNING);
 }
}

Eu já havia lido sobre o assunto mas, só agora com esses exemplos eu pude compreender como funciona a coisa estaticamente.

Will, muito obrigado por perguntar. Evandro, suas explicações foram excelentes (continue assim! rsrs).

>
Estático em PHP é um pouco diferente e pode ter efeitos inesperados. Por exemplo, o que você acha que vai ser exibido a partir deste script:

Bom, esse código está mal escrito e vai de encontro com STRICT STANDARDS, sei que foi propositalmente escrito para se ilustrar seu ponto de vista mas lembre-se que não estamos mais no PHP 4.

error_reporting( E_ALL | E_STRICT );

class Instancia
{

	public function hello()
	{
	Estatica::hello();
	}
}

class Estatica
{

	public static function hello()
	{
	var_dump($this);
	}
}

$instancia = new Instancia;
$instancia->hello();

A saída será:

>
Notice: Undefined variable: this in /var/www/html/estatico.php on line 29

NULL

João, value pelo E_STRICT. Estava pensando nesta questão de estáticos e não me ocorreu porque o PHP permitia este tipo de coisa. Claro que é uma burrice fazer isso que demonstrei, mas é que o PHP permite a chamada de modo estático de métodos não estáticos. Sua única restrição parace ser sobre a palavra reservada static, que não carrega $this no escopo do método...

Uma demonstração do problema:

class A52 {

public static function who(){
	return __CLASS__;
}

public static function test(){
	return self::who();
}
}

class B52 extends A52 {

public static function who(){
	return __CLASS__;
}
}

Como pode ver, a classe B52 é derivada de A52, pela lógica, ao chamar B52::test() (herdado de A52) o método B52::who() deveria ser chamado, mas, como:

>
Referências estáticas para a atual classe como self:: ou __CLASS__ são resolvidas usando a classe na qual a função pertence, como onde ele foi definido:

B52::test() vai retornar A52 e não B52 como esperado.

No 5.3 foi introduzido o Late Static Binding que resolve o problema:

class A53 {

public static function who() {
	return __CLASS__;
}
public static function test() {
	return static::who();
}
}

class B53 extends A53 {

public static function who() {
	return __CLASS__;
}
}

Agora, devido ao Late Static Binding, B53::test() retornará B53 como pode ser visto no fragmento abaixo:

var_dump( B52::test() );
var_dump( B53::test() );

A saída será:

>
string(3) "A52"

string(3) "B53"

;)

Existe alguma maneira de proibir, lançar erro, warning ou notice quando utilizamos um método não-estático de maneira estática?

Era o E_STRICT mesmo desabilitado. Agora veio: Strict standards: Non-static method Estatica::hello() should not be called statically. Obrigado pela dica, João Batista Neto.

>
Existe alguma maneira de proibir, lançar erro, warning ou notice quando utilizamos um método não-estático de maneira estática?

Isso ?

class Test {

private $nonStaticData = 1;

public function nonStaticTest(){
	return $this->nonStaticData;
}
}

error_reporting( E_ALL | E_STRICT );

var_dump( Test::nonStaticTest() );

Saída:

>
Strict Standards: Non-static method Test::nonStaticTest() should not be called statically in /var/www/html/staticTest.php on line 24

Fatal error: Using $this when not in object context in /var/www/html/staticTest.php on line 18

Obrigado pela ajuda pessoal. As séries de artigos do João Batista Neto foram muitos importantes para o entendimento do assunto!