new to oop in PHP a plea for clarifying concepts

Question

I love the PHP language, Ive got SOME coding experience but I am fairly new to PHP although I have been learning a lot I feel I am now stuck / held back by not getting the hang of OOP concepts, although I have been browsing through multiple tutorials.

This is not so much a question about the code itself but rather behind the logic of it

Consider this tutorial I worked from

class person { 
    var $name; 
    function set_name($new_name) { 
        $this->name = $new_name;
    } 
    function get_name() { 
        return $this->name 
    } 
} 

$stefan = new person();
$jimmy = new person;   
$stefan->set_name("Stefan Mischook"); 
$jimmy->set_name("Nick Waddles");  

echo "Stefan's full name: " . $stefan->get_name(); 
echo "Nick's full name: " . $jimmy->get_name(); ?>

I understand what is going on above and I understand the concept but I cant see the benefit of it, I just feel I could have created the above in a much simpler way by simply doing

function person($name){
    return $name;
}
echo person("Tim Jones");

Why the getter and the setter function, why not just one function in class person?
Why go through all that code above when my function above is so much shorter?
Where is the benefit here?

I'm basically just looking for someone to give me a bit of clarification on the whole OOP concept which I cant seem to get by the many repetitive tutorials I have been reading.

This is a fairly broad topic in which a lot of books have been written, maybe you could buy one of them. — Daan, Jul 29 '15 at 15:03
OOP isn't about making code shorter -it's about organizing behaviors and attributes of things. You don't need to use getters and setters, but using them allows you to prevent other objects from modifying properties they shouldn't have access to. — Michael Berkowski, Jul 29 '15 at 15:04
By the way, the `var` keyword in your code (and absence of `public/private` keywords) suggests the tutorial you are using is sort of outdated. The `var` keyword is part of the PHP 4 class definition syntax and is deprecated. An updated tutorial would be helpful. — Michael Berkowski, Jul 29 '15 at 15:06
I also think you need to look at some more up to date tutorials as `var $name;` _is so last season man_. But seriously, look for some PHP5 and above tutorials, PHP5.6 would be even better. Things in the OO area of PHP have changed HUGHLY since PHP4 — RiggsFolly, Jul 29 '15 at 15:06
@Daan yes and I will buy one but as far as I am concerned, SO has always been very kind to me. I just need that little light bulb to go on to grasp the concept. The SO community has always been very kind in this regard with assisting and advising me hench I turned here — Timothy Coetzee, Jul 29 '15 at 15:09
Understanding the S.O.L.I.D. principles may be a good start - basically, well designed OO code is very easy to test and extend. https://scotch.io/bar-talk/s-o-l-i-d-the-first-five-principles-of-object-oriented-design — Michael Berkowski, Jul 29 '15 at 15:10
#1: http://stackoverflow.com/questions/1568091/why-use-getters-and-setters. #2 Apples and Oranges. You end up echoing a string in your example, whereas the OOP example results in an object with properties. #3 In such a short example there really isn't a benefit in using OOP over what you proposed, but then again you don't end up with the same thing. Also, OOP is usually more suited for larger projects or code that will be re-used or shared. — j08691, Jul 29 '15 at 15:11
OOP doesn't necessarely make your specific case easier or harder or whatever, but it is very useful when you need to write and mantain a logic in your code. Objects are useful when you need to fastly get/change data on a large project or when you need to provide your code to someone else, or when you need to change the output of a serie of elements instead of a single element. Just try to write a quite interesting project (let's say 5k lines of code for instance) and wait a week: if you read that code again you will just get mad if you don't follow a specific logic behind your code. — briosheje, Jul 29 '15 at 15:31

score 2 · Answer 1 · edited Jul 29 '15 at 15:34

The advantages of OOP is that anything acting upon a class or object does not need to know how that class or object works under the hood, and much more complicated things can be accomplished in the background with the bulk of your application being un-involved, making your code much more readable.

Consider the following [partially]pseudocode web app example:

$users = array();
$users[] = new User('joe', ADMIN, ACTIVE);
$users[] = new User('jane', ADMIN, ACTIVE);
$users[] = new User('bill', USER, INACTIVE);

class User {

    public $Name;
    public $Security;
    public $Active;

    public function __construct($name, $security = USER, $active = INACTIVE) {
        $this->Name = $name;
        $this->Security = $security;
        $this->Active = $active;
    }

    public function ToggleActive() {
        //Not actual working code ahead
        $this->Active = ($this->Active) ? INACTIVE : ACTIVE;
        $sql->query('UPDATE users SET active=$this->Active WHERE name=$this->Name');
    }

    public function SetSecurity($security) {
        //More non-functional examples
        $this->Security = $security;
        $sql->query('UPDATE users SET security=$this->Security WHERE name=$this->Name');
    }

}

?>

<html>
    <form>
        <!-- this is, of course, the wrong markup, but the concept is there-->
        foreach($users as $user) {
            <name>$user->Name</name>
            <security>$user->Security <button $user->SetSecurity(ADMIN)>Set Admin</button> <button $user->SetSecurity(User)>Set User</button>
            <active>$user->Active <button $user->ToggleActive>Toggle Active</button>
        }
        <!-- you could even have the class itself output the form html with something like $user->DrawEntryHTML();-->
    </form>
