Hej
Jakiś czas temu, zamówiłem książkę o OOP, trochę poczytałem i zacząłem praktykę. Stworzyłem sobie klasę mail która wysyła maila, i użyłem w niej konstruktora, i chciałem się dowiedzieć, czy dobrze myślę odnośnie tworzenia klas i użycia konstruktora w nich. Oto kod:

[PHP] pobierz, plaintext 
<?php
        class mail
        {
            public $nadawca;
            public $odbiorca;
            public $temat;
            public $tresc;
            
            
                    function __construct($odbiorca)
                    {
                        $this -> odbiorca = $odbiorca;
                    }
                    
                    
                    public function ustawTemat($temat)
                    {
                        $this-> temat = $temat;
                    }
                    
                    
                    public function ustawTresc($tresc)
                    {
                        $this -> tresc= $tresc;
                    }
                    
                    
                    public function ustawNadawce($nadawca)
                    {
                        $this-> nadawca = $nadawca;
                    }
                    
                    
                    public function wyslijMaila()
                    {
                        mail($this->odbiorca,$this->temat,$this->tresc.$this->nadawca);
                    }
        }
        
$mail=new mail('adres@wp.pl');
$mail->ustawNadawce('ktos@adres.pl');
$mail->ustawTemat('Temat testowy');
$mail->ustawTresc('przykladowa tresc');
$mail->wyslijMaila();
?>
[PHP] pobierz, plaintext 

Proszę o opinie, w szczególności czy mój tok rozumowania odnośnie tworzenia klas i używania w nich konstruktora jest dobry. Wiem że dla Was, napisanie takiej klasy to pikuś, ale dopiero raczkuje w OOP i chciałbym poznać waszą opinię.

@belliash: nie musi.

@ExPlOiT: całkiem zgrabnie jak na początek, ale kilka uwag się znajdzie.
Po pierwsze, może być kilku odbiorców, a ty tego nie wziąłeś pod uwagę.

Po drugie mógłbyś wydzielić wysyłanie maila np. do osobnej klasy lub poprzez dziedziczenie.

[PHP] pobierz, plaintext 
<?php
// wysylanie maila w osobnej klasie
class mail
{
    protected $sender;
 
    public __construct(mailSender $sender)
    {
        $this->sender = $sender;
    }
 
    // tutaj reszta Twoich metod + ustawNadawce/Nadawcow
 
    public function wyslijMaila()
    {
        // teraz mozesz tworzyc klase dziedziczaca po mailSender
        // i wewnatrz niej użyć mail lub inną w której sam będziesz składać nagłowki do kupy
        // i wysylac do serwera poczty.
        $this->sender->send($this->odbiorca,$this->temat,$this->tresc.$this->nadawca);
    }
}
?>
[PHP] pobierz, plaintext 

Wiem, że na początek to dużo po wprowadzam rzeczy z którymi niekoniecznie jesteś zaznajomiony, ale w ten sposób od początku nauczysz się dobrych praktyk.

a ja to rozwiązałem tak:

Temat: klasa_mailing

tylko wydaje mi się że trochę nie o to chodzi bo ty na sztywno podajesz maile a ja je dynamicznie wczytuje.

Ale to już kwestia standardów kodowania a nie poprawnej konstrukcji klasy.



Mailing (wysyłka do subskrybentów) )a mailer (mechanizm wysyłania maila) to dwie rożne rzeczy i nie powinieneś Ich mieszać. Skłaniałbym się do wykorzystania obiektów mail wewnątrz klasy mailera.

Dzięki za uwagi. Ta klasa ma obsłużyć wysyłanie do mnie maila z formularza kontaktowego, czyli będzie jeden odbiorca. Bo w przypadku gdyby było kilku odbiorców mógłbym to tak zrobić:

