Visit https://ebookmass.

com to download the full version and

browse more ebooks or textbooks

PHP: 3 books in 1 : PHP Basics for Beginners + PHP

security and session management + Advanced PHP
functions Andy Vickler

_____ Press the link below to begin your download _____

https://ebookmass.com/product/php-3-books-in-1-php-basics-
for-beginners-php-security-and-session-management-advanced-
php-functions-andy-vickler/

Access ebookmass.com now to download high-quality

ebooks or textbooks
 We believe these products will be a great fit for you. Click
the link to download now, or visit ebookmass.com
to discover even more!

PHP 8 Basics: For Programming and Web Development Gunnard

Engebreth

https://ebookmass.com/product/php-8-basics-for-programming-and-web-
development-gunnard-engebreth/

An Introduction to PHP: Learn PHP 8 to Create Dynamic

Websites 1st Edition Mark Simon

https://ebookmass.com/product/an-introduction-to-php-learn-php-8-to-
create-dynamic-websites-1st-edition-mark-simon/

An Introduction to PHP: Learn PHP 8 to Create Dynamic

Websites Mark Simon

https://ebookmass.com/product/an-introduction-to-php-learn-php-8-to-
create-dynamic-websites-mark-simon/

PHP 8 Basics: For Programming and Web Development 1st

Edition Gunnard Engebreth

https://ebookmass.com/product/php-8-basics-for-programming-and-web-
development-1st-edition-gunnard-engebreth/
Safety of Web Applications. Risks, Encryption and Handling
Vulnerabilities with PHP 1st Edition Edition Éric Quinton
(Auth.)
https://ebookmass.com/product/safety-of-web-applications-risks-
encryption-and-handling-vulnerabilities-with-php-1st-edition-edition-
eric-quinton-auth/

Learn French for Beginners Complete Bundle!: Beginners

Guide to French Vocabulary, Phrases, and Verbs - 3 books
in 1 Daily Learning Academy
https://ebookmass.com/product/learn-french-for-beginners-complete-
bundle-beginners-guide-to-french-vocabulary-phrases-and-verbs-3-books-
in-1-daily-learning-academy/

Python for Beginners: Master Python Programming from

Basics to Advanced Level Tim Simon

https://ebookmass.com/product/python-for-beginners-master-python-
programming-from-basics-to-advanced-level-tim-simon/

Coding for Kids 5 Books in 1: Javascript, Python and C++

Guide for Kids and Beginners (Coding for Absolute
Beginners) Mather
https://ebookmass.com/product/coding-for-kids-5-books-in-1-javascript-
python-and-c-guide-for-kids-and-beginners-coding-for-absolute-
beginners-mather/

Coding for Kids 5 Books in 1: Javascript, Python and C++

Guide for Kids and Beginners Bob Mather

https://ebookmass.com/product/coding-for-kids-5-books-in-1-javascript-
python-and-c-guide-for-kids-and-beginners-bob-mather/
 © Copyright 2022 - All rights reserved.

The contents of this book may not be reproduced, duplicated, or transmitted without direct written permission from the author.
Under no circumstances will any legal responsibility or blame be held against the publisher for any reparation, damages, or
monetary loss due to the information herein, either directly or indirectly.

Legal Notice:
You cannot amend, distribute, sell, use, quote, or paraphrase any part of the content within this book without the consent of the
author.

Disclaimer Notice:
Please note the information contained within this document is for educational and entertainment purposes only. No warranties of
any kind are expressed or implied. Readers acknowledge that the author is not engaging in the rendering of legal, financial,
medical, or professional advice. Please consult a licensed professional before attempting any techniques outlined in this book.

By reading this document, the reader agrees that under no circumstances is the author responsible for any losses, direct or
indirect, which are incurred as a result of the use of the information contained within this document, including, but not limited to,
—errors, omissions, or inaccuracies.
 Table of Contents

PHP
PHP Basics for Beginners
Introduction
PHP – Definition and History
PHP Structure
PHP Code Syntax.
PHP Objects & Classes
Obstacles to Mastering Object-Oriented Programming
What Are Object and Classes in PHP
Instantiation
The Variable $this
Access Modifiers
Inheritance
The Overriding of Method
Horizontal Inheritance - Using Traits
Invoking Parent Methods
Polymorphism
Encapsulation
Dunder Methods in PHP
__construct ()
__destruct()
__get(), __set(), __isset()
__call()
__sleep()
__wakeup()
__clone()
Abstract Classes & Method
Abstract Keyword
Abstract Methods
Final Keyword
Interfaces
Interface and Implements Keywords
Static Methods & Properties
 Static Properties
Late Static Binding
Error Control and Exception Handling in PHP
The Pre-Existing Exception Class
Throwing an Exception
Setting a Level of Desired Error Sensitivity.
Error Reporting Sensitivity Levels
Logging Options
The Design Pattern of Model_View_Controller
The MCV URL Structure & URL Mapping
The index.PHP File
MVC Folder Structure
Develop the Functionality to Add New Carte Products
The Reflection API
The Pear Library
Install PEAR in a Windows Zend Framework Environment
Installation of PEAR in a Windows XAMPP Environment
Install PEAR in a Windows WAMP Environment
Install PEAR on Mac OS
Installing PEAR on Linux
Using PEAR - EXAMPLE:
Unit Testing With Phpunit
Installation of PHPUnit
Install PHPUnit on Macbook
Installation of PHPUnit on Linux
Test fixtures
Test Phases
Writing Test Cases
Assertion Methods
Testing Data from HTML Form Submissions
Test Suites
Mocks and Stubs
Create a Mock Class
Running PHPUnit from Eclipse Without Plug-ins
SVN - Source Code Management With Subversion
Installing Subversion on Windows
Installing Subversion on Macbook
 PHP
PHP Security and Session Management
Chapter 1: Introduction to Php Security
XSS Attacks
Session Hijacking
Injection
Php Sessions
Create Sessions
Access Session
Destroy Session
XSS (Cross-Site Scripting) Attack
Session Side Jacking
Fixation of the Session
PHP Session Protection
Php Manual
Chapter 2: XSS (Site-to-Site Scripting)
Virus Infection of a Website
Stored (Persistent) XSS
Examples of Cross-Site Scripting (XSS)
Hijacking
Risk Levels of XSS Vulnerabilities
Preventing and Mitigating XSS Attacks
The usage of similar data types.
Validation of Input
Sanitization of the Output
XSS Testing Tool by PT AI
Chapter 3: Session Hijacking
The Different Types of Brute Force Attacks
Malicious Activity Hijacking Systems
Brute-Force-Attacking Tools
How Can Brute Force Attacks Be Prevented?
Chapter 4: Injections
SQLI Avoidance and Prevention
Cross-Site Scripting (Cross-Site Scripting) is an (XSS)
Alternate XSS Syntax
How to Prevent Code Injection in Applications?
 How Can You Find Injection Flaws in Your Web App?
How Can Injection Attacks be Avoided?
Chapter 5: XSRF/CSRF
Preventing XSRF or CSRF Attack
Chapter 6: Php Security Best Practices
Chapter 7: Session Management
Chapter 8: Php Sessions
What Is a PHP Session, Exactly?
Create Sessions
Access Sessions
Destroying a Session
Chapter 9: How Secure Is Php Session
Unpatched Vulnerabilities With PHP Presentations
Hijacking Session Attack Working
Chapter 10: Php Session Management Best Practice
Chapter 11: Php Manual

PHP
Advanced PHP Functions
Introduction
Chapter 1: PHP Functions
Defining a Function
Types of Functions in PHP
PHP Function Arguments
PHP Function Default Values
Returning Values
Chapter 2: PHP Arrays
Length of an Array
PHP Indexed Arrays
PHP Associative Arrays
Multidimensional Arrays
Sorting Arrays
Chapter 3: PHP Superglobals
PHP $_SERVER
 PHP $_POST Variable
Interactive PHP Programming
PHP Date and Time
Chapter 4: Object-oriented Programming
PHP Classes
Class Objects
Adding More Methods to the Guns Class
PHP The_Construct Function
The_Destruct Function of PHP
PHP Access Modifiers
Inheritance Classes
PHP Final Keyword
PHP Abstract Classes
PHP Class Interfaces
Chapter 5: Database Creation in PHP
Make the Connection
MySQLi Procedural
Database Creation
Table Creation
Chapter 6: PHP and SQL Database Commands
SQL Column Selection
WHERE Examples
Text Fields
The SQL AND, OR Operators
The NOT Clause
The Double Not Clause
Deciphering the SQL ORDER BY Keyboard
SQL Insert Into Clause
The UPDATE Statement
The DELETE Statement
TOP, ROWNUM, LIMIT Clause
The TOP 50 Percent
The Wildcards
Chapter 7: Restful APIs
Benefits of RESTful APIs
How to Create RESTful APIs
The Syntax for RESTful APIs
Chapter 8: PHP and Internet Services
 Benefits of Using PHP for Internet Services
Challenges in Using PHP for Internet Services
Examples of Internet Services That Use PHP
Chapter 9: PHP Graphics
Drawing Lines in PHP
Drawing Rectangles in PHP
Drawing Circles in PHP
Drawing Polygons in PHP
Chapter 10: Files
PHP File Function Syntax
Uses of the Files Function
Chapter 11: Session and Cookies
Types of Cookies in PHP
Chapter 12: Mathematical Functions
Chapter 13: Working With Arrays
Chapter 14: String Functions
Benefits of String Functions in PHP
Examples of String Functions
Conclusion
 PHP
PHP BASICS FOR BEGINNERS

Andy Vickler
 Introduction

After learning PHP, I secured a high-paying back-end web development job right out of college
by demonstrating to recruiters my command of the language and my understanding of other
aspects of web development through my developed project. PHP is a relatively easy language for
beginners to learn, with a clean and stylish syntax, whose mastery is possible within a relatively
short duration from beginner to the professional level, typically 2–3 months. However, there is a
caveat.

As a novice, the instructor and the method of instruction have a considerable impact on the
learner's ability to assimilate. Without a good tutor, the student may quickly lose interest in the
subject. This can have a huge impact on one's career path in the worst-case situation. I, too, had
to struggle to learn these things.

Throughout my education, I learned that most PHP study materials - books, PDFs, and tutorials -
are not user-friendly. I felt that the author/tutor rushed through the course and neglected to
clarify the thought process required to get at the reasoning behind particular lines of code,
assuming the audience is already conversant with PHP. This is not the case for a newbie, so I
will spend time explaining the logic behind each code in this book.

When it comes to learning PHP, it is critical to choose an effective resource - one that keeps the
learning curve linear and progresses to difficult topics. After providing sufficient insight and
examples on the concepts, one that discusses the questions asked by recruiters at top
organizations, one that offers in-class support in the form of resolving any doubts students may
have about a concept or while solving practice problems, one that provides in-class support in the
form of resolving any questions students may have about a concept.

I'd like to emphasize that I relied heavily on free online video classes when I began learning.
However, as time went on, I learned that one of the primary challenges with learning from them
is that a 'free and open to everyone' society often attracts those who only want to make a quick
buck resulting in low-quality content.

Additionally, I noticed on a few websites that the author uses untaught reasoning when
answering programming queries or defining a concept. As a result, the learner will be guided to
the educational portions that handle that specific subject. The topics taught in those sections are
based on the rationale offered in another resource area; this book will try to avoid such an
approach.
 PHP – Definition and History

The abbreviation PHP means Hypertext Preprocessor. The initial letter of the acronym represents
the full term, a most confusing trait of the language. It is considered to be a pretty simple one to
master.

PHP is a scripting language primarily built for the construction of websites. Data retrieval from
SQL databases is a typical use. It is also used in the production of graphs and other
visualizations. For instance, a designer can create links to images or make thumbnails for an
image gallery. PHP is responsible for duties such as password acceptance, user authentication,
and handling forum posts and guest books. Another frequent application is Facebook integration.

You may even use PHP to develop a website that enables users to create content - even if they
lack basic HTML knowledge!

