Convert procedural PHP to object oriented PHP

Question

I currently have a fairly large application written entirely with procedural PHP. I want to continue my PHP experience and transcode most of my applications using object-oriented methods.

There are many areas where OOP can help reduce code and make it easier to read. However, I have a few questions.

1) I understand that one class is used as a plan for any number of objects, but any one class represents only one object, not more than one. Thus, one class can represent a player, but never consisting of several players.

2) . Since I will have quite a few different classes, should I use the "Loader" class to load all of them using spl_autoload_register or just use spl_autoload_register in the program files for my application?

Edit: So my autoloader will be a class that will then create an instance to run autoload, or just a php file with a function and spl_autoload_register that I would include to avoid repeating the same code in multiple files?

3) Some of my classes depend on other classes. I have never encountered this before, so I honestly don't know the answer. If I include all classes in my main program file, but the class of my class does not include the class that it needs to use, will the player class work since the main program includes the class on which the player depends?

Edit: So, although one class can create an instance of an object of type Player, and the Player class is not directly included in this class, it will still work, because the controller class includes the Player class

4) There are several cases when I will need to work with the objects that I create. I am wondering how I should do this. For example, in my Player class, I sometimes need to send something from one player to another player. So, am I implementing a static method in the Player class that takes two players as parameters and performs the transfer, or am I doing something else?

Edit: Good, so avoid static methods. Now I have a serious problem: I have methods that are executed several times in my application, but I can not implement them as static methods. Should I implement them as instance methods? For example, sending from one player to another. Would I create an instance method that takes a Player object and sends it to him or him?

5) I have many methods that really do not belong to any instance of the class, nor do they really work like static methods. Should they be declared in their own class as static methods such as Common or similar? What is being done in practice in this situation?

Edit: Will these methods belong to a specific application file for which they are used, or possibly stored in their own functions.php file?

6) I would like to learn how to use namespaces, but my code will never be used by others, and I will never use any other code in my application. Are namespaces an overkill in my application, or would it be a good idea to learn how to use them? Regardless of whether one application has one namespace (application name?) Or does each class belong to its own namespace?

7) Finally, is it common to have one class for connecting to the database, as well as a class for network methods? My application needs both. I think that the main problem that I am encountering in converting my code to using object-oriented methods is determining which methods should be placed where they are currently all in the same monolithic file.

Thanks for any help and understanding you can provide.

Answer 1

1) I understand that one class is used as a plan for any number of objects, but any one class represents only one object, not more than one. Thus, one class can represent a player, but never consisting of several players.

Typically, you will also have classes representing collections of objects, for example. the Players class, which can be used to extract one player from the collection of all players:

 $players = new Players(); $john = $players->findByName("john"); 

2) Since I will have enough of several different classes, can I use the "Loader" class to load them all with spl_autoload_register or just use spl_autoload_register in the program files for my application?

It pretty much depends on the complexity of your project. A simple autoloader function will usually be good enough, but you can take a look at the Zend Framework autoloader class .

3) Some of my classes depend on other classes. I have never encountered this before, so I honestly don't know the answer. If I include all classes in my main program file, but the class of my class does not include the class that it needs to use, will the player class work since the main program includes the class on which the player depends?

Yes. However, at startup, you don’t have to worry about this at all. If you do not use autoload, it is recommended that you add the necessary classes to the file that the class defines (using require_once() to avoid including the same file more than once).

4) There are several cases when I will need to work on the objects that I create. I am wondering how I should do this. For example, in my Player class, I sometimes need to send something from one player to another player. So, am I implementing a static method in the Player class that takes two players as parameters and performs the transfer, or am I doing something else?

Static methods are almost always the wrong approach. Normal methods refer to an instance (i.e., a specific player) and static methods refer to a class, i.e. The general "idea" of a player. If you need to transfer things from one player to another, why not implement it as follows:

 class Player { public function transferMoney(Player $recipient, $amount) { ... } } $tom = new Player("tom"); $marc = new Player("marc"); $tom->transferMoney($marc, 500); 

5) I have many methods that really do not belong to any instance of the class, nor do they really work like static methods. Should they be declared in their own class as static methods such as Common or similar? What is being done in practice in this situation?

I can not answer that. However, there are still simple functions in PHP that seem to be the best method for such cases. However, if you do OOP correctly, you will most likely never encounter such problems. This is usually a design problem for your class, which makes you realize that these methods do not belong to any object.

6) I would like to learn how to use namespaces, but my code will never be used by others, and I will never use any other code in my application. Are namespaces an overkill in my application, or would it be a good idea to learn how to use them? Regardless of whether one application has one namespace (application name?) Or does each class belong to its own namespace?

Namespaces are great, but your code is likely to be unchanged. Because namespaces can be nested, you will usually have a top-level namespace and sub-names for each component.

7) Finally, is it common to have one class for connecting to the database, as well as a class for network methods? My application needs both. I think that the main problem that I am encountering in converting my code to using object-oriented methods is determining which methods should be placed where they are currently all in the same monolithic file.

It depends on how you model your real situation. If connecting to a database and “network” are two different things for you, two ways is the way.

Answer 2

1) I understand that one class is used as a plan for any number of objects, but any one class represents only one object, not more than one. Thus, one class can represent a player, but never consisting of several players.

A class does not represent anything, because, as you correctly stated, it is just a project for any number of objects. You can have several instances (objects) of one class representing several players.

2) Since I will have enough of several different classes, can I use the "Loader" class to load them all with spl_autoload_register or just use spl_autoload_register in the program files for my application?

Not knowing what you mean by “program files for my application,” I say yes. Use the autoloader because it works, and you don’t have to worry about doing require_* .

3) Some of my classes depend on other classes. I have never encountered this before, so I honestly don't know the answer. If I include all classes in my main program file, but the class of my class does not include the class that it needs to use, will the player class work since the main program includes the class on which the player depends?

You do not want to load all classes, but only those that you intend to use. Which again is not what you need to worry about when using the autoloader. But yes, once the class is loaded, it can be implemented throughout the application.

Usually you want to start the autoloader at the initial boot stage of the application .

4) There are several cases when I will need to work on the objects that I create. I am wondering how I should do this. For example, in my Player class, I sometimes need to send something from one player to another player. So, am I implementing a static method in the Player class that takes two players as parameters and performs the transfer, or am I doing something else?

Avoid using static methods in OOP PHP. It is almost never needed. You might consider having another class that acts like a pool of players that takes care of “sending data” from one player to another.

Thus, it doesn't matter where the class file is included until it tries to create it.

5) I have many methods that really do not belong to any instance of the class, nor do they really work like static methods. Should they be declared in their own class as static methods such as Common or similar? What is being done in practice in this situation?

Do not use static methods again. If you use them inside any other class, you only complicate the unit test of your classes and introduce hidden dependencies. In my experience, it almost never happens that someone has any one method. You may be doing too much.

But it's hard to say just by reading your question. Maybe you can give an example in a comment?

6) I would like to learn how to use namespaces, but my code will never be used by others, and I will never use any other code in my application. Are namespaces an overkill in my application, or would it be a good idea to learn how to use them?

The namespace in PHP is structuring. Although no one will use your code, you do not have to worry about using the same name for any class. What will happen as soon as the application becomes larger, and not earlier.

Regardless of whether one application has one namespace (application name?) Or does each class belong to its own namespace?

I often follow PSR-0 when it comes to namespaces.

7) Finally, is it common to have one class for connecting to the database, as well as a class for network methods? My application needs both. I think that the main problem that I am encountering in converting my code to using object-oriented methods is determining which methods should be placed where they are currently all in the same monolithic file.

Just keep the principle of sole responsibility and in general SOLID .

I also highly recommend watching these and keeping an eye on them until you understand this.

Answer 3

• A PlayerCollection will be a valid class. Of course, the object of this is one set of several players.

• Use spl_autoload_register, period. Better follow the PSR-0 standard and use any existing PSR-0 compatible autoloader (i.e. Symfony Loader )

• That will work. But since you use an autoloader (see 2.), you do not need to worry about including classes at all

• Sending a message from player 1 to player 2 is easily translated when calling the method of player 2 in player 1. However, “sending things” and “working on objects” can mean a lot of things, so the answer is: it depends. But overall, this is good advice to avoid static methods.

• This is very similar to procedural thinking. Sorry, but I can’t give you the answer to the silver bullet, you will need to study and understand the principles of object-oriented design for their application. There is standard literature on the Internet and many useful resources. An example study may also be useful (look at other OO applications and frameworks that are open source)

• "does one application have one namespace (application name?) or does each class belong to its own namespace?" - the answer is between them. Namespaces are useful for grouping things that work together, and they are useful no matter who uses or sees the code.

• The first rule of object-oriented design: one class, one responsibility.