[PHP] pobierz, plaintext 
<?php
        class mail
        {
            public $nadawca;
            public $odbiorca;
            public $temat;
            public $tresc;
            
            
                    function __construct($nadawca)
                    {
                        $this -> nadawca = $nadawca;
                        $this -> odbiorca = array();
                    }
                    
                    
                    public function ustawTemat($temat)
                    {
                        $this-> temat = $temat;
                    }
                    
                    
                    public function ustawTresc($tresc)
                    {
                        $this -> tresc= $tresc;
                    }
                    
                    
                    public function dodajOdbiorce($odbiorca)
                    {
                        array_push($this->odbiorca,$odbiorca);
                    }
                    
                    
                    public function wyslijMaila()
                    {
                        
                        foreach($this->odbiorca as $dokogo)
                        {
                        mail($dokogo,$this -> temat,$this->tresc,'From:'. $this->nadawca);
                        }
                    }
        }
        
$mail=new mail('nadawca@wp.pl');
$mail->dodajOdbiorce('biuro@cos.pl');
$mail->ustawTemat('Temat testowy');
$mail->ustawTresc('przykladowa tresc');
$mail->wyslijMaila();
?>
[PHP] pobierz, plaintext 

Oczywiście o ile dobrze myślę. I np w wczytać listę odbiorców z pliku txt

Rada: jak najszybciej porzuć polskie nazewnictwo w kodzie

@LBO: Jak rozumiem chciałeś pokazać możliwość uzyskania kilku dróg wysłania maila, przez: mail(), smtp, cokolwiek innego. Tylko wtedy klasa MailSender nie może dziedziczyć po Mail - to by bez sensu było przecież. Powinna za to przyjmować cały obiekt Mail jako jakiś argument (w końcu z czasem klasa Mail rozrośnie się o dołączanie załączników itp. więc przekazywanie poszczególnych pól danych nie spisze się za dobrze).

[PHP] pobierz, plaintext 
<?php
 
class Mail{
    private $addressee = array();
    private $sender;
    
    private $subject;
    private $content;
    
    public function __construct(){
        //w konstruktowrze nie ma sensu niczego upychać na siłę
        //możesz co prawda dodać obsługę nadawania nadawcy
    }
    
    public function addAddressee($mail, $name){
        //mail to adres, name to ładna nazwa trafiająca do nagłówka
        $this->addressee[$mail] = $name;
    }
    
    public function setSender($sender){
        $this->seneder = $sender;
    }
    
    public fuction setSubject($subject){
        $this->subject = $subject;
    }
    
    public function setContent($content){
        $this->content = $content;
    }
}
 
abstract class MailSender{
    private $mail;
 
    public function setMail(Mail $mail){
        $this->mail = $mail;
    }
    
    abstract public function send();
}
 
class SMTPMailSender extends MailSender{
    public function send(){
        //wysyłanie maila poprzez SMTP
    }
}
 
class MailMailSender extends MailSender{
    public function send(){
        //wysyłanie maila poprzez mail()
    }
}
 
//--------------------------
$mail = new Mail();
//ustawienie wszystkich danych
$sender = new MailMailSender();
$sender->setMail($mail);
$sender->send();
 
 
//--------------------------
//ewentalnie możesz w Mail dodać metodę robiącą to co powyżej
?>
[PHP] pobierz, plaintext 

Oczywiście to tylko szkielet z najbardziej podstawowymi metodami. Zauważ że taka konstrukcja umożliwia Ci masowe wysyłanie dwóch rodzajów maili:
1) Wielu adresatów, jedna treść: wtedy tworzysz jeden Mail, jeden MailSender a wielu adresatów obsługujesz poprzez podanie wielu maili w pierwszym parametrze mail() (więcej w manualu)
2) Wielu adresatów, dla każdego inna treść: wtedy tworzysz kilka obiektów Mail i poprzez MailSeneder::addMail() (tutaj nie pokazanej) wielokrotnie (w pętli) wykonujesz całe wysyłanie

A czytałeś dołączony kod? Napisałem wyraźnie dziedziczenie ALBO dodatkowy obiekt.

Pozdrawiam

Czytałem, to albo też - tyle że z dziedziczeniem to zły pomysł - z dodatkowym obiektem jak najbardziej - dlatego się "czepiam".

Dziedziczenie? Nie bardziej polimorfizm?

a Czemu zły? Ile razy Ci się zdarza zmieniać silnik wysyłający maile?
Fakt, wydzielenie obiektu wysyłającego jest elastyczne, ale wcale nie znaczy, że potrzebne. Czasami to zwykłe komplikowanie kodu.