The fact that PHP is dynamic is one of the key distinctions between it and normal HTML.
However, this is not an either/or scenario as both languages are interoperable. PHP has the
ability to generate HTML code.

PHP in its current form is a descendent of a program called PHP/FI. PHP’s first release was in
1994 by Rasmus Lerdorf. He named the script package "Personal Home Page Tools" or "PHP
Tools" because it was originally used to track visits to his online curriculum vitae. Rasmus
modified PHP Tools over time when additional functionality became necessary, resulting in a
substantially larger and more powerful implementation.

This new paradigm may interact with databases and other systems, enabling users to construct
simple dynamic web applications such as guestbooks. Rasmus gave the PHP Tools source code
to the public in June 1995, allowing developers to tweak it as desired. Additionally, users were
able - and encouraged - to provide solutions for code faults as well as general improvements.

Rasmus expanded PHP in September of that year, and for a little period, the PHP designation
was discarded. The new implementation, termed FI, includes several of PHP's essential functions
(short for "Forms Interpreter"). Variables resembling those found in Perl, automatic form
variable interpretation, and embedded HTML syntax were all included. Similar to Perl's syntax,
but far more restricted, basic, and inconsistent.

Developers must use HTML comments to embed code in an HTML file. Despite mixed reviews,
FI gained popularity and acceptability as a CGI tool — but not quite as much as it did as a
language. In October 1995, all this changed because Rasmus did a complete redesign of the code.
It was the first edition that included what is often considered an advanced scripting interface,
briefly called "Personal Home Page Construction Kit." The language's structure is similar to that
of C. It is, therefore, simpler for developers with experience in C, Perl, and other related
languages. The prospect of a Windows NT implementation was being explored, which had
previously been restricted to UNIX and POSIX-compliant PCs.

Rasmus renamed the code PHP/FI in April 1996, combining the names of previous iterations.
PHP began to truly emerge as a programming language in its own right with this second-
generation implementation. It supported databases DBM, mySQL, and Postgres95, as well as
cookies and user-defined functions. In June of that year, PHP / FI was upgraded to status 2.0.
PHP 2.0 was released as a single full version. It began as a beta version in the November of
1997. By that time, the main parsing engine had been totally rewritten.

Despite its brief development period, In the still-developing field of web development, it gained
a lot of traction quickly. PHP/FI gained a devoted presence of a couple of thousand individuals
throughout the world between 1997 and 1998. According to a May 1998 Netcraft survey,
Approximately 60,000 domains included the phrase "PHP" in their headers, showing that the
host server was executing it. At the time, this represented over 1% of total domains on the
Internet. Even with these impressive figures, PHP/development FI's remained small; while there
were a few tiny contributors, most of the code was written by a single person.

The edition that resembled PHP today was PHP 3.0. Following the discovery that PHP/FI 2.0
was still problematic and was incapable of running an ‘e-commerce application’ they tried to
establish as a university project, ‘Zeev Suraski’ and ‘Andi Gutmans’ of Tel Aviv, Israel, rebuilt
the parser in 1997. They corresponded with Rasmus via email over the reconstruction of PHP
and several parts of their recent implementations. Zeev, Andi, and Rasmus together begin
working on this programming language in order to improvise it and make it independent in order
to boost the engine and begin increasing the PHP/current FI user base. To prevent the idea of
limited personal usage implied by the PHP/FI 2.0 nomenclature, this brand-new language was
renamed. It was renamed "PHP" by recursively shortening the phrase Hypertext Preprocessor.

The strongest and most required characteristic of the new PHP 3.0 was its extensibility. The
language's extensibility drew numerous developers devoted to adding various components as
well as a matured interface for various APIs, protocols, and databases. This was perhaps the
deciding factor in PHP 3.0's enormous success. Additionally, PHP 3.0 was capable of supporting
OOP (object-oriented programming) along with a language syntax with substantial advancement
and uniformity.

The newly formed PHP Development Team launched PHP 3.0; PHP/FI 2.0’s official successor,
in June of 1998, attracting a significant number of fresh developers from all across the globe.
Since November of the previous year, it was clear that development on PHP/FI 2.0 had come to a
stop. ‘PHP 3.0’ has already been deployed on over 70,000 domains worldwide after nine months
of free public testing before it was allowed to portable_opetaring_system (POSIX-compliant). A
limited segment of websites reported PHP hosting on NT servers, "Windows 95, 98", and "Apple
computer." PHP 3.0 was formerly utilized on around 10% of all website servers.

In 1998, when PHP 3.0 had officially launched, Zeev Suraski and Andi Gutmans continued
working on rewriting PHP's foundation. The design's goal was to boost the efficiency of
complicated apps while simultaneously increasing the versatility of the structure of PHP. While
its enhanced functionality and availability for a vast scope of arbitrator databases and APIs
enabled such applications possible, PHP 3.0 was not designed to manage such complicated
systems rapidly.

This updated engine, nicknamed the "Zend Engine" (a combination of its founder developer's
names, Andi and Zeev), appeared in mid-1999 and accomplished these design goals. May 2000
marks the launch of PHP 4.0, succeeding its predecessor by almost two years. It was built on this
engine and included a plethora of new capabilities. PHP 4.0 has out-of-the-box support for a
plethora of new web servers, buffering of outputs, HTTP sessions, major performance
improvements, more secure methods for user input management, as well as a suite of new
language structures.

After a lengthy development and many pre-releases, July of 2004 marked the release of PHP 5. It
is primarily carried forward via its base, Zend Engine 2.0, which has a redesigned object-oriented
approach as well as a slew of additional improvements. PHP features hundreds of programmers
and others working on PHP-related and assisting initiatives such as PEAR, PECL, and manuals,
as well as a fundamental internet infrastructure that covers six contents of the world. Despite the
fact that this is an estimate based on prior years' statistics, This is reasonable to assume that PHP
is now running on hundreds of millions, if not thousands of millions, of domains worldwide.

PHP has garnered mixed reviews due to its lack of native Unicode support. In 2005, a project
was started to provide native Unicode compatibility for PHP. Andrei Zmievski oversaw this
endeavor. Due to the magnitude of the changes, it was decided to release this upgrade as a new
version, PHP 6.0. However, the project was delayed due to a dearth of developers who
understood the required enhancements. Despite the delay, PHP 5.3 was published in 2009, with a
large number of the PHP 6 project's features. In March 2010, the project was halted.

In 2014 and 2015, PHP introduced a new major version. PHP 7 was assigned to this version,
which caused some confusion, considering PHP 6 was never released. PHP 7 was also referred to
as PHP NG (PHPng). This version's purpose was to increase performance by redesigning the
Zend Engine while maintaining near-complete language compatibility. Benchmarks from July
2014 revealed a roughly 100% boost in performance. Zend Engine 3 is the new name for the
improved Zend Engine. This is a result of several key modifications.
 PHP Structure

PHP Code Syntax.

PHP structure is something I must discuss before getting into more hard-core PHP programming.
So basically, PHP programming starts with a tag “<?PHP” that’s an opening tag while “>?” is
the closing tag. What it does is it tells the web browser that this is PHP and the PHP interpreter is
needed to be called. Whatever is within these two tags, that’s gonna be the actual PHP.

PHP files end with a .PHP extension with it. If you’ve worked in any other language, say html,
your files tend to end in .html. Just like that, the PHP files ends with .PHP, so whenever you save
a PHP file, you must add . PHP extention alongside the name of the file. For instance,
NewAPP.PHP.

You can also write your PHP code in html tags. In the instance shown below, you can see I’ve
used Html tags, but in the body, I have started with a PHP opening tag, and I ended PHP with
closing tag. Within these two tags comes the real PHP code. After that I used html tags again.
Here again, while using PHP and html together, make sure when you save the file you use a
.PHP extention.

This says that you can code html in your PHP file just way you want along with PHP but when it
comes to saving the file you save it with .PHP extention, and ultimately, it’s a PHP file now.

But if you’re working in pure PHP, without using any other language like html, then I’d suggest
you to not end with a closing tag >? . The reason why is when it’s just PHP in the file and
suppose you have ended with the closing tag, agter that if there’s any white spacing remaining in
your PHP script it can actually screw your program/website with the white space. So it’s better to
leave the document without a closing tag. It doesn’t make any difference when working in PHP
only.

So when working in pure PHP, just start with an opening tag and do whatever you want to do.
With pure PHP what I mean is you’re not using html css in that file. It’s only PHP in there.
When working along with html and PHP you must use your closing tag. And the extention of the
file will be .PHP.

The next thing that you’ll use the most is a semi colon ;. Just about every statement of PHP code
end with a semi colon. It differs throughout programming languages, some end with a colon (:)
some don’t use anything at all, but PHP always ends in a semi colon. You must practice this as
forgetting to add a semi colon can lead errors.
 PHP Objects & Classes

Obstacles to Mastering Object-Oriented Programming

The main difficulty in explaining object-oriented programming is that there is no apparent linear
or sequential path to follow; all of the fundamental ideas are global in nature. Men are thought to
be linear thinkers, whereas women are said to be global thinkers. Men normally start at the
beginning and work in a logical order, accomplishing one task at a time. While women consider
the bigger picture, which makes them global thinkers. Object-oriented programming is built on a
foundation of broad ideas, while pure procedural programming, on the other hand, is
unambiguously linear.

This is an advantage of OOP, but it isn't helpful when describing it to someone who doesn't
know what it is. The great majority of teachers will begin by going through the three main
benefits of OOP: encapsulation, inheritance, and polymorphism, and then go over each one in
detail.

What Are Object and Classes in PHP

I'd explain what an object is at this point, although an object can't exist without a class function.
A class is nothing more than an object's blueprint. It's a C-struct-like sophisticated user-defined
data type. In OOP, "Object" refers to a class Instance (single).

A class, like a blueprint, describes the attributes of an instance. An object's properties describe it
and can be assigned values. While color is a property, "red" is a value that has been assigned to
it. ‘Method’, It’s a function acting as a class member. These functions are used to manipulate
data values.

The behavior of the object produced from the class is controlled by the properties assigned to
them within the class. A good illustration is one that shows how a method can take an object's
property value, such as its color, and write it to the database or the other way around.

Let me define an object in terms of computer programming because objects are important to
object-oriented programming. A user-defined template is used to organize data into objects. A
programming construct that specifies the members of a component and is used to create
duplicates of itself is known as a Class. A class function is simply a blueprint for defining the
attributes of a class, the properties of an object, how it will behave, and how its methods operate.
The properties of an object are what define it.

Objects can be anything from a bird to a table to a house to a person. If the object is an animal,
there are a few things to consider.
The animal's name, height, species, and a number of le,gs and habitat are all common features
that can be used to identify them. A class must declare an object before it may exist. Our basic
"Animal" class in PHP will be as follows:
<?PHP
class Animal
{
}
?>

This is the simplest definition possible, as it simply defines our class. Our class is currently
empty. It lacks characteristics that allow for the specification of the objects that will be built from
it, as well as methods that enable those objects to perform tasks and process data. Add some of
the following vital characteristics to the mix:
class Animal
{
$title;
$height;
$species;
$numOflegs;
$habitat
}

We provided various attributes to better describe an animal, but we can't use them because there
are no ways for setting or obtaining their values. To manage our properties, let's add some
"setter" and "getter" functions. We'll also create a method named __construct, but we won't use
or implement it for the time being. Later in the book, when we discuss PHP Magic Methods,
we'll go over this in further depth.
<?PHP
class Pet
{
$m_title;
$m_clr;
$m_numOflegs;
function set_Title_Pet($pet_title)
{
$this->m_title = $pet_title;
}
function get_Title_Pet()
{
return $this->m_title;
}

function set_Clr_Pet($pet_clr)
{
$this->m_clr = $pet_clr;
}
function get_Clr_Pet()
{
return $this->m_clr;
}

function set_No_Of_Legs($pet_noOflegs)
{
 $this->m_noOflegs = $pet_numOflegs;
}
function get_No_Of_Legs()
{
return $this->m_noOflegs;
}
function __construct(){}
}
?>

