~ubuntu-branches/ubuntu/intrepid/perl-doc-html/intrepid

We're counting on <code class="inline"><a class="l_k" href="functions/no.html">no</a> <a class="l_w" href="strict.html">strict</a> <a class="l_w" href="subs.html">subs</a></code>

132

We're counting on <code class="inline"><a class="l_k" href="functions/no.html">no</a> strict subs</code>

130

133

mode, certainly not recommended

131

134

for larger programs. And why was that necessary? Because the name of

132

135

the package seems to be inseparable from the name of the subroutine we

133

136

want to invoke within that package.

134

137

Or is it?

135

138

<a name="Introducing-the-method-invocation-arrow"></a><h2>Introducing the method invocation arrow</h2>

136

For now, let's say that <code class="inline">Class->method</code>

139

For now, let's say that <code class="inline">Class->method</code>

137

140

invokes subroutine

138

<code class="inline">method</code>

139

in package <code class="inline">Class</code>

141

<code class="inline">method</code>

142

in package <code class="inline">Class</code>

140

143

. (Here, "Class" is used in its

141

144

"category" meaning, not its "scholastic" meaning.) That's not

142

145

completely accurate, but we'll do this one step at a time. Now let's

143

146

use it like so:

144

147

<pre class="verbatim"> # Cow::speak, Horse::speak, Sheep::speak as before

145

Cow->speak;

146

Horse->speak;

147

Sheep->speak;</pre>

148

Cow->speak;

149

Horse->speak;

150

Sheep->speak;</pre>

148

151

And once again, this results in:

149

<pre class="verbatim"> a Cow goes moooo!

150

a Horse goes neigh!

151

a Sheep goes baaaah!</pre>

152

<pre class="verbatim"> a Cow goes moooo!

153

a Horse goes neigh!

154

a Sheep goes baaaah!</pre>

152

155

That's not fun yet. Same number of characters, all constant, no

153

156

variables. But yet, the parts are separable now. Watch:

154

157

<pre class="verbatim"> $a = "Cow";

155

158

$a->speak; # invokes Cow->speak</pre>

156

159

Ahh! Now that the package name has been parted from the subroutine

157

160

name, we can use a variable package name. And this time, we've got

158

something that works even when <code class="inline"><a class="l_k" href="functions/use.html">use</a> <a class="l_w" href="strict.html">strict</a> refs</code>

161

something that works even when <code class="inline"><a class="l_k" href="functions/use.html">use</a> strict refs</code>

159

162

is enabled.

160

163

<a name="Invoking-a-barnyard"></a><h2>Invoking a barnyard</h2>

161

164

Let's take that new arrow invocation and put it back in the barnyard

167

170

<a class="l_k" href="functions/print.html">print</a> "a Horse goes neigh!\n";

168

171

}

169

172

<a name="Sheep::speak"></a> sub Sheep::speak {

170

<a class="l_k" href="functions/print.html">print</a> "a Sheep goes baaaah!\n"

173

<a class="l_k" href="functions/print.html">print</a> "a Sheep goes baaaah!\n";

171

174

}</pre>

172

175

<pre class="verbatim"> @pasture = qw(Cow Cow Horse Sheep Sheep);

173

176

foreach $animal (@pasture) {

175

178

}</pre>

176

179

There! Now we have the animals all talking, and safely at that,

177

180

without the use of symbolic coderefs.

178

But look at all that common code. Each of the <code class="inline">speak</code>

181

But look at all that common code. Each of the <code class="inline">speak</code>

179

182

routines has a

180

183

similar structure: a <code class="inline"><a class="l_k" href="functions/print.html">print</a></code> operator and a string that contains

181

184

common text, except for two of the words. It'd be nice if we could

182

185

factor out the commonality, in case we decide later to change it all

183

to <code class="inline">says</code>

184

instead of <code class="inline">goes</code>

186

to <code class="inline">says</code>

187

instead of <code class="inline">goes</code>

185

188

.

186

189

And we actually have a way of doing that without much fuss, but we

187

190

have to hear a bit more about what the method invocation arrow is

188

191

actually doing for us.

189

192

<a name="The-extra-parameter-of-method-invocation"></a><h2>The extra parameter of method invocation</h2>

190

193

The invocation of:

191

<pre class="verbatim"> Class->method(@args)</pre>

192

attempts to invoke subroutine <code class="inline">Class::method</code>

194

<pre class="verbatim"> Class->method(@args)</pre>

195

attempts to invoke subroutine <code class="inline">Class::method</code>

193

196

as:

194

197

<pre class="verbatim"> Class::method("Class", @args);</pre>

195

198

(If the subroutine can't be found, "inheritance" kicks in, but we'll

196

199

get to that later.) This means that we get the class name as the

197

200

first parameter (the only parameter, if no arguments are given). So

198

we can rewrite the <code class="inline">Sheep</code>

201

