第1页 / 共290页
第2页 / 共290页
第3页 / 共290页
第4页 / 共290页
第5页 / 共290页
第6页 / 共290页
第7页 / 共290页
第8页 / 共290页
SmallTalk教程.pdf
Acknowledgments
Acknowledgments
Introduction
Approach
Layout of the book
Examples
Target audience
About Smalltalk
Features of Smalltalk
Interpreted language
Browsers
The Debugger
The Class Library
The Garbage Collector
Object-Oriented Thinking
Modifying and Extending the Environment
Smalltalk is reflective
Summary
Acknowledgments
Basic Concepts
Objects
Encapsulation
Classes
The Class as code respository
The Class as factory
The Class as abstractor
Inheritance
Polymorphism
Abstract Superclasses
Summary
Acknowledgments
Messages
Unary Messages
Binary Messages
Keyword Messages
Message chaining
Message precedence
What happens when a message is sent
The receiver of the message
self
super
Acknowledgments
Methods
Method Types
Method Length
Method names
Stupid methods
Method formatting
Public and Private methods
Returning from a method
Return object defined by method name
Return object defined by last statement
Guard clauses
Consistency in objects returned
Misplaced Methods
Number of Methods
Defaulting Parameters
Method Template
Acknowledgments
Variables
Variable names
Instance variables
Class variables
Classes referencing their instances (advanced)
Class instance variables
Parameters
Method parameters
Block parameters
Temporary variables
Temporary to the method
Temporary to the block
Global variables
Variables as slots
Accessors
Accessors for collections
The five accessor approach
Accessors or Direct Referencing
Direct referencing
Referencing through accessors
Which way to go
Chains of accessors
Documentation on variables
Acknowledgments
Instance Creation
Setting default values
Overriding new
Setting instance specific values
Overriding new to avoid it being used
Avoiding the use of new:
Sole instances of a class
Acknowledgments
Special Variables, Characters, and Symbols
Character Pairs
"This is a comment"
'This is a string'
(2 * 3)
[some code]
Prefixes
Special Variables
Assignment
Return
Statement Separator
Cascading
Automatically Constructed Objects
SmallInteger
Float
String
Character
Symbol
Array
BlockClosure
= and ==
Identically equal
Equal
Acknowledgments
Global Variables
Global Dictionary
Pool Dictionaries
Class side variables
Default instances
Environment Variables / Command Line Arguments
Image Version Number
Acknowledgments
Control Structures
Conditional Execution
Looping
Repetition
Optimized Messages
Acknowledgments
Object-Oriented Thinking
Little steps
Write down the concepts
Put off the work
Tell, Don't Ask
Don't check the results of doing things
Signs of Object-Oriented Thinking
Short methods
No dense black methods
No super-intelligent objects
No manager objects
Objects with clear responsibilities
Not too many instance variables
Getting started with Object-Oriented Thinking
Acknowledgments
Object
Accessing
Changing
Class membership
Comparing
Converting
Copying
Dependents access
Error handling
File In/Out
Initialize-release
Message handling
Printing
System primitives
Testing
Updating
User interface
Acknowledgments
Collections
Collection types
OrderedCollection
SortedCollection
List
Array
Dictionary
Set
Bag
LinkedList
Creating new collections
new:
new
The with: family
Adding to and removing from Collections
Enumerating
do:
collect:
select:
reject:
detect:
inject:into:
Enumeration wrap-up
General messages for collections
Adding objects
Removing objects
Accessing and locating objects
Replacing objects
Sizes and counts
Testing
Creating other collections from a collection.
Growing collections
Acknowledgments
Strings
Creating a string
Adding to a string
Comparing strings
Changing case and converting to a number
Pattern matching
Looking for characters or words in a string
Replacing characters
Creating a new string
Modifying the string in place
Getting a substring
Expanding a format string
Additional useful methods
Trimming white space from a string
Capitalizing a string
Acknowledgments
Streams
Streams and their uses
Streams in printOn:
Streams in file access
Streams on strings
The benefits of a Stream
Creating streams
Reading, writing, and positioning streams
Writing
Reading
Positioning
Example
Acknowledgments
Files
Filename
Opening files
Closing files
What files are open?
Reading from and writing to files
Reading text files
Reading and writing binary data
Positioning
End of line character
Flushing buffers to disk
Utilities
Class side utilities
Instance side utilities
Directories
Contents of files
Information about files
Manipulating files
Acknowledgments
Printing Objects
Display strings
Printing formatted numbers, dates, and times
VisualWorks 2.5
printf-scanf
Acknowledgments
Processes
Priority
Communicating between Processes
The SharedQueue
The PrioritySharedQueue
A general SharedQueue reading mechanism
Terminating processes
Making shared data threadsafe
Controlling the running of the process
Interrupting Processes
Working with Processes
Tracking processes with a Global variable
Tracking processes by subclassing
Microsoft Word - 19 - Chapter 17 - Coordinating and Sequencing Events.doc
Acknowledgments
Cleaning up at Termination
The CleanUp object
Using the CleanUp object
Other approaches
Acknowledgments
The Dependency Mechanism
Basic Dependency
Underlying mechanism
Model
expressInterestIn:for:sendBack:
onChangeSend:to:
Which mechanism should you use?
Broadcasting
Dependency Considerations
Dependency violation
Breaking dependencies
Acknowledgments
Error Handling
Signals and Exceptions
Creating your own signal
A single application signal
Multiple application signals
Overriding errorSignal
Central error messages
More on Signal Creation
Specifying the proceedability of the signal
Notifier strings and inspector information
Parents handling signals
Signal collections
Handler lists / collections
Passing information with an Exception
raise
raiseWith: aParameter
raiseErrorString: aString
raiseWith: aParameter errorString: aString
Parameter Substitution
raiseWith:errorTemplate:
raiseWith:errorPattern:
Handling the exception
return
returnWith:
reject
restart
restartDo:
self error:
doesNotUnderstand:
valueNowOrOnUnwindDo:
Emergency Exception Handler
noHandlerSignal
Exceptions and Processes
When to look for errors
Acknowledgments
Debugging
Bringing up a Notifier window
Using a Debugger window
Inspectors
Modifying values in an Inspector
Halting
Modifying halt and halt:
Writing your own myHalt and myHalt:
Conditional halting
Halting without adding a halt
Writing information to a file or the Transcript
Audible and Visible information
Monitoring activity of objects
A brief aside
Objects not being garbage collected
Public Domain debugging software
Commercial debugging software
The Smalltalk Professional Debug Package
Object Explorer
Acknowledgments
Common Errors
Notifier window messages
Losing code you modified in a debugger
Removing from a collection you are iterating over
Not returning the injection variable in inject:into:
Missing ^
Not implementing =
Assuming that messages return self
Incorrect messages to Booleans
Not reinitializing class variables
Problems with copies
Modifying copy of non-collection object
Modifying copy of collection
^ in block returns from method
Modifying a literal array
Acknowledgments
Model-View-Controller
Why is Model-View-Controller important?
How are they tied together?
The macro and micro view
The ApplicationModel Framework
ValueHolder
AspectAdaptor
Subject Channels
Summary
Acknowledgments
MVC Dependencies
Example One: Using addDependent:
Example Two: ValueHolders
Example Three: AspectAdaptors
Example Four: Subject Channels and differently named accessors
Example Five: Delaying updates
Example Six: Aspect Paths
Example Seven: Buffered Aspect Paths
Example Eight: PluggableAdaptors
Summary
Acknowledgments
Hooks into the System
Copying
postCopy
copyEmpty:
User interface opening
initialize
preBuildWith: aBuilder
postBuildWith: aBuilder
postOpenWith: aBuilder
Support methods
User Interface closing
changeRequest
requestForWindowClose
noticeOfWindowClose:
Acknowledgments
Changing Widgets at Runtime
The builder
Components
Widgets
Controllers
Modifying things
Enabling and Disabling
Visible and Invisible
Changing labels
Changing selections and cursor position
Changing colors and fonts
Changing Menus
Replacing menus
Modifying menus and menu items
Creating the menu at selection time
Keyboard events and double-clicking
/Users/ducasse/Desktop/SmalltalkByExample/29 - Chapter 27 - Extending the Framework.pdf
Acknowledgments
Eliminating Procedural Code
Tell, don't ask
Processing external objects
perform:
Dictionary of classes
Summary
Acknowledgments
Meta-Programming
Classes and Metaclasses
Adding general class side behavior
Examples we've seen in other chapters
Examples we promised in other chapters
Finding classes with a specified protocol
allInstancesAndSubInstances
Creating accessors for instance variables
A brief overview of other capabilities
Acknowledgments
Testing
The Test class
Building the TstTest class
The Test Result
The Test Manager
Running Tests
All Tests
Selected Tests
Running tests that never complete
Loading in the tests
Acknowledgments
Customizing your Environment
Keyboard
VisualWorks 2.5 change
Launcher
Window label
Other menu
VisualWorks 2.0
VisualWorks 2.5
Both
Changes
VisualWorks 2.0
VisualWorks 2.5
Both
Default browser
Adding VisualLauncher menus to a mouse button
Templates
Screen Color
Speed up startup
Acknowledgments
Changes to System Classes
Subclass where possible
Types of changes to system classes
Development environment vs. deployed classes
Added vs Modified methods
Summary
Distinguishing your additions and modifications
Some useful additions
Acknowledgments
Managing Source Code
Change Set
Filing in code
Filing in the application
Filing in development environment changes
Generic Development Environment changes
Using a class to file in the code
Filing out
Creating a production image
Common to VisualWorks 2.0 and 2.5
VisualWorks 2.0
VisualWorks 2.5
Common to VisualWorks 2.0 and 2.5
Saving the mkIm image
Runtime Packager
Acknowledgments
ENVY
Code sharing
Applications and subapplications
Version Control
Visibility
Methods
Classes
Applications
Products and subsystems
Scratch Editions
Management of Applications and Classes
Application manager diagram
An example of controlling parallel development
Code reviews
ENVY/Developer 3.01 enhancements
Additional Information
Microsoft Word - 37 - Chapter 35 - Public Domain Code and Information.doc
Acknowledgments
Source Files
Source files mentioned in chapters
New classes and subclasses
Files for installing applications
System class additions
System class modifications
Acknowledgments
Source Code for Chapter 24
Superclasses
Example One
Example Two
Example Three
Example Four
Example Five
Example Six
Example Seven
Example Eight
Copyright © 1997 by Alec Sharp
PDF-Conversion by Lukas Renggli
Download more free Smalltalk-Books at:
The University of Berne: http://www.iam.unibe.ch/~ducasse/WebPages/FreeBooks.html
European Smalltalk Users Group: http://www.esug.org
This book has been prepared by Lukas Renggli and Stéphane Ducasse.
We thank the author that gave us the right to make this great book available to
everybody.
Bern 30th of Augut 2004
If you want to help promoting smalltalk contact ESUG: www.esug.org
Acknowledgments
I’d like to thank all those people who helped during the development of this manuscript, by reviewing parts
of the manuscript, by general feedback, or by other assistance. Those people include TW Cook, Jim Dutton, and
Boyd Hays of ParcPlace-Digitalk, Dave Farmer, Clark Hobbie, Mike Latta, Dave Muirhead, Dave Myers, and
Bill Wright. I also received valuable contributions from those anonymous reviewers of an early draft whose
favorable opinions were vital to getting this manuscript published. To all of these people: your comments and
suggestions have helped make this book considerably better than it might have been. To the anonymous
reviewers: thanks for the favorable opinions!
Thanks also all the people I worked with at McGraw-Hill who helped bring this book from concept to reality.
In particular, Scott Amerman, Michael Christopher, Jennifer DiGiovanna, and John Wyzalek.
I also want to thank all those people who have contributed to whatever knowledge I have of object-oriented
thinking and Smalltalk programming. Many people have contributed to my education, including the authors of
various books and magazine articles. From this group I’d like to acknowledge Kent Beck and Alan Knight for
their wonderful articles in The Smalltalk Report. Of the people I have worked with, I’d like to particularly thank
the following: Rob Forbes, Boyd Hays, Clark Hobbie, Mike Latta, Alan Wostenberg, Bill Wright, and the Daves
(Bond, Farmer, Muirhead, and Myers).
In particular, I’d like to thank four friends for special contributions. Dave Farmer for all the fun we had
learning Smalltalk and working on our first Smalltalk project together. Boyd Hays for the philosophy and
information he imparted when he came in as a consultant to review the design and progress of our first project.
Scott Allen, my manager at StorageTek, who had the courage to bring in Smalltalk and commit to doing a key
project in it. Bill Wright for the incredible review he did of the final manuscript, and for being the greatest office
partner. To these four people: thanks.
Most of all, I want to acknowledge and thank the people whose lives were most affected by this book: my
daughter, Nikki, who had less of a father during the evenings and weekends I worked on the book, and my wife,
Muriel, to whom I offer the greatest thanks. On top of her own busy life she took on many additional household
and child-minding duties as I spent long hours at the computer. Thanks, I couldn’t have done it without you.
Copyright © 1997 by Alec Sharp
Download more free Smalltalk-Books at:
- The University of Berne: http://www.iam.unibe.ch/~ducasse/WebPages/FreeBooks.html
- European Smalltalk Users Group: http://www.esug.org
Introduction
This book is the book that I wanted when I started programming in Smalltalk. None of the books on the
market seemed quite right; they all lacked some of what I needed to get my job done. Some were more like
reference books, making sense if one already understood the material, but not very good if one lacked the basic
knowledge. Others simply went over material that I could easily get by looking at the system classes using a
Browser. The bottom line was that none of them seemed to provide answers to the questions I had: how do I use
these capabilities when writing my application, how can I do the specific things I want to do, which is the best
approach to take, how can I modify my development environment to make it more productive? In short, I wanted
information that would steer me in the right direction and none of the books seemed to give that. This book is
written for people who have similar questions and needs, who want to become productive in Smalltalk
programming in as short a time as possible.
A lot of the material describes standard Smalltalk, but some material is specific to VisualWorks from
ParcPlace-Digitalk. The book assumes that the reader is using VisualWorks 2.0 or VisualWorks 2.5, and where
appropriate it explains the differences between these two releases. All the examples have been verified on both
VisualWorks 2.0 and VisualWorks 2.5. Note that in most examples, to save space I have not shown the
temporary variable declarations, so you will be prompted when you try to run or accept the code.
Approach
"Example is the school of mankind, and they will learn at no other". Like Edmund Burke, and like most
people, I learn best from example. People generally find it difficult to take a theory and apply it to create a
practical example. They usually find it far easier to take a concrete example, work with it, and extrapolate out the
general behavior. Because of this, I've tried to include plenty of examples in the book, practical examples that the
reader can use when developing applications. My goal has been to make this book different by focusing on
practicality, on helping developers solve the real programming problems they face. The book has an attached
diskette which contains the code for most of the examples.
This book presents the information that the reader needs in order to understand the concepts and the
capabilities of Smalltalk. It then goes a step beyond and gives practical examples of how readers would use the
capabilities when developing products. The book starts with the basic concepts of object-oriented development,
specifically in the context of Smalltalk programming. It builds on this and talks about control structures,
Collections, Streams, and other useful building blocks. Then it extends the basics and shows how the reader can
use the Smalltalk classes when writing application programs. For example, Chapter 20, Error Handling, looks at
the Signal and Exception mechanism that Smalltalk provides, then shows how you might use this mechanism
when writing your application. Chapter 30, Testing, shows how you might test your application. Chapter, 33,
Copyright © 1997 by Alec Sharp
Download more free Smalltalk-Books at:
- The University of Berne: http://www.iam.unibe.ch/~ducasse/WebPages/FreeBooks.html
- European Smalltalk Users Group: http://www.esug.org
Introduction
2
Managing Source Code, shows how you can track your changes, make sure that your image has the latest
changes, and build a production image from the latest changes.
Layout of the book
The book is split into five sections: Basics, the Basic System Classes, Skills and Techniques, User Interface,
and Advanced.
Section One, Basics, talks about the basics of Smalltalk. It talks about objects and classes, about messages
and methods, and about variables and language syntax. It covers creating instances of classes and controlling
program flow with the various conditional and looping structures. It ends with a chapter on thinking in terms of
objects.
Section Two, the Basic System Classes, goes over some of the fundamental classes that you will use.
Because everything in Smalltalk is an object, and all objects are instances of a class, we will talk about classes in
every section. However, Section Two is more information oriented and less technique oriented than some of the
other sections.
Section Three, Skills and Techniques, also talks a lot about the system classes, but covers techniques in using
the classes. It shows how you work with Processes, how you can implement error handling code, and how to
debug in Smalltalk. The section covers a lot of skills and techniques that you will use when developing your
application.
Section Four, User Interface, focuses on user interface issues. It gives a lot of attention to the Model-View-
Controller paradigm, then talks about how you can modify user interfaces at run-time. Since the user interface
mechanisms differs widely between the different flavors of Smalltalk, this is the section most specific to
VisualWorks.
Section Five, Advanced, is an advanced section, not because the topics are esoteric, but because the chapters
tend to use advanced techniques or knowledge. In fact, some of the material in this section may be very useful,
covering such topics as testing, adding methods to system classes, and customizing your development
environment.
The book includes a comprehensive index. I've always been frustrated when I know a book contains the
information I want, but I can't find it. So I hope this index proves to be less frustrating than some. However,
some chapters, such as those on Collections, Streams, Object, and Meta-Programming, make passing references
to a lot of messages, and I will not duplicate those references in the index.
Examples
The book contains many examples of Smalltalk code to illustrate points made in the chapters. There are two
flavors of code: code that you can type into a workspace, highlight, and evaluate or inspect; and code that
consists of classes and methods. The accompanying diskette contains all the code shown in the book. The two
types of code are separated into two types of file. Files with an extension of .ex contain example code to be
selected and evaluated. Files with an extension of of .st contain classes and methods that can be filed into the
image. Appendix A, Source Files, describes which files relate to which chapters.
Introduction
3
(When highlighting and selecting code in a Workspace, you will sometimes find that when you click to the
right of the code, the following line is highlighted rather than the line to the left of where you click. By ending
the statement with a period you can prevent this problem.)
Target audience
Based on a categorization of Smalltalk programmers into three categories — beginner, intermediate, and
expert — this book is targeted at beginning to intermediate Smalltalk programmers. Expert programmers may
get some useful new information from the book, but they will also know a great deal of what it contains.
Beginning and intermediate programmers should find that the book answers a lot of questions about how to
program in Smalltalk, how to use the system classes, and how to incorporate the Smalltalk mechanisms into
application programs. It is a beginner book in the sense that it goes over the basic concepts, talking about classes,
instances, messages and methods, then building on this to look at Collections, Streams, Processes, and so on.
However, it doesn't spend as long on the basics as would a book geared totally toward beginners. My feeling is
that it doesn't take too long to understand the basics, and I wanted this book to have greater use than just a few
weeks. It is an intermediate book in that it gives suggestions on how the reader might write better applications,
eliminate procedural code, implement more effective error handling mechanisms, and better test their software. It
also contains many tips and hints that often take years to discover.
The book expects some amount of programming experience, whether in procedural or object-oriented
programming. A complete novice will get some use from the book, but it will take more effort. While no
significant knowledge of object-oriented programming or of Smalltalk is required, I do assume some basic
knowledge of the VisualWorks tools, including how to use the Browsers to define classes and write code (when
the book refers to a tool, it is referring to the VisualWorks functionality).
About Smalltalk
Smalltalk has been around a long time. It's origins date back to the early Seventies, when Alan Kay, then at
Xerox PARC, wanted to create a language that children could program in. Kay's classic article, The Early
History of Smalltalk, published in the ACM SIGPLAN Notices, Volume 28, No. 3, March 1993, talks about the
evolution of early Smalltalk and about the influences of other languages on it.
Smalltalk was the original Object-Oriented (OO) language, and is still among the purest of OO languages.
Unlike hybrid languages such as C++, Smalltalk forces you to think and program in OO terms. When it was
originally developed it ran on its own hardware, and was basically the operating system for the hardware.
Perhaps due to that heritage, it contains a lot of useful process control features that one would normally associate
with an operating system, such as forked processes, semaphores, and mutual exclusion semaphores.
For most of its life, Smalltalk was associated with research and prototyping. However, it is now the fastest
growing OO language. The advent of C++ has popularized and legitimized OO programming, but over time
some people have become frustrated with the difficulties inherent in C++ development. Because of the new
legitimacy of OO development and the difficulties of C++ development, a lot of attention has turned to
Smalltalk. It has been further legitimized by IBM, which has made Smalltalk an important part of their
development language strategy.
Introduction
4
Smalltalk is often used for business applications, but it is also used for applications with a greater engineering
orientation. Texas Instruments used Smalltalk to control an entire state-of-the-art wafer fabrication plant, adding
extensions to allow distributed objects. Hewlett-Packard created Distributed Smalltalk, an extension to
ParcPlace's VisualWorks that allows objects to communicate transparently over networks. Back in the Eighties,
Tektronix began to use Smalltalk to run their logic analyzers and datascopes.
Features of Smalltalk
Smalltalk is a wonderful language to work with — in fact, it's hard to imagine a serious programming
language being more fun than Smalltalk. Certainly, I've had more fun programming in Smalltalk than any other
language I've worked with; so much fun that at times it's seemed incredible that I've also been paid to enjoy
myself. If Smalltalk is so great, what makes it this way? I think it's a combination of things. In no particular
order, here are some of those things.
Interpreted language
Smalltalk is conceptually an interpreted language. This means you can make changes to code and
immediately execute them without having to go through a lengthy compile and link process. In fact, you can
make code changes to an application that is actually running and have the changes take effect next time that
piece of code is executed. You can also write short code segments (in any window) and execute them
immediately1.
Browsers
Smalltalk is a very well thought out environment, with a rich set of browsing tools. Because it was designed
with children in mind, it is very easy to use. You can look at classes and their methods, and you can see just the
local methods or also include inherited methods. From within a method you can ask to see all the methods that
invoke it (the senders of the message), all the implementors of identically named methods (polymorphism), or
you can browse the code of any of the methods this method invokes. From any of these displays you can modify
code.
The Debugger
The debugger gives you a stack trace of where you are, allowing you to look at any of the methods in the
stack and to inspect any of the variables. The inspection capability is excellent, allowing you to easily follow
through objects and their own instance variables using just the mouse. As well as inspecting object values, you
can also change them. The debugger also has the browsing capabilities of being able to look at senders and
implementors of methods. Because of the interpreted nature of Smalltalk, you can evaluate code segments in the
1 While Smalltalk is conceptually interpreted, the actual implementation is rather more sophisticated. When you
accept a method, the compiler checks it for correctness, complains about syntax errors, gives you warnings about
semantic errors, then compiles your text into byte codes. Having pre-compiled byte codes to interpret at run time
is a lot faster than interpreting the text each time. On top of that, VisualWorks caches the machine instructions.
When the byte code are interpreted, machine instructions are generated and executed. VisualWorks caches the
machine instructions so that it doesn't need to interpret the byte codes next time it executes the method. Of
course, as in any cache, infrequently used methods may be swapped out.
Introduction
5
debugger and also change the methods that are stopped in. Being able to change a method then continue
execution is one of the best features of the debugger. In fact, I often consciously program using the debugger. If I
don't know exactly how to program a method, I'll simply ask the method to bring up a debugger by writing self
halt. Then I'll write the method in the debugger, using it to inspect variables and evaluate code snippets as I
write.
The Class Library
One of the big productivity gains comes from reusable software. Smalltalk provides a class library of around
one thousand classes, all of which make life a lot easier and a lot more productive for programmers. (In a new
VisualWorks 2.5 image with no additional tools or classes loaded, there are 960 classes and 23,131 methods.
With the Advanced Tools loaded, the counts are 1,014 and 24,529). It's nice to be able to use an already existing
class to manage a queue. It's nice to be able to convert it to a sorted collection with a single message send. Most
of the classes are conceptually simple — they have a well defined role and perform it well — which allows you
to easily combine and reuse objects.
The system class code is all there for you to peruse, which gives you three benefits. First, you can figure out
exactly how to use it instead of having to rely on usually incomplete or hard-to-understand documentation.
Second, you can learn new techniques from reading the system classes. Third, it makes it a lot easier to subclass
from the system classes. For example, some applications using forked processes may find that a simple
SharedQueue will suffice for passing objects between processes. Other applications may need a priority based
shared queue, and having a visible class library makes this very easy.
The bottom line is that having an extensive class library means that you have a huge amount of high quality
code available, which means you can put together applications very quickly.
The Garbage Collector
One of the features of Smalltalk that makes writing code much easier is the Garbage Collector. When objects
are no longer needed, you don't have to explicitly destroy them as in most other object-oriented languages.
Instead, they are automatically garbage collected when they are no longer referenced by another object. This
garbage collection makes it possible to concentrate on the application problem, not worrying about what will
happen to your objects. When they are no longer needed they will simply disappear and the memory will be
reclaimed.
Object-Oriented Thinking
Smalltalk is one of the pure OO languages. Unlike C++, in which it's easy to write procedural code, Smalltalk
makes it difficult to write procedural code. It usually takes about 8-12 months for experienced procedural
programmers to become fairly automatic in their Object-Oriented (OO) thinking. To use a language that doesn't
help that process makes it much easier to remain in a half-way schizophrenic state.
OO thinking is fun and it is different. One difference is that OO development tends to be more iterative than
procedural development, more spiral. In OO development we acknowledge that we don't fully understand our
objects and their interactions and we acknowledge that they will be changed and transformed as we increasingly
understand the problem.
相关推荐
2023年江西萍乡中考道德与法治真题及答案.doc
2012年重庆南川中考生物真题及答案.doc
2013年江西师范大学地理学综合及文艺理论基础考研真题.doc
2020年四川甘孜小升初语文真题及答案I卷.doc
2020年注册岩土工程师专业基础考试真题及答案.doc
2023-2024学年福建省厦门市九年级上学期数学月考试题及答案.doc
2021-2022学年辽宁省沈阳市大东区九年级上学期语文期末试题及答案.doc
2022-2023学年北京东城区初三第一学期物理期末试卷及答案.doc
2018上半年江西教师资格初中地理学科知识与教学能力真题及答案.doc
2012年河北国家公务员申论考试真题及答案-省级.doc
2020-2021学年江苏省扬州市江都区邵樊片九年级上学期数学第一次质量检测试题及答案.doc
2022下半年黑龙江教师资格证中学综合素质真题及答案.doc