Animal now contains descriptive properties as well as ways for storing and retrieving such
information. Bear in mind how the variable "$this" was utilized; we'll return to it later.

Now that we've created the person class let's use it to create several person objects. Permit me to
present you to two new acquaintances, Crocodile and Chicken, that are both instances of the
Animal (objects). Before we can construct Crocodile and Chicken, they must be instantiated.

Instantiation
‘Instantiation’ is the development of an object based on a class or an instance/object of that
particular class is known as ‘instantiating a class.’ A fresh keyword is used to instantiate an
object in PHP, as seen below:
$Crocodile = new Animal()
$Chicken = new Animal()

$Crocodile and $Chicken are now instances (objects) of the type Animal, which enables accurate
property assignment. Take note of the parenthesis immediately before the word "animal" this is
because the constructor of the Animal class is the first function called after the properties have
been supplied. Although this constructor is not utilized in this example, I will explain why later
when we discuss Magic Methods. Let us begin by examining Crocodile. Let us clarify the name
and other identifying characteristics:
$Crocodile->setName(‘Crocodile’);
$Crocodile->setHeight(‘brown’);
$Crocodile->setSpecies(‘reptile’);
$Crocodile->setNoOfLegs(‘four’);
$Crocodile->setHabitat(‘lakes’);

Now for Chicken:

$Chicken->setName(‘Chicken’);
$Chicken->setHeight(‘white’);
$Chicken->setSpecies(‘bird’);
$Chicken->setNoOfLegs(‘two’);
$Chicken->setHabitat(‘farms’);

The Variable $this

The object that is invoking the function is represented by the variable $this. If that doesn't make
sense to you, let me explain it in Crocodiles terms. Two geeks built a metaphysical animal called
Crocodile. When we instantiated $Crocodile, that's exactly what happened. The Animal class
was the blueprint. The following steps were taken to create the green eyes:
$Crocodile->setSpecies(‘reptile’);

That method is defined in the Animal class like so:

public function setSpecies($species)
{
$this->species = $species;
}

As a result, $this has been temporarily replaced by $Crocodile. It was instantiated because
$Crocodile is a clone of the Animal class that contains more particular characteristics than $this.
As a result, as seen below, the setSpecies('reptile') function is added to the $Crocodile object:
public function setSpecies(‘reptile’)
{
$Crocodile->species = ‘reptile’;
}

Access Modifiers
Access modifiers are keywords that specify how class properties and methods are visible. PHP
files can be classed as private, protected, or public. Assume each Crocodile has a cage. We could
code it as follows in PHP:
class Crocodile {
$cage_location;
function setLocation() { }
}

When we do it this way, the cage is automatically made public. It’ll be visible throughout the
program, in other words. It's the same as if you wrote it as:
class Crocodile {
public $cage_location;
}

Anyone, including Harry, Alex, and James, who are tourists, can see the Crocodile's cage due to
its public exposure, which is managed through a public access modification. Assume the zoo
keepers don’t want the tourists to see the Crocodile’s cage.
class Crocodile {
protected $cage_location;
protected function setLocation(){}
}

In PHP, we can let only some selected people see the cage by sending an invitation to the people
the zoo keepers want to see it through the extends keyword:
class Harry extends Crocodile {
function viewCage(){}
 }
class Alex extends Crocodile....
class James extends Crocodile....

Because of all of these classes, the Crocodile's cage is visible. This is inheritance, and all of these
classes that extend Crocodile are part of its inheritance hierarchy. Imagine the zoo keepers want
only the doctor to see the cage. In PHP lingo, this means:
class Crocodile {
private $cage_location;
private setLocation(){}
private letHarrySee(){}
}

In other terms, PHP's three access modifiers are as follows: When a class is marked as private,
access to it is restricted. Private members are accessible only through methods, which belongs to
the same class. Take a look at the given instance:
class Visitor{
private $m_visitor_name;
public $m_visitor_height;
public function __construct($visitor_name, $visitor_height) {
$this->m_visitor_name = $visitor_name;
$this->m_visitor_height = $visitor_height;
}
}
$tmpVisitor = new Visitor ("Jhon","150");
echo "Visitor Name : " . $ tmpVisitor->m_visitor_name; //causes an error

Declaring data members as private aims to prevent external programs from altering the values
inappropriately without conducting sufficient validation. You must provide public getter/setter
methods for the data member's value if you make it private. The access modifier protected
provides access to data members as well as member methods for a given class and all of its
subclasses. Global access isn’t allowed.
class Pet {
protected $m__pet_name;
}
class Dog extends Pet {
function set_Pet_Name($pet_name) {
//this works as $pet_name is protected in Pet
$this->m_pet_name = $pet_name;
}
}
$tmpVisitor = new Visitor();
$tmpVisitor->set_Visitor_Name("Chandler");
$tmpVisitor->m_visitor_name = "Chandler"; //this causes error as $m_visitor_Name is protected and not public

The term "public" denotes that any code can access the member by its name.
class Visitor {
private $m_Visitor_Name;
public $m_Visitor_Height;
public function __construct($visitor_name, $visitor_height) {
$this->m_Visitor_Name = $visitor_Name;
$this->m_Visitor_Height = $visitor_Height;
 }
}
$tmpVisitor = new Visitor("Chandler","150");
echo "Height : " . $tmpVisitor ->m_Visitor_Height; //prints 150

Returning to my earlier remark that object-oriented principles are "global" in the sense that they
should be regarded by a developer. I demonstrated access modifiers using the Crocodile’s cage,
but I also needed to illustrate encapsulation and inheritance. Inheritance and encapsulation are
essential strategies for limiting the capabilities of a class-defined object.

Inheritance
You're probably familiar with the Crocodile’s cage, notably the one made out of steel bars. In
PHP, the cage was designated as protected, which meant that it could be viewed by the Crocodile
and its extended classes. In PHP5, the keyword extends should be used in the class definition to
indicate inheritance.
class Parent
{
}
class Child extends Parent
{
}

Inheritance refers to the transmission of "knowledge" down the hierarchy. It is a technique for
incrementally adding new functionality to existing code. Class hierarchies are used to organize
classes, and heredity allows a single class's design and functions to somehow get transferred
through the ladder. As a result, minimal programming is required when introducing further
functionality to complex systems.

When a step is positioned at the bottom of the ladder, just the computation and information
associated with that step must be added. During that period, everything else gets transferred to
you. The capability of object-oriented programming to reuse existing objects is a big advantage.

The Overriding of Method

Method overriding occurs when the base class's method is re-defined using the derived class's
name, function signature, and access modifier (public or protected). The purpose of overriding a
method is to provide the functionality to the base class that isn't previously specified. Assume
you have a milkshake class from which two subclasses, mango, and strawberry, are derived.

While the Beverage class defines methods for mixing, shaking, and other operations, the
specialized classes Mango and Strawberry will need to override the stir and mix features because
they will have their own methods for mixing and stirring. Consider the following scenario for a
milkshake:
class MilkShakes {
public function mixing_method() {
 echo "Mix method of MilkShakes Class";
}
public function shaking_method() {
echo "Shake method of MilkShakes Class";
}
}

class Mango extends MilkShakes {

public function mixing_method() {
echo "Mixing method of Mango Class ";
}
public function shaking_method () {
echo "Shaking method of the Mango Class ";
}
}

class Strawberry extends MilkShakes {

public function mixing_method() {
echo "Mixing method of strawberry Class ";
}
public function shaking_method() {
echo "Shaking method of the Strawberry Class";
}
}
$mango = new Mango();
$strawberry = new Strawberry();

$mango->shaking_method();
echo "\n";
$strawberry->shaking_method();

Output:
Shaking method of the Mango Class
Shaking method of the Strawberry Class

Horizontal Inheritance - Using Traits

Multiple inheritances is not supported in PHP; so for a given class, only a single base class can
be extended. What happens if you require code from many classes? Until recently, developers
had to work around this by copying and pasting code from other classes that were not necessary
in the base class. This is now possible due to the addition of a new feature in PHP5.4 called a
trait, which enables horizontal inheritance.

A trait resembles a class structurally, but it cannot be instantiated. While properties and methods
can be specified within a trait structure, they can only be used by a class that includes the use
keyword, which is called within the class that uses it, that is, within the curly brackets. Outside
of the curly brackets, it is not referred to in the class specification, unlike interfaces and the
extending class.
trait Calculation
{
public function addition($arg_1, $arg_2)
{
return $arg_1 + $arg_2;
}
public function subtraction($arg_1, $arg_2)
{
 return $arg_1 - $arg_2;
}
}
trait BusTicket
{
private $bus_ticket = array();
public function addition($bus)
{
array_push($this->bus_ticket,$bus);
}
public function get_Bus_Ticket()
{
return $this->bus_ticket;
}
}
class BusTicketBook
{
use Calculation,BusTicket;
{
//Give priority to the addition method from the Calculation trait
Calculation::addtion insteadof BusTicket;
}
}
$bus_ticket_book = new BusTicketBook ();
echo $bus_ticket_book->addtion(9,6), "<br />";

Output:
15

Invoking Parent Methods

To begin, the term "invoke" refers to the act of "inviting" or "requesting" something to do
something. I simply wanted to get that out of the way as quickly as possible. When you override
a base class method, the functionality of the overridden method is fully hidden until It's
summoned directly from the child class. Use the term parent along with the two colons like
this"::" it’s known as the ‘scope resolution operator,’ and the method name to access methods
from a parent class.

For instance:
parent::name_of_function();

below is the code written;

class Pet {
public function pet_tail() {
echo "This is tail of Animal ";
}
}
class Parrot extends Pet{
public function pet_tail() {
parent::pet_tail();
echo "This is parrot's tail ";
}
}
$parrot = new Parrot();
 $parrot->pet_tail();

Output:
This is Pet’s tail()
This is Parrot’s tail()

The tail() function of the Lion child class calls the tail() function of the Animal parent class in
the prior example. When the program calls the tail() method, it first calls the Lion class, which
then calls the parent class's tail() method. The remaining code in the Lion class's tail() function is
executed when the parent class's tail() function is completed.

Polymorphism
Now that you understand that a class acts as a blueprint from which objects are created, it's
critical to understand that a single class can be used to create a wide range of distinct objects. I
may only have one table class, but I can use that class to generate a wide range of table objects. I
can choose between a round table, a square table, a long table, and a short table. I had the option
of choosing between a blue and a brown table. I could have an oak table or a plastic table; both
are of the same basic quality.

The existence of multiple forms is referred to as polymorphism. Polymorphism is the ability to

generate multiple forms of a variable, function, or object in order to adapt to the task at hand. It
is a method that allows various types of objects to communicate with one another via a common
interface.

Polymorphism is used to improve application modularity and extensibility. Instead of clumsy,

difficult-to-read conditional statements defining alternative procedures, the programmer designs
reusable objects to suit their required needs. Polymorphism's primary goal is to achieve this.

Polymorphism is a technique that allows objects of different types to communicate with one
another through a single interface.

Using a common illustrative example, A program may declare an object type called Person that
contains the function speak() and then derive object sub-types such as Mary, Jane, and so on,
each with their own unique implementation of the speak() function. Polymorphism allows such
software to call the speak() function without knowing whether it is for Mary, Jane, or any other
derivative Person, while still performing the correct function for that specific Person.

Polymorphism should not be confused with method overloading or overriding (a method in OOP
is a function that belongs to a class, whereas class variables are called members) and should not
be used interchangeably.

Late Binding / Dynamic Binding

The process of polymorphism is called dynamic binding or (late-binding). A base class defines
the speak() function, but it also calls getName(), a polymorphic function that each child class
implements differently. The phrase "late binding" refers to the fact that the request is only bound
to a specific data type when the function is called at runtime. Simply put, despite the fact that
speak() is specified in the generic Person class, it will invoke the getName() implementation
particular to the child. True polymorphism is enabled through this late-binding feature, which is
PHP’s new feature.

