book

Sams Teach Yourself Object Oriented Programming in 21 Days, Second Edition

by Anthony Sintes

September 2001

Beginner

698 pages

13h 46m

English

Sams

Read now

Unlock full access

Dedication
About the ExamplesWhat You Need to Know to Use This Book
Object Oriented Programming in a Historical ContextPrecursors to OOPObject Oriented ProgrammingAn OOP Approach to Software Using ObjectsWhat Is a Class?Putting It All Together: Classes and ObjectsPutting Objects to WorkObject RelationshipsHow Object Oriented Programming Builds Upon the PastBenefits and Goals of OONaturalReliableReusableMaintainableExtendableTimelyPitfallsPitfall 1: Thinking of OOP as Simply a LanguagePitfall 2: Fearing ReusePitfall 3: Thinking of OO as a Cure-AllPitfall 4: Selfish ProgrammingThe Week AheadSummaryQ&AWorkshopQuizExercises
The Three Pillars of Object Oriented ProgrammingEncapsulation: The First PillarAn Example of Interface and ImplementationPublic, Private, and ProtectedWhy Should You Encapsulate?Abstraction: Learning to Think and Program AbstractlyWhat Is Abstraction?Two Examples of AbstractionEffective AbstractionKeeping Your Secrets Through Implementation HidingProtecting Your Object Through the Abstract Data Type (ADT)What Is a Type?An Example ADTProtecting Others from Your Secrets Through Implementation HidingA Real-World Example of Implementation HidingDivision of Responsibility: Minding Your Own BusinessEncapsulation Tips and PitfallsAbstraction Tips and PitfallsADT Tips and PitfallsImplementation Hiding TipsHow Encapsulation Fulfills the Goals of OO ProgrammingCaveatsSummaryQ&AWorkshopQuizExercises

