devtut.github.io/java/generics.html at master · devtut/devtut.github.io

History

521 lines (415 loc) · 152 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

<!DOCTYPE html>

<head>

<title>Java - Generics</title>

</head>

<body>

<div id="app" data-server-rendered="true"><div class="theme-container"><header class="navbar"><div class="sidebar-button"><svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" role="img" viewBox="0 0 448 512" class="icon"><path fill="currentColor" d="M436 124H12c-6.627 0-12-5.373-12-12V80c0-6.627 5.373-12 12-12h424c6.627 0 12 5.373 12 12v32c0 6.627-5.373 12-12 12zm0 160H12c-6.627 0-12-5.373-12-12v-32c0-6.627 5.373-12 12-12h424c6.627 0 12 5.373 12 12v32c0 6.627-5.373 12-12 12zm0 160H12c-6.627 0-12-5.373-12-12v-32c0-6.627 5.373-12 12-12h424c6.627 0 12 5.373 12 12v32c0 6.627-5.373 12-12 12z"></path></svg></div> <a href="/" class="home-link router-link-active"> DevTut</a> <div class="links"><form id="search-form" role="search" class="algolia-search-wrapper search-box"><input id="algolia-search-input" class="search-query"></form> <nav class="nav-links can-hide"> <a href="https://github.com/devtut/generate" target="_blank" rel="noopener noreferrer" class="repo-link">

GitHub

private T value;

public T getValue() {

return value;

}

public void setValue(T value) {

this.value = value;

}

</code></pre></div>To instantiate this class, provide a type argument in place of <code>T</code>. For example, <code>Integer</code>: <div class="language-java extra-class"><pre class="language-java"><code>Param<Integer> integerParam = new Param<Integer>();

</code></pre></div>The type argument can be any reference type, including arrays and other generic types: <div class="language-java extra-class"><pre class="language-java"><code>Param<String[]> stringArrayParam;

Param<int[][]> int2dArrayParam;

Param<Param<Object>> objectNestedParam;

</code></pre></div>In Java SE 7 and later, the type argument can be replaced with an empty set of type arguments (<code><></code>) called the <a href="http://stackoverflow.com/documentation/java/92/generics/457/diamond-operator#t=201607241742205098515" target="_blank" rel="noopener noreferrer">diamond<svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" focusable="false" x="0px" y="0px" viewBox="0 0 100 100" width="15" height="15" class="icon outbound"><path fill="currentColor" d="M18.8,85.1h56l0,0c2.2,0,4-1.8,4-4v-32h-8v28h-48v-48h28v-8h-32l0,0c-2.2,0-4,1.8-4,4v56C14.8,83.3,16.6,85.1,18.8,85.1z"></path> <polygon fill="currentColor" points="45.7,48.7 51.3,54.3 77.2,28.5 77.2,37.2 85.2,37.2 85.2,14.9 62.8,14.9 62.8,22.9 71.5,22.9"></polygon></svg> (opens new window)</a>: <div class="language-java extra-class"><pre class="language-java"><code>Param<Integer> integerParam = new Param<>();

</code></pre></div>Unlike other identifiers, type parameters have no naming constraints. However their names are commonly the first letter of their purpose in upper case. (This is true even throughout the official JavaDocs.)

Examples include <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html" target="_blank" rel="noopener noreferrer"><code>T</code> for "type"<svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" focusable="false" x="0px" y="0px" viewBox="0 0 100 100" width="15" height="15" class="icon outbound"><path fill="currentColor" d="M18.8,85.1h56l0,0c2.2,0,4-1.8,4-4v-32h-8v28h-48v-48h28v-8h-32l0,0c-2.2,0-4,1.8-4,4v56C14.8,83.3,16.6,85.1,18.8,85.1z"></path> <polygon fill="currentColor" points="45.7,48.7 51.3,54.3 77.2,28.5 77.2,37.2 85.2,37.2 85.2,14.9 62.8,14.9 62.8,22.9 71.5,22.9"></polygon></svg> (opens new window)</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html" target="_blank" rel="noopener noreferrer"><code>E</code> for "element"<svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" focusable="false" x="0px" y="0px" viewBox="0 0 100 100" width="15" height="15" class="icon outbound"><path fill="currentColor" d="M18.8,85.1h56l0,0c2.2,0,4-1.8,4-4v-32h-8v28h-48v-48h28v-8h-32l0,0c-2.2,0-4,1.8-4,4v56C14.8,83.3,16.6,85.1,18.8,85.1z"></path> <polygon fill="currentColor" points="45.7,48.7 51.3,54.3 77.2,28.5 77.2,37.2 85.2,37.2 85.2,14.9 62.8,14.9 62.8,22.9 71.5,22.9"></polygon></svg> (opens new window)</a> and <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html" target="_blank" rel="noopener noreferrer"><code>K</code>/<code>V</code> for "key"/"value"<svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" focusable="false" x="0px" y="0px" viewBox="0 0 100 100" width="15" height="15" class="icon outbound"><path fill="currentColor" d="M18.8,85.1h56l0,0c2.2,0,4-1.8,4-4v-32h-8v28h-48v-48h28v-8h-32l0,0c-2.2,0-4,1.8-4,4v56C14.8,83.3,16.6,85.1,18.8,85.1z"></path> <polygon fill="currentColor" points="45.7,48.7 51.3,54.3 77.2,28.5 77.2,37.2 85.2,37.2 85.2,14.9 62.8,14.9 62.8,22.9 71.5,22.9"></polygon></svg> (opens new window)</a>. <h3 id="extending-a-generic-class"><a href="#extending-a-generic-class" class="header-anchor">#</a> Extending a generic class</h3> <div class="language-java extra-class"><pre class="language-java"><code>public abstract class AbstractParam<T> {

private T value;

return value;

}

this.value = value;

}