Another example:
class Character {
protected $m_Character_Title;
public function __construct($character_Title)
{
$this->m_Character_Title = $character_Title;
}
public function get_Character_Title()
{
return $this->m_Character_Title;
}
}
class Rachel extends Character
{
public function get_Character_Title()
{
return 'Rachel: '.parent::get_Character_Title();
}
}

function Character_Name(Character $character)

{
echo $character->get_Character_Title();
}
$girlCharacter = new Rachel("who");
Name($girlCharacter);

This is a polymorphism example since the Name() function is aware that it is receiving an object
of type Person but is unaware of whether the Product is Lucy, or Jane, or someone else. Take
note of how we declared the type Person as a parameter for the Name() function – in highly
typed languages, stating the data type of function arguments is compulsory, whereas in PHP,
specifying the data type (known as type hinting) of functions is optional. If they are included,
PHP will throw a fatal error if a non-object or an object which is different from the expected data
type is passed to the function.

PHP is a dynamic programming language because it performs many of the same tasks as other
languages at compile time. It is loosely typed or dynamically typed, in the sense that the majority
of type checking occurs during runtime rather than during compilation. While values have types
in dynamic typing, variables do not; consequently, a variable can refer to any value of any type.

Method Overloading
If two or more methods (functions) within a given class has the same name, but with differing
parameter counts and/or data types, this is referred to as method overloading.

Method Overriding
When a child class (one derived through inheritance) calls a method with a name and parameters
the same as the parent class's function but with a different implementation, this is referred to as
method overriding. This is not synonymous with polymorphism because late-binding is not
always required; rather, overriding is a required component of the technique by which
polymorphism occurs. All of this may appear confusing at first, but a simple code sample can
help to clarify:
class Character {
protected $m_Character_Title;
public function __construct($character_Title)
{
$this->m_Character_Title = $character_Title;
}
public function get_Character_Title()
{
return $this->m_Character_Title;
}
}
class Rachel extends Character
{
public function get_Character_Title()
{
return 'Rachel: '.parent::get_Character_Title();
}
}
$girlCharacter = new Rachel("who");
echo $girlCharacter->get_Character_Title();

This is an example of overriding. In contrast to polymorphism, we define Lucy and invoke a

Lucy function directly via the Lucy's interface. PHP being a weakly typed language, means that
the vast bulk of data type handling is performed implicitly by PHP rather than by the
programmer. As a result, with PHP, the line between overriding and polymorphism can be quite
fine. Consider the following illustration:
<?PHP
class Character {
protected $m_Character_Title;
public function __construct($cahracter_Name)
{
$this->m_Character_Title = $character_Title;
}

public function get_Character_Title()

{
return $this->m_Character_Title;
}

public function Character_Talk()

{
return $this->get_Character_Title().' is talking <br />';
 }
}

class Rachel extends Character

{
public function get_Character_Title()
{
return 'Rachel: '.parent::get_Character_Title();
}
}

$girlCharacter = new Rachel("who");

echo $girlCharacter->Character_Talk();
$character = new Character("someone");
echo $character->Character_Talk();
?>

OUTPUT:
Rachel: Who is speaking
someone is speaking

Encapsulation
The act of putting anything into a "capsule," or encapsulating functionality into a single package,
is referred to as encapsulation. Consider a capsule or a box containing Products to be an object.
The access modifiers work similarly to windows, with 'public' access being a large open window
that allows everyone to see inside and 'private' access being completely shaded and preventing
anyone from seeing inside.

The ability to control the visibility of an object's contents is a critical aspect of how
encapsulation works. An object is composed of attributes and methods, and because they are all
contained within an object, they form a mini-program with control over the visibility of its
contents, data. This is the idea behind encapsulation.

Encapsulation is a technical term for the creation of self-contained modules that link processing
processes to data. By keeping routines distinct and less prone to conflict, encapsulation promotes
code modularity. To summarize, each object is a miniature program that manages its own tasks
as if it were a standalone capsule or pill.
 Dunder Methods in PHP

Dunder-methods are reserved method names that you may utilize in your classes to access PHP
function that isn't available otherwise. Magic methods allow you access to PHP behavior that
isn't available to the general public. Magic techniques are named by starting with with two
leading underscores followed by lower camel-case letters.

__construct ()
The constructor is a magical Technique which gets invoked during the creation of an object or a
class instance. Although, typically the first Product inside a class declaration, it is not essential; it
is merely another method that can be declared anywhere in the class. When we instantiated
Crocodile, recall how I stated the parenthesis following the Person class name?
$Mindi = new Person();

The constructor of the $Mindi object is a reference to the Person() class. The constructor is not
implemented in this situation since there is nothing enclosed in parenthesis. We don't initialize
any of $Mindi's properties when we call the constructor. The PHP engine will presume we're
using an unimplemented constructor if our class doesn't have a constructor function.
public function __contruct(){}

Constructors can be passed down the heirachy just like any other method. From the previous
inheritance example from Intro to OOP, the following constructor can be added to Person class:
// character.PHP
class Character
 {
public function __construct() {
$this->object_creation_time = time();
$this->log_file = fopen('log_file.txt', 'w');
}
}

We may now construct a descendant class of the Person class. We can declare Lucy class which
inherits from Person without changing anything:
class Lucy extends Person {
}
$holy = new Lucy();
echo $holy->created;

Assuming we introduce a __construct method in Lucy class, it will be used instead by

instantiated Lucy instances.. Because there isn't one, PHP looks for and leverages information
included in the parent class definition. As a result, we now have the option of overriding or not
overriding in our new class, which is quite convenient.

Invoking Parent Constructor and Destructor

Using the same syntax as the parent method, we may call the function Object() { [native code] }
and destructor of PHP5's parent class, just like shown by the preceding illustration:
__destruct()
Have you noticed the constructor's file handle? When we're finished with an object, we don't
want to leave it sitting about, which is why the __destruct method overrides the constructor's
behavior. It is destroyed when we explicitly destroy an object or when we no longer require it,
which PHP handles for us. Person's __destruct method would be as follows:
class Character{
public function __construct() {
$this->character_creation_time = time();
$this->log_file = fopen('log_file.txt', 'w');
}
public function __destruct() {
fclose($this->log_file);
}
}

__get(), __set(), __isset()

In PHP, property overloading refers to the process of setting and retrieving values for properties
in a class that aren't explicitly declared. The PHP engine will automatically invoke the __set()
function when a script tries to assign something to a class property which has never been stated
explicitly. The __get() function is invoked silently when a script tries to obtain the value of an
undeclared class property. The __isset() function is also invoked when called on an undefined
property. Use __isset() to validate a property before interacting with it.
"User" illustration 1

Assume that there is a fundamental class called "User" that represents a real-world user in
software. The following is how this hypothetical class would be defined:
class Customer {
private $m_Customer_Forename = 'Ross';
private $m_Customer_Surname = 'Geller';
private $m_Customer_Email = 'rossgeller@domain.com';
// constructor (not implemented)
public function __construct(){}
// set customer's Fore_Name
public function set_Customer_Fore_Name($customer_fore_name)
{
$this->m_Customer_Forename = $customer_fore_name;
}
// get Customer's fore name
public function get_Customer_Fore_Name()
{
return $this->m_Customer_Fore_Name;
}
// set user's last name
public function set_Customer_Sur_Name($customer_Sur_Nname)
{
$this->m_Customer_Surname = $customer_Sur_Name;
}

// get customer's sur name

public function get_Customer_Sur_Name()
{
return $this->m_Customer_Sur_Name;
}
// set Customer's email address
public function set_Customer_Email($customer_Email)
{
$this->m_Customer_Email = $customer_Email;
}

// get Customer's email address

public function get_Customer_Email()
{
return $this->m_Customer_Email;
}
}

As is evident, the aforementioned "User" class is quite straightforward to design. It just has a few
setters and getters for defining and obtaining the attributes with its three specified properties,
$firstname, $lastname, and $email. So far, nothing unusual has occurred, correct? A basic
explanation is mentioned below:
$customer = new Customer();
$customer->set_Customer_Fore_Name('Ross');
$customer->set_Customer_Sur_Name('Geller');
$customer->set_Customer_Email('rossgeller@domain.com');
 // display customer data
echo 'Customer’s Fore Name: ' . $customer->get_Customer_Fore_Name() . '<BR> Customer’s Sur Name: ' . $user-
>get_Customer_Sur_Name() . '<BR> Customers Email: ' .
$user->get_Customer_Email();

