Format:
Online-Ressource (720 p.)
Edition:
2nd ed
Edition:
Online-Ausg.
ISBN:
9780596009205
Series Statement:
Head first series
Content:
Learning a complex new language is no easy task especially when it s an object-oriented computer programming language like Java. You might think the problem is your brain. It seems to have a mind of its own, a mind that doesn't always want to take in the dry, technical stuff you're forced to study. The fact is your brain craves novelty. It's constantly searching, scanning, waiting for something unusual to happen. After all, that's the way it was built to help you stay alive. It takes all the routine, ordinary, dull stuff and filters it to the background so it won't interfere with your brai
Note:
Description based upon print version of record
,
Table of Contents; Intro.: How to Use This Book; Who is this book for?; We know what you're thinking.; And we know what your brain is thinking.; Metacognition: thinking about thinking.; Here's what WE did:; Here's what YOU can do to bend your brain into submission.; What you need for this book:; Last-minute things you need to know:; Technical Editors; Other people to credit; Just when you thought there wouldn't be anymore acknowledgements*.; Chapter 1. Dive in A Quick Dip: Breaking the Surface; The Way Java Works; What you'll do in Java; Code structure in Java; Anatomy of a class
,
Writing a class with a mainConditional branching; Coding a Serious Business Application; Phrase-O-Matic; Chapter 2. Classes and Objects: A Trip to Objectville; Chair Wars; Making your first object; Making and testing Movie objects; Quick! Get out of main!; Running the Guessing Game; Chapter 3. Primitives and References: Know Your Variables; Declaring a variable; "I'd like a double mocha, no, make it an int."; You really don't want to spill that...; Back away from that keyword!; This table reserved.; Controlling your Dog object; An object reference is justanother variable value.
,
An array is like a tray of cupsArrays are objects too; Make an array of Dogs; Control your Dog; A Heap o' Trouble; Chapter 4. Methods Use Instance Variables: How Objects Behave; Remember: a class describes what an object knows and what an object does; The size affects the bark; You can send things to a method; You can get things back from a method.; You can send more than one thing to a method; Cool things you can do with parameters and return types; Encapsulation; Encapsulating the GoodDog class; How do objects in an array behave?; Declaring and initializing instance variables
,
The difference bet ween instance and local variablesComparing variables (primitives or references); Chapter 5. Writing a Program: Extra-Strength Methods; Let's build a Battleship-style game: "Sink a Dot Com"; First, a high-level design; The "Simple Dot Com Game" a gentler introduction; Developing a Class; The checkYourself() method; The game's main() method; More about for loops; Trips through a loop; The enhanced for loop; Chapter 6. Get to Know The Java API: Using the Java Library; In our last chapter, we left you with the cliff-hanger. A bug.; So what happened?; How do we fix it ?
,
Option one is too clunkyOption t wo is a little better, but still pretty clunky; Wake up and smell the library; Some things you can do with ArrayList; Comparing ArrayList to a regular array; Let's fix the DotCom code.; New and improved DotCom class; Let's build the REAL game: "Sink a Dot Com"; What needs to change?; Who does what in the DotComBust game (and when); Prep code for the real DotComBust class; The final version of the DotCom class; Super Powerful Boolean Expressions; Using the Library (the Java API); You have to know the full name* of the class you want to use in your code.
,
How to play with the API
,
Breaking the SurfaceThe way Java works -- Code structure in Java -- Anatomy of a class -- The main() method -- Looping -- Conditional branching (if tests) -- Coding the "99 bottles of beer" app -- Phrase-o-matic -- Fireside chat: compiler vs. JVM -- A Trip to Objectville -- Chair Wars (Brad the OO guy vs. Larry the procedural guy) -- Inheritance (an introduction) -- Overriding methods (an introduction) -- What's in a class? (methods, instance variables) -- Making your first object -- Using main() -- Guessing Game code -- Know Your Variables -- Declaring a variable (Java cares about type) -- Primitive types ("I'd like a double with extra foam, please") -- Java keywords -- Reference variables (remote control to an object) -- Object declaration and assignment -- Objects on the garbage-collectible heap -- Arrays (a first look) -- How Objects Behave -- Methods use object state (bark different) -- Method arguments and return types -- Pass-by-value (the variable is always copied) -- Getters and Setters -- Encapsulation (do it or risk humiliation) -- Using references in an array -- Extra-Strength Methods -- Building the Sink a Dot Com game -- Starting with the Simple Dot Com game (a simpler version) -- Writing prepcode (pseudocode for the game) -- Test code for Simple Dot Com -- Coding the Simple Dot Com game -- Final code for Simple Dot Com -- Generating random numbers with Math.random() -- Ready-bake code for getting user input from the command-line -- Looping with for loops -- Casting primitives from a large size to a smaller size -- Converting a String to an int with Integer.parseInt() -- Using the Java Library -- Analying the bug in the Simple Dot Com Game -- ArrayList (taking advantage of the Java API) -- Fixing the DotCom class code -- Building the real game (Sink a Dot Com) -- Prepcode for the real game -- Code for the real game -- boolean expressions -- Using the library (Java API) -- Using packages (import statements, fully-qualified names) -- Using the HTML API docs and reference books -- Better Living in Objectville -- Understanding inheritance (superclass and subclass relationships) -- Designing an inheritance tree (the Animal simulation) -- Avoiding duplicate code (using inheritance) -- Overriding methods -- IS-A and HAS-A (bathtub girl) -- What do you inherit from your superclass? -- What does inheritance really buy you? -- Polymorphism (using a supertype reference to a subclass object) -- Rules for overriding (don't touch those arguments and return types!) -- Method overloading (nothing more than method name re-use) -- Serious Polymorphism -- Some classes just should not be instantiated -- Abstract classes (can't be instantiated) -- Abstract methods (must be implemented) -- Polymorphism in action -- Class Object (the ultimate superclass of everything) -- Taking objects out of an ArrayList (they come out as type Object) -- Compiler checks the reference type (before letting you call a method) -- Get in touch with your inner object -- Polymorphic references -- Casting an object reference (moving lower on the inheritance tree) -- Deadly Diamond of Death (multiple inheritance problem) -- Using interfaces (the best solution!) -- Life and Death of an Object -- The stack and the heap, where objects and variables live -- Methods on the stack -- Where local variables live -- Where instance variables live -- The miracle of object creation -- Constructors (the code that runs when you say new) -- Initializing the state of a new Duck -- Overloaded constructors -- Superclass constructors (constructor chaining) -- Invoking overloaded constructors using this() -- Life of an object -- Garbage Collection (and making objects eligible) -- Numbers Matter -- Math class (do you really need an instance of it?) -- static methods -- static variables -- Constants (static final variables) -- Math methods (random(), round(), abs(), etc.) -- Wrapper classes (Integer, Boolean, Character, etc.) -- Autoboxing -- Number formatting -- Date formatting and manipulation -- Static imports -- Risky Behavior -- Making a music machine (the BeatBox) -- What if you need to call risky code? -- Exceptions say "something bad may have happened ..." -- The compiler guarantees (it checks) that you're aware of the risks -- Catching exceptions using a try/catch (skateboarder) -- Flow control in try/catch blocks -- The finally block (no matter what happens, turn off the oven!) -- Catching multiple exceptions (the order matters) -- Declaring an exception (just duck it) -- Handle or declare law -- Code Kitchen (making sounds) -- A Very Graphic Story -- Your first GUI -- Getting a user event -- Implement a listener interface -- Getting a button's ActionEvent -- Putting graphics on a GUI -- Fun with paintComponent() -- The Graphics2D object -- Putting more than one button on a screen -- Inner classes to the rescue (make your listener an inner class) -- Animation (move it, paint it, move it, paint it, move it, paint it ...) -- Code Kitchen (painting graphics with the beat of the music) -- Work on your Swing -- Swing Components -- Layout Managers (they control size and placement) -- Three Layout Managers (border, flow, box) -- BorderLayout (cares about five regions) -- FlowLayout (cares about the order and preferred size) -- BoxLayout (like flow, but can stack components vertically) -- JTextField (for single-line user input) -- JTextArea (for multi-line, scrolling text) -- JCheckBox (is it selected?) -- JList (a scrollable, selectable list) -- Code Kitchen (The Big One -- building the BeatBox chat client) -- Saving Objects -- Saving object state -- Writing a serialized object to a file -- Java input and output streams (connections and chains) -- Object serialization -- Implementing the Serializable interface -- Using transient variables -- Deserializing an object -- Writing to a text file -- java.io. File -- Reading from a text file -- Splitting a String into tokens with split() -- CodeKitchen -- Make a Connection -- Chat program overview -- Connecting, sending, and receiving -- Network sockets -- TCP ports -- Reading data from a socket (using BufferedReader) -- Writing data to a socket (using PrintWriter) -- Writing the Daily Advice Client program -- Writing a simple server -- Daily Advice Server code -- Writing a chat client -- Multiple call stacks -- Launching a new thread (make it, start it) -- The Runnable interface (the thread's job) -- Three states of a new Thread object (new, runnable, running) -- The runnable-running loop -- Thread scheduler (it's his decision, not yours) -- Putting a thread to sleep -- Making and starting two threads -- Concurrency issues: can this couple be saved? -- The Ryan and Monica concurrency problem, in code -- Locking to make things atomic -- Every object has a lock -- The dreaded "Lost Update" problem -- Synchronized methods (using a lock) -- Deadlock! -- Multithreaded ChatClient code -- Ready-bake SimpleChatServer -- Data Structures -- Collections -- Sorting an ArrayList with Collections.sort() -- Generics and type-safety -- Sorting things that implement the Comparable interface -- Sorting things with a custom Comparator -- The collection API-lists, sets, and maps -- Avoiding duplicates with HashSet -- Overriding hashCode() and equals() -- HashMap -- Using wildcards for polymorphism -- Release Your Code -- Deployment options -- Keep your source code and class files separate -- Making an executable JAR (Java ARchives) -- Running an executable JAR -- Put your classes in a package! -- Packages must have a matching directory structure -- Compiling and running with packages -- Compiling with -d -- Making an executable JAR (with packages) -- Java Web Start (JWS) for deployment from the web -- How to make and deploy a JWS application -- Distributed Computing -- Java Remote Method Invocation (RMI), hands-on, very detailed -- Servlets (a quick look) -- Enterprise JavaBeans (EJB), a very quick look -- Jini, the best trick of all -- Building the really cool universal servic
Additional Edition:
9780596800765
Additional Edition:
Print version Head First Java
Language:
English
Keywords:
Electronic books
Bookmarklink
