Muutke küpsiste eelistusi

E-raamat: Object-Oriented Thought Process, The

3.73/5 (522 hinnangut Goodreads-ist)
  • Formaat: 360 pages
  • Sari: Developer's Library
  • Ilmumisaeg: 04-Apr-2019
  • Kirjastus: Addison Wesley
  • Keel: eng
  • ISBN-13: 9780135182123
Teised raamatud teemal:
  • Formaat - PDF+DRM
  • Hind: 31,58 €*
  • * hind on lõplik, st. muud allahindlused enam ei rakendu
  • Lisa ostukorvi
  • Lisa soovinimekirja
  • See e-raamat on mõeldud ainult isiklikuks kasutamiseks. E-raamatuid ei saa tagastada.
Object-Oriented Thought Process, TheSuurem pilt
  • Formaat: 360 pages
  • Sari: Developer's Library
  • Ilmumisaeg: 04-Apr-2019
  • Kirjastus: Addison Wesley
  • Keel: eng
  • ISBN-13: 9780135182123
Teised raamatud teemal:

DRM piirangud

  • Kopeerimine (copy/paste):

    ei ole lubatud

  • Printimine:

    ei ole lubatud

  • Kasutamine:

    Digitaalõiguste kaitse (DRM)
    Kirjastus on väljastanud selle e-raamatu krüpteeritud kujul, mis tähendab, et selle lugemiseks peate installeerima spetsiaalse tarkvara. Samuti peate looma endale  Adobe ID Rohkem infot siin. E-raamatut saab lugeda 1 kasutaja ning alla laadida kuni 6'de seadmesse (kõik autoriseeritud sama Adobe ID-ga).

    Vajalik tarkvara
    Mobiilsetes seadmetes (telefon või tahvelarvuti) lugemiseks peate installeerima selle tasuta rakenduse: PocketBook Reader (iOS / Android)

    PC või Mac seadmes lugemiseks peate installima Adobe Digital Editionsi (Seeon tasuta rakendus spetsiaalselt e-raamatute lugemiseks. Seda ei tohi segamini ajada Adober Reader'iga, mis tõenäoliselt on juba teie arvutisse installeeritud )

    Seda e-raamatut ei saa lugeda Amazon Kindle's. 

Object-oriented programming (OOP) is the foundation of modern programming languages, including C++, Java, C#, Visual Basic .NET, Ruby, Objective-C, and Swift. Objects also form the basis for many web technologies such as JavaScript, Python, and PHP.







It is of vital importance to learn the fundamental concepts of object orientation before starting to use object-oriented development environments. OOP promotes good design practices, code portability, and reusebut it requires a shift in thinking to be fully understood. Programmers new to OOP should resist the temptation to jump directly into a particular programming language or a modeling language, and instead first take the time to learn what author Matt Weisfeld calls the object-oriented thought process.







Written by a developer for developers who want to improve their understanding of object-oriented technologies, The Object-Oriented Thought Process provides a solutions-oriented approach to object-oriented programming. Readers will learn to understand the proper uses of inheritance and composition, the difference between aggregation and association, and the important distinction between interfaces and implementations.







While programming technologies have been changing and evolving over the years, object-oriented concepts remain a constantno matter what the platform. This revised edition focuses on the OOP technologies that have survived the past 20 years and remain at its core, with new and expanded coverage of design patterns, avoiding dependencies, and the SOLID principles to help make software designs understandable, flexible, and maintainable.

 
Introduction 1(4)
This Book's Scope
1(1)
What's New in the Fifth Edition
2(1)
The Intended Audience
3(1)
The Book's Approach
4(1)
Source Code Used in This Book
4(1)
1 Introduction to Object-Oriented Concepts
5(28)
The Fundamental Concepts
5(1)
Objects and Legacy Systems
6(1)
Procedural Versus OO Programming
7(4)
Moving from Procedural to Object-Oriented Development
11(1)
Procedural Programming
11(1)
OO Programming
11(1)
What Exactly Is an Object?
12(4)
Object Data
12(1)
Object Behaviors
13(3)
What Exactly Is a Class?
16(3)
Creating Objects
17(1)
Attributes
18(1)
Methods
19(1)
Messages
19(1)
Using Class Diagrams as a Visual Tool
19(1)
Encapsulation and Data Hiding
20(3)
Interfaces
20(1)
Implementations
21(1)
A Real-World Example of the Interface/Implementation Paradigm
21(1)
A Model of the Interface/Implementation Paradigm
22(1)
Inheritance
23(4)
Superclasses and Subclasses
24(1)
Abstraction
25(1)
Is-a Relationships
26(1)
Polymorphism
27(3)
Composition
30(1)
Abstraction
30(1)
Has-a Relationships
31(1)
Conclusion
31(2)
2 How to Think in Terms of Objects
33(14)
Knowing the Difference Between the Interface and the Implementation
34(7)
The Interface
36(1)
The Implementation
36(1)
An Interface/Implementation Example
36(5)
Using Abstract Thinking When Designing Interfaces
41(1)
Providing the Absolute Minimal User Interface Possible
42(4)
Determining the Users
43(1)
Object Behavior
44(1)
Environmental Constraints
44(1)
Identifying the Public Interfaces
44(1)
Identifying the Implementation
45(1)
Conclusion
46(1)
References
46(1)
3 More Object-Oriented Concepts
47(20)
Constructors
47(7)
When Is a Constructor Called?
48(1)
What's Inside a Constructor?
48(1)
The Default Constructor
48(1)
Using Multiple Constructors
49(4)
The Design of Constructors
53(1)
Error Handling
54(3)
Ignoring the Problem
54(1)
Checking for Problems and Aborting the Application
54(1)
Checking for Problems and Attempting to Recover
54(1)
Throwing an Exception
55(2)
The Importance of Scope
57(6)
Local Attributes
58(1)
Object Attributes
59(2)
Class Attributes
61(1)
Operator Overloading
62(1)
Multiple Inheritance
63(1)
Object Operations
63(2)
Conclusion
65(1)
References
65(2)
4 The Anatomy of a Class
67(10)
The Name of the Class
67(2)
Comments
69(1)
Attributes
69(2)
Constructors
71(2)
Accessors
73(2)
Public Interface Methods
75(1)
Private Implementation Methods
76(1)
Conclusion
76(1)
References
76(1)
5 Class Design Guidelines
77(14)
Modeling Real-World Systems
77(1)
Identifying the Public Interfaces
78(2)
The Minimum Public Interface
78(1)
Hiding the Implementation
79(1)
Designing Robust Constructors (and Perhaps Destructors)
80(1)
Designing Error Handling into a Class
81(1)
Documenting a Class and Using Comments
81(1)
Building Objects with the Intent to Cooperate
82(1)
Designing with Reuse in Mind
82(1)
Designing with Extensibility in Mind
83(3)
Making Names Descriptive
83(1)
Abstracting Out Nonportable Code
84(1)
Providing a Way to Copy and Compare Objects
84(1)
Keeping the Scope as Small as Possible
84(2)
Designing with Maintainability in Mind
86(2)
Using Iteration in the Development Process
86(1)
Testing the Interface
86(2)
Using Object Persistence
88(2)
Serializing and Marshaling Objects
89(1)
Conclusion
90(1)
References
90(1)
6 Designing with Objects
91(14)
Design Guidelines
91(6)
Performing the Proper Analysis
95(1)
Developing a Statement of Work
95(1)
Gathering the Requirements
95(1)
Developing a System Prototype
96(1)
Identifying the Classes
96(1)
Determining the Responsibilities of Each Class
96(1)
Determining How the Classes Collaborate with Each Other
96(1)
Creating a Class Model to Describe the System
96(1)
Prototyping the User Interface in Code
97(1)
Object Wrappers
97(5)
Structured Code
98(1)
Wrapping Structured Code
99(2)
Wrapping Nonportable Code
101(1)
Wrapping Existing Classes
101(1)
Conclusion
102(1)
References
103(2)
7 Mastering Inheritance and Composition
105(20)
Reusing Objects
105(1)
Inheritance
106(6)
Generalization and Specialization
109(1)
Design Decisions
110(2)
Composition
112(3)
Representing Composition with UML
113(2)
Why Encapsulation Is Fundamental to 00
115(8)
How Inheritance Weakens Encapsulation
115(2)
A Detailed Example of Polymorphism
117(1)
Object Responsibility
118(3)
Abstract Classes, Virtual Methods, and Protocols
121(2)
Conclusion
123(1)
References
123(2)
8 Frameworks and Reuse: Designing with Interfaces and Abstract Classes
125(22)
Code: To Reuse or Not to Reuse?
125(1)
What Is a Framework?
126(2)
What Is a Contract?
128(11)
Abstract Classes
128(3)
Interfaces
131(2)
Tying It All Together
133(2)
The Compiler Proof
135(1)
Making a Contract
136(2)
System Plug-in Points
138(1)
An E-Business Example
139(7)
An E-Business Problem
139(1)
The Non-Reuse Approach
139(2)
An E-Business Solution
141(1)
The UML Object Model
142(4)
Conclusion
146(1)
References
146(1)
9 Building Objects and Object-Oriented Design
147(14)
Composition Relationships
148(1)
Building in Phases
149(2)
Types of Composition
151(3)
Aggregations
151(1)
Associations
152(1)
Using Associations and Aggregations Together
153(1)
Avoiding Dependencies
154(1)
Cardinality
155(4)
Multiple Object Associations
157(1)
Optional Associations
158(1)
Tying It All Together: An Example
159(1)
Conclusion
160(1)
References
160(1)
10 Design Patterns
161(14)
Why Design Patterns?
162(1)
Smalltalk's Model/View/Controller
163(1)
Types of Design Patterns
164(9)
Creational Patterns
165(4)
Structural Patterns
169(2)
Behavioral Patterns
171(2)
Antipatterns
173(1)
Conclusion
174(1)
References
174(1)
11 Avoiding Dependencies and Highly Coupled Classes
175(12)
Composition versus Inheritance and Dependency Injection
177(8)
1) Inheritance
177(2)
2) Composition
179(3)
Dependency Injection
182(3)
Conclusion
185(1)
References
185(2)
12 The SOLID Principles of Object-Oriented Design
187(18)
The SOLID Principles of Object-Oriented Design
188(16)
1) SRP: Single Responsibility Principle
188(4)
2) OCP: Open/Close Principle
192(2)
3) LSP: Liskov Substitution Principle
194(3)
4) IPS: Interface Segregation Principle
197(1)
5) DIP: Dependency Inversion Principle
198(6)
Conclusion
204(1)
References
204(1)
Index 205
Matt Weisfeld is a college professor, software developer, and author based in Cleveland, Ohio. Prior to teaching college full time, he spent 20 years in the information technology industry as a software developer, entrepreneur, and adjunct professor. Weisfeld holds an MS in computer science and an MBA. Besides several editions of The Object-Oriented Thought Process, Matt has authored two other software development books and published many articles in magazines and journals, such as informit.com, developer.com, Dr. Dobbs Journal, The C/C++ Users Journal, Software Development Magazine, Java Report, and the international journal Project Management.
Lisainfo e-raamatute kohta Lisainfo e-raamatute kohta
Püsilink: https://www.kriso.ee/db/97801351821232e.html
Märksõnad: