Keyword : Category :
 
 
 
 
Windows
Unix
Php and mysql
Linux
Java
Mobile programming
Certification
Asterisk
Python
Autocad
3d-animation
Hacks
Programming
Hardware
Networking
Web design
Multimedia - graphics
Simple steps
Dummies
.net programming
Oracle
Sql server
Operating system
Telecommunications
Microsoft
Office
Web development
Cisco
Graphics
C sharp
Software development
Database
Computer science
Uml
Security
General
Cms
Mac
Android
 
 
Email:
 
 
HEAD FIRST DESIGN PATTERNS: BUILDING EXTENSIBLE AND MAINTAINABLE OBJECT-ORIENTED SOFTWARE, SECOND EDITION
NRS 2360.00
 
Book details / order
HEAD FIRST JAVA, 2ND EDITION YOUR BRAIN ON JAVA - A LEARNER'S GUIDE
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 brain's real work--recording things that matter. how does your brain know what matters? it's like the creators of the head first approach say, suppose you're out for a hike and a tiger jumps in front of you, what happens in your brain? neurons fire. emotions crank up. chemicals surge. that's how your brain knows. and that's how your brain will learn java. head first java combines puzzles, strong visuals, mysteries, and soul-searching interviews with famous java objects to engage you in many different ways. it's fast, it's fun, and its effective. and, despite its playful appearance, head first java is serious stuff: a complete introduction to object-oriented programming and java. you'll learn everything from the fundamentals to advanced topics, including threads, network sockets, and distributed programming with rmi. and the new. second edition focuses on java 5.0, the latest version of the java language and development platform. because java 5.0 is a major update to the platform, with deep, code-level changes, even more careful study and implementation is required. so learning the head first way is more important than ever. if you've read a head first book, you know what to expect--a visually rich format designed for the way your brain works. if you haven't, you're in for a treat. you'll see why people say it's unlike any other java book you've ever read. by exploiting how your brain works, head first java compresses the time it takes to learn and retain--complex information. its unique approach not only shows you what you need to know about java syntax, it teaches you to think like a java programmer. if you want to be bored, buy some other book. but if you want to understand java, this book's for you. about the authors kathy sierra has been interested in learning theory since her days as a game developer (virgin, mgm, amblin'). more recently, she's been a master trainer for sun microsystems, teaching sun's java instructors how to teach the latest technologies to customers, and a lead developer of several sun certification exams. along with her partner bert bates, kathy created the head first series. she's also the original founder of the software development/jolt productivity award-winning javaranch.com, the largest (and friendliest) all-volunteer java community. bert bates is a 20-year software developer, a java instructor, and a co-developer of sun's upcoming ejb exam (sun certified business component developer). his background features a long stint in artificial intelligence, with clients like the weather channel, a&e;network, rockwell, and timken. chapter 1 dive in a quick dip: breaking the surface the way java works what you’ll do in java a very brief history of java code structure in java anatomy of a class writing a class with a main looping and looping and... conditional branching coding a serious business application phrase-o-matic chapter 2 classes and objects: a trip to objectville chair wars: (or how objects can change your life) 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 just another variable value an array is like a tray of cups arrays are objects too make an array of dogs control your dog (with a reference variable) a dog example 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 java is pass-by-value. that means pass-by-copy 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 between instance and local variables comparing 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 casting primitives 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 clunky option two 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 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) how to play with the api chapter 7 inheritance and polymorphism: better living in objectville chair wars revisited... let’s design the inheritance tree for an animal simulation program using inheritance to avoid duplicating code in subclasses do all animals eat the same way? looking for more inheritance opportunities designing an inheritance tree when designing with inheritance, are you using or abusing? keeping the contract: rules for overriding overloading a method chapter 8 interfaces and abstract classes: serious polymorphism did we forget about something when we designed this? interface to the rescue! making and implementing the pet interface chapter 9 constructors and garbage collection: life and death of an object the stack and the heap: where things live methods are stacked what about local variables that are objects? if local variables live on the stack, where do instance variables live? the miracle of object creation construct a duck initializing the state of a new duck using the constructor to initialize important duck statenot to imply that not all duck state is not unimportant. make it easy to make a duck doesn’t the compiler always make a no-arg constructor for you? no! nanoreview: four things to remember about constructors wait a minute... we never did talk about superclasses and inheritance and how that all fits in with constructors the role of superclass constructors in an object’s life making a hippo means making the animal and object parts too... how do you invoke a superclass constructor? can the child exist before the parents? superclass constructors with arguments invoking one overloaded constructor from another now we know how an object is born, but how long does an object live? what about reference variables? chapter 10 numbers and statics: numbers matter math methods: as close as you’ll ever get to a global method the difference between regular (non-static) and static methods what it means to have a class with static methods static methods can’t use non-static (instance) variables! static methods can’t use non-static methods, either! static variable: value is the same for all instances of the class initializing a static variable static final variables are constants final isn’t just for static variables... math methods wrapping a primitive before java 5.0, you had to do the work... autoboxing: blurring the line between primitive and object autoboxing works almost everywhere but wait! there’s more! wrappers have static utility methods too! and now in reverse... turning a primitive number into a string number formatting formatting deconstructed... the percent (%) says, “insert argument here” (and format it using these instructions) the format string uses its own little language syntax the format specifier the only required specifier is for type what happens if i have more than one argument? so much for numbers, what about dates? working with dates moving backward and forward in time getting an object that extends calendar working with calendar objects highlights of the calendar api even more statics!... static imports chapter 11 exception handling: risky behavior let’s make a music machine we’ll start with the basics first we need a sequencer the compiler needs to know that you know you’re calling a risky method an exception is an object... of type exception if it’s your code that catches the exception, then whose code throws it? flow control in try/catch blocks finally: for the things you want to do no matter what did we mention that a method can throw more than one exception? exceptions are polymorphic multiple catch blocks must be ordered from smallest to biggest you can’t put bigger baskets above smaller baskets when you don’t want to handle an exception... ducking (by declaring) only delays the inevitable getting back to our music code... making actual sound your very first sound player app making a midievent (song data) midi message: the heart of a midievent change a message chapter 12 getting gui: a very graphic story it all starts with a window your first gui: a button on a frame but nothing happens when i click it... getting a user event listeners, sources, and events getting back to graphics... make your own drawing widget fun things to do in paintcomponent() behind every good graphics reference is a graphics2d object because life’s too short to paint the circle a solid color when there’s a gradient blend waiting for you we can get an event. we can paint graphics. but can we paint graphics when we get an event? gui layouts: putting more than one widget on a frame let’s try it with two buttons so now we need four widgets and we need to get two events inner class to the rescue! an inner class instance must be tied to an outer class instancethere’s an exception to this, for a very special case—an inner class defined within a static method. but we’re not going there, and you might go your entire java life without ever encountering one of these. how to make an instance of an inner class using an inner class for animation listening for a non-gui event an easier way to make messages / events chapter 13 using swing: work on your swing swing components layout managers how does the layout manager decide? the big three layout managers: border, flow, and box playing with swing components making the beatbox chapter 14 serialization and file i/o: saving objects capture the beat saving state writing a serialized object to a file data moves in streams from one place to another what really happens to an object when it’s serialized? but what exactly is an object’s state? what needs to be saved? if you want your class to be serializable, implement serializable deserialization: restoring an object what happens during deserialization? saving and restoring the game characters writing a string to a text file text file example: e-flashcards quiz card builder (code outline) the java.io.file class reading from a text file quiz card player (code outline) parsing with string split() version id: a big serialization gotcha using the serialversionuid saving a beatbox pattern restoring a beatbox pattern chapter 15 networking and threads: make a connection real-time beat box chat connecting, sending, and receiving make a network socket connection a tcp port is just a number. a 16-bit number that identifies a specific program on the server to read data from a socket, use a bufferedreader to write data to a socket, use a printwriter the dailyadviceclient dailyadviceclient code writing a simple server dailyadviceserver code writing a chat client java has multiple threads but only one thread class what does it mean to have more than one call stack? every thread needs a job to do. a method to put on the new thread stack to make a job for your thread, implement the runnable interface the thread scheduler putting a thread to sleep using sleep to make our program more predictable making and starting two threads what will happen? um, yes. there is a dark side the ryan and monica problem, in code we need the makewithdrawal ( ) method to run as one atomic thing using an object’s lock the dreaded “lost update” problem let’s run this code... make the increment() method atomic. synchronize it! the deadly side of synchronization new and improved simplechatclient the really really simple chat server chapter 16 collections and generics: data structures tracking song popularity on your jukebox here’s what you have so far, without the sort: but the arraylist class does not have a sort() method! arraylist is not the only collection you could use a treeset... or you could use the collections.sort() method adding collections.sort() to the jukebox code but now you need song objects, not just simple strings changing the jukebox code to use songs instead of strings it won’t compile! generics means more type-safety learning generics using generic classes using type parameters with arraylist using generic methods here’s where it gets weird... revisiting the sort( ) method in generics, “extends” means “extends or implements” finally we know what’s wrong... the new, improved, comparable song class we can sort the list, but... using a custom comparator updating the jukebox to use a comparator uh-oh. the sorting all works, but now we have duplicates... we need a set instead of a list the collection api (part of it) using a hashset instead of arraylist what makes two objects equal? how a hashset checks for duplicates: hashcode() and equals() the song class with overridden hashcode() and equals() and if we want the set to stay sorted, we’ve got treeset what you must know about treeset... treeset elements must be comparable we’ve seen lists and sets, now we’ll use a map finally, back to generics using polymorphic arguments and generics but will it work with arraylist ? what could happen if it were allowed... wildcards to the rescue alternate syntax for doing the same thing chapter 17 package, jars and deployment: release your code deploying your application imagine this scenario... separate source code and class files put your java in a jar running (executing) the jar put your classes in packages! preventing package name conflicts compiling and running with packages the -d flag is even cooler than we said making an executable jar with packages so where did the manifest file go? java web start the .jnlp file chapter 18 remote deployment with rmi: distributed computing method calls are always between two objects on the same heap what if you want to invoke a method on an object running on another machine? object a, running on little, wants to call a method on object b, running on big but you can’t do that the role of the ‘helpers’ java rmi gives you the client and service helper objects! how does the client get the stub object? how does the client get the stub class? be sure each machine has the class files it needs yeah, but who really uses rmi? appendix final code kitchen final beatbox client program final beatbox server program appendix the top ten topics that almost made it into the real book... #10 bit manipulation #9 immutability #8 assertions #7 block scope #6 linked invocations #5 anonymous and static nested classes #4 access levels and access modifiers (who sees what) #3 string and stringbuffer/stringbuilder methods #2 multidimensional arrays and the number one topic that didn’t quite make it in... #1 enumerations (also called enumerated types or enums) appendix this isn’t goodbye.

Author : Kathy sierra, bert bates
Publication : Oreilly
Isbn : 9788173666025
Store book number : 105
NRS 1920.00
  
Order This Book
*Marked Field Is Necessary
Your Name: *
Your Address:
Your Email: *
Your Cell Phone:
Your Work Phone:
Quantity: *
Total:
Message (if any)
Security code: *
Case Sensitive
 
 
Packt publication
Microsoft press
Wrox
Bpb
Phi
Dreamtech press
Sybex
Wiley
Tata
Oreilly
Macmilan
Vikas
Apress
Spd
Pearson
Cambridge
Oxford
Idg
Charles river media
Murach
Niit
Black book
Bible
Elsevier
Sk kataria
Pragmatic bookshelf
Fusion books
 
 
HEAD FIRST GO: A BRAIN-FRIENDLY GUIDE
NRS 2400.00
 
 
Professional ASP.NET MVC 4
Mastering Microsoft Exchange ...
Android Hacker's Handbook
CCNA Cisco Certified Network ...
Windows Phone 7 Application ...
Beginning Drupal (Wrox Progr ...
Troubleshooting Windows 7 In ...
 More>>
 
All Right Reserved © bookplus.com.np 2008