Effective Java – Techglot

Methods

Memory map

Objective

Following rules are described

Item 49: Check parameters for validity
Item 50: Make defensive copies when needed
Item 51: Design method signatures carefully
Item 52: Use overloading judiciously
Item 53: Use varargs judiciously
Item 54: Return empty collections or arrays, not nulls
Item 55: Return optionals judiciously
Item 56: Write doc comments for all exposed API elements

Pages: 12345678

Serialization

Following rules are described-

Introduction
Item 85: Prefer alternatives to Java serialization
Item 86: Implement Serializable with great caution
Item 87: Consider using a custom serialized form
Item 88: Write readObject methods defensively
Item 89: For instance control, prefer enum types to readResolve
Item 90: Consider serialization proxies instead of serialized instances

Introduction

JAVA – Object SERIALIZATION,
It is Java’s framework for encoding objects as byte streams (serialising) and reconstructing objects from their encoding (serialising). This mechanism is used to persist the object. This chapter focuses on the dangers of serialization and how to minimize them.

Pages: 1234567

Concurrency

Objective

Concurrency canot be avoided it is inherent in platform(multicore) and requirement if you want to achieve better performance from multicore processors.
Motivation:
Concurrent programming is harder than single-threaded programming, because more things can go
wrong, and failures can be hard to reproduce.

Memory Map

Following rules are described

Item 78: Synchronize access to shared mutable data . . . . . . . . . . 311
Item 79: Avoid excessive synchronization . . . . . . . . . . . . . . . . . . 317
Item 80: Prefer executors, tasks, and streams to threads . . . . . . . 323
Item 81: Prefer concurrency utilities to wait and notify . . . . . . 325
Item 82: Document thread safety . . . . . . . . . . . . . . . . . . . . . . . . . 330
Item 83: Use lazy initialization judiciously . . . . . . . . . . . . . . . . . 333
Item 84: Don’t depend on the thread scheduler . . . . . . . . . . . . . . 336

Pages: 12345678

General Programming

Following rules are desscribed

Item 57: Minimize the scope of local variables
Item 58: Prefer for-each loops to traditional for loops
Item 59: Know and use the libraries
Item 60: Avoid float and double if exact answers are required
Item 61: Prefer primitive types to boxed primitives
Item 62: Avoid strings where other types are more appropriate
Item 63: Beware the performance of string concatenation
Item 64: Refer to objects by their interfaces
Item 65: Prefer interfaces to reflection
Item 66: Use native methods judiciously. .
Item 67: Optimize judiciously
Item 68: Adhere to generally accepted naming conventions .

Pages: 12345678910111213

Lambdas and Streams

Memory Map

Objective

Following rules are described

Item 42: Prefer lambdas to anonymous classes
Item 43: Prefer method references to lambdas
Item 44: Favor the use of standard functional interfaces
Item 45: Use streams judiciously
Item 46: Prefer side-effect-free functions in streams
Item 47: Prefer Collection to Stream as a return type
Item 48: Use caution when making streams parallel

Pages: 12345678

Generics

What is Generics:

Generic are introduced to programming language from v5, also it maintains support to Raw type.
Generic type is a class or interface followed by Parameter. the parameter is given in angular Bracket.
Generiic allow us to pass the type(Integer ,String ..user defined type) to method ,class or interface.

Parameter can be Formal or actual .
Formal Paramter is used when we declare the Generic type the actual parameter is used when we pass the values.

Why ?

It is better to detect the bug at earlist . the GENERICS provides the type safety so compiler complains when you to enter values other than one specified in generic parameter.
thus ensuring destructibility at compile time (rather than leaving it for run time error .)

Following rules are described –

Item 26: Don’t use raw types . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
Item 27: Eliminate unchecked warnings. . . . . . . . . . . . . . . . . . . . 123
Item 28: Prefer lists to arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
Item 29: Favor generic types. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
Item 30: Favor generic methods . . . . . . . . . . . . . . . . . . . . . . . . . . 135
Item 31: Use bounded wildcards to increase API flexibility . . . . 139
Item 32: Combine generics and varargs judiciously. . . . . . . . . . . 146
Item 33: Consider typesafe heterogeneous containers . . . . . . . . . 151

MemoryMap

Pages: 123456789

Methods Common to All Objects

Introduction

Objective-

Following Rules are described

Item 0: Obey the general contract when overriding equals
Item 1: Always override hashCode when you override equals
Item 2: Always override toString
Item 3: Override clone judiciously
Item 4: Consider implementing Comparable

Pages: 123456

Creating & Destroying Objects

THIS Section concerns creating and destroying objects:

When and how to create them,
When and how to avoid creating them,
How to ensure they are destroyed in a timely manner, and
How to manage any cleanup actions that must precede their destruction.

Following Rules are described

Consider static factory methods instead of constructors
Consider a builder when faced with many constructor parameters
Enforce the singleton property with a private constructor an enum type
Enforce non-instantiability with a private constructor
Prefer dependency injection to hard-wiring resources
Avoid creating unnecessary objects
Eliminate obsolete object references
Avoid finalizers and cleaners
Prefer try-with-resources to try-finally

Pages: 12345678910

Introduction to Effective Java:

Following Topics are described with best practices and rules around it in next sections:

Creating and Destroying Objects
Methods Common to all Objects
Classes and Interface
Generics
Enum and Annotations
Lambdas and Streams
Methods
General Programming
Exceptions
Concurrency
Serialization

Progress

Revisit Each Topic and complete a rule (in-progress)
1. Creating and destroying objects (in-progress)

Objectives:

Your thoughts on Why this topics? What is it about ?
- As you go thought content verify if it matches what you thought if different what is it?
Things that create Triggered point of realization for a concept
- Words sentences worth remembering for reiteration in public or interview.
- In general – 2 things in a text : message and presentation(points that gets your attention)
Getting outcome applying things wither in code or in interview -knowledge sharing
Application -where to apply in implementation
Learning process — make it fast!!!

Exceptions

Memory Map

Objective

Following rules are described

Item 69: Use exceptions only for exceptional conditions . . . . . . . 293
Item 70: Use checked exceptions for recoverable conditions and
runtime exceptions for programming errors . . . . . . . . . . 296
Item 71: Avoid unnecessary use of checked exceptions . . . . . . . . 298
Item 72: Favor the use of standard exceptions. . . . . . . . . . . . . . . . 300
Item 73: Throw exceptions appropriate to the abstraction. . . . . . . 302
Item 74: Document all exceptions thrown by each method. . . . . . 304
Item 75: Include failure-capture information in detail messages. . 306
Item 76: Strive for failure atomicity . . . . . . . . . . . . . . . . . . . . . . . 308
Item 77: Don’t ignore exceptions . . . . . . . . . . . . . . . . . . . . . . . . . 310

Pages: 1234567891011