/*

displays the following:

Customer’s Fore Name: Ross
Customer’s Sur Name: Geller
Customer’s Email: rossgeller@domain.com
"User" illustration 2

I constructed a simple "User" class with an API that enabled us to rapidly apply and get the
quantities of its stated properties in the preceding example. As previously indicated, by putting
the "__set()" and "__get()" methods into practice, it is feasible to abbreviate and make its
explanation more "dynamic." To better show this notion, I'll extend this sample class so that we
may generate new class attributes at runtime and get their related values quickly. Please have a
look at the changed "User" class. Now that we understand what I'm going to do in the following
lines, let's get started. The following is how it is now displayed:
class User
class Customer
{
// constructor (not implemented)
public function _construct(){}

// set undeclared property

function __set($property_Of_Customer, $value_Of_Property)
{
$this->$property_Of_Customer = $value_Of_Property;
}

// get defined property

function __get($property_Of_Customer)
{
if (isset($this->$property_Of_Customer))
{
return $this->$property_Of_Customer;
}
}
}

the "__set()" method creates an undefined property and sets it a value. in the first scenario,
whereas the "__get()" function gets the value when the property in the second instance has
already been defined.

The use of these techniques simplifies the process of overloading properties. Additionally, it
minimizes the size and complexity of the source code of class. The shortcoming of this method is
it has a lot of disadvantages. To begin, the code is harder to understand and grasp due to the
absence of specific declarations for each class property. Second, an integrated development
environment (IDE) such as Eclipse PDT would have difficulty keeping track of such attributes
for commenting or documentation.
// example of usage of 'Customer' class with property overloading
$customer = new Customer();
$customer->m_Customer_Forename = 'Ross';
$user->m_Customer_Surname = 'Geller';
$user->m_Customer_Email = 'rossgeller@domain.com';
$user->m_Customer_Address = 'Central Perk';

// display customer data

echo 'Customer Fore Name: ' . $user->m_Customer_Forename . 'Customer Sur Name: ' . $user-
>m_Customer Surname . '<BR> Customer Email: ' . $user->m_Customer_Email .
'<BR>Customer Address: ' . $user->m_Customer_Address;

OUTPUT:
Customer Fore Name: Ross
Customer Sur Name: Geller
Customer Email: rossgeller@domain.com
Customer Address: Central Perk

__call()
When you call a method on a class object that doesn't exist, the class's implementation of __call()
is utilised instead. Consider the following scenario:
<?PHP
//This class demonstrate how the __call() Magic Method is used
class PHPCallProgramTest {
private $arr = array(2, 1, 6);

public function __call($title_of_method, $args) {

echo "The method \"$title_of_method\" called.\n";
var_dump($args);
return $this->arr;
}
}
//test() doesn’t exist
$PHPCallProgramTest = new PHPCallProgramTest();
$var = $PHPCallProgramTest->test('a', 'b', 'c');
var_dump($var);
?>
Now let's add a test() function and rerun the program. It's worth noting that test() was used
instead of __call() this time:
<?PHP
//This class demonstrate how the __call() Magic Method is used
class PHPCallProgramTest {
private $arr = array(2, 1, 6);

public function __call($title_of_method, $args) {

echo "The method \"$naem_of_method\" called.\n";
var_dump($args);
return $this->arr;
}

public function test($args) {

echo "The method \"test\" exists now!\n";
return NULL;
}
}

//test() doesn’t exist

$PHPCallProgramTest = new PHPCallProgramTest();
$var = $example->test('a', 'b', 'c');
var_dump($varr);
?>

OUTPUT:
The method "test" exists now!
NULL

__sleep()
The __sleep() magic function is invoked when a class object is going to be serialised.
Serialization is just converting of objects into byte-by-byte sequence for storage or transmission
across a network. __sleep()returns an array as a mysterious method that takes no parameters. The
array must include searialized members of class in a list. This means if you do not want a
member of a class to be serialized, leave it out of the array. Consider the following illustration:

In the example above, the data just holds the fname of the Employee Object in serialized string.
It’s because __sleep() magic function provided an array with just the 'fname' data element,

__wakeup()
The __wakeup() magic method accepts no parameters and returns none, just as the __sleep()
method. It's responsible for re-initializing an object that has been unserialized. The opposite of
serialize is unserialize, which converts an array to a standard string that may be saved to a file or
supplied as a URL. When a string is transformed from a serialized string to an array, it is
unserialized. The PHP methods serialize() and unserialize() are used to perform these tasks.
Consider the case below:

OUTPUT:
object(Staff)#2 (2) {
["m_Staff_Forename:private"]=>
string(3) "Joey"
["m_Staff_Date_Of_Birth:private"]=>
string(10) "23-03-1969"
}

We utilize the $data variable and provide it to the unserialize() method once the $e object has
been serialised. The outcome is placed in the $data variable after being translated to a common
string. The __wakeup() function is invoked while the object is unserialized and created.

__clone()
Objects in PHP are generally allocated and passed through reference. For instance:
Class CloneStaffClass
{
public $m_Staff_Name;
}

$firstStaff = new CloneStaffClass();

$firstStaff->m_Staff_Name="Joey";
$secondStaff = $firstStaff;

echo "first Staff = " . $firstStaff->m_Staff_Name . "<BR><BR>";

$secondStaff->m_Staff_Name="Tribbiani";

echo "first Staff = " . $firstStaff->m_Staff_Name. "<BR>";

echo "second Staff = " . $secondStaff->m_Staff_Name . "<BR>";

OUTPUT:
first Staff = Joey
first Staff= Tribbiani
second Staff= Tribbiani

After I made a copy of the $first object named $secondStaff and set the value of $second-
>m_Staff_Name="Tribbiani," the value of the $firstStaff->m_Staff_Name property changed
from "Joey" to "Tribbiani." This is because the $secondStaff object was assigned by reference,
and both the $firstStaff and $secondStaff objects relate to the same object.

The __clone() magic-method can also be castoff to produce a duplicate of an object that does not
relate to the original object but instead creates a new, fully different object. Instead of setting
$secondStaff = $firstStaff, I'll use __clone() to explain how it works in the prior example.
Class CloneStaffClass
{
public $m_Staff_Name;
}
$firstStaff = new CloneStaffClass();
$firstStaff->m_Staff_Name="Joey";
$secondStaff = clone $firstStaff;
echo "first Staff = " . $first->m_Staff_Name . "<BR><BR>";

$secondStaff->m_Staff_Name="Tribbiani";

echo "first Staff= " . $firstStaff->m_Staff_Name . "<BR>";

echo "second Staff= " . $secondStaff->m_Staff_Name . "<BR>";

OUTPUT:
First Staff = Joey
first Staff = Joey
second Staff = Tribbiani

The value of $firstStaff->m_Staff_Name did not change after we set a value for $secondStaff-
>m_Staff_Name. This is due to the fact that cloning allows us to create an object that is
completely different from the original. As a result, instead of just two pointers to the same
object, we now have two objects.
 Abstract Classes & Method

Polymorphism is strongly reliant on the shared interface. A shared interface is a technique that
enables the communication of components. Interfaces and abstract classes are the two methods in
PHP for defining a shared interface. Both are useful, and you can combine them in your class
hierarchy as you see fit. These characteristics can be accounted for in a variety of ways.
According to some, the abstract class is a combination of the interface and the class. I'd rather
save the explanation of the PHP interface for the Chapter later and instead concentrate on the
abstract class.

In PHP, it is a generic class that can solely be utilized as a base class and can't be created. An
abstract class serves as the inheritance for more specialized classes to inherit from. Inheriting
from the abstract class allows subclasses to execute the methods and attributes of the abstract
class in other classes. While an abstract class cannot be used to construct an object, all of its
methods and properties must be used by objects derived from the abstract class's classes.

Before I proceed to perplex you, allow me to share some further information about Lucy and her
friend Jane. At the beach, the ladies enjoy flaunting their expensive yet stunning bikinis. Who
would have believed such a small quantity of apparel would be so expensive? Allow us to assist
Lucy and Jane by hiring them as waitresses. Being beautiful as a waiter or waitress is
advantageous, but appearances are not everything. Finally, any outstanding waiter or waitress
must be familiar with the carte. Let's take it a step further and assist the ladies by developing a
carte for them so they can perform their jobs, make money, and return to the beach in their new
bikinis! Let's begin with the carte Products, as they are the foundation of a carte.

Now, in order to provide the females with options regarding where they work and the type of
cuisine they serve, we're going to allow them to build any carte they like. To begin, we should
aim for as much generic or abstract language as feasible.

Abstract Keyword
Apply the abstract keyword to define an abstract class or function. To maximize our versatility
and allow us to generate as many different types of cartes and carte Products as possible, we
must begin with an abstract Carte class.
abstract class Carte
{

Our carte Products have an abstract class, however it is ineffective because it is empty. Let us
think about this for the benefit of Lucy and Jane. If we build a database, each of our cartes and
carte Products will need a unique identifier.

There are a number of methods to do this, but for now, let's build our carte generator to produce
a list of generic carte Products that may be used on one or more cartes (Lunch Carte, Dinner
Carte, etc.). This points to a one-to-many entity relationship, in which a single carteid can
represent a numerious carteids. Because of this, the carte class will need a carteProductid
property. Include the fields for name and description as well.

It is often best not to abstract the CarteProduct class, as we will need to instantiate it in order to
generate a general list, or table, of carte Products with a common structure.

To begin, each carte Product will require the following: a unique ID, a name, a description, a
price, a serving size, and a link to an image. Additionally, let us provide it with methods for
setting and getting the values of these characteristics.
class CarteProduct
{
private $m_Carte_Product_Id;
private $m_Carte_Product_Name;
 private $m_Carte_Product_Description;
private $m_Carte_Product_Price;
private $m_Carte_Product_Picture;

public function set_Carte_Product_ID($carte_Product_Id){$this-> m_Carte_Product_Id = $ $carte_Product_Id;}

public function get_Carte_Product_ID(){return $this-> m_Carte_Product_Id;}

public function set_Carte_Product_Price($carte_Product_price){$this-> m_Carte_Product_Price =

$carte_Product_Price;}
public function get_Carte_Product_Price(){return $this-> m_Carte_Product_Price;}

public function set_Carte_Product_Picture($carte_Product_Picture){$this-> m_Carte_Product_Picture =

$carte_Product_Picture;}
public function get_Carte_Product_Picture (){return $this-> m_Carte_Product_Picture;}

public function set_Carte_Product_Name($carte_Product_Name){$this-> m_Carte_Product_Name =

$carte_Product_Name;}
public function get_Carte_Product_ProductName(){return $this-> m_Carte_Product_Name;}

public function set_Carte_Product_Description($carte_Product_Description){$this->

m_Carte_Product_Description= $carte_Product_Description;}
public function get_Carte_Product_Description(){return $this-> m_Carte_Product_Description;}

After we've created our base carte class, let's develop some specialized carte classes from which we'll instantiate our
real carte objects.

class MainCarte extends Carte

{
}

class DrinkCarte extends Carte

{
}

class LunchCarte extends Carte

{
}

class KidsCarte extends Carte

{
}

class DessertCarte extends Carte

{
}

Take a peek at the KidsCarte and DessertCarte carte classes. There's probably no reason to make
these two classes extendable by developing classes that can inherit from them. The Dessert Carte
is usually the last Product on anyone's mind when they go out to eat, and the Kids Carte is self-
explanatory.

Let's limit the extension of these classes to minimize future misunderstandings for Lucy and Jane
by making them final. This is accomplished with the final keyword

Abstract Methods
You were introduced to the concept of Method Overriding earlier in the polymorphism speak.
On the other hand, abstract methods must be overridden because they cannot be directly invoked.
Whenever one attempts to run an abstract method, one will receive an error. Methods that are
abstract must be specified within an abstract class. Declaring an abstract method inside a non-
abstract class will show an error during compilation.

Here, it’s a Cat abstract class with an abstract method meow() :

<?PHP

abstract class Cat {

private $title = null;

private $gender = null;
public function __construct($title) {
$this->name = $title;
}

public function getName() {return $this->name;}

public function setName($title) {$this->name = $title;}
abstract public function meow();

// Override the abstract meow() method from abstract Cat class

class Persian extends Cat {

public function meow() {

echo "MEOW!! MEOW! MEOW!" . "<br>";
}
}

class Maine extends Cat {

public function meow() {
echo "BRRR! BRRR! BRRR!" . "<br>";
}
}

// the class fails to enforce meow() resulting in an error of compilation.

class Mutt extends Cat {
// this will cause an error because this cat didn't override meow()
}

?>

OUTPUT:
Fatal error: Class Cat contains 1 abstract method and must therefore be declared abstract or implement the
remaining methods (Cat::meow)

Final Keyword
final Class KidsCarte extends Carte
{
//...
}
final Class DessertCarte extends Carte
{
//...
}
Within a class hierarchy, inheritance gives you a lot of freedom. Overriding a class or method
means that based on the class instance provided, a call in a client method can have different
consequences.

A class or function should occasionally remain constant, such as with our Kids Carte and Dessert
Carte. The final keyword signifies the conclusion of inheritance. A final class can't have any
classes or methods, and it can't be overridden.
Other documents randomly have
different content
not return the trump, because he holds major tenace over the king,
which must be in Y’s hand. At trick 5 B still holds major tenace in
trumps, and leads a small card of his long suit to try to get A into
the lead again. If A leads trumps again, his only possible card of re-
entry for his club suit is gone. At trick 7, if B draws Y’s king, he kills
A’s card of re-entry at the same time.
No. 2. This is an excellent example of the American Game. A
has a three-trump hand, but his long suit is not headed by two
honors in sequence, and the Queen of clubs cannot be considered as
a re-entry, so A makes the gambit opening of the singleton diamond.
His partner, having nothing in plain suits, immediately returns the
diamond. A now leads an intermediate club, and B forces him again.
At trick 6, A avoids changing suits. If the long spade suit is opened,
and Z returns the diamond 10, A-B will make four tricks less on this
hand.
No. 3. This example of the Short-suit Game is from Val Starnes’
Short-Suit Whist. This is sometimes called the Gambit opening. The
leader, having no reason to lead trumps, even with five, and not
having three honours in his long suit, prefers the gambit opening of
the singly guarded queen. Y holds what is called a potential or
imperfect fourchette, and covers, in order to make A-B play two
honours to get one trick. B also makes a gambit opening by
returning a supporting spade. Three tricks are gained by the two
leads of the supporting cards, and five would have been made but
for Y’s covering on the first trick.
No. 4. This is an example of Playing to the Score. The game is
English Whist, 5 points, counting honours. The first lead of trumps
shows Z that honours are divided, and that he must make 11 tricks
to win the game. At trick 3, he must trump; to discard clubs would
be inconsistent with refusing to trump in order to bring them in. At
trick 4, if Y cannot win a trick in clubs and give Z a finesse in
trumps, Z cannot win the game. At trick 7, both black queens are
against Z, and he must take the best chance to win if the diamond
ace is also against him. The adversaries cannot place the club ace,
and so Z underplays in clubs as his only chance for the game.

PRUSSIAN WHIST. This is the ordinary 5, 7 or 10 point whist,

with or without honours, except that instead of turning up the last
card for trump, the player to the left of the dealer cuts a trump from
the still pack, which is shuffled and presented to him by the dealer’s
partner.
FAVOURITE WHIST. This is the regular 5, 7 or 10 point whist,
with or without honours, except that whichever suit is cut for the
trump on the first deal of the rubber is called the favourite.
Whenever the suit turns up for trump, after the first deal, tricks and
honours count double towards game. There must be a new favourite
at the beginning of each rubber, unless the same suit happens to be
cut again.
A variation is to attach a progressive value to the four suits; tricks
being worth 1 point when Spades are trumps; when Clubs 2; when
Diamonds 3; and when Hearts 4. Honours do not count, and the
game is 10 points, made by tricks alone. The hands are played out;
the winners score all tricks taken, and the winners of the rubber add
10 points for bonus. The value of the rubber is the difference
between the scores of the winners and that of the losers. For
instance: If the rubber is in A-B’s favour with the score shown in the
margin A-B win a rubber of 8 points.

1st game; 10 to 6
2nd game; 4 to 16
3rd game; 14 to 8
Rubber; 10
Totals 38 to 30

This is a good game for superstitious people, who believe that

certain trump suits are favourable to them.
 TEXT-BOOKS.

The following list of works on whist, alphabetically arranged,

contains the principal standard text-books on the game. Those
marked * are especially for the beginner. Those marked x are chiefly
devoted to the Short-suit game.

Art of Practical Whist, by Major Gen. Drayson.

* Foster’s Whist Manual, by R.F. Foster.
* Foster’s Whist Tactics, by R.F. Foster.
x Foster’s Common Sense in Whist, by R.F. Foster.
* Foster’s Self-Playing Cards, by R.F. Foster.
x Foster’s Duplicate Whist, by R.F. Foster.
Foster’s American Leads, by R.F. Foster.
* Foster’s Whist at a Glance, by R.F. Foster.
* Gist of Whist, by C.E. Coffin.
x Howell’s Whist Openings, by E.C. Howell.
Laws and Principles of Whist, by “Cavendish.”
Modern Scientific Whist, by C.D.P. Hamilton.
Philosophy of Whist, by Dr. W. Pole.
* Practical Guide to Whist, by Fisher Ames.
x Short-Suit Whist, by Val. W. Starnes.
* Short Whist, by James Clay.
* Theory of Whist, by Dr. W. Pole.
* Whist, or Bumblepuppy, by “Pembridge.”
Whist Developments, by “Cavendish.”
* Whist of To-day, by Milton C. Work.
 * Whist à Trois, by Ch. Lahure. [Dummy.]
x Whist, and its Masters, by R.F. Foster.
* Whist, A monthly journal; pub. Milwaukee, Wis., U.S.A.

DUPLICATE WHIST.
Duplicate whist is not a distinct game, but is simply the name
given to that manner of playing whist in which a number of hands
are played over again with the same cards, but by different persons.
CARDS. The cards have the same rank as at whist; they are dealt
in the same manner, and the same rules apply to all irregularities in
the deal, except that a misdealer must deal again. The objects of the
game are the same, and so are all the suggestions for good play.
The only differences that require attention are the positions of the
players, the manner of counting the tricks, and the methods of
keeping and comparing the scores.
THEORY. It may briefly be stated that duplicate proceeds upon
the principle that if two partners have made a certain number of
tricks with certain cards, under certain conditions with respect to the
lead, distribution of the other cards in the adversaries’ hands, etc.,
the only way to decide whether or not two other players could have
done better, or cannot do so well, is to let them try it, by giving
them the same cards, under exactly similar conditions.
This comparison may be carried out in various ways; but in every
instance it depends entirely upon the number and arrangement of
the players engaged. The most common forms are: club against
club; team against team; pair against pair; or man against man. The
reason for the arrangement of the players will be better understood
if we first describe the method.
METHOD OF PLAYING. There is no cutting for partners, and
choice of seats and cards as at whist, because the players take their
places and deal according to a pre-arranged schedule.
 The player to the left of the dealer begins by placing the card he
leads face up on the table, and in front of him. The second player
follows by placing his card in front of him in the same manner; and
so the third, and so the fourth. The four cards are then turned face
down, and the dealer takes up the trump. The partners winning the
trick place their cards lengthwise, pointing towards each other; the
adversaries place theirs across. At the end of the hand, the number
of tricks taken by each side can be seen by glancing at any player’s
cards. If there is any discrepancy, a comparison of the turned cards
will show in which trick it occurs, and the cards can be readily faced
and examined.
 N & S 6; E & W 7. East has made a mistake in turning the fifth trick.
COUNTERS. In some places 13 counters are placed on the table, the
winner of each trick taking down one. This system often leads to
disputes, as there can be no check upon it, and there is nothing to show
in which trick the error occurred.
COUNTING TRICKS. At the end of each hand, the players sitting
North and South score the total number of tricks they have taken;
instead of the number in excess of a book. Their adversaries, sitting
East and West, do the same. Each player then slightly shuffles his 13
cards; so as to conceal the order in which they were played, and the
four separate hands of 13 cards each are then left on the table, face
down; the trump being turned at the dealer’s place.
TRAYS. When any apparatus is used for holding the cards, such as
trays, boxes, or envelopes, each player puts his 13 cards in the
compartment provided for them. Each tray has a mark upon it, usually
an arrow, showing which end of the tray should point toward a given
direction, usually the North. The pocket into which the dealer’s cards go
is marked “dealer,” and it is usual to provide a trump slip for each tray.
When the hand is first dealt, the trump is recorded on this slip, which
travels round the room with the tray. After the dealer has turned up the
designated trump, he places the trump slip in the tray, face down. When
the play of the hand is finished and the cards replaced in the tray, the
dealer puts his trump slip on the top of his cards. The four hands can
then be conveniently carried or handed to any other table to be
overplayed.

Various Apparatus for Duplicate.

SCORING. There should be two score-cards at each table. The

various methods of putting down and comparing the scores can best be
described in connection with the variety of competition to which they
belong. It is a common practice to note the trump card on the score
sheets.
POSITION OF THE PLAYERS. The four players at each table are
distinguished by the letters N S E W; North and South being partners
against East and West. West should always be the dealer in the first
hand, North having the original lead. In all published illustrative hands,
North is the leader, unless otherwise specified.
The deal passes in rotation to the left, and the number of hands
played should always be some multiple of four, so that each player may
have the original lead an equal number of times. 24 hands at each table
is the usual number, and is the rule at all League tournaments. The
partners and adversaries should be changed after each eight hands.
Three changes in 24 hands will bring each member of a set of four into
partnership with every other member for an equal number of hands.
 If two teams of four on a side, A B C D, and W X Y Z, play against
each other, the arrangement in a League tournament would be as
follows:—that A B C D should represent the players of the visiting club,
or challengers, and W X Y Z the home club, or holders; and that the
positions of the players should be changed after every four hands. It is
usual to play 24 hands in the afternoon, and 24 more at night.

A A A A A A
W X Y Z W Y X Z X Y W Z
B B C C D D

1st. 2nd. 3rd. 4th. 5th. 6th.

Y W X W W X
C D C D B D B D B C B C
Z X Z Y Z Y

If more than four players are engaged on each side, this arrangement
must be repeated with every additional four; the tables being always in
sets of two each, but in such cases, and in fact in anything but League
matches, it is usual to play only the 1st, 3rd and 5th sets.
CLUB AGAINST CLUB. The smaller club should put into the field as
many multiples of four as it can; the larger club presenting an equal
number to play against them. The opposing sides are then so arranged
that half the members of each club sit North and South, the other half
East and West. If we distinguish the clubs by the marks O and X, and
suppose 16 to be engaged on each side, they would be arranged at 8
tables, thus:—
 O O O O
X 1 X X 3 X X 5 X X 7 X
O O O O

1st set 2nd set 3rd set 4th set

X X X X
O 2 O O 4 O O 6 O O 8 O
X X X X

If apparatus is used, the players may sit still for four hands, putting
the trays aside, and then exchanging them for the four trays played at
the other table in their set. If not, the cards are left on the table, as
already described, and the fours change places; those at table No. 1
going to table No. 2, while those at No. 2 go to No. 1, the other sets
changing in the same manner. This brings them into this position:—

X X X X
O 1 O O 3 O O 5 O O 7 O
X X X X

O O O O
X 2 X X 4 X X 6 X X 8 X
O O O O

The two O’s that have just played the N & S hands at table No. 1,
proceed to play at table No. 2, the N & S hands which have just been
played by two X’s; while the two O’s that played the E & W hands at
table No. 2, overplay at table No. 1, the E & W hands just held by the
two X’s.
It is now evident that the four O’s have held between them all the 52
cards dealt at each table; for the first pair have held all the N & S hands
dealt at both tables, and the second pair have held all the E & W hands.
The same is true of the four X players; and if there is any difference in
the number of tricks taken by the opposing fours, it is supposed to be
due to a difference in skill, other matters having been equalised as far
as the limitations of the game will permit.
 The overplay finished, the cards are gathered, shuffled, cut, and dealt
afresh, East now having the original lead. It must be remembered that
the deal can never be lost, and that no matter what happens, the player
whose proper turn it is to deal must do so.
NUMBERING HANDS. The hands simultaneously played are scored
under the same number, but distinguished by the number of the table at
which they are first dealt. Each pair of partners in a team play two No. 1
hands, in one of which they are N & S; in the other E & W.
SCORING. The result of the hand is entered upon the score sheets,
which the opposing players at each table should then compare, and turn
them face down, leaving them on the table when they change places.
Let us suppose the N & S partners of the O team to make 7 tricks at
table No. 1; the E & W partners of the X team making 6. Each pair
enters on its own score-card the number it makes. The E & W partners
of the O team now come to table No. 1, and play the 26 cards which the
other members of their team did not hold. They are not permitted to
look at the score-card until the hand has been overplayed. Then they
enter the result, which should be 6 tricks. If the total of the tricks taken
by the same team on the N & S and the E & W hands is not 13, it must
be a loss or a gain. At the end of the 24 hands, the result of the match
can be immediately ascertained by laying side by side the score cards of
the East and West hands played at the same table. The North and South
scores are not compared, because the laws say they may be incorrect,
but the East and West must be, officially, right.
We give on the two preceding pages an illustration of the full score of
a match. The check marks in the 6th column show that the N & S
players compared the score with the E & W before turning down their
cards. The figures in the 2nd column are the gains on the various hands.
The figures in the 7th column show which of the four players whose
names appear at the top of the score-card were partners for that series
of hands. The result shows that the O team had a majority of one trick
at table No. 1, while the X team had a majority of three tricks at table
No. 2, leaving them the winners of the match by two tricks.
If sixteen players were engaged, it would be necessary to institute a
similar comparison between each set of tables, and there would be
sixteen score-cards to compare, two at a time, instead of four.
TEAM AGAINST TEAM. The methods just described for a match of
club against club are identical with those which are used in a contest
between two teams of four; the only difference being that of proportion.
In the latter case there will be only one set, of two tables, and only four
score-cards to compare.
The change of partners should be exhaustive in team matches; which
will require six sets.
TEAMS AGAINST TEAMS. When several quartette teams compete
with one another, Howell’s system of arrangement will be found the
best. There are two methods; for odd and for even numbers of teams.
Odd Numbers of Teams. This is the simplest form of contest. Let us
suppose five teams to offer for play, which we shall distinguish by the
letters, a, b, c, d, e, arranging each at its own table thus:—

N a b c d e
W + E a 1 a b 2 b c 3 c d 4 d e 5 e
S a b c d e
 The names of the N & S and the E & W members of each team should
first be entered on the score-cards; then all the N & S players move to
the next table East; those at table 5 going to table 1; and each table
dealing and playing four hands, afterwards putting them away in trays.

e a b c d
a 1 a b 2 b c 3 c d 4 d e 5 e
e a b c d
Hands:— 1 to 4 5 to 8 9 to 12 13 to 16 17 to 20

The peculiarity of this system is in the movement of the trays; those

at the middle table always going to the extreme West of the line, the
others moving up as many tables at a time as may be necessary to
follow them. In this instance the trays at table 3 go to 1, all others
moving up two tables. At the same time the N & S players all move one
table further East, bringing about this position:—

2nd set. d e a b c
a 1 a b 2 b c 3 c d 4 d e 5 e
 d e a b c
Hands:— 9 to 12 13 to 16 17 to 20 1 to 4 5 to 8

This movement of the trays and players is continued for two more
sets, which completes the round:—

3rd set. c d e a b
a 1 a b 2 b c 3 c d 4 d e 5 e
c d e a b
Hands:— 17 to 20 1 to 4 5 to 8 9 to 12 13 to 16

4th set. b c d e a
a 1 a b 2 b c 3 c d 4 d e 5 e
b c d e a

Hands:— 5 to 8 9 to 12 13 to 16 17 to 20 1 to 4

If we now take any two of the teams engaged, a and d for instance,
we shall find that the E & W a and the N & S d pairs of those teams
have played hands 9 to 12 at table 1, in the 2nd set; and that N & S a
and E & W d pairs have overplayed the same hands at table 4, in the
3rd set; so that we have really been carrying out a number of matches
simultaneously, between five teams of four players each.
If there are 5, 7, 9 or 11 tables in play, the movement of the trays
must be 2, 3, 4 or 5 tables at a time; but the movement of the players
remains the same; one table at a time, in the direction opposite to the
trays.
Gilman’s System. Another method, recommended by Charles F.
Gilman, of Boston, which prevents any possibility of players giving hints
to their friends as they pass the trays, is to have each team play at its
own table first, so as to get an individual score. The E & W players then
move to the next table but one, in either direction, going from 11 to 9;
from 9 to 7, etc., the N & S players sitting still. This movement is
continued until the E & W players have gone twice round. The trays
move in the same direction as the players, but only one table at a time;
going from 11 to 10, 9 to 8, etc. This brings about the same result as
the Howell’s system.
Even Numbers of Teams. The present method of arranging even
numbers of teams is also Gilman’s; but it requires considerable care in
the movement of the trays, because half of them lie idle during each
round, which is the same as skipping a table in other methods.
Suppose we have ten tables, arranged in two rows thus, with a team
of four players at each:

1 2 3 4 5
6 7 8 9 10

Taking 30 deals as the number to be played, we place trays No. 1, 2,

3, to be played and overplayed by tables 1 and 6, which are opposite
each other in the rows. Trays 4, 5, 6, we lay aside. Trays 7, 8, 9, are to
be played and overplayed by tables 2 and 7; while 10, 11, 12, are laid
aside, and so on until we get to tables 5 and 10, which play and
overplay trays 25, 26, 27. The easiest way to manage this is to give tray
No. 2 to table 6, while tray 1 is at table 1, and then to let table 1 take
tray 2, while table 6 plays tray 3. Then table 1 will get tray 3, while table
6 overplays tray 1. This will make all the trays come in numerical order
to table 1, and will act as a check.
The play of the first round, three deals, finished, the E & W players all
move one table, 2 going to 1, 3 to 2, etc. The umpire now brings into
play the trays that were idle, giving trays 4, 5, 6, to tables 1 and 6; trays
10, 11, 12, to tables 2 and 7, and so on down the line, all the trays that
were used in the first round lying idle.
Again the players move, and now table 1 gets the 7, 8, 9, set of trays
to overplay with table 6, and so on; so that all the sets move up a table
after each intervening round, and table 1 will get all the trays from 1 to
30 in order.
SCORING. In both the foregoing systems, each pair should have its
own score-card, and should mark the name of the team it plays against
for each series of four hands. These score-cards are more for private
reference than anything else in tournaments; because there is always a
professional scorer, for whose use small slips are filled out and collected
from the tables at the end of each round. The winner is the team that
wins the most matches; not the one that gains the most tricks. In case
of ties, the number of tricks won must decide. If the number of tricks
taken by each side is a tie in any match, the score is marked zero, and
each team counts half a match won. We give an illustration of the final
score in a match between five teams. The c and d teams are tied for a
second place in the number of matches; but the c team takes third
place, because it has lost one more trick than the d team. The b and c
teams score a half match; so do the c and e teams.

PAIR AGAINST PAIR. This is the most interesting form of

competition, especially for domestic parties, as the arrangement of the
players will allow of great latitude in the number engaged, table after
table being added as long as players offer to fill them.
Two Pairs. When only four players are engaged at a single table, the
game is called Memory Duplicate; which is forbidden in all first-class
clubs. The players retain their seats until they have played an agreed
number of hands, which are laid aside one by one in trays. No trump is
turned in Memory Duplicate; one suit being declared trumps for the
entire sitting.
Instead of the players changing positions for the overplay, the trays
are reversed. If the indicators pointed N & S on the original deals, they
must lie E & W for the overplay.
 Original Position of Trays. Position for Overplay.

Scoring. The E & W hands only are scored, the card being laid aside
after the original play is completed, and a new card used for the
overplay. The difference in the totals of these two sets of score-cards
will show which pair gained the most tricks.
Four Pairs. These should be arranged at two tables, changing
adversaries after every 8 hands. The third set will exhaust the
combinations, and it will then be found that each pair has played and
overplayed an equal number of hands against every other pair.

1st set 2nd set 3rd set

b c d
a a a a a a
b c d
Hands:— 1 to 8 9 to 16 17 to 24

d b c
c c d d b b
d b c

Four hands are dealt at each table in each set, and then exchanged.
The trump card is turned for every original deal.
Scoring. Each pair carries its own score-card with it from table to
table, until the 24 hands have been played. The 7th column is used to
designate the pair played against. The pairs at the second table should
begin scoring with hands Nos. 5, 13 and 21 respectively; as they will
presently receive from the first table the series beginning 1, 9 and 17
respectively. Eight hands complete a match, and the result must be
tabulated in the same manner as for teams of four, ties being decided by
the majority of tricks won. We give an example.

The a pair wins the tie with d, being 6 tricks plus.

Six Pairs. This is a very awkward number to handle, and should be
avoided if possible. The whole could be played at three tables
simultaneously; but such a course would necessitate their changing
places ten times, following a very complicated schedule in so doing. The
simplest way to handle six pairs is to arrange them at three tables, two
of which are constantly in play, the third only half the time. This is the
first position:—

b d f
a 1 a c 2 c e 3 e
b d f

Tables 1 and 2 deal and play two hands each, and then exchange
trays with each other. At table 3, two hands are dealt and played, both
being left in the trays.
The players at tables 1 and 2 then change adversaries; dealing,
playing and exchanging two fresh hands. The players at the third table
remain idle, or look on.

c d f
a 1 a b 2 b e 3 e
c d f
 Hands 5 and 6
None.
played and exchanged.

The b and c pairs now give way to e and f:—

e d b
a 1 a f 2 f c 3 c
e d b

Hands 7 and 8
3 and 4.
played and exchanged.

While tables 1 and 2 are playing two fresh hands, the trays containing
hands Nos. 3 and 4 which were left at table 3 are overplayed by the b
and c pairs, which makes a match between them and the e and f pairs.
Again the pairs at the first two tables change adversaries; dealing,
playing and exchanging two more hands; the third table remaining idle.

f d b
a 1 a e 2 e c 3 c
f d b

Hands 9 and 10
None.
played and exchanged.

The pairs a and d now give way to b and c, and the b c e f pairs play
two hands and exchange them; then change adversaries for two more
hands; a and d remaining idle all the time. All the pairs have now been
matched but a and d, and they take seats E & W at two tables, the N &
S positions being filled up by any of the other players in the match.

any any
a 1 a d 2 d
any any
 No notice is taken of the scores made by the N & S hands in the last
set; as it is simply a match between the a and d pairs.
Scoring. Each pair against each is considered a match, and the
winner of the most matches wins, tricks deciding ties.
Compass Whist. When we come to handle large numbers, the
changes of position become too complicated, and the simplest plan is to
arrange them at as many tables as they will fill, and to place on each
table an equal number of trays. At the Knickerbocker Whist Club, New
York, which is still famous for its compass games, they play a minimum
of 24 trays, or get as near that number as possible. If there are 14
tables, they play two deals at each. If there are only 10 tables, they play
30 trays.
All the N & S players sit still, and at the end of each round, two or
three deals as the case may be, all the E & W players move up one
table, 2 going to 1, 3 to 2, etc. Each pair keeps its own score card, on
which is put down the number of the tray, the number of the pair played
against, which is always the number of the table at which they started;
one of the pairs remaining there being No. 3 N & S, the other moving
away, being No. 3 E & W.
Each pair adds up its score card at the end, and puts down the total
number of tricks they have won. The names of the players having been
previously written on the blackboard, their scores are put down opposite
their names, each side, N & S and E & W, is then added up in order to
find the average, and all scores above average are plus, while all below
average are minus.
The following is an example of the averaging of a game in which five
tables took part, playing 30 deals:—

N&S E&W
a 201 -6 f 189 +6
b 204 -3 g 186 +3
c 211 +4 h 179 -4
d 207 = j 183 =
e 212 +5 k 178 -5
5 1035 5 915
 Aver. 207, N & S. Aver. 183, E & W.

The e and f pairs make the best scores N & S and E & W respectively;
the f pair, having won the greatest number of tricks above the average
of the hands, would be the winners.
Howell Pair System. A very popular system of managing pairs in
club games, and also in the national tournaments for the Minneapolis
trophy, is called the Howell Pairs. Indicator cards are placed on the
tables, which show each player the number of the table and the position
at that table to which he should move next. Sometimes he will sit N,
sometimes S, and sometimes E or W, but he always finds his partner
opposite him, and at the end of the game he will have had every other
pair in the game for an adversary once, and will have played all the
hands dealt.
A different set of indicator cards is required for every different number
of tables in the game. They are the invention of the late E.C. Howell of
Washington, D.C., and have been arranged for any number of pairs from
four to thirty-four.
INDIVIDUALS. When four play memory duplicate, one of the four,
usually S, retains his seat and keeps the score, the others changing
places right and left alternately, each playing with S as a partner for 8
hands. These changes successively bring about the three following
positions:—

c b a
a b a c c b
S S S

Hands:— 1 to 4 5 to 8 9 to 12

For the overplay, the trays are reversed, the hands originally dealt N &
S being placed E & W; but the players continue to change right and left
alternately. This brings the same partners together, but on different
sides of the table.

c b a
 b a c a c b
S S S

Hands:— 1 to 4 5 to 8 9 to 12

Scoring. The names of the four players should be written at the head
of each score-card, and as there is no trump turned in memory
duplicate, the third and seventh columns can both be used for the
numbers of the players that are partners, and the sixth column for the N
& S gains.
When the match is finished, a tabulation of the tricks lost or won by
each player will readily show which is the winner. In the illustration
which we give, No. 3 finishes plus 6; No. 4 plus 2; No. 1 minus 4; and
No. 2 minus 4.

It must be remembered that the hands which are here scored N & S,
in the 5th column, were E & W when originally dealt; so that the 1st and
5th columns are really the same hands. The score-card should be folded
down the middle during the overplay, so that the original scores cannot
be seen. It is even better to use a new card.
 Foster’s System of playing two pairs at one table, which was used
at all the matches for the Utica Trophy, in which one pair from a club
challenged the pair that held the trophy for another club, consisted in
having an umpire to transpose the suits between the original and the
overplay of the deals. The trays containing the hands were sent in to the
umpire’s room, and he had an extra pack of cards, from which he
duplicated each hand of thirteen cards as he took it out of the pocket to
which it belonged, but changed the suits, making clubs trumps instead
of hearts, etc. This system was found to do away with the memory part
of the game, it being very difficult to recognize a hand unless it had
some startling feature.
Coupled with the present practice of throwing out all hands in which
there is found to be a suit of more than six cards, and dealing it over
again, Foster’s system for two pairs is the best so far suggested.
Eight Individuals. This form of contest is seldom used, because
players dislike the continual changing of position, and the delay in
arriving at the results of the score. It would require seven sets to
exhaust the combinations; and at each table two hands should be dealt,
played, and exchanged with the other table in the set, before the
players change positions. This would require 28 hands to complete the
match.
Safford’s System for arranging the players is to have indicator cards
on the tables:—

The players take their seats in any order for the first set; after which
they go to the next higher number; 8 keeping his seat, and 7 going to 1.
Scoring. Each individual must keep his own score, adding up the
total tricks taken in each set of four hands. These totals must then be
compared with those of the player occupying the same position, N, S, E,
or W, at the other table in the set; and it will save time in the end if
these are tabulated at once, on a sheet prepared for the purpose. For
instance: Let this be the arrangement of eight players in the first set:—

b f
a 1 c Hands 1 to 4. e 2 g
d h

If a and c take 34 tricks E & W; e and g taking only 30 with the same
cards, either a and c must have gained them, or e and g must have lost
them. It is a waste of time to put down both losses and gains, and all
that is necessary is to call the top score zero, and charge all players with
the loss of as many tricks as their total is short of the top score. In this
case we charge e and g with a loss of 4 each. It must be obvious that f
and h have also made 4 more tricks than b and d; and that the latter
must be charged with a loss of 4 on the same hands that e and g lose
on.
We give as an illustration a sheet balanced in this way, showing the
losses of the various players. The totals at the end of the match show
that c is the winner, losing less tricks than any other player.

Large Numbers of Individuals. Several ingenious methods have

been devised for handling large numbers of players, especially in
domestic parties; Safford and Mitchell having both distinguished
themselves in this line. The simplest form has been suggested by
Mitchell, and is especially adapted for social gatherings of ladies and
gentlemen.
As many tables as possible are filled; all the ladies sitting N & E; the
gentlemen S and W.

The number of hands dealt at each table must be adjusted to the

number of tables filled, and the time to be devoted to play. The trays
containing the hands are passed to the West, and all the gentlemen
move one table to the East, the ladies sitting still. In all the changes
each gentleman keeps to his original point of the compass, South or
West. When he arrives at the table he started from, the round is
finished. If an odd number of tables are engaged in play, the changes
may take place in regular order to the end. If even, a dummy must be
put in; but as that is objectionable in a social gathering, it is better to
adopt one of the two systems following, unless half the number of
tables is an odd number, when the method already described may be
used.
1st Method. Some table in the series, which must not be either the
first or the last, deals no original hands, but overplays all the hands
coming from the other tables to the East of it. The four players sit still,
taking no part in the progression; thus obliging those whose turn it
would be to play at their table to pass on to the next.
2nd Method. Each gentleman should carefully note the number of
the hand originally dealt at the table from which he starts. He
progresses until he meets this hand again. The first to observe this
should give notice to the company by a bell tap, as all the gentlemen
must meet their original hands at the same time. Instead of stopping at
the table at which this tray is encountered, all the gentlemen move on
to the next, leaving the trays as they are. This skip enables each to
finish the round without playing any of the hands twice.
 Scoring. There must be four winners; the ladies with the best scores
for the N & E hands respectively, and the gentlemen with the best S &
W scores. If a choice is necessary, the lady and the gentleman taking
the greatest number of tricks above the average should be selected as
the winners.
MARRIED COUPLES. Safford has an ingenious schedule for eight
married couples, so arranged in two sets that no husband and wife are
ever in the same set at the same time. When seven sets have been
played, every lady will have overplayed four hands against every other
lady and gentleman, including four held by her husband. The same will
be true of every man. Indicators are placed on the tables to show
players their successive positions. The numbers represent the husbands,
and the letters the wives, the couples being a-1, b-2, etc. The couple a-
1 always sit still; the ladies go to the next higher letter of the alphabet,
and the men to the next higher number; h going to b, as a sits still; and
8 to 2.

One hand is dealt at each table, and overplayed at each of the others.
A different point of the compass should deal at each table, in order to
equalise the lead.
Scoring. The score of each four hands should be added up by each
individual player, and the results tabulated at the end of every four
hands, in the manner described for eight individuals. The winner is the
player who loses the fewest tricks. This is the only known system for
deciding whether or not a man can play whist better than his wife.
PROGRESSIVE DUPLICATE WHIST is the generic name by which
those systems of duplicate are known in which the purpose is to have as
many as possible of the players meet one another during the progress
of the match. Most of the systems we have been describing belong to
this class.
 There are at present only two works on Duplicate Whist; but a
number of articles on the subject may be found in “Whist.”

Duplicate Whist; by John T. Mitchell, 1896.

Foster’s Duplicate Whist; 1894.
Whist; Jan., 1892; Jan., 1894; Aug., 1894; Oct., 1894; Jan., 1895:
Mar., 1895; May, 1895; July, 1895; Oct., 1895.

THE LAWS OF DUPLICATE WHIST.

The Laws of Duplicate Whist as Amended and Adopted at the Whist

Congress, Niagara Falls, New York, July, 1900; as amended at the
Twelfth Congress, June, 1902; as amended at the Thirteenth Congress,
July, 1903; Fourteenth A.W.L. Congress, July, 1904; Fifteenth Congress,
July, 1905; Sixteenth Congress, July, 1906; Twentieth Congress, July
1910.

DEFINITIONS.

The words and phrases used in these laws shall be construed in

accordance with the following definitions unless such construction is
inconsistent with the context:
(a) The thirteen cards received by any one player are termed a
“hand.”
(b) The four hands into which a pack is distributed for play are termed
a “deal;” the same term is also used to designate the act of distributing
the cards to the players.
(c) A “tray” is a device for retaining the hands of a deal and indicating
the order of playing them.
(d) The player who is entitled to the trump card is termed the
“dealer,” whether the cards have or have not been dealt by him.
(e) The first play of a deal is termed “the original play;” the second or
any subsequent play of such deal, the “overplay.”
 (f) “Duplicate Whist” is that form of the game of whist in which each
deal is played only once by each player, and in which each deal is so
overplayed as to bring the play of teams, pairs of individuals into
comparison.
(g) A player “renounces” when he does not follow suit to the card led;
he “renounces in error” when, although holding one or more cards of
the suit led, he plays a card of a different suit; if such renounce in error
is not lawfully corrected it constitutes a “revoke.”
(h) A card is “played” whenever, in the course of play, it is placed or
dropped face upwards on the table.
(i) A trick is “turned and quitted” when all four players have turned
and quitted their respective cards.

LAW I.—Shuffling.

Sec. 1. Before the cards are dealt they must be shuffled in the
presence of an adversary or the umpire.
Sec. 2. The pack must not be so shuffled as to expose the face of any
card; if a card is so exposed the pack must be reshuffled.

LAW II.—Cutting for the Trump.

Sec. 1. The dealer must present the cards to his right hand adversary
to be cut; such adversary must take from the top of the pack at least
four cards and place them toward the dealer, leaving at least four cards
in the remaining packet; the dealer must reunite the packets by placing
the one not removed in cutting upon the other. If, in cutting or in
reuniting the separate packets, a card is exposed, the pack must be
reshuffled and cut again; if there is any confusion of the cards or doubt
as to the place where the pack was separated, there must be a new cut.

LAW III.—Dealing.
 Sec. 1. When the pack has been properly cut and reunited, the cards
must be dealt, one at a time, face down, from the top of the pack, the
first to the player at the left of the dealer, and each successive card to
the player at the left of the one to whom the last preceding card has
been dealt. The last, which is the trump card, must be turned and
placed face up on the tray, if one is used; otherwise, at the right of the
dealer.
Sec. 2. There must be a new deal—
(a) If any card except the last is faced or exposed in any way in
dealing;
(b) If the pack is proved incorrect or imperfect;
(c) If either more or less than thirteen cards are dealt to any player;
(d) If, after the first trick has been turned and quitted on the original
play of a deal, one or more cards are found to have been left in the tray.

LAW IV.—The Trump Card.

Sec. 1. The trump card and the number of the deal must be recorded,
before the play begins, on a slip provided for that purpose, and must
not be elsewhere recorded. Such slip must be shown to an adversary,
then turned face down and placed in the tray, if one is used.
Sec. 2. The dealer must leave the trump card face up until it is his turn
to play to the first trick; he must take the trump card into his hand and
turn down the trump slip before the second trick is turned and quitted.
Sec. 3. When a deal is taken up for overplay, the dealer must show the
trump slip to an adversary, and thereafter the trump slip and trump card
shall be treated as in the case of an original deal.
Sec. 4. After the trump card has been lawfully taken into the hand and
the trump slip turned face down, the trump card must not be named nor
the trump slip examined during the play of the deal; a player may,
however, ask what the trump suit is.
Sec. 5. If a player unlawfully looks at the trump slip, his highest or
lowest trump may be called; if a player unlawfully names the trump
card, or unlawfully shows the trump slip to his partner, his partner’s
highest or lowest trump may be called.
Sec. 6. These penalties can be inflicted by either adversary at any time
during the play of the deal in which they are incurred before the player
from whom the call can be made has played to the current trick; the call
may be repeated at each or any trick until the card is played, but cannot
be changed.
Sec. 7. When a deal has been played the cards of the respective
players, including the trump card, must be placed in the tray face down
and the trump slip placed face up on top of the dealer’s cards.
Sec. 8. If on the overplay of a deal, the dealer turns a trump card
other than the one recorded on the trump slip, and such error is
discovered and corrected before the play of the deal is commenced, the
card turned in error is liable to be called.
Sec. 9. If such error is not corrected until after the overplay has begun
and more than two tables are engaged in play, the players at that table
shall take the average score for the deal; if less than three tables are in
play there must be a new deal.
Sec. 10. Should a player record on the trump slip a different trump
from one turned in dealing and the error be discovered at the next
table, there must be a new deal. If the deal has been played at one or
more tables with the wrong trump, the recorded trump must be taken
as correct and the players at the original table take the average score
for the deal; if less than three tables are in play, there must be a new
deal.
Sec. 11. By the unanimous consent of the players in any match, a
trump suit may be declared and no trump turned.

LAW V.—Irregularities in the Hand.

Sec. 1. If, on the overplay, a player is found to have more than his
correct number of cards or the trump card is not in the dealer’s hand, or
any card except the trump card is so faced as to expose any of the
printing on its face, and less than three tables are engaged, there must
be a new deal. If more than two tables are in play, the hands must be
rectified and then passed to the next table; the table at which the error
was discovered must not overplay the deal but shall take the average
score.
Sec. 2. If after the first trick has been turned and quitted on the
overplay of a deal, a player is found to have less than his correct
number of cards, and the others have their correct number, such player
shall be answerable for the missing card or cards and for any revoke or
revokes which he has made by reason of its or their absence.

LAW VI.—Playing, Turning and Quitting the Cards.

Sec. 1. Each player when it is his turn to play, must place his card face
up before him and towards the center of the table and allow it to remain
in this position until all have played to the trick, when he must turn it
over and place its face down and nearer to himself, placing each
successive card as he turns it, so that it overlaps the last card played by
him and with the ends towards the winners of the trick. After he has
played his card and also after he has turned it, he must quit it by
removing his hand.
Sec. 2. The cards must be left in the order in which they were played
and quitted until the scores for the deal are recorded.
Sec. 3. During the play of a deal a player must not pick up or turn
another player’s card.
Sec. 4. Before a trick is turned and quitted any player may require any
of the other players to show the face of the card played to that trick.
Sec. 5. If a player names a card of a trick which has been turned and
quitted or turns or raises any such card so that any portion of its face
can be seen by himself or his partner he is liable to the same penalty as
if he had led out of turn.

LAW VII.—Cards Liable to be Called.

Sec. 1. The following cards are liable to be called:

Welcome to our website – the perfect destination for book lovers and
knowledge seekers. We believe that every book holds a new world,
offering opportunities for learning, discovery, and personal growth.
That’s why we are dedicated to bringing you a diverse collection of
books, ranging from classic literature and specialized publications to
self-development guides and children's books.

More than just a book-buying platform, we strive to be a bridge

connecting you with timeless cultural and intellectual values. With an
elegant, user-friendly interface and a smart search system, you can
quickly find the books that best suit your interests. Additionally,
our special promotions and home delivery services help you save time
and fully enjoy the joy of reading.

Join us on a journey of knowledge exploration, passion nurturing, and

personal growth every day!

ebookmasss.com