[PHP] pobierz, plaintext 
<?php
abstract class Mail
{
    // settery i gettery
 
    abstract public function send();
}
 
class BasicMail extends Mail
{
    public function send()
    {
        // tutaj używasz mail()
    }
}
 
class SmtpMail extends Mail
{
    // konstruktor z danymi konfiguracyjnymi do serwera
 
    public function send()
    {
        // a tutaj składasz nagłówki i odpowiedź dla serwera SMTP
    }
}
?>
[PHP] pobierz, plaintext 

I też bangla.

edit:

mały błędzik był

Bardzo często w środowisku deweloperskim masz inny mechanizm do wysyłki maili.
Że już nie wspomnę o testowaniu aplikacji. Podczas nich często zdarza się zmieniać silnik wysyłający maile.

A to dlaczego?

No więc tak tutaj jest część kodu odpowiedzialna za dodanie adresata/adresu:

[PHP] pobierz, plaintext 
<?php
public function addAddressee($mail, $name){
        //mail to adres, name to ładna nazwa trafiająca do nagłówka
        $this->addressee[$mail] = $name;
    }
?>
[PHP] pobierz, plaintext 

I jak zrobić to żeby, wczytać wszystkie maile i wysłać do każdego? Bo wczoraj napisałem kod który wczytuje, ale wysyłał tylko do jednej osoby, i kod wyglądał tak:

[PHP] pobierz, plaintext 
<?php
         class mail
         {
             public $nadawca;
             public $odbiorca;
             public $temat;
             public $tresc;
             
             
                     function __construct($nadawca)
                     {
                         $this -> nadawca = $nadawca;
                         $this -> odbiorca = array();
                     }
                     
                     
                     public function ustawTemat($temat)
                     {
                         $this-> temat = $temat;
                     }
                     
                     
                     public function ustawTresc($tresc)
                     {
                         $this -> tresc= $tresc;
                     }
                     
                     
                     public function dodajOdbiorce()
                        {
                    
                            $email=file('emaile.txt');
                            foreach($email as $odbiorca)
                            {
                              array_push($this->odbiorca,$odbiorca);
                              return $odbiorca;
                             }
                        }
                     
                     
                     public function wyslijMaila()
                     {
                         
                         foreach($this->odbiorca as $dokogo)
                         {
                         mail($dokogo,$this -> temat,$this->tresc,'From:'. $this->nadawca);
                         }
                     }
         }
         
 $mail=new mail('nadawca@wp.pl');
 $mail->dodajOdbiorce();
 $mail->ustawTemat('Temat testowy');
 $mail->ustawTresc('przykladowa tresc');
 $mail->wyslijMaila();
 ?>
[PHP] pobierz, plaintext 

Domyślam się, że gdzieś popełniłem pewnie parę błędów.

1) Estetyka. Języki prog. same w sobie stosują ang. nazewnictwo (function, class, new, this, switch itp.) a mieszanie dwóch języków wygląda paskudnie:
2) Kod pisany po polsku zrozumiały jest dla może kilkuset tysięcy osób - Polacy mający jakieś pojęcie o prog. Kod pisany po angielsku jest dostępny dla iluś tam milionów
3) Wszystkie dokumentacje etc. pisane są pierwotnie po angielsku.


Funkcja mail() może przyjąć jako pierwszy argument całą listę adresów mailowych na które ma wysłać maila - zobacz w manualu.

[PHP] pobierz, plaintext 
<?php
$mail=new mail('adres@wp.pl');
$mail->ustawNadawce('ktos@adres.pl');
$mail->ustawTemat('Temat testowy');
$mail->ustawTresc('przykladowa tresc');
$mail->wyslijMaila();
?>
[PHP] pobierz, plaintext 

a może lepiej nieco to uprościć, po co się męczyć i za każdym razem pisać $mail->ustawCośtam?

$mail=new mail('nadawca@wp.pl', 'biuro@cos.pl', 'Temat testowy', 'przykladowa tresc');
$mail->wyslijMaila();