</html>

Obviously, there is a lot more that goes in to the web app interface of such an operation (AJAX, function handlers, etc.), but the basics are there, and only the user object itself needs to know how to perform the operation. The rest of your app can simply say Hey, user. You're active now.

OOP gives you an abstract but meaningful way of accomplishing what you want your application components to do. In most applications these days, when a user interacts, or a task happens, a number of things need to happen in order to store, display, and modify its elements. You also gain the advantage of only needing to change a small bit of code in your class in case of a change, update, or feature addition, rather than chasing all over the rest of your code for everything that relates to your users (in this case).

You'll find that a well-written OOP application has a very short program loop (or index.php), and the bulk of the work happens within its class objects.

score 2 · Answer 2 · answered Jul 29 '15 at 15:32

A good case for using classes is when you may want to expand or rewrite functionality later on.

A few years back I wrote an application in PHP which was used to create issues within Jira. At this point, I was using SOAP to perform the actual issue creation and updates using the published API

Later on, within the same application, I needed to use features within Jira which were associated with the Atlassian Greenhopper/Agile extension. This extension used a REST API and it became apparent that Atlassian was moving all their APIs across to using REST

As I had used a class for the calls to Jira, all the actual grunt work in the background was abstracted. I knew which data was expected and what data I would be expecting

In the end, I wrote a new class to use REST (via cURL calls), and re-wrote the class which accessed Jira. I didn't have to go through the whole application and check each call to a Jira function as the data in and data out was the same.

In reality, the classes I wrote all descended from the REST class:

REST -> JIRA_BASE -> JIRA

The JIRA_BASE class contained methods which were common across all Jira projects (get project names, get user id's etc). The JIRA class itself contained a couple of functions (createJiraIssue and updateJiraIssue) which were particular to each Jira project

The other advantage of using classes and objects is that you can put place-holders in for functions. In the REST class, trying to use a DELETE method (rather than GET, POST or PUT) for a REST call would error straight away (I hadn't written it as I didn't need it). However, I have re-used the same class in another application where I did need to use the DELETE method so that is now written

It also became apparent that the new application needed a change in one aspect of functionality. This was implemented without re-writing any of the calling code

Getters and setters are used to ensure that data is accessed in a controlled manner. If you just use a variable within a script, any part of that script could alter the data. If that data is stored within a class and set to private, then only a call to the getter or setter can alter or retrieve that data.

Additionally, getters and setters can alter the way the data is actually stored but still present it in a usable format. For example, when performing a call to

$obj -> setName('DaveyBoy');

that data could be reversed, escaped, encrypted, stored in session variables, sent to a database and rot13'ed (in no particular order). But, a call to

$name  = $obj -> getName()

would still store 'DaveyBoy' in $name without any intervening steps.

I've rambled about classes and why I use them but, hopefuly, this helps to explain a bit.

score 1 · Accepted Answer · answered Jul 29 '15 at 15:23

Consider what happens when you want to change the behaviour of the code - suppose it's been running for a while and you discover that you have lots of duplicate records where people have used variants in the whitespace and capitals. You might then want to amend the code to....

 function set_name($new_name) { 
    $new_name=trim(strtoupper($new_name));
    $new_name=str_replace('  ',' ', $new_name);
    $new_name=str_replace('  ',' ', $new_name);
    $name_parts=explode(' ', $new_name);
    $this->surname=array_pop($name_parts);
    $this->forenames=implode(' ', $name_parts);
 } 
 function get_name()
 {
    return $this->forenames . ' ' . $this->surname;
 }

But you don't need to change any of the code which interacts with the object.

Now think about a class which describes organizations rather than individuals - they have names - but not forenames and surnames. If you have a class with the same interface (get_name, set_name) then you can throw a mixed bundle of person and organizations at your Christmas card printer application without having to amend the app to cope with the different data types.

(tutorial examples are kept very simple for a reason, unfortunately a lot of the benefits of OO only become apparent when dealing with complex problems - stick with it and you'll get there)

Frankie · Answer 4 · 2015-08-14T16:29:49.933

Notice that my answer focus not on the major strengths of OOP as you have already read on those and - as they currently don't apply to your situation - were meaningless. I'm going to focus on what OOP can do to you right now.

The example you give is actually a good one.

Say that you also wanted to attach height, weight, birthday and profession to a person.

Not using objects you could create an array of arrays (to store multiple persons with multiple attributes) but 2 hours into the coding you would try to access the persons job as:

echo $persons[0]['job'];

And it would fail as that field is actually named 'profession'; using objects not only will your IDE know the getters it will also help you.

The major strength of OOP is only really seen when you work in teams or expose code to be used by others however the example I gave should suffice to understand why even as a single developer there are benefits.

That being said, for over simplistic actions it can be overkill.

new to oop in PHP a plea for clarifying concepts

4 Answers4