</code></pre></div><code>AbstractParam</code> is an <a href="http://stackoverflow.com/documentation/java/87/inheritance/397/abstract-classes#t=201607241739430410595" target="_blank" rel="noopener noreferrer">abstract class<svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" focusable="false" x="0px" y="0px" viewBox="0 0 100 100" width="15" height="15" class="icon outbound"><path fill="currentColor" d="M18.8,85.1h56l0,0c2.2,0,4-1.8,4-4v-32h-8v28h-48v-48h28v-8h-32l0,0c-2.2,0-4,1.8-4,4v56C14.8,83.3,16.6,85.1,18.8,85.1z"></path> <polygon fill="currentColor" points="45.7,48.7 51.3,54.3 77.2,28.5 77.2,37.2 85.2,37.2 85.2,14.9 62.8,14.9 62.8,22.9 71.5,22.9"></polygon></svg> (opens new window)</a> declared with a type parameter of <code>T</code>. When extending this class, that type parameter can be replaced by a type argument written inside <code><></code>, or the type parameter can remain unchanged. In the first and second examples below, <code>String</code> and <code>Integer</code> replace the type parameter. In the third example, the type parameter remains unchanged. The fourth example doesn't use generics at all, so it's similar to if the class had an <code>Object</code> parameter. The compiler will warn about <code>AbstractParam</code> being a raw type, but it will compile the <code>ObjectParam</code> class. The fifth example has 2 type parameters (see "multiple type parameters" below), choosing the second parameter as the type parameter passed to the superclass. <div class="language-java extra-class"><pre class="language-java"><code>public class Email extends AbstractParam<String> {

// ...

}

public class Age extends AbstractParam<Integer> {

// ...

}

public class Height<T> extends AbstractParam<T> {

// ...

}

public class ObjectParam extends AbstractParam {

// ...

}

public class MultiParam<T, E> extends AbstractParam<E> {

// ...

}

</code></pre></div>The following is the usage: <div class="language-java extra-class"><pre class="language-java"><code>Email email = new Email();

email.setValue("[email protected]");

String retrievedEmail = email.getValue();

Age age = new Age();

age.setValue(25);

Integer retrievedAge = age.getValue();

int autounboxedAge = age.getValue();

Height<Integer> heightInInt = new Height<>();

heightInInt.setValue(125);

Height<Float> heightInFloat = new Height<>();

heightInFloat.setValue(120.3f);

MultiParam<String, Double> multiParam = new MultiParam<>();

multiParam.setValue(3.3);

</code></pre></div>Notice that in the <code>Email</code> class, the <code>T getValue()</code> method acts as if it had a signature of <code>String getValue()</code>, and the <code>void setValue(T)</code> method acts as if it was declared <code>void setValue(String)</code>. It is also possible to instantiate with anonymous inner class with an empty curly braces (<code>{}</code>): <div class="language-java extra-class"><pre class="language-java"><code>AbstractParam<Double> height = new AbstractParam<Double>(){};

height.setValue(198.6);

</code></pre></div>Note that <a href="http://stackoverflow.com/questions/22200647/why-cant-java-7-diamond-operator-be-used-with-anonymous-classes" target="_blank" rel="noopener noreferrer">using the diamond with anonymous inner classes is not allowed.<svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" focusable="false" x="0px" y="0px" viewBox="0 0 100 100" width="15" height="15" class="icon outbound"><path fill="currentColor" d="M18.8,85.1h56l0,0c2.2,0,4-1.8,4-4v-32h-8v28h-48v-48h28v-8h-32l0,0c-2.2,0-4,1.8-4,4v56C14.8,83.3,16.6,85.1,18.8,85.1z"></path> <polygon fill="currentColor" points="45.7,48.7 51.3,54.3 77.2,28.5 77.2,37.2 85.2,37.2 85.2,14.9 62.8,14.9 62.8,22.9 71.5,22.9"></polygon></svg> (opens new window)</a> <h3 id="multiple-type-parameters"><a href="#multiple-type-parameters" class="header-anchor">#</a> Multiple type parameters</h3> Java provides the ability to use more than one type parameter in a generic class or interface. Multiple type parameters can be used in a class or interface by placing a comma-separated list of types between the angle brackets. Example: <div class="language-java extra-class"><pre class="language-java"><code>public class MultiGenericParam<T, S> {

private T firstParam;

private S secondParam;

public MultiGenericParam(T firstParam, S secondParam) {

this.firstParam = firstParam;

this.secondParam = secondParam;

}

public T getFirstParam() {

return firstParam;

}

public void setFirstParam(T firstParam) {

this.firstParam = firstParam;

}

public S getSecondParam() {

return secondParam;

}

public void setSecondParam(S secondParam) {

this.secondParam = secondParam;

}

</code></pre></div>The usage can be done as below: <div class="language-java extra-class"><pre class="language-java"><code>MultiGenericParam<String, String> aParam = new MultiGenericParam<String, String>("value1", "value2");

MultiGenericParam<Integer, Double> dayOfWeekDegrees = new MultiGenericParam<Integer, Double>(1, 2.6);

</code></pre></div><h2 id="deciding-between-t-super-t-and-extends-t"><a href="#deciding-between-t-super-t-and-extends-t" class="header-anchor">#</a> Deciding between <code>T</code>, <code>? super T</code>, and <code>? extends T</code></h2> The syntax for Java generics bounded wildcards, representing the unknown type by <code>?</code> is: <li>

`? extends T` represents an upper bounded wildcard. The unknown type represents a type that must be a subtype of T, or type T itself.

</li> <li>

`? super T` represents a lower bounded wildcard. The unknown type represents a type that must be a supertype of T, or type T itself.

</li> As a rule of thumb, you should use <ul><li><code>? extends T</code> if you only need "read" access ("input")</li> <li><code>? super T</code> if you need "write" access ("output")</li> <li><code>T</code> if you need both ("modify")</li></ul> Using <code>extends</code> or <code>super</code> is usually better because it makes your code more flexible (as in: allowing the use of subtypes and supertypes), as you will see below. <div class="language-java extra-class"><pre class="language-java"><code>class Shoe {}

class IPhone {}

interface Fruit {}

class Apple implements Fruit {}

class Banana implements Fruit {}

class GrannySmith extends Apple {}