tak łatwiej, lepiej i bardziej "obiektowo". W końcu do tego służą konstruktory. A jak będziesz miał kilku odbiorców to możesz przecież ich podać też w konstruktorze jako tablicę:
$odbiorcy = array('prezydent@polska.gov', 'premier@sejm.pl', 'ciocia_jadzia@gmail.com');
$mail=new mail('nadawca@wp.pl', $odbiorcy, 'Temat testowy', 'przykladowa tresc');
$mail->wyslijMaila();
a w funkcji wyslijMaila sprawdzasz czy $odbiorca jest tablica is_array($this->odbiorca) , i jak tak to przelatujesz foreach, a jak nie to wysyłaś tylko do jednego odbiorcy. Proste i elastyczne. Po wywaleniu funkcji dostępowych twoja klasa wydaje się dużo mniejsza i bardziej przejrzysta. A jeżeli jednak nie odpowiada Ci podawanie danych w konstruktorze (bo na przykład masz zamiar modyfikować twojego maila zanim go wyślesz) to poczytaj o metodach magicznych __set i __get
http://www.php.rk.edu.pl/w/p/metody-magiczne/

[PHP] pobierz, plaintext 
<?php
public $temat;
  
  ...
  
  public function ustawTemat($temat)
  {
      $this-> temat = $temat;
  }
?>
[PHP] pobierz, plaintext 

No ale albo robisz zmienną $temat (i inne) publiczne, albo robisz prywatne i dopiero wtedy potrzebujesz metod dostępowych typu ustawTemat. Przecież jak masz public to możesz się normalnie, bez żadnych funkcji odwoływać do tych zmiennych poprzez $mail->temat = "dzieńdobry ciociu" w dowolnym miejscu kodu, o ile stworzyłeś wcześniej ten obiekt. Z tym, że takie "upublicznianie danych" nie jest wcale zalecane w programowaniu obiektowym i dlatego w trosce o prywatność obiektów robi się zmienne prywatne (private zamiast public przed nazwą ) conajwyżej udostępniając publiczną "metodę dostępową". Co najwyżej, bo czasami jest to zbyteczne. Na przykład jeśli treść danego maila się nie będzie zmieniała, tylko raz przypiszesz i już to równie dobrze można to umieścić w konstruktorze i już nie męczyć się i obiektu


Hmm... ja bym powiedział, że za dużo się napatrzyłeś w czyjś kod i przykłady, a brakuje Ci teoretycznego zrozumienia wiesz "jak", ale nie wiesz "po co"

Hej mike, piszesz o mockowaniu obiektów? To rozumiem i się zgadzam.
Bardziej mi chodziło o podmianę sendera w czasie działania skryptu, bo przy takim bzdeciku nie widzę za bardzo innego zastosowania.
A tak nadal podtrzymuje moje dalsze słowa (których już nie skomentowałeś ;P)

Ja lubie zaczynac pisanie klas od drugiej strony, czyli od jej uzywania, potrzebujesz wyslac mailing do 1000 userow, kazdy dostanie ten sam email.

[PHP] pobierz, plaintext 
<?php
$emailSender=  new EmailSender($serverSMTP, 'user', 'haslo');
$email = new Email( $title, $subject );
foreach ( $users as $user )
{
    $emailSender->send( $email, $user->email );
}
?>
[PHP] pobierz, plaintext 

a teraz stworz klasy ktore to wykonaja.

Dzieki temu stworzysz cos czego potrzebujesz, i cos co robi to czego pragniesz.
Nie bedziesz dopisywal 100tek metod ktorych nigdy nie uzyjesz (no chyba ze piszesz uniwersalna biblioteke - ale, tu masz uniwersalne potrzeby).

Potem okaze sie ze potrzebujesz czegos jezszce - poprawiasz, itd.

No właśnie, bo w książce mało co jest napisane o przykładach.


dr_bonzo dzięki, może uda mi się coś wykombinować, z tego co widzę to będę musiał napisać dwie klasy:
EmailSender
Email
I napewno będę musiał zastosować dziedziczenie

PrinceOfPersia z OOP mam jak narazie małe doświadczenie, a więc komplikuje sobie wszystko jak mogę ponieważ nie jestem w tym płynny, ale się staram.

Crozin masz rację z tym nazewnictwem, mam znajomego programistę i to samo mówił o nazewnictwie co Ty

Tylko nie zrób telefonistki dziedziczącej po telefonie