Lab 1: Setting Up the Java EnvironmentProblem StatementLab 2: Class BasicsProblem StatementSolutions and DiscussionLab 3: Encapsulation RoundupProblem StatementSolutions and DiscussionLab 4: Case Study—The Java Primitive Wrappers (Optional)Problem StatementSolutions and DiscussionQ&AWorkshopQuizExercises
What Is Inheritance?Why Inheritance?“Is-A” Versus “Has-A”: Learning When to Use InheritanceLearning to Navigate Inheritance’s Tangled WebInheritance MechanicsOverridden Methods and AttributesNew Methods and AttributesRecursive Methods and AttributesTypes of InheritanceInheritance for ImplementationImplementation Inheritance ProblemsInheritance for DifferenceSpecializationInheritance for Type SubstitutionTips to Effective InheritanceSummaryHow Inheritance Fulfills the Goals of OOQ&AWorkshopQuizExercises
Lab 1: Simple InheritanceProblem StatementSolutions and DiscussionLab 2: Using Abstract Classes for Planned InheritanceProblem StatementSolutions and DiscussionLab 3: Bank Account—Practicing Simple InheritanceA Generic AccountThe Savings AccountThe Timed Maturity AccountChecking AccountOverdraft AccountProblem StatementExtended Problem StatementSolutions and DiscussionLab 4: Case Study—“Is-A,” “Has-A,” and the java.util.StackProblem StatementSolutions and DiscussionSummaryQ&AWorkshopQuizExercises
PolymorphismInclusion PolymorphismParametric PolymorphismParametric MethodsParametric typesOverridingOverloadingCoercionEffective PolymorphismPolymorphic PitfallsPitfall 1: Moving Behaviors Up the HierarchyPitfall 2: Performance OverheadPitfall 3: BlindersCaveatsHow Polymorphism Fulfills the Goals of OOSummaryQ&AWorkshopQuizExercises
Lab 1: Applying PolymorphismProblem StatementSolutions and DiscussionLab 2: Bank Account—Applying Polymorphism to a Familiar ExampleProblem StatementSolutions and DiscussionLab 3: Bank Account—Using Polymorphism to Write Future-Proof CodeProblem StatementSolutions and DiscussionLab 4: Case Study—The Java Switch and PolymorphismFixing a ConditionalProblem StatementSolutions and DiscussionSummaryQ&AWorkshopQuizExercises
Introduction to the Unified Modeling LanguageModeling Your ClassesBasic Class NotationAdvanced Class NotationModeling Your Classes to Suit Your PurposesModeling a Class RelationshipDependencyAssociationAggregationCompositionGeneralizationPutting It All TogetherSummaryQ&AWorkshopQuizExercises
The Software Development ProcessThe Iterative ProcessAn Iterative ApproachAn Incremental ApproachA High-Level MethodologyObject Oriented Analysis (OOA)Using Use Cases to Discover System UseIdentify the ActorsCreate a Preliminary List of Use CasesRefine and Name the Use CasesSplitting Use CasesCombining Use CasesThe Resulting Use CasesDefine Each Use Case’s Sequence of EventsUse-Case DiagramsInteraction DiagramsSequence DiagramsCollaboration DiagramsActivity DiagramsBuilding the Domain ModelSo Now What?SummaryQ&AWorkshopQuizExercises
Object Oriented Design (OOD)How Do You Apply OOD?Step 1: Generate an Initial List of ObjectsStep 2: Refine Your Objects’ ResponsibilitiesWhat Are CRC Cards?How Do You Apply CRC Cards?An Example CRC CardHow Many Responsibilities Per Class?CRC Card LimitationsStep 3: Develop the Points of InteractionInterfacesAgentsFuture ConsiderationsData TransformationStep 4: Detail the Relationships Between ObjectsStep 5: Build Your ModelSummaryQ&AWorkshopQuizExercises
Design ReuseDesign PatternsThe Pattern NameThe ProblemThe SolutionThe ConsequencesPattern RealitiesPatterns by ExampleThe Adapter PatternImplementing an AdapterWhen to Use the Adapter PatternThe Proxy PatternPublish/Subscribe and the Proxy PatternThe General Proxy PatternWhen to Use the Proxy PatternThe Iterator PatternImplementing an IteratorWhen to Use the Iterator PatternMaking a Pattern YoursSummaryQ&AWorkshopQuizExercisesAnswers to QuizAnswers to Exercises
More Patterns by ExampleThe Abstract Factory PatternImplementing an Abstract FactoryWhen to Use the Abstract Factory PatternThe Singleton PatternImplementing a SingletonInheritance and the Singleton PatternWhen to Use the Singleton PatternThe Typesafe Enum PatternImplementing the Typesafe Enum PatternWhen to Use the Typesafe Enum PatternPattern PitfallsSummaryQ&AWorkshopQuizExercisesAnswers to QuizAnswers to Exercises
OOP and the User InterfaceThe Importance of Decoupled UIsHow to Decouple the UI Using the Model View Controller PatternThe ModelImplementing The ModelThe ViewImplementing the ViewThe ControllerImplementing the ControllerPutting the Model View and Controller TogetherProblems with the Model View ControllerAn Emphasis on DataTight CouplingInefficiencySummaryQ&AWorkshopQuizExercises
Testing OO SoftwareTesting and the Iterative Software Development ProcessForms of TestingUnit TestingIntegration TestingSystem TestingRegression TestingA Guide to Writing Reliable CodeCombining Development and TestingAn Example Unit TestWhy You Should Write Unit TestsWriting Unit TestsJUnitWriting Advanced Unit TestsWriting Exceptional CodeWriting Effective DocumentationSource Code as DocumentationCoding ConventionsConstantsCommentsNamesMethod and Class HeadersSummaryQ&AWorkshopQuizExercises
BlackjackWhy Blackjack?Vision StatementOverriding RequirementsInitial Blackjack AnalysisThe Blackjack RulesBettingDealingPlayingSettlementMiscellaneousIdentifying the ActorsCreating a Preliminary List of Use CasesPlanning the IterationsIteration 1: Basic Game PlayIteration 2: RulesIteration 3: BettingIteration 4: User InterfaceIteration 1: Basic Game PlayBlackjack AnalysisRefining the Use CasesModeling the Use CasesModeling The DomainBlackjack DesignCRC CardsThe Command Line UIThe Blackjack ModelThe ImplementationThe CardThe Deck and DeckpileThe Player and HumanPlayerThe DealerThe BlackjackGameA Procedural PitfallTestingSummaryQ&AWorkshopQuizExercises
Blackjack RulesRules AnalysisBlackjack Rules Use Case AnalysisModeling the Use CasesUpdating the Blackjack Domain ModelRules DesignState DiagramsModeling the Player StatesModeling the Dealer StatesThe Updated Blackjack ModelRules ImplementationChanges to HandChanges to PlayerChanges to Dealer and BlackjackDealerTestingSummaryQ&AWorkshopQuizExercises
Blackjack BettingBetting AnalysisBlackjack Betting Use Case AnalysisUpdating the Blackjack Domain ModelBetting DesignDesigning the BankThe Betting DesignRefactoring the Player HierarchyThe Updated Blackjack ModelBetting ImplementationThe Bank ImplementationThe BettingPlayer ImplementationChanges to Dealer and HumanPlayerChanges to BlackjackDealerMiscellaneous ChangesA Little Testing: A Mock ObjectSummaryQ&AWorkshopQuizExercises
Blackjack PresentationCommand Line TweaksBlackjack GUI AnalysisGUI Use CasesGUI Visual Mock UpsBlackjack GUI DesignGUI CRC CardsPlayerViewOptionView and OptionViewControllerCardViewBlackjackGUIMiscellaneousGUI StructureRefactoringGUI Class DiagramBlackjack GUI ImplementationImplementing the VCard, VDeck, and CardViewImplementing the PlayerViewImplementing the OptionView and the OptionViewControllerImplementing the GUIPlayerPutting It All Together with the BlackjackGUISummaryQ&AWorkshopQuizExercises
An Alternative Blackjack GUIThe PAC LayersThe PAC PhilosophyWhen to Use the PAC Design PatternAnalyzing the PAC Blackjack GUIDesigning the PAC Blackjack GUIIdentifying the Presentation Layer ComponentsDesigning the Abstraction Layer ComponentsDesigning the ControlUsing the Factory Pattern to Avoid Common ErrorsImplementing the PAC Blackjack GUIImplementing the VCard and VHandImplementing the VBettingPlayerImplementing the VBlackjackDealerImplementing the GUIPlayerPutting It All Together with the ControlSummaryQ&AWorkshopQuizExercises
Having Fun with PolymorphismCreating a PlayerThe Safe PlayerAdding the SafePlayer to the GUIPolishOOP and SimulationsThe Blackjack PlayersImplementing the FlipPlayerImplementing the OneHitPlayerImplementing the SmartPlayerSetting Up the SimulatorThe ResultsSummaryQ&AWorkshopQuizExercises
Tying Up the Loose EndsRefactoring the Blackjack Design for Reuse in Other SystemsThe Design ProblemSewing a Solution with ThreadsIdentifying the Benefits the OOP Brought to the Blackjack SystemIndustry Realities and OOPSummaryQ&AWorkshopQuizExercises
Day 1 Quiz AnswersAnswers to QuizDay 2 Quiz and Exercise AnswersAnswers to QuizAnswers to ExercisesDay 3 Quiz and Exercise AnswersAnswers to QuizAnswers to ExercisesDay 4 Quiz and Exercise AnswersAnswers to QuizAnswers to ExercisesDay 5 Quiz AnswersAnswers to QuizDay 6 Quiz and Exercise AnswersAnswers to QuizAnswers to ExercisesDay 7 Quiz AnswersAnswers to QuizDay 8 Quiz and Exercise AnswersAnswers to QuizAnswers to ExercisesDay 9 Quiz and Exercise AnswersAnswers to QuizAnswers to ExercisesDay 10 Quiz and Exercise AnswersAnswers to QuizAnswers to ExercisesDay 11 Quiz and Exercise AnswersAnswers to QuizAnswers to ExercisesDay 12 Quiz and Exercise AnswersAnswers to QuizAnswers to ExercisesDay 13 Quiz and Exercise AnswersAnswers to QuizAnswers to ExercisesDay 14 Quiz and Exercise AnswersAnswers to QuizAnswers to ExercisesDay 15 Quiz and Exercise AnswersAnswers to QuizAnswers to ExercisesDay 16 Quiz and Exercise AnswersAnswers to QuizAnswers to ExercisesDay 17 Quiz and Exercise AnswersAnswers to QuizAnswers to ExercisesDay 18 Quiz and Exercise AnswersAnswers to QuizAnswers to ExercisesDay 19 Quiz and Exercise AnswersAnswers to QuizAnswers to ExercisesDay 20 Quiz and Exercise AnswersAnswers to QuizAnswers to ExercisesDay 21 Quiz and Exercise AnswersAnswers to QuizAnswers to Exercises
Java Developer’s Kit: J2SE 1.3 SDKDevelopment Environment ConfigurationSDK Tools OverviewJava Compiler: javacJava Interpreter: javaJava Archive Utility: jarJava Documentation and the Documentation Generator: javadocJava Playpen: Your First Java ProgramCompiling and RunningCreating a .jar FileGenerating javadocJava Language MechanicsSimple Java ClassData TypesVariablesConstantsOperatorsConditional StatementsLoopsClasses and Interfaces—Building Blocks of JavaUsing Existing ClassesCreating Your Own ClassesInterfacesInner Classes and Anonymous Inner ClassesSummary
UML ReferenceClassesObjectVisibilityAbstract Classes and MethodsNotesStereotypesRelationshipsDependencyAssociationRolesMultiplicityAggregationCompositionGeneralizationInteraction DiagramsCollaboration DiagramsSequence Diagrams
Analysis, Design, and MethodologiesC++ ProgrammingDesign PatternsGeneral OO Principals and Theory“Hard Core” Theory (But Don’t Let That Scare You!)Java ProgrammingMiscellaneousSmalltalkTesting
blackjack.coreblackjack.core.threadedblackjack.exeblackjack.playersblackjack.uiblackjack.ui.mvcblackjack.ui.pac

Overview

Sams Teach Yourself Object Oriented Programming in 21 Days differs from other OOP books in two main ways. Many classic OOP books are designed for software engineers and teach at an academic level. Sams Teach Yourself Object Oriented Programming in 21 Days presents accessible, user-friendly lessons designed with the beginning programmer in mind. Other OOP books work to present both OOP and to teach a programming language (for example: Object-Oriented Programming in C++). Although Sams Teach Yourself Object Oriented Programming in 21 Days uses Java to present the examples, the book is designed to present concepts that apply to any OOP environment.