This document provides an overview of object-oriented programming concepts like encapsulation, inheritance and access levels. It also summarizes Laravel fundamentals like directory structure, configuration, routing and controllers. Key points covered include defining public, private and protected properties and methods, using a front controller pattern, caching configurations, and organizing controller classes to handle requests.

1. Object-Oriented
Programming
(with Laravel)
By: Shahrzad Peyman
Session 2
April-2017
shahrzad.peyman@gmail.com
1

2. 2
Today’s Presentation
• Encapsulation, Access Level and Inheritance
• Local Development Server
• Front Controller
• Configuration
• Directory Structure
• The Root Directory
• The App Directory
• Routing
• Controllers

3. Encapsulation
• In basic terms, it’s the way we define the
visibility of our properties and methods.
• When you’re creating classes, you have to
ask yourself what properties and methods
can be accessed outside of the class.
3

4. Access Levels
Specifier Class SubClass all
Private *
Protected * *
Public * * *
4

5. Inheritance
• In object-oriented programming, inheritance
is when a class is based on another class,
using the same implementation or specifying
a new implementation to maintain the same
behavior.
• Such an inherited class is called a subclass
of its parent class or super class.
5

6. Inheritance
6

7. Inheritance
7

8. Local Development Server
• If you have PHP installed locally and you
would like to use PHP's built-in development
server to serve your application, you may use
the serve artisan command.
• This command will start a development
server at http://localhost:8000
• Of course, more robust local development
options are available via Homestead and Valet.
8

9. Front Controller
• Like HTTP itself, the Request and Response objects are
pretty simple. The hard part of building an application
is writing what comes in between. In other words, the
real work comes in writing the code that interprets the
request information and creates the response
• Your application probably does many things, like
sending emails, handling form submissions, saving
things to a database, rendering HTML pages and
protecting content with security. How can you manage
all of this and still keep your code organized and
maintainable?

10. Front Controller
• Traditionally, applications were built so that each
"page" of a site was its own physical file:
A. index.php
B. contact.php
C. blog.php
• There are several problems with this approach,
including the inflexibility of the URLs (what if you
wanted to change blog.php to news.php without
breaking all of your links?) and the fact that each
file must manually include some set of core files
so that security, database connections and the
"look" of the site can remain consistent.

11. Front Controller
• A much better solution is to use a front
controller: a single PHP file that handles
every request coming into your application.
• Now, every request is handled exactly the
same way. Instead of individual URLs
executing different PHP files, the front
controller is always executed, and the routing
of different URLs to different parts of your
application is done internally.

12. Configuration
Public Directory:
After installing Laravel, you should configure
your web server's document / web root to be
the public directory.
The index.php in this directory serves as the
front controller for all HTTP requests entering
your application.
12

13. Configuration
Config Directory:
All of the configuration files for the Laravel
framework are stored in the config directory.
Application Key:
The next thing you should do after installing Laravel
is set your application key to a random string. If you
installed Laravel via Composer or the Laravel
installer, this key has already been set for you by the
php artisan key:generate command.
13

14. Configuration
Configuration Caching:
To give your application a speed boost, you should
cache all of your configuration files into a single file
using the config:cache Artisan command.
This will combine all of the configuration options for
your application into a single file which will be loaded
quickly by the framework.
14

15. Configuration
Maintenance Mode:
When your application is in maintenance mode, a
custom view will be displayed for all requests into
your application. This makes it easy to "disable"
your application while it is updating or when you are
performing maintenance.
To enable maintenance mode, simply execute the
down Artisan command: php artisan down.
To disable maintenance mode, use the up command.
15

16. Directory Structure
The default Laravel application structure is
intended to provide a great starting point for
both large and small applications. Of course, you
are free to organize your application however
you like.
Where is Models Directory?
16

17. The Root Directory
• App
• Bootstrap
• Config
• Database
• Public
• Resources
• Routes
• Storage
• Tests
• Vendor
17

18. 18
The App Directory
The majority of your application is housed in the App
directory. By default, this directory is namespaced under
App and is autoloaded by Composer using the PSR-4
autoloading standard.
The App directory contains a variety of additional
directories such as Console, Http and Providers. Think of
the Console and Http directories as providing an API into
the core of your application. The HTTP protocol and CLI
are both mechanisms to interact with your application,
but do not actually contain application logic.

19. Routing
The most basic Laravel routes simply accept a
URI and a Closure, providing a very simple and
expressive method of defining routes:
All Laravel routes are defined in your route
files, which are located in the routes directory.
19

20. Available Router Methods
20

21. Route Parameters
21

22. Regular Expression Constraints
22

23. Global Constraints
If you would like a route parameter to always be
constrained by a given regular expression, you
may use the pattern method. You should define
these patterns in the boot method of your
RouteServiceProvider:
23

24. 24
Named Routes

25. 25
Route Prefixes

26. 26
Controllers
Instead of defining all of your request handling logic as
Closures in route files, you may wish to organize this
behavior using Controller classes. Controllers can group
related request handling logic into a single class.
Controllers are stored in the app/http/controllers directory.

27. Single Action Controllers
27