we can rewrite the <code class="inline">Sheep</code>

199

202

speaking subroutine as:

200

203

<pre class="verbatim"><a name="Sheep::speak"></a> sub Sheep::speak {

201

204

<a class="l_k" href="functions/my.html">my</a> $class = <a class="l_k" href="functions/shift.html">shift</a>;

216

219

we factor that out even further? Yes, by calling another method in

217

220

the same class.

218

221

<a name="Calling-a-second-method-to-simplify-things"></a><h2>Calling a second method to simplify things</h2>

219

Let's call out from <code class="inline">speak</code>

220

to a helper method called <code class="inline">sound</code>

222

Let's call out from <code class="inline">speak</code>

223

to a helper method called <code class="inline">sound</code>

221

224

222

225

This method provides the constant text for the sound itself.

223

226

<pre class="verbatim"><a name="package-Cow"></a> { package Cow;

224

227

<a name="sound"></a> sub sound { "moooo" }

225

228

<a name="speak"></a> sub speak {

226

229

<a class="l_k" href="functions/my.html">my</a> $class = <a class="l_k" href="functions/shift.html">shift</a>;

227

<a class="l_k" href="functions/print.html">print</a> "a $class goes ", $class->sound, "!\n"

230

228

231

}

229

232

230

Now, when we call <code class="inline">Cow->speak</code>

233

Now, when we call <code class="inline">Cow->speak</code>

231

234

, we get a <code class="inline">$class</code>

232

of <code class="inline">Cow</code>

235

of <code class="inline">Cow</code>

233

236

234

<code class="inline">speak</code>

235

. This in turn selects the <code class="inline">Cow->sound</code>

237

<code class="inline">speak</code>

238

. This in turn selects the <code class="inline">Cow->sound</code>

236

239

method, which

237

returns <code class="inline">moooo</code>

238

. But how different would this be for the <code class="inline">Horse</code>

240

returns <code class="inline">moooo</code>

241

. But how different would this be for the <code class="inline">Horse</code>

239

242

?

240

243

<pre class="verbatim"><a name="package-Horse"></a> { package Horse;

241

244

<a name="sound"></a> sub sound { "neigh" }

242

245

<a name="speak"></a> sub speak {

243

246

<a class="l_k" href="functions/my.html">my</a> $class = <a class="l_k" href="functions/shift.html">shift</a>;

244

247

245

248

}

246

249

247

250

Only the name of the package and the specific sound change. So can we

248

somehow share the definition for <code class="inline">speak</code>

251

somehow share the definition for <code class="inline">speak</code>

249

252

between the Cow and the

250

253

Horse? Yes, with inheritance!

251

254

<a name="Inheriting-the-windpipes"></a><h2>Inheriting the windpipes</h2>

252

We'll define a common subroutine package called <code class="inline">Animal</code>

255

We'll define a common subroutine package called <code class="inline">Animal</code>

253

256

, with the

254

definition for <code class="inline">speak</code>

257

definition for <code class="inline">speak</code>

255

258

:

256

259

<pre class="verbatim"><a name="package-Animal"></a> { package Animal;

257

260

<a name="speak"></a> sub speak {

258

261

<a class="l_k" href="functions/my.html">my</a> $class = <a class="l_k" href="functions/shift.html">shift</a>;

259

262

260

263

}

261

264

262

Then, for each animal, we say it "inherits" from <code class="inline">Animal</code>

265

Then, for each animal, we say it "inherits" from <code class="inline">Animal</code>

263

266

, along

264

267

with the animal-specific sound:

265

268

<pre class="verbatim"><a name="package-Cow"></a> { package Cow;

268

271

269

272

Note the added <code class="inline">@ISA</code>

270

273

array. We'll get to that in a minute.

271

But what happens when we invoke <code class="inline">Cow->speak</code>

274

But what happens when we invoke <code class="inline">Cow->speak</code>

272

275

now?

273

276

First, Perl constructs the argument list. In this case, it's just

274

275

. Then Perl looks for <code class="inline">Cow::speak</code>

277

278

. Then Perl looks for <code class="inline">Cow::speak</code>

276

279

. But that's not there, so

277

280

Perl checks for the inheritance array <code class="inline">@Cow::ISA</code>

278

281

. It's there,

279

and contains the single name <code class="inline">Animal</code>

282

and contains the single name <code class="inline">Animal</code>

280

283

.

281

Perl next checks for <code class="inline">speak</code>

282

inside <code class="inline">Animal</code>

284

Perl next checks for <code class="inline">speak</code>

285

inside <code class="inline">Animal</code>

283

286

instead, as in

284

<code class="inline">Animal::speak</code>

287

<code class="inline">Animal::speak</code>

285

288

. And that's found, so Perl invokes that subroutine

286

289

with the already frozen argument list.

287

Inside the <code class="inline">Animal::speak</code>

290

Inside the <code class="inline">Animal::speak</code>

288

291

subroutine, <code class="inline">$class</code>

289

becomes <code class="inline">Cow</code>

292

becomes <code class="inline">Cow</code>

290

293

(the

291

294

first argument). So when we get to the step of invoking

292

295

<code class="inline">$class->sound</code>

293

, it'll be looking for <code class="inline">Cow->sound</code>

296

, it'll be looking for <code class="inline">Cow->sound</code>

294

297

, which

295

298

gets it on the first try without looking at <code class="inline">@ISA</code>

296

299

. Success!

297

300

<a name="A-few-notes-about-%40ISA"></a><h2>A few notes about @ISA</h2>

298

301

This magical <code class="inline">@ISA</code>

299

302

variable (pronounced "is a" not "ice-uh"), has

300

declared that <code class="inline">Cow</code>

301

"is a" <code class="inline">Animal</code>

303

declared that <code class="inline">Cow</code>

304

"is a" <code class="inline">Animal</code>

302

305

. Note that it's an array,

303

306

not a simple single value, because on rare occasions, it makes sense

304

307

to have more than one parent class searched for the missing methods.

305

If <code class="inline">Animal</code>

308

If <code class="inline">Animal</code>

306

309

also had an <code class="inline">@ISA</code>

307

310

, then we'd check there too. The

308

311

search is recursive, depth-first, left-to-right in each <code class="inline">@ISA</code>

309

310

Typically, each <code class="inline">@ISA</code>

311

has only one element (multiple elements means

312

multiple inheritance and multiple headaches), so we get a nice tree of

313

inheritance.

314

When we turn on <code class="inline"><a class="l_k" href="functions/use.html">use</a> <a class="l_w" href="strict.html">strict</a></code>

312

313

default (see <a href="mro.html">mro</a> for alternatives). Typically, each <code class="inline">@ISA</code>

314

has

315

only one element (multiple elements means multiple inheritance and

316

multiple headaches), so we get a nice tree of inheritance.

317

When we turn on <code class="inline"><a class="l_k" href="functions/use.html">use</a> strict</code>

315

318

, we'll get complaints on <code class="inline">@ISA</code>

316

319

, since

317

320

it's not a variable containing an explicit package name, nor is it a

322

325

<pre class="verbatim"> @Cow::ISA = qw(Animal);</pre>

323

326

Or allow it as an implicitly named package variable:

324

327

<pre class="verbatim"><a name="package-Cow"></a> package Cow;

325

<a class="l_k" href="functions/use.html">use</a> <a class="l_w" href="vars.html">vars</a> qw(@ISA);

328

<a class="l_k" href="functions/use.html">use</a> vars qw(@ISA);

326

329

@ISA = qw(Animal);</pre>

327

330

If you're bringing in the class from outside, via an object-oriented

328

331

module, you change:

329

332

<pre class="verbatim"><a name="package-Cow"></a> package Cow;

330

<a class="l_k" href="functions/use.html">use</a> Animal;

331

<a class="l_k" href="functions/use.html">use</a> <a class="l_w" href="vars.html">vars</a> qw(@ISA);

333

<a class="l_k" href="functions/use.html">use</a> Animal;

334

<a class="l_k" href="functions/use.html">use</a> vars qw(@ISA);

332

335

@ISA = qw(Animal);</pre>

333

336

into just:

334

337

<pre class="verbatim"><a name="package-Cow"></a> package Cow;

335

<a class="l_k" href="functions/use.html">use</a> <a class="l_w" href="base.html">base</a> qw(Animal);</pre>

338

<a class="l_k" href="functions/use.html">use</a> base qw(Animal);</pre>

336

339

And that's pretty darn compact.

337

340

<a name="Overriding-the-methods"></a><h2>Overriding the methods</h2>

338

341

Let's add a mouse, which can barely be heard:

346

349

<a class="l_k" href="functions/print.html">print</a> "[but you can barely hear it!]\n";

347

350

}

348

351

349

<pre class="verbatim"> Mouse->speak;</pre>

352

<pre class="verbatim"> Mouse->speak;</pre>

350

353

which results in:

351

<pre class="verbatim"> a Mouse goes squeak!

352

[but you can barely hear it!]</pre>

353

Here, <code class="inline">Mouse</code>

354

has its own speaking routine, so <code class="inline">Mouse->speak</code>

354

<pre class="verbatim"> a Mouse goes squeak!

355

[but you can barely hear it!]</pre>

356

Here, <code class="inline">Mouse</code>

357

has its own speaking routine, so <code class="inline">Mouse->speak</code>

355

358

356

doesn't immediately invoke <code class="inline">Animal->speak</code>

359

doesn't immediately invoke <code class="inline">Animal->speak</code>

357

360

. This is known as

358

"overriding". In fact, we didn't even need to say that a <code class="inline">Mouse</code>

361

"overriding". In fact, we didn't even need to say that a <code class="inline">Mouse</code>

359

362

was

360

an <code class="inline">Animal</code>

361

at all, since all of the methods needed for <code class="inline">speak</code>

363

an <code class="inline">Animal</code>

364

at all, since all of the methods needed for <code class="inline">speak</code>

362

365

are

363

completely defined with <code class="inline">Mouse</code>

366

completely defined with <code class="inline">Mouse</code>

364

367

.

365

But we've now duplicated some of the code from <code class="inline">Animal->speak</code>

368

But we've now duplicated some of the code from <code class="inline">Animal->speak</code>

366

369

367

370

and this can once again be a maintenance headache. So, can we avoid

368

that? Can we say somehow that a <code class="inline">Mouse</code>

371

that? Can we say somehow that a <code class="inline">Mouse</code>

369

372

does everything any other

370

<code class="inline">Animal</code>

373

<code class="inline">Animal</code>

371

374

does, but add in the extra comment? Sure!

372

First, we can invoke the <code class="inline">Animal::speak</code>

375

First, we can invoke the <code class="inline">Animal::speak</code>

373

376

method directly:

374

377

<pre class="verbatim"> # Animal package from before

375

378

<a name="package-Mouse"></a> { package Mouse;

384

387

Note that we have to include the <code class="inline">$class</code>

385

388

parameter (almost surely

386

389

the value of <code class="inline">"Mouse"</code>

387

) as the first parameter to <code class="inline">Animal::speak</code>

390

) as the first parameter to <code class="inline">Animal::speak</code>

388

391

389

392

since we've stopped using the method arrow. Why did we stop? Well,

390

if we invoke <code class="inline">Animal->speak</code>

393

if we invoke <code class="inline">Animal->speak</code>

391

394

there, the first parameter to the

392

395

method will be <code class="inline">"Animal"</code>

393

396

not <code class="inline">"Mouse"</code>

394

397

, and when time comes for it

395

to call for the <code class="inline">sound</code>

398

to call for the <code class="inline">sound</code>

396

399

, it won't have the right class to come back

397

400

to this package.

398

Invoking <code class="inline">Animal::speak</code>

401

Invoking <code class="inline">Animal::speak</code>

399

402

directly is a mess, however. What if

400

<code class="inline">Animal::speak</code>

403

<code class="inline">Animal::speak</code>

401

404

didn't exist before, and was being inherited from a

402

405

class mentioned in <code class="inline">@Animal::ISA</code>

403

406

? Because we are no longer using

404

407

the method arrow, we get one and only one chance to hit the right

405

408

subroutine.

406

Also note that the <code class="inline">Animal</code>

409

Also note that the <code class="inline">Animal</code>

407

410

classname is now hardwired into the

408

411

subroutine selection. This is a mess if someone maintains the code,

409

412

changing <code class="inline">@ISA</code>

410

for <Mouse> and didn't notice <code class="inline">Animal</code>

413

for <code class="inline">Mouse</code>

414

and didn't notice <code class="inline">Animal</code>

411

415

there in

412

<code class="inline">speak</code>

416

<code class="inline">speak</code>

413

417

. So, this is probably not the right way to go.

414

418

<a name="Starting-the-search-from-a-different-place"></a><h2>Starting the search from a different place</h2>

415

419

A better solution is to tell Perl to search from a higher place

423

427

<a class="l_k" href="functions/print.html">print</a> "[but you can barely hear it!]\n";

424

428

}

425

429

426

Ahh. This works. Using this syntax, we start with <code class="inline">Animal</code>

430

Ahh. This works. Using this syntax, we start with <code class="inline">Animal</code>

427

431

to find

428

<code class="inline">speak</code>

429

, and use all of <code class="inline">Animal</code>

432

<code class="inline">speak</code>

433

, and use all of <code class="inline">Animal</code>

430

434

's inheritance chain if not found

431

435

immediately. And yet the first parameter will be <code class="inline">$class</code>

432

436

, so the

433

found <code class="inline">speak</code>

434

method will get <code class="inline">Mouse</code>

437

found <code class="inline">speak</code>

438

method will get <code class="inline">Mouse</code>

435

439

as its first entry, and

436

eventually work its way back to <code class="inline">Mouse::sound</code>

440

eventually work its way back to <code class="inline">Mouse::sound</code>

437

441

for the details.

438

442

But this isn't the best solution. We still have to keep the <code class="inline">@ISA</code>

439

443

440

and the initial search package coordinated. Worse, if <code class="inline">Mouse</code>

444

and the initial search package coordinated. Worse, if <code class="inline">Mouse</code>

441

445

had

442

446

multiple entries in <code class="inline">@ISA</code>

443

447

, we wouldn't necessarily know which one

444

had actually defined <code class="inline">speak</code>

448

had actually defined <code class="inline">speak</code>

445

449

. So, is there an even better way?

446

450

<a name="The-SUPER-way-of-doing-things"></a><h2>The SUPER way of doing things</h2>

447

By changing the <code class="inline">Animal</code>

448

class to the <code class="inline">SUPER</code>

451

By changing the <code class="inline">Animal</code>

452

class to the <code class="inline">SUPER</code>

449

453

class in that

450

454

invocation, we get a search of all of our super classes (classes

451

455

listed in <code class="inline">@ISA</code>

459

463

<a class="l_k" href="functions/print.html">print</a> "[but you can barely hear it!]\n";

460

464

}

461

465

462

So, <code class="inline">SUPER::speak</code>

466

So, <code class="inline">SUPER::speak</code>

463

467

means look in the current package's <code class="inline">@ISA</code>

464

468

for

465

<code class="inline">speak</code>

469

<code class="inline">speak</code>

466

470

, invoking the first one found. Note that it does not look in

467

471

the <code class="inline">@ISA</code>

468

472

of <code class="inline">$class</code>

469

473

.

470

474

<a name="Where-we're-at-so-far..."></a><h2>Where we're at so far...</h2>

471

475

So far, we've seen the method arrow syntax:

472

<pre class="verbatim"> Class->method(@args);</pre>

476

<pre class="verbatim"> Class->method(@args);</pre>

473

477

or the equivalent:

474

478

<pre class="verbatim"> $a = "Class";

475

479

$a->method(@args);</pre>

477

481

<pre class="verbatim"> ("Class", @args)</pre>

478

482

and attempts to invoke

479

483

<pre class="verbatim"> Class::method("Class", @Args);</pre>

480

However, if <code class="inline">Class::method</code>

484

However, if <code class="inline">Class::method</code>

481

485

is not found, then <code class="inline">@Class::ISA</code>

482

486

is examined

483

(recursively) to locate a package that does indeed contain <code class="inline">method</code>

487

(recursively) to locate a package that does indeed contain <code class="inline">method</code>

484

488

485

489

and that subroutine is invoked instead.

486

490

Using this simple syntax, we have class methods, (multiple)

490

494

objects provide, but objects also provide instance data, which we

491

495

haven't even begun to cover.

492

496

<a name="A-horse-is-a-horse%2c-of-course-of-course----or-is-it%3f"></a><h2>A horse is a horse, of course of course -- or is it?</h2>

493

Let's start with the code for the <code class="inline">Animal</code>

497

Let's start with the code for the <code class="inline">Animal</code>

494

498

class

495

and the <code class="inline">Horse</code>

499

and the <code class="inline">Horse</code>

496

500

class:

497

501

<pre class="verbatim"><a name="package-Animal"></a> { package Animal;

498

502

<a name="speak"></a> sub speak {

499

503

<a class="l_k" href="functions/my.html">my</a> $class = <a class="l_k" href="functions/shift.html">shift</a>;

500

504

501

505

}

502

506

<a name="package-main"></a> }

503

507

<a name="package-Horse"></a> { package Horse;

504

508

@ISA = qw(Animal);

505

509

<a name="sound"></a> sub sound { "neigh" }

506

510

507

This lets us invoke <code class="inline">Horse->speak</code>

511

This lets us invoke <code class="inline">Horse->speak</code>

508

512

to ripple upward to

509

<code class="inline">Animal::speak</code>

510

, calling back to <code class="inline">Horse::sound</code>

513

<code class="inline">Animal::speak</code>

514

, calling back to <code class="inline">Horse::sound</code>

511

515

to get the specific

512

516

sound, and the output of:

513

<pre class="verbatim"> a Horse goes neigh!</pre>

517

<pre class="verbatim"> a Horse goes neigh!</pre>

514

518

But all of our Horse objects would have to be absolutely identical.

515

519

If I add a subroutine, all horses automatically share it. That's

516

520

great for making horses the same, but how do we capture the

527

531

is a reference to what will be the instance-specific

528

532

data (the name). The final step in turning this into a real instance

529

533

is with a special operator called <code class="inline"><a class="l_k" href="functions/bless.html">bless</a></code>:

530

<pre class="verbatim"> <a class="l_k" href="functions/bless.html">bless</a> $talking, Horse;</pre>

531

This operator stores information about the package named <code class="inline">Horse</code>

534

<pre class="verbatim"> <a class="l_k" href="functions/bless.html">bless</a> $talking, Horse;</pre>

535

This operator stores information about the package named <code class="inline">Horse</code>

532

536

into

533

537

the thing pointed at by the reference. At this point, we say

534

538

<code class="inline">$talking</code>

535

is an instance of <code class="inline">Horse</code>

539

is an instance of <code class="inline">Horse</code>

536

540

. That is, it's a specific

537

541

horse. The reference is otherwise unchanged, and can still be used

538

542

with traditional dereferencing operators.

541

545

packages (classes). So, let's get the sound that <code class="inline">$talking</code>

542

546

makes:

543

547

<pre class="verbatim"> <a class="l_k" href="functions/my.html">my</a> $noise = $talking->sound;</pre>

544

To invoke <code class="inline">sound</code>

548

To invoke <code class="inline">sound</code>

545

549

, Perl first notes that <code class="inline">$talking</code>

546

550

is a blessed

547

551

reference (and thus an instance). It then constructs an argument

550

554

arguments will take their place following the instance variable,

551

555

just like with classes.)

552

556

Now for the fun part: Perl takes the class in which the instance was

553

blessed, in this case <code class="inline">Horse</code>

557

blessed, in this case <code class="inline">Horse</code>

554

558

, and uses that to locate the subroutine

555

to invoke the method. In this case, <code class="inline">Horse::sound</code>

559

to invoke the method. In this case, <code class="inline">Horse::sound</code>

556

560

is found directly

557

561

(without using inheritance), yielding the final subroutine invocation:

558

562

<pre class="verbatim"> Horse::sound($talking)</pre>

559

563

Note that the first parameter here is still the instance, not the name

560

of the class as before. We'll get <code class="inline">neigh</code>

564

of the class as before. We'll get <code class="inline">neigh</code>

561

565

as the return value, and

562

566

that'll end up as the <code class="inline">$noise</code>

563

567

variable above.

581

585

582

586

Now we call for the name:

583

587

<pre class="verbatim"> <a class="l_k" href="functions/print.html">print</a> $talking->name, " says ", $talking->sound, "\n";</pre>

584

Inside <code class="inline">Horse::name</code>

588

Inside <code class="inline">Horse::name</code>

585

589

, the <code class="inline">@_</code>

586

590

array contains just <code class="inline">$talking</code>

587

591

595

for instance

592

596

methods, so stay with that unless you have strong reasons otherwise.)

593

597

Then, <code class="inline">$self</code>

594

gets de-referenced as a scalar ref, yielding <code class="inline">Mr. Ed</code>

598

gets de-referenced as a scalar ref, yielding <code class="inline">Mr. Ed</code>

595

599

596

600

and we're done with that. The result is:

597

<pre class="verbatim"> Mr. Ed says neigh.</pre>

601

<pre class="verbatim"> Mr. Ed says neigh.</pre>

598

602

<a name="How-to-build-a-horse"></a><h2>How to build a horse</h2>

599

603

Of course, if we constructed all of our horses by hand, we'd most

600

604

likely make mistakes from time to time. We're also violating one of

615

619

<a class="l_k" href="functions/bless.html">bless</a> \$name, $class;

616

620

}

617

621

618

Now with the new <code class="inline">named</code>

622

Now with the new <code class="inline">named</code>

619

623

method, we can build a horse:

620

<pre class="verbatim"> <a class="l_k" href="functions/my.html">my</a> $talking = Horse->named("Mr. Ed");</pre>

624

<pre class="verbatim"> <a class="l_k" href="functions/my.html">my</a> $talking = Horse->named("Mr. Ed");</pre>

621

625

Notice we're back to a class method, so the two arguments to

622

<code class="inline">Horse::named</code>

623

are <code class="inline">Horse</code>

624

and <code class="inline">Mr. Ed</code>

626

<code class="inline">Horse::named</code>

627

are <code class="inline">Horse</code>

628

and <code class="inline">Mr. Ed</code>

625

629

. The <code class="inline"><a class="l_k" href="functions/bless.html">bless</a></code> operator

626

630

not only blesses <code class="inline">$name</code>

627

631

, it also returns the reference to <code class="inline">$name</code>

628

632

629

633

so that's fine as a return value. And that's how to build a horse.

630

We've called the constructor <code class="inline">named</code>

634

We've called the constructor <code class="inline">named</code>

631

635

here, so that it quickly denotes

632

the constructor's argument as the name for this particular <code class="inline">Horse</code>

636

the constructor's argument as the name for this particular <code class="inline">Horse</code>

633

637

634

638

You can use different constructors with different names for different

635

639

ways of "giving birth" to the object (like maybe recording its

636

640

pedigree or date of birth). However, you'll find that most people

637

641

coming to Perl from more limited languages use a single constructor

638

named <code class="inline">new</code>

642

named <code class="inline">new</code>

639

643

, with various ways of interpreting the arguments to

640

644

641

645

. Either style is fine, as long as you document your particular

642

646

way of giving birth to an object. (And you were going to do that,

643

647

right?)

644

648

<a name="Inheriting-the-constructor"></a><h2>Inheriting the constructor</h2>

645

But was there anything specific to <code class="inline">Horse</code>

649

But was there anything specific to <code class="inline">Horse</code>

646

650

in that method? No. Therefore,

647

651

it's also the same recipe for building anything else that inherited from

648

<code class="inline">Animal</code>

652

<code class="inline">Animal</code>

649

653

, so let's put it there:

650

654

<pre class="verbatim"><a name="package-Animal"></a> { package Animal;

651

655

<a name="speak"></a> sub speak {

652

656

<a class="l_k" href="functions/my.html">my</a> $class = <a class="l_k" href="functions/shift.html">shift</a>;

653

657

654

658

}

655

659

<a name="name"></a> sub name {

656

660

<a class="l_k" href="functions/my.html">my</a> $self = <a class="l_k" href="functions/shift.html">shift</a>;

666

670

@ISA = qw(Animal);

667

671

<a name="sound"></a> sub sound { "neigh" }

668

672

669

Ahh, but what happens if we invoke <code class="inline">speak</code>

673

Ahh, but what happens if we invoke <code class="inline">speak</code>

670

674

on an instance?

671

675

672

676

$talking->speak;</pre>

673

677

We get a debugging value:

674

<pre class="verbatim"> a Horse=SCALAR(0xaca42ac) goes neigh!</pre>Why? Because the <code class="inline">Animal::speak</code>

678

<pre class="verbatim"> a Horse=SCALAR(0xaca42ac) goes neigh!</pre>Why? Because the <code class="inline">Animal::speak</code>

675

679

routine is expecting a classname as

676

680

its first parameter, not an instance. When the instance is passed in,

677

681

we'll end up using a blessed scalar reference as a string, and that

680

684

All we need is for a method to detect if it is being called on a class

681

685

or called on an instance. The most straightforward way is with the

682

686

<code class="inline"><a class="l_k" href="functions/ref.html">ref</a></code> operator. This returns a string (the classname) when used on a

683

blessed reference, and <code class="inline"><a class="l_k" href="functions/undef.html">undef</a></code> when used on a string (like a

684

classname). Let's modify the <code class="inline">name</code>

687

blessed reference, and an empty string when used on a string (like a

688

classname). Let's modify the <code class="inline">name</code>

685

689

method first to notice the change:

686

690

<pre class="verbatim"><a name="name"></a> sub name {

687

691

<a class="l_k" href="functions/my.html">my</a> $either = <a class="l_k" href="functions/shift.html">shift</a>;

694

698

instance or a class. Note that I've changed the first parameter

695

699

holder to <code class="inline">$either</code>

696

700

to show that this is intended:

697

701

698

702

<a class="l_k" href="functions/print.html">print</a> Horse->name, "\n"; # prints "an unnamed Horse\n"

699

703

<a class="l_k" href="functions/print.html">print</a> $talking->name, "\n"; # prints "Mr Ed.\n"</pre>

700

and now we'll fix <code class="inline">speak</code>

704

and now we'll fix <code class="inline">speak</code>

701

705

to use this:

702

706

<pre class="verbatim"><a name="speak"></a> sub speak {

703

707

<a class="l_k" href="functions/my.html">my</a> $either = <a class="l_k" href="functions/shift.html">shift</a>;

704

708

<a class="l_k" href="functions/print.html">print</a> $either->name, " goes ", $either->sound, "\n";

705

709

}</pre>

706

And since <code class="inline">sound</code>

710

And since <code class="inline">sound</code>

707

711

already worked with either a class or an instance,

708

712

we're done!

709

713

<a name="Adding-parameters-to-a-method"></a><h2>Adding parameters to a method</h2>

739

743

<a name="sound-1"></a> sub sound { "baaaah" }

740

744

741

745

And now try it out:

742

746

743

747

$talking->eat("hay");

744

Sheep->eat("grass");</pre>

748

Sheep->eat("grass");</pre>

745

749

which prints:

746

<pre class="verbatim"> Mr. Ed eats hay.

747

an unnamed Sheep eats grass.</pre>

750

<pre class="verbatim"> Mr. Ed eats hay.

751

an unnamed Sheep eats grass.</pre>

748

752

An instance method with parameters gets invoked with the instance,

749

753

and then the list of parameters. So that first invocation is like:

750

754

<pre class="verbatim"> Animal::eat($talking, "hay");</pre>

760

764

reference as a blessed scalar reference, as long as everything that

761

765

looks at the reference is changed accordingly.

762

766

Let's make a sheep that has a name and a color:

763

<pre class="verbatim"> <a class="l_k" href="functions/my.html">my</a> $bad = <a class="l_k" href="functions/bless.html">bless</a> { Name => "Evil", Color => "black" }, Sheep;</pre>

764

so <code class="inline">$bad->{Name}</code>

765

has <code class="inline">Evil</code>

766

, and <code class="inline">$bad->{Color}</code>

767

<pre class="verbatim"> <a class="l_k" href="functions/my.html">my</a> $bad = <a class="l_k" href="functions/bless.html">bless</a> { Name => "Evil", Color => "black" }, Sheep;</pre>

768

so <code class="inline">$bad->{Name}</code>

769

has <code class="inline">Evil</code>

770

, and <code class="inline">$bad->{Color}</code>

767

771

has

768

<code class="inline">black</code>

772

<code class="inline">black</code>

769

773

. But we want to make <code class="inline">$bad->name</code>

770

774

access the name, and

771

775

that's now messed up because it's expecting a scalar reference. Not

774

778

<a name="name"></a> sub name {

775

779

<a class="l_k" href="functions/my.html">my</a> $either = <a class="l_k" href="functions/shift.html">shift</a>;

776

780

<a class="l_k" href="functions/ref.html">ref</a> $either ?

777

$either->{Name} :

781

$either->{Name} :

778

782

"an unnamed $either";

779

783

}</pre>

780

And of course <code class="inline">named</code>

784

And of course <code class="inline">named</code>

781

785

still builds a scalar sheep, so let's fix that

782

786

as well:

783

787

<pre class="verbatim"> ## in Animal

784

788

<a name="named"></a> sub named {

785

789

<a class="l_k" href="functions/my.html">my</a> $class = <a class="l_k" href="functions/shift.html">shift</a>;

786

790

<a class="l_k" href="functions/my.html">my</a> $name = <a class="l_k" href="functions/shift.html">shift</a>;

787

<a class="l_k" href="functions/my.html">my</a> $self = { Name => $name, Color => $class->default_color };

791

<a class="l_k" href="functions/my.html">my</a> $self = { Name => $name, Color => $class->default_color };

788

792

<a class="l_k" href="functions/bless.html">bless</a> $self, $class;

789

793

}</pre>

790

What's this <code class="inline">default_color</code>

791

? Well, if <code class="inline">named</code>

794

What's this <code class="inline">default_color</code>

795

? Well, if <code class="inline">named</code>

792

796

has only the name,

793

797

we still need to set a color, so we'll have a class-specific initial color.

794

798

For a sheep, we might define it as white:

796

800

<a name="default_color"></a> sub default_color { "white" }</pre>

797

801

And then to keep from having to define one for each additional class,

798

802

we'll define a "backstop" method that serves as the "default default",

799

directly in <code class="inline">Animal</code>

803

directly in <code class="inline">Animal</code>

800

804

:

801

805

<pre class="verbatim"> ## in Animal

802

806

<a name="default_color"></a> sub default_color { "brown" }</pre>

803

Now, because <code class="inline">name</code>

804

and <code class="inline">named</code>

807

Now, because <code class="inline">name</code>

808

and <code class="inline">named</code>

805

809

were the only methods that

806

810

referenced the "structure" of the object, the rest of the methods can

807

remain the same, so <code class="inline">speak</code>

811

remain the same, so <code class="inline">speak</code>

808

812

still works as before.

809

813

<a name="A-horse-of-a-different-color"></a><h2>A horse of a different color</h2>

810

814

But having all our horses be brown would be boring. So let's add a

811

815

method or two to get and set the color.

812

816

<pre class="verbatim"> ## in Animal

813

817

<a name="color"></a> sub color {

814

$_[0]->{Color}

818

$_[0]->{Color}

815

819

}

816

820

<a name="set_color"></a> sub set_color {

817

$_[0]->{Color} = $_[1];

821

$_[0]->{Color} = $_[1];

818

822

}</pre>

819

823

Note the alternate way of accessing the arguments: <code class="inline">$_[0]</code>

820

824

is used

821

825

in-place, rather than with a <code class="inline"><a class="l_k" href="functions/shift.html">shift</a></code>. (This saves us a bit of time

822

826

for something that may be invoked frequently.) And now we can fix

823

827

that color for Mr. Ed:

824

828

825

829

$talking->set_color("black-and-white");

826

830

<a class="l_k" href="functions/print.html">print</a> $talking->name, " is colored ", $talking->color, "\n";</pre>

827

831

which results in:

828

<pre class="verbatim"> Mr. Ed is colored black-and-white</pre>

832

<pre class="verbatim"> Mr. Ed is colored black-and-white</pre>

829

833

<a name="Summary"></a><h2>Summary</h2>

830

834

So, now we have class methods, constructors, instance methods,

831

835

instance data, and even accessors. But that's still just the

832

836

beginning of what Perl has to offer. We haven't even begun to talk

833

837

about accessors that double as getters and setters, destructors,

834

838

indirect object notation, subclasses that add instance data, per-class

835

data, overloading, "isa" and "can" tests, <code class="inline"><a class="l_w" href="UNIVERSAL.html">UNIVERSAL</a></code> class, and so

839

data, overloading, "isa" and "can" tests, <code class="inline">UNIVERSAL</code>

840

class, and so

836

841

on. That's for the rest of the Perl documentation to cover.

837

842

Hopefully, this gets you started, though.

838

843

873

878

874

879

</form>

875

880

881

876

882

<h2>Labels:</h2>

877

883

878

884

Older »