public class FruitHelper {

public void eatAll(Collection<? extends Fruit> fruits) {}

public void addApple(Collection<? super Apple> apples) {}

}

</code></pre></div>The compiler will now be able to detect certain bad usage: <div class="language- extra-class"><pre class="language-text"><code>

public class GenericsTest {

public static void main(String[] args){

FruitHelper fruitHelper = new FruitHelper() ;

List<Fruit> fruits = new ArrayList<Fruit>();

fruits.add(new Apple()); // Allowed, as Apple is a Fruit

fruits.add(new Banana()); // Allowed, as Banana is a Fruit

fruitHelper.addApple(fruits); // Allowed, as "Fruit super Apple"

fruitHelper.eatAll(fruits); // Allowed

Collection<Banana> bananas = new ArrayList<>();

bananas.add(new Banana()); // Allowed

//fruitHelper.addApple(bananas); // Compile error: may only contain Bananas!

fruitHelper.eatAll(bananas); // Allowed, as all Bananas are Fruits

Collection<Apple> apples = new ArrayList<>();

fruitHelper.addApple(apples); // Allowed

apples.add(new GrannySmith()); // Allowed, as this is an Apple

fruitHelper.eatAll(apples); // Allowed, as all Apples are Fruits.

Collection<GrannySmith> grannySmithApples = new ArrayList<>();

fruitHelper.addApple(grannySmithApples); //Compile error: Not allowed.

// GrannySmith is not a supertype of Apple

apples.add(new GrannySmith()); //Still allowed, GrannySmith is an Apple

fruitHelper.eatAll(grannySmithApples);//Still allowed, GrannySmith is a Fruit

Collection<Object> objects = new ArrayList<>();

fruitHelper.addApple(objects); // Allowed, as Object super Apple

objects.add(new Shoe()); // Not a fruit

objects.add(new IPhone()); // Not a fruit

//fruitHelper.eatAll(objects); // Compile error: may contain a Shoe, too!

}

</code></pre></div>Choosing the right <code>T</code>, <code>? super T</code> or <code>? extends T</code> is necessary to allow the use with subtypes. The compiler can then ensure type safety; you should not need to cast (which is not type safe, and may cause programming errors) if you use them properly. If it is not easy to understand, please remember PECS rule: <blockquote></blockquote> Producer uses "Extends" and Consumer uses "Super". (Producer has only write access, and Consumer has only read access) <h2 id="the-diamond"><a href="#the-diamond" class="header-anchor">#</a> The Diamond</h2> Java 7 introduced the <a href="http://docs.oracle.com/javase/7/docs/technotes/guides/language/type-inference-generic-instance-creation.html" target="_blank" rel="noopener noreferrer">Diamond<svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" focusable="false" x="0px" y="0px" viewBox="0 0 100 100" width="15" height="15" class="icon outbound"><path fill="currentColor" d="M18.8,85.1h56l0,0c2.2,0,4-1.8,4-4v-32h-8v28h-48v-48h28v-8h-32l0,0c-2.2,0-4,1.8-4,4v56C14.8,83.3,16.6,85.1,18.8,85.1z"></path> <polygon fill="currentColor" points="45.7,48.7 51.3,54.3 77.2,28.5 77.2,37.2 85.2,37.2 85.2,14.9 62.8,14.9 62.8,22.9 71.5,22.9"></polygon></svg> (opens new window)</a>1 to remove some boiler-plate around generic class instantiation. With Java 7+ you can write: <div class="language-java extra-class"><pre class="language-java"><code>List<String> list = new LinkedList<>();

</code></pre></div>Where you had to write in previous versions, this: <div class="language-java extra-class"><pre class="language-java"><code>List<String> list = new LinkedList<String>();

</code></pre></div>One limitation is for <a href="http://stackoverflow.com/documentation/java/3317/nested-and-inner-classes/18796/anonymous-inner-classes#t=201612181613574439584" target="_blank" rel="noopener noreferrer">Anonymous Classes<svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" focusable="false" x="0px" y="0px" viewBox="0 0 100 100" width="15" height="15" class="icon outbound"><path fill="currentColor" d="M18.8,85.1h56l0,0c2.2,0,4-1.8,4-4v-32h-8v28h-48v-48h28v-8h-32l0,0c-2.2,0-4,1.8-4,4v56C14.8,83.3,16.6,85.1,18.8,85.1z"></path> <polygon fill="currentColor" points="45.7,48.7 51.3,54.3 77.2,28.5 77.2,37.2 85.2,37.2 85.2,14.9 62.8,14.9 62.8,22.9 71.5,22.9"></polygon></svg> (opens new window)</a>, where you still must provide the type parameter in the instantiation: <div class="language-java extra-class"><pre class="language-java"><code>// This will compile:

Comparator<String> caseInsensitiveComparator = new Comparator<String>() {

@Override

public int compare(String s1, String s2) {

return s1.compareToIgnoreCase(s2);

}

};

// But this will not:

Comparator<String> caseInsensitiveComparator = new Comparator<>() {

@Override

}

};

</code></pre></div>Although using the diamond with <a href="http://stackoverflow.com/documentation/java/3317/nested-and-inner-classes/18796/anonymous-inner-classes#t=201612181613574439584" target="_blank" rel="noopener noreferrer">Anonymous Inner Classes<svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" focusable="false" x="0px" y="0px" viewBox="0 0 100 100" width="15" height="15" class="icon outbound"><path fill="currentColor" d="M18.8,85.1h56l0,0c2.2,0,4-1.8,4-4v-32h-8v28h-48v-48h28v-8h-32l0,0c-2.2,0-4,1.8-4,4v56C14.8,83.3,16.6,85.1,18.8,85.1z"></path> <polygon fill="currentColor" points="45.7,48.7 51.3,54.3 77.2,28.5 77.2,37.2 85.2,37.2 85.2,14.9 62.8,14.9 62.8,22.9 71.5,22.9"></polygon></svg> (opens new window)</a> is not supported in Java 7 and 8, <a href="https://bugs.openjdk.java.net/browse/JDK-8062373" target="_blank" rel="noopener noreferrer">it will be included as a new feature in Java 9<svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" focusable="false" x="0px" y="0px" viewBox="0 0 100 100" width="15" height="15" class="icon outbound"><path fill="currentColor" d="M18.8,85.1h56l0,0c2.2,0,4-1.8,4-4v-32h-8v28h-48v-48h28v-8h-32l0,0c-2.2,0-4,1.8-4,4v56C14.8,83.3,16.6,85.1,18.8,85.1z"></path> <polygon fill="currentColor" points="45.7,48.7 51.3,54.3 77.2,28.5 77.2,37.2 85.2,37.2 85.2,14.9 62.8,14.9 62.8,22.9 71.5,22.9"></polygon></svg> (opens new window)</a>. Footnote: 1 - Some people call the <code><></code> usage the "diamond operator". This is incorrect. The diamond does not behave as an operator, and is not described or listed anywhere in the JLS or the (official) Java Tutorials as an operator. Indeed, <code><></code> is not even a distinct Java token. Rather it is a <code><</code> token followed by a <code>></code> token, and it is legal (though bad style) to have whitespace or comments between the two. The JLS and the Tutorials consistently refer to <code><></code> as "the diamond", and that is therefore the correct term for it. <h2 id="declaring-a-generic-method"><a href="#declaring-a-generic-method" class="header-anchor">#</a> Declaring a Generic Method</h2> Methods can also have <a href="https://docs.oracle.com/javase/tutorial/java/generics/" target="_blank" rel="noopener noreferrer">generic<svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" focusable="false" x="0px" y="0px" viewBox="0 0 100 100" width="15" height="15" class="icon outbound"><path fill="currentColor" d="M18.8,85.1h56l0,0c2.2,0,4-1.8,4-4v-32h-8v28h-48v-48h28v-8h-32l0,0c-2.2,0-4,1.8-4,4v56C14.8,83.3,16.6,85.1,18.8,85.1z"></path> <polygon fill="currentColor" points="45.7,48.7 51.3,54.3 77.2,28.5 77.2,37.2 85.2,37.2 85.2,14.9 62.8,14.9 62.8,22.9 71.5,22.9"></polygon></svg> (opens new window)</a> type parameters. <div class="language-java extra-class"><pre class="language-java"><code>public class Example {

// The type parameter T is scoped to the method

// and is independent of type parameters of other methods.

public <T> List<T> makeList(T t1, T t2) {

List<T> result = new ArrayList<T>();

result.add(t1);

result.add(t2);

return result;

}

public void usage() {

List<String> listString = makeList("Jeff", "Atwood");

List<Integer> listInteger = makeList(1, 2);

}

</code></pre></div>Notice that we don't have to pass an actual type argument to a generic method. The compiler infers the type argument for us, based on the target type (e.g. the variable we assign the result to), or on the types of the actual arguments. It will generally infer the most specific type argument that will make the call type-correct. Sometimes, albeit rarely, it can be necessary to override this type inference with explicit type arguments: <div class="language-java extra-class"><pre class="language-java"><code>void usage() {

consumeObjects(this.<Object>makeList("Jeff", "Atwood").stream());

}

void consumeObjects(Stream<Object> stream) { ... }

</code></pre></div>It's necessary in this example because the compiler can't "look ahead" to see that <code>Object</code> is desired for <code>T</code> after calling <code>stream()</code> and it would otherwise infer <code>String</code> based on the <code>makeList</code> arguments. Note that the Java language doesn't support omitting the class or object on which the method is called (<code>this</code> in the above example) when type arguments are explicitly provided. <h2 id="requiring-multiple-upper-bounds-extends-a-b"><a href="#requiring-multiple-upper-bounds-extends-a-b" class="header-anchor">#</a> Requiring multiple upper bounds ("extends A & B")</h2> You can require a generic type to extend multiple upper bounds. Example: we want to sort a list of numbers but <code>Number</code> doesn't implement <code>Comparable</code>. <div class="language-java extra-class"><pre class="language-java"><code>public <T extends Number & Comparable<T>> void sortNumbers( List<T> n ) {

Collections.sort( n );

}

</code></pre></div>In this example <code>T</code> must extend <code>Number</code> and implement <code>Comparable<T></code> which should fit all "normal" built-in number implementations like <code>Integer</code> or <code>BigDecimal</code> but doesn't fit the more exotic ones like <code>Striped64</code>. Since multiple inheritance is not allowed, you can use at most one class as a bound and it must be the first listed. For example, <code><T extends Comparable<T> & Number></code> is not allowed because Comparable is an interface, and not a class. <h2 id="benefits-of-generic-class-and-interface"><a href="#benefits-of-generic-class-and-interface" class="header-anchor">#</a> Benefits of Generic class and interface</h2> Code that uses generics has many benefits over non-generic code. Below are the main benefits <h3 id="stronger-type-checks-at-compile-time"><a href="#stronger-type-checks-at-compile-time" class="header-anchor">#</a> Stronger type checks at compile time</h3> A Java compiler applies strong type checking to generic code and issues errors if the code violates type safety. Fixing compile-time errors is easier than fixing runtime errors, which can be difficult to find. <h3 id="elimination-of-casts"><a href="#elimination-of-casts" class="header-anchor">#</a> Elimination of casts</h3> The following code snippet without generics requires casting: <div class="language-java extra-class"><pre class="language-java"><code>List list = new ArrayList();

list.add("hello");

String s = (String) list.get(0);

</code></pre></div>When re-written to use generics, the code does not require casting: <div class="language-java extra-class"><pre class="language-java"><code>List<String> list = new ArrayList<>();

String s = list.get(0); // no cast

</code></pre></div><h3 id="enabling-programmers-to-implement-generic-algorithms"><a href="#enabling-programmers-to-implement-generic-algorithms" class="header-anchor">#</a> Enabling programmers to implement generic algorithms</h3> By using generics, programmers can implement generic algorithms that work on collections of different types, can be customized, and are type safe and easier to read. <h2 id="instantiating-a-generic-type"><a href="#instantiating-a-generic-type" class="header-anchor">#</a> Instantiating a generic type</h2> Due to type erasure the following will not work: <div class="language-java extra-class"><pre class="language-java"><code>public <T> void genericMethod() {

T t = new T(); // Can not instantiate the type T.

}

</code></pre></div>The type <code>T</code> is erased. Since, at runtime, the JVM does not know what <code>T</code> originally was, it does not know which constructor to call. <h3 id="workarounds"><a href="#workarounds" class="header-anchor">#</a> Workarounds</h3> <li>

Passing `T`'s class when calling `genericMethod`:

<div class="language-java extra-class"><pre class="language-java"><code>public <T> void genericMethod(Class<T> cls) {

try {

T t = cls.newInstance();

} catch (InstantiationException | IllegalAccessException e) {

System.err.println("Could not instantiate: " + cls.getName());

}

</code></pre></div><div class="language-java extra-class"><pre class="language-java"><code>genericMethod(String.class);

</code></pre></div>Which throws exceptions, since there is no way to know if the passed class has an accessible default constructor.

</li> <li>

Passing a [reference](http://stackoverflow.com/documentation/java/91/lambda-expressions/5080/method-references) to `T`'s constructor:

<div class="language-java extra-class"><pre class="language-java"><code>public <T> void genericMethod(Supplier<T> cons) {

T t = cons.get();

}

</code></pre></div><div class="language-java extra-class"><pre class="language-java"><code>genericMethod(String::new);

</code></pre></div></li> <h2 id="obtain-class-that-satisfies-generic-parameter-at-runtime"><a href="#obtain-class-that-satisfies-generic-parameter-at-runtime" class="header-anchor">#</a> Obtain class that satisfies generic parameter at runtime</h2> Many unbound generic parameters, like those used in a static method, cannot be recovered at runtime (see Other Threads on Erasure). However there is a common strategy employed for accessing the type satisfying a generic parameter on a class at runtime. This allows for generic code that depends on access to type without having to thread type information through every call. Background Generic parameterization on a class can be inspected by creating an anonymous inner class. This class will capture the type information. In general this mechanism is referred to as super type tokens, which are detailed in <a href="http://gafter.blogspot.com/2006/12/super-type-tokens.html" target="_blank" rel="noopener noreferrer">Neal Gafter's blog post<svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" focusable="false" x="0px" y="0px" viewBox="0 0 100 100" width="15" height="15" class="icon outbound"><path fill="currentColor" d="M18.8,85.1h56l0,0c2.2,0,4-1.8,4-4v-32h-8v28h-48v-48h28v-8h-32l0,0c-2.2,0-4,1.8-4,4v56C14.8,83.3,16.6,85.1,18.8,85.1z"></path> <polygon fill="currentColor" points="45.7,48.7 51.3,54.3 77.2,28.5 77.2,37.2 85.2,37.2 85.2,14.9 62.8,14.9 62.8,22.9 71.5,22.9"></polygon></svg> (opens new window)</a>. Implementations Three common implementations in Java are: <ul><li><a href="https://github.com/google/guava/wiki/ReflectionExplained" target="_blank" rel="noopener noreferrer">Guava's TypeToken<svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" focusable="false" x="0px" y="0px" viewBox="0 0 100 100" width="15" height="15" class="icon outbound"><path fill="currentColor" d="M18.8,85.1h56l0,0c2.2,0,4-1.8,4-4v-32h-8v28h-48v-48h28v-8h-32l0,0c-2.2,0-4,1.8-4,4v56C14.8,83.3,16.6,85.1,18.8,85.1z"></path> <polygon fill="currentColor" points="45.7,48.7 51.3,54.3 77.2,28.5 77.2,37.2 85.2,37.2 85.2,14.9 62.8,14.9 62.8,22.9 71.5,22.9"></polygon></svg> (opens new window)</a></li> <li><a href="http://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/core/ParameterizedTypeReference.html" target="_blank" rel="noopener noreferrer">Spring's ParameterizedTypeReference<svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" focusable="false" x="0px" y="0px" viewBox="0 0 100 100" width="15" height="15" class="icon outbound"><path fill="currentColor" d="M18.8,85.1h56l0,0c2.2,0,4-1.8,4-4v-32h-8v28h-48v-48h28v-8h-32l0,0c-2.2,0-4,1.8-4,4v56C14.8,83.3,16.6,85.1,18.8,85.1z"></path> <polygon fill="currentColor" points="45.7,48.7 51.3,54.3 77.2,28.5 77.2,37.2 85.2,37.2 85.2,14.9 62.8,14.9 62.8,22.9 71.5,22.9"></polygon></svg> (opens new window)</a></li> <li><a href="http://fasterxml.github.io/jackson-core/javadoc/2.0.0/com/fasterxml/jackson/core/type/TypeReference.html" target="_blank" rel="noopener noreferrer">Jackson's TypeReference<svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" focusable="false" x="0px" y="0px" viewBox="0 0 100 100" width="15" height="15" class="icon outbound"><path fill="currentColor" d="M18.8,85.1h56l0,0c2.2,0,4-1.8,4-4v-32h-8v28h-48v-48h28v-8h-32l0,0c-2.2,0-4,1.8-4,4v56C14.8,83.3,16.6,85.1,18.8,85.1z"></path> <polygon fill="currentColor" points="45.7,48.7 51.3,54.3 77.2,28.5 77.2,37.2 85.2,37.2 85.2,14.9 62.8,14.9 62.8,22.9 71.5,22.9"></polygon></svg> (opens new window)</a></li></ul> Example usage <div class="language-java extra-class"><pre class="language-java"><code>public class DataService<MODEL_TYPE> {

private final DataDao dataDao = new DataDao();

private final Class<MODEL_TYPE> type = (Class<MODEL_TYPE>) new TypeToken<MODEL_TYPE>

(getClass()){}.getRawType();

public List<MODEL_TYPE> getAll() {

return dataDao.getAllOfType(type);

}

// the subclass definitively binds the parameterization to User

// for all instances of this class, so that information can be

// recovered at runtime

public class UserService extends DataService<User> {}

public class Main {

public static void main(String[] args) {

UserService service = new UserService();

List<User> users = service.getAll();

}

</code></pre></div><h2 id="creating-a-bounded-generic-class"><a href="#creating-a-bounded-generic-class" class="header-anchor">#</a> Creating a Bounded Generic Class</h2> You can restrict the valid types used in a generic class by bounding that type in the class definition. Given the following simple type hierarchy: <div class="language-java extra-class"><pre class="language-java"><code>public abstract class Animal {

public abstract String getSound();

}

public class Cat extends Animal {

public String getSound() {

return "Meow";

}

public class Dog extends Animal {

return "Woof";

}

</code></pre></div>Without bounded generics, we cannot make a container class that is both generic and knows that each element is an animal: <div class="language-java extra-class"><pre class="language-java"><code>public class AnimalContainer<T> {

private Collection<T> col;

public AnimalContainer() {

col = new ArrayList<T>();

}

public void add(T t) {

col.add(t);

}

public void printAllSounds() {

for (T t : col) {

// Illegal, type T doesn't have makeSound()

// it is used as an java.lang.Object here

}

</code></pre></div>With generic bound in class definition, this is now possible. <div class="language-java extra-class"><pre class="language-java"><code>public class BoundedAnimalContainer<T extends Animal> { // Note bound here.

public BoundedAnimalContainer() {

}

// Now works because T is extending Animal

}

</code></pre></div>This also restricts the valid instantiations of the generic type: <div class="language-java extra-class"><pre class="language-java"><code>// Legal

AnimalContainer<Cat> a = new AnimalContainer<Cat>();

// Legal

AnimalContainer<String> a = new AnimalContainer<String>();

</code></pre></div><div class="language-java extra-class"><pre class="language-java"><code>// Legal because Cat extends Animal

BoundedAnimalContainer<Cat> b = new BoundedAnimalContainer<Cat>();

// Illegal because String doesn't extends Animal

BoundedAnimalContainer<String> b = new BoundedAnimalContainer<String>();

</code></pre></div><h2 id="referring-to-the-declared-generic-type-within-its-own-declaration"><a href="#referring-to-the-declared-generic-type-within-its-own-declaration" class="header-anchor">#</a> Referring to the declared generic type within its own declaration</h2> How do you go about using an instance of a (possibly further) inherited generic type within a method declaration in the generic type itself being declared? This is one of the problems you will face when you dig a bit deeper into generics, but still a fairly common one. Assume we have a <code>DataSeries<T></code> type (interface here), which defines a generic data series containing values of type <code>T</code>. It is cumbersome to work with this type directly when we want to perform a lot of operations with e.g. double values, so we define <code>DoubleSeries extends DataSeries<Double></code>. Now assume, the original <code>DataSeries<T></code> type has a method <code>add(values)</code> which adds another series of the same length and returns a new one. How do we enforce the type of <code>values</code> and the type of the return to be <code>DoubleSeries</code> rather than <code>DataSeries<Double></code> in our derived class? The problem can be solved by adding a generic type parameter referring back to and extending the type being declared (applied to an interface here, but the same stands for classes): <div class="language-java extra-class"><pre class="language-java"><code>public interface DataSeries<T, DS extends DataSeries<T, DS>> {

DS add(DS values);

}

</code></pre></div>Here <code>T</code> represents the data type the series holds, e.g. <code>Double</code> and <code>DS</code> the series itself. An inherited type (or types) can now be easily implemented by substituting the above mentioned parameter by a corresponding derived type, thus, yielding a concrete <code>Double</code>-based definition of the form: <div class="language-java extra-class"><pre class="language-java"><code>public interface DoubleSeries extends DataSeries<Double, DoubleSeries> {

static DoubleSeries instance(Collection<Double> data) {

return new DoubleSeriesImpl(data);

}

</code></pre></div>At this moment even an IDE will implement the above interface with correct types in place, which, after a bit of content filling may look like this: <div class="language-java extra-class"><pre class="language-java"><code>class DoubleSeriesImpl implements DoubleSeries {

private final List<Double> data;

DoubleSeriesImpl(Collection<Double> data) {

this.data = new ArrayList<>(data);

}

@Override

public DoubleSeries add(DoubleSeries values) {

List<Double> incoming = values != null ? values.data() : null;

if (incoming == null || incoming.size() != data.size()) {

throw new IllegalArgumentException("bad series");

}

List<Double> newdata = new ArrayList<>(data.size());

for (int i = 0; i < data.size(); i++) {

newdata.add(this.data.get(i) + incoming.get(i)); // beware autoboxing

}

return DoubleSeries.instance(newdata);

}

@Override

public List<Double> data() {

return Collections.unmodifiableList(data);

}

</code></pre></div>As you can see the <code>add</code> method is declared as <code>DoubleSeries add(DoubleSeries values)</code> and the compiler is happy. The pattern can be further nested if required. <h2 id="binding-generic-parameter-to-more-than-1-type"><a href="#binding-generic-parameter-to-more-than-1-type" class="header-anchor">#</a> Binding generic parameter to more than 1 type</h2> Generic parameters can also be bound to more than one type using the <code>T extends Type1 & Type2 & ...</code> syntax. Let's say you want to create a class whose Generic type should implement both <code>Flushable</code> and <code>Closeable</code>, you can write <div class="language-java extra-class"><pre class="language-java"><code>class ExampleClass<T extends Flushable & Closeable> {

}

</code></pre></div>Now, the <code>ExampleClass</code> only accepts as generic parameters, types which implement both <code>Flushable</code> and <code>Closeable</code>. <div class="language-java extra-class"><pre class="language-java"><code>ExampleClass<BufferedWriter> arg1; // Works because BufferedWriter implements both Flushable and Closeable

ExampleClass<Console> arg4; // Does NOT work because Console only implements Flushable

ExampleClass<ZipFile> arg5; // Does NOT work because ZipFile only implements Closeable

ExampleClass<Flushable> arg2; // Does NOT work because Closeable bound is not satisfied.

ExampleClass<Closeable> arg3; // Does NOT work because Flushable bound is not satisfied.

</code></pre></div>The class methods can choose to infer generic type arguments as either <code>Closeable</code> or <code>Flushable</code>. <div class="language-java extra-class"><pre class="language-java"><code>class ExampleClass<T extends Flushable & Closeable> {

/* Assign it to a valid type as you want. */

public void test (T param) {

Flushable arg1 = param; // Works

Closeable arg2 = param; // Works too.

}

/* You can even invoke the methods of any valid type directly. */

public void test2 (T param) {

param.flush(); // Method of Flushable called on T and works fine.

param.close(); // Method of Closeable called on T and works fine too.

}

</code></pre></div><h3 id="note"><a href="#note" class="header-anchor">#</a> Note:</h3> You cannot bind the generic parameter to either of the type using OR (<code>|</code>) clause. Only the AND (<code>&</code>) clause is supported.

Generic type can extends only one class and many interfaces. Class must be

placed at the beginning of the list. <h2 id="using-generics-to-auto-cast"><a href="#using-generics-to-auto-cast" class="header-anchor">#</a> Using Generics to auto-cast</h2> With generics, it's possible to return whatever the caller expects: <div class="language-java extra-class"><pre class="language-java"><code>private Map<String, Object> data;

return (T) data.get(key);

}

</code></pre></div>The method will compile with a warning. The code is actually more safe than it looks because the Java runtime will do a cast when you use it: <div class="language-java extra-class"><pre class="language-java"><code>Bar bar = foo.get("bar");

</code></pre></div>It's less safe when you use generic types: <div class="language-java extra-class"><pre class="language-java"><code>List<Bar> bars = foo.get("bars");

</code></pre></div>Here, the cast will work when the returned type is any kind of <code>List</code> (i.e. returning <code>List<String></code> would not trigger a <code>ClassCastException</code>; you'd eventually get it when taking elements out of the list). To work around this problem, you can create an API which uses typed keys: <div class="language-java extra-class"><pre class="language-java"><code>public final static Key<List<Bar>> BARS = new Key<>("BARS");

</code></pre></div>along with this <code>put()</code> method: <div class="language-java extra-class"><pre class="language-java"><code>public <T> T put(Key<T> key, T value);

</code></pre></div>With this approach, you can't put the wrong type into the map, so the result will always be correct (unless you accidentally create two keys with the same name but different types). Related: <ul><li><a href="https://blog.pdark.de/2010/05/28/type-safe-object-map/" target="_blank" rel="noopener noreferrer">Type-safe Map<svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" focusable="false" x="0px" y="0px" viewBox="0 0 100 100" width="15" height="15" class="icon outbound"><path fill="currentColor" d="M18.8,85.1h56l0,0c2.2,0,4-1.8,4-4v-32h-8v28h-48v-48h28v-8h-32l0,0c-2.2,0-4,1.8-4,4v56C14.8,83.3,16.6,85.1,18.8,85.1z"></path> <polygon fill="currentColor" points="45.7,48.7 51.3,54.3 77.2,28.5 77.2,37.2 85.2,37.2 85.2,14.9 62.8,14.9 62.8,22.9 71.5,22.9"></polygon></svg> (opens new window)</a></li></ul> <h2 id="use-of-instanceof-with-generics"><a href="#use-of-instanceof-with-generics" class="header-anchor">#</a> Use of instanceof with Generics</h2> Using generics to define the type in instanceof Consider the following generic class <code>Example</code> declared with the formal parameter <code><T></code>: <div class="language-java extra-class"><pre class="language-java"><code>class Example<T> {

public boolean isTypeAString(String s) {

return s instanceof T; // Compilation error, cannot use T as class type here

}

</code></pre></div>This will always give a Compilation error because as soon as the compiler compiles the Java source into Java bytecode it applies a process known as type erasure, which converts all generic code into non-generic code, making impossible to distinguish among T types at runtime. The type used with <code>instanceof</code> has to be <a href="https://docs.oracle.com/javase/tutorial/java/generics/nonReifiableVarargsType.html" target="_blank" rel="noopener noreferrer">reifiable<svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" focusable="false" x="0px" y="0px" viewBox="0 0 100 100" width="15" height="15" class="icon outbound"><path fill="currentColor" d="M18.8,85.1h56l0,0c2.2,0,4-1.8,4-4v-32h-8v28h-48v-48h28v-8h-32l0,0c-2.2,0-4,1.8-4,4v56C14.8,83.3,16.6,85.1,18.8,85.1z"></path> <polygon fill="currentColor" points="45.7,48.7 51.3,54.3 77.2,28.5 77.2,37.2 85.2,37.2 85.2,14.9 62.8,14.9 62.8,22.9 71.5,22.9"></polygon></svg> (opens new window)</a>, which means that all information about the type has to be available at runtime, and this is usually not the case for generic types. The following class represents what two different classes of <code>Example</code>, <code>Example<String></code> and <code>Example<Number></code>, look like after generics has stripped off by type erasure: <div class="language-java extra-class"><pre class="language-java"><code>class Example { // formal parameter is gone

return s instanceof Object; // Both <String> and <Number> are now Object

}

</code></pre></div>Since types are gone, it's not possible for the JVM to know which type is <code>T</code>. Exception to the previous rule You can always use unbounded wildcard (?) for specifying a type in the <code>instanceof</code> as follows: <div class="language- extra-class"><pre class="language-text"><code>

public boolean isAList(Object obj) {

return obj instanceof List<?>;

}

</code></pre></div>This can be useful to evaluate whether an instance <code>obj</code> is a <code>List</code> or not: <div class="language-java extra-class"><pre class="language-java"><code>System.out.println(isAList("foo")); // prints false

System.out.println(isAList(new ArrayList<String>()); // prints true

System.out.println(isAList(new ArrayList<Float>()); // prints true

</code></pre></div>In fact, unbounded wildcard is considered a reifiable type. Using a generic instance with instanceof The other side of the coin is that using an instance <code>t</code> of <code>T</code> with <code>instanceof</code> is legal, as shown in the following example: <div class="language-java extra-class"><pre class="language-java"><code>class Example<T> {

public boolean isTypeAString(T t) {

return t instanceof String; // No compilation error this time

}

</code></pre></div>because after the type erasure the class will look like the following: <div class="language-java extra-class"><pre class="language-java"><code>class Example { // formal parameter is gone

public boolean isTypeAString(Object t) {

}

</code></pre></div>Since, even if the type erasure happen anyway, now the JVM can distinguish among different types in memory, even if they use the same reference type (<code>Object</code>), as the following snippet shows: <div class="language-java extra-class"><pre class="language-java"><code>Object obj1 = new String("foo"); // reference type Object, object type String

Object obj2 = new Integer(11); // reference type Object, object type Integer

</code></pre></div><h2 id="different-ways-for-implementing-a-generic-interface-or-extending-a-generic-class"><a href="#different-ways-for-implementing-a-generic-interface-or-extending-a-generic-class" class="header-anchor">#</a> Different ways for implementing a Generic Interface (or extending a Generic Class)</h2> Suppose the following generic interface has been declared: <div class="language-java extra-class"><pre class="language-java"><code>public interface MyGenericInterface<T> {

public void foo(T t);

}

</code></pre></div>Below are listed the possible ways to implement it. Non-generic class implementation with a specific type Choose a specific type to replace the formal type parameter <code><T></code> of <code>MyGenericClass</code> and implement it, as the following example does: <div class="language-java extra-class"><pre class="language-java"><code>public class NonGenericClass implements MyGenericInterface<String> {

public void foo(String t) { } // type T has been replaced by String

}

</code></pre></div>This class only deals with <code>String</code>, and this means that using <code>MyGenericInterface</code> with different parameters (e.g. <code>Integer</code>, <code>Object</code> etc.) won't compile, as the following snippet shows: <div class="language-java extra-class"><pre class="language-java"><code>NonGenericClass myClass = new NonGenericClass();

myClass.foo("foo_string"); // OK, legal

myClass.foo(11); // NOT OK, does not compile

myClass.foo(new Object()); // NOT OK, does not compile

</code></pre></div>Generic class implementation Declare another generic interface with the formal type parameter <code><T></code> which implements <code>MyGenericInterface</code>, as follows: <div class="language-java extra-class"><pre class="language-java"><code>public class MyGenericSubclass<T> implements MyGenericInterface<T> {

// other methods...

}

</code></pre></div>Note that a different formal type parameter may have been used, as follows: <div class="language-java extra-class"><pre class="language-java"><code>public class MyGenericSubclass<U> implements MyGenericInterface<U> { // equivalent to the previous declaration

public void foo(U t) { }

// other methods...

}

</code></pre></div>Raw type class implementation Declare a non-generic class which implements <code>MyGenericInteface</code> as a raw type (not using generic at all), as follows: <div class="language-java extra-class"><pre class="language-java"><code>public class MyGenericSubclass implements MyGenericInterface {

public void foo(Object t) { } // type T has been replaced by Object

// other possible methods

}

</code></pre></div>This way is not recommended, since it is not 100% safe at runtime because it mixes up raw type (of the subclass) with generics (of the interface) and it is also confusing. Modern Java compilers will raise a warning with this kind of implementation, nevertheless the code - for compatibility reasons with older JVM (1.4 or earlier) - will compile. All the ways listed above are also allowed when using a generic class as a supertype instead of a generic interface. <h4 id="syntax"><a href="#syntax" class="header-anchor">#</a> Syntax</h4> <ul><li>class ArrayList<E> {} // a generic class with type parameter E</E></li> <li>class HashMap<K, V> {} // a generic class with two type parameters K and V</li> <li><E> void print(E element) {} // a generic method with type parameter E

</E></li> <li>ArrayList<String> names; // declaration of a generic class</String></li> <li>ArrayList<?> objects; // declaration of a generic class with an unknown type parameter</li> <li>new ArrayList<String>() // instantiation of a generic class</String></li> <li>new ArrayList<>() // instantiation with type inference "diamond" (Java 7 or later)</li></ul> <h4 id="remarks"><a href="#remarks" class="header-anchor">#</a> Remarks</h4> Generics are implemented in Java through Type erasure, which means that during runtime the Type information specified in the instantiation of a generic class is not available. For example, the statement <code>List<String> names = new ArrayList<>();</code> produces a list object from which the element type <code>String</code> cannot be recovered at runtime. However, if the list is stored in a field of type <code>List<String></code>, or passed to a method/constructor parameter of this same type, or returned from a method of that return type, then the full type information can be recovered at runtime through the Java Reflection API. This also means that when casting to a generic type (e.g.: <code>(List<String>) list</code>), the cast is an unchecked cast. Because the parameter <code><String></code> is erased, the JVM cannot check if a cast from a <code>List<?></code> to a <code>List<String></code> is correct; the JVM only sees a cast for <code>List</code> to <code>List</code> at runtime.</div> <footer class="page-edit"><div class="edit-link"><a href="https://github.com/devtut/generate/edit/master/docs/java/generics.md" target="_blank" rel="noopener noreferrer">Edit this page on GitHub</a> <svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" focusable="false" x="0px" y="0px" viewBox="0 0 100 100" width="15" height="15" class="icon outbound"><path fill="currentColor" d="M18.8,85.1h56l0,0c2.2,0,4-1.8,4-4v-32h-8v28h-48v-48h28v-8h-32l0,0c-2.2,0-4,1.8-4,4v56C14.8,83.3,16.6,85.1,18.8,85.1z"></path> <polygon fill="currentColor" points="45.7,48.7 51.3,54.3 77.2,28.5 77.2,37.2 85.2,37.2 85.2,14.9 62.8,14.9 62.8,22.9 71.5,22.9"></polygon></svg> (opens new window)</div> </footer> <div class="page-nav">

←

Visibility (controlling access to members of a class)

</a> <a href="/java/classes-and-objects.html">

Classes and Objects

</a>

→

</div> </main></div><div class="global-ui"></div></div>

</body>

</html>

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

FilesExpand file tree

generics.html

Latest commit

History

generics.html

File metadata and controls