Muutke küpsiste eelistusi

E-raamat: Java All-in-One For Dummies

4.01/5 (164 hinnangut Goodreads-ist)
  • Formaat: EPUB+DRM
  • Ilmumisaeg: 14-Aug-2020
  • Kirjastus: For Dummies
  • Keel: eng
  • ISBN-13: 9781119680512
Teised raamatud teemal:
  • Formaat - EPUB+DRM
  • Hind: 27,29 €*
  • * 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.
Java All-in-One For DummiesSuurem pilt
  • Formaat: EPUB+DRM
  • Ilmumisaeg: 14-Aug-2020
  • Kirjastus: For Dummies
  • Keel: eng
  • ISBN-13: 9781119680512
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. 

Java—from first steps to first apps

Knowing Java is a must-have programming skill for any programmer. It’s used in a wide array of programming projects—from enterprise apps and mobile apps to big data, scientific, and financial uses. The language regularly ranks #1 in surveys of the most popular language based on number of developers, lines of code written, and real-world usage. It’s also the language of choice in AP Computer Science classes taught in the U.S. 

This guide provides an easy-to-follow path from understanding the basics of writing Java code to applying those skills to real projects. Split into eight minibooks covering core aspects of Java, the book introduces the basics of the Java language and object-oriented programming before setting you on the path to building web apps and databases.

• Get up to speed on Java basics

• Explore object-oriented programming

• Learn about strings, arrays, and collections

• Find out about files and databases

Step-by-step instructions are provided to ensure that you don't get lost at any point along the way.

Introduction 1(4)
About This Book
2(1)
Foolish Assumptions
2(1)
Icons Used in This Book
3(1)
Beyond the Book
4(1)
Where to Go from Here
4(1)
BOOK 1 JAVA BASICS
5(36)
Chapter 1 Welcome to Java
1(18)
What Is Java, and Why Is It So Great?
8(3)
Platform independence
8(1)
Object orientation
9(1)
The Java API
10(1)
The Internet
10(1)
Java versus Other Languages
11(1)
Important Features of the Java Language
12(3)
Type checking
13(1)
Exception handling
14(1)
On the Downside: Java's Weaknesses
15(1)
Java Version Insanity
16(2)
What's in a Name?
18(1)
Chapter 2 Installing and Using Java Tools
19(14)
Downloading and Installing the Java Development Kit
20(4)
Downloading the JDK
20(1)
Installing the JDK
21(1)
Perusing the JDK folders
21(1)
Setting the path
22(2)
Usingjava's Command-Line Tools
24(6)
Compiling a program
24(1)
Compiling more than one file
25(1)
Usingjava compiler options
26(2)
Running a Java program
28(1)
Using thejavap command
28(2)
Using Java Documentation
30(3)
Chapter 3 Working with TextPad
33(8)
Downloading and Installing TextPad
33(2)
Editing Source Files
35(2)
Compiling a Program
37(1)
Running a Java Program
38(3)
BOOK 2 PROGRAMMING BASICS
41(198)
Chapter 1 Java Programming Basics
43(20)
Looking at the Infamous Hello, World! Program
44(3)
Dealing with Keywords
47(2)
Working with Statements
49(3)
Types of statements
49(1)
White space
50(2)
Working with Blocks
52(1)
Creating Identifiers
53(1)
Crafting Comments
54(2)
End-of-line comments
54(1)
Traditional comments
54(1)
JavaDoc comments
55(1)
Introducing Object-Oriented Programming
56(5)
Understanding classes and objects
56(1)
Understanding static methods
56(1)
Creating an object from a class
57(1)
Viewing a program that uses an object
58(2)
So whafs the difference?
60(1)
Importing Java API Classes
61(2)
Chapter 2 Working with Variables and Data Types
63(36)
Declaring Variables
64(4)
Declaring two or more variables in one statement
65(1)
Declaring class variables
65(1)
Declaring instance variables
66(1)
Declaring local variables
67(1)
Initializing Variables
68(2)
Initializing variables with assignment statements
69(1)
Initializing variables with initializers
70(1)
Using Final Variables (Constants)
70(1)
Working with Primitive Data Types
71(10)
Integer types
72(2)
Floating-point types
74(2)
The char type
76(1)
The Boolean type
77(1)
Using wrapper classes
78(1)
Using reference types
78(2)
Using inferred variable types
80(1)
Working with Strings
81(4)
Declaring and initializing strings
82(1)
Combining strings
82(1)
Converting primitives to strings
83(1)
Converting strings to primitives
84(1)
Converting and Casting Numeric Data
85(2)
Automatic conversions
85(1)
Type casting
86(1)
Thinking Inside the Box
87(1)
Understanding Scope
87(2)
Shadowing Variables
89(1)
Printing Data with System.out
90(3)
Using standard input and output streams
91(1)
Using System.out and System.err
92(1)
Getting Input with the Scanner Class
93(3)
Importing the Scanner class
94(1)
Declaring and creating a Scanner object
94(1)
Getting input
94(2)
Getting Input with the JOptionPane Class
96(2)
Using enum to Create Your Own Data Types
98(1)
Chapter 3 Working with Numbers and Expressions
99(30)
Working with Arithmetic Operators
99(3)
Dividing Integers
102(2)
Combining Operators
104(1)
Using the Unary Plus and Minus Operators
105(1)
Using Increment and Decrement Operators
106(2)
Using the Assignment Operator
108(2)
Using Compound Assignment Operators
110(1)
Using the Math Class
111(10)
Using constants of the Math class
112(1)
Working with mathematical functions
113(3)
Creating random numbers
116(3)
Rounding functions
119(2)
Formatting Numbers
121(2)
Recognizing Weird Things about Java Math
123(6)
Integer overflow
123(1)
Floating-point weirdness
124(1)
Division by zero
125(4)
Chapter 4 Making Choices
129(22)
Using Simple Boolean Expressions
130(2)
Using if Statements r.
132(10)
Simple if statements
132(3)
if-else statements
135(1)
Nested if statements
136(4)
else-if statements
140(2)
Using Mr. Spock's Favorite Operators (Logical Ones, of Course)
142(6)
Using the ! operator
142(2)
Using the & and && operators
144(1)
Using the | and || operators
145(1)
Using the A operator
146(1)
Combining logical operators
147(1)
Using the Conditional Operator
148(1)
Comparing Strings
149(2)
Chapter 5 Going Around in Circles (Or, Using Loops)
151(28)
Using Your Basic while Loop
152(2)
The while statement
152(1)
A counting loop
152(2)
Breaking Out of a Loop
154(1)
Looping Forever
154(4)
Letting the user decide when to quit
156(1)
Letting the user decide in another way
157(1)
Using the continue Statement
158(1)
Running do-while Loops
159(2)
Validating Input from the User
161(3)
Using the Famous for Loop
164(9)
Understanding the formal format of the for loop
164(2)
Scoping out the counter variable
166(1)
Counting even numbers
167(1)
Counting backward
168(1)
Using for loops without bodies
169(1)
Ganging up your expressions
170(2)
Omitting expressions
172(1)
Breaking and continuing your for loops
172(1)
Nesting Your Loops
173(6)
A simple nested for loop
174(1)
A guessing game
174(5)
Chapter 6 Pulling a Switcheroo
179(18)
Battling else-if Monstrosities
179(4)
Viewing an example else-if program
180(1)
Creating a better version of the example program
181(2)
Using the switch Statement
183(4)
Viewing a boring switch example, complete with flowchart
184(2)
Putting if statements inside switch statements
186(1)
Creating Character Cases
187(1)
Intentionally Leaving Out a Break Statement
188(4)
Switching with Strings
192(1)
Enhanced Switch Features with Java 13
193(4)
Chapter 7 Adding Some Methods to Your Madness
197(20)
The Joy of Methods
198(1)
The Basics of Making Methods
198(5)
An example
200(1)
Another example
201(2)
Methods That Return Values
203(7)
Declaring the method's return type
203(1)
Using the return statement to return the value
204(1)
Using a method that returns a type
205(1)
You gotta have a proper return statement
205(2)
Trying another version of theguessing-game program
207(3)
Methods That Take Parameters
210(7)
Declaring parameters
211(1)
Scoping out parameters
212(1)
Understanding pass-by-value
213(1)
Trying yet another version of the guessing-game program
214(3)
Chapter 8 Handling Exceptions
217(22)
Understanding Exceptions
218(3)
Witnessing an exception
219(1)
Finding the culprit
220(1)
Catching Exceptions
221(3)
A simple example
222(1)
Another example
222(2)
Handling Exceptions with a Preemptive Strike
224(2)
Catching All Exceptions at Once
226(1)
Displaying the Exception Message
227(1)
Using a finally Block
228(3)
Handling Checked Exceptions
231(5)
Viewing the catch-or-throw compiler error
232(1)
Catching FileNotFoundException
232(1)
Throwing the FileNotFoundException
233(1)
Throwing an exception from main
234(1)
Swallowing exceptions
234(2)
Throwing Your Own Exceptions
236(3)
BOOK 3 OBJECT-ORIENTED PROGRAMMING
239(142)
Chapter 1 Understanding Object-Oriented Programming
241(14)
What Is Object-Oriented Programming?
242(1)
Understanding Objects
243(4)
Objects have identity
243(1)
Objects have type
244(1)
Objects have state
245(1)
Objects have behavior
246(1)
Understanding the Life Cycle of an Object
247(1)
Working with Related Classes
248(2)
Inheritance
248(1)
Interfaces
249(1)
Designing a Program with Objects
250(1)
Diagramming Classes with UML
251(4)
Drawing classes
252(1)
Drawing arrows
253(2)
Chapter 2 Making Your Own Classes
255(20)
Declaring a Class
256(3)
Picking class names
256(1)
Knowing what goes in the class body
257(1)
Seeing where classes go
258(1)
Working with Members
259(2)
Understanding fields
259(1)
Understanding instance methods
260(1)
Understanding visibility
261(1)
Using Getters and Setters
261(3)
Overloading Methods
264(2)
Creating Constructors
266(4)
Creating basic constructors
266(1)
Creating default constructors
267(1)
Calling other constructors
268(2)
Finding More Uses for the this Keyword
270(1)
Using Initializers
271(2)
Using Records
273(2)
Chapter 3 Working with Statics
275(10)
Understanding Static Fields and Methods
275(1)
Working with Static Fields
276(1)
Using Static Methods
277(1)
Counting Instances
278(3)
Preventing Instances
281(1)
Using Static Initializers
282(3)
Chapter 4 Using Subclasses and Inheritance
285(22)
Introducing Inheritance
285(4)
Motorcycles, trains, and automobiles
287(1)
Game play
287(1)
A businesslike example
288(1)
Inheritance hierarchies
288(1)
Creating Subclasses
289(2)
Overriding Methods
291(1)
Protecting Your Members
292(1)
Using this and super in Your Subclasses
293(1)
Understanding Inheritance and Constructors
294(1)
Using final
295(2)
Final methods
296(1)
Final classes
296(1)
Casting Up and Down
297(2)
Determining an Objects Type
299(1)
Poly What?
300(2)
Creating Custom Exceptions
302(5)
Tracing the Throwable hierarchy
302(2)
Creating an exception class
304(1)
Throwing a custom exception
305(2)
Chapter 5 Using Abstract Classes and Interfaces
307(16)
Using Abstract Classes
307(3)
Using Interfaces
310(4)
Creating a basic interface
311(1)
Implementing an interface
312(1)
Using an interface as a type
313(1)
More Things You Can Do with Interfaces
314(6)
Adding fields to an interface
314(1)
Extending interfaces
315(1)
Using interfaces for callbacks
316(4)
Using Additional Interface Method Types
320(3)
Chapter 6 Using the Object and Class Classes
323(26)
The Mother of All Classes: Object
323(4)
Every object is an Object
324(1)
Object as a type
324(1)
Methods of the Object class
325(1)
Primitives aren't objects
326(1)
The toString Method
327(3)
Using toString
327(1)
Overriding toString
328(2)
The equals Method
330(6)
Using equals
331(1)
Overriding the equals method
332(4)
The clone Method
336(10)
Implementing the clone method
336(3)
Using clone to create a shallow copy
339(2)
Creating deep copies
341(5)
The Class Class
346(3)
Chapter 7 Using Inner Classes, Anonymous Classes, and Lambda Expressions
349(12)
Declaring Inner Classes
350(4)
Understanding inner classes
350(1)
Viewing an example
351(3)
Using Static Inner Classes
354(1)
Using Anonymous Inner Classes
355(4)
Creating an anonymous class
356(1)
Creating a program with an anonymous class
357(2)
Using Lambda Expressions
359(2)
Chapter 8 Working with Packages and the Java Module System
361(20)
Working with Packages
362(4)
Importing classes and packages
362(1)
Creating your own packages
363(2)
An example
365(1)
Putting Your Classes in a JAR File
366(4)
jar command-line options
366(1)
Archiving a package
367(1)
Adding a jar to your classpath
368(1)
Running a program directly from an archive
369(1)
Using Javadoc to Document Your Classes
370(5)
Adding Javadoc comments
371(2)
Using the javadoc command
373(1)
Viewing Javadoc pages
374(1)
Using the Java Module System
375(6)
Understanding modules
376(1)
The module-info.java file
377(1)
Setting up folders for a module
378(1)
Compiling a module
379(1)
Creating a modular JAR file
379(1)
Running a modular JAR file
380(1)
BOOK 4 STRINGS, ARRAYS, AND COLLECTIONS
381(100)
Chapter 1 Working with Strings
383(18)
Reviewing Strings
384(2)
Using the String Class
386(9)
Finding the length of a string
388(1)
Making simple string modifications
389(1)
Extracting characters from a string
389(1)
Extracting substrings from a string
390(2)
Splitting a string
392(2)
Replacing parts of a string
394(1)
Using the StringBuilder and StringBuffer Classes
395(4)
Creating a StringBuilder object
396(1)
Using StringBuilder methods
396(2)
Viewing a StringBuilder example
398(1)
Using the CharSequence Interface
399(2)
Chapter 2 Using Arrays
401(44)
Understanding Arrays
401(1)
Creating Arrays
402(2)
Initializing an Array
404(1)
Using for Loops with Arrays
404(1)
Solving Homework Problems with Arrays
405(3)
Using the Enhanced for Loop
408(1)
Using Arrays with Methods
409(1)
Using Varargs
410(1)
Using Two-Dimensional Arrays
411(6)
Creating a two-dimensional array
412(1)
Accessing two-dimensional array elements
413(1)
Initializing a two-dimensional array
414(1)
Using jagged arrays
415(1)
Going beyond two dimensions
416(1)
Working with a Fun but Complicated Example: A Chessboard
417(8)
Using the Arrays Class
425(6)
Filling an array
426(1)
Copying an array
427(1)
Sorting an array
428(1)
Searching an array
429(1)
Comparing arrays
429(1)
Converting arrays to strings
430(1)
Chapter 3 Using the Array List Class
431(1)
Understanding the ArrayList Class
432(3)
Creating an ArrayList Object
435(1)
Adding Elements
436(1)
Accessing Elements
437(1)
Printing an ArrayList
438(1)
Using an Iterator
438(2)
Updating Elements
440(2)
Deleting Elements
442(3)
Chapter 4 Using the LinkedList Class
445(12)
Understanding the LinkedList Class
446(4)
Creating a LinkedList
450(1)
Adding Items to a LinkedList
450(2)
Retrieving Items from a LinkedList
452(2)
Updating LinkedList Items
454(1)
Removing LinkedList Items
455(2)
Chapter 5 Creating Generic Collection Classes
457(14)
Why Generics?
458(1)
Creating a Generic Class
459(2)
A Generic Stack Class
461(3)
Using Wildcard-Type Parameters
464(2)
A Generic Queue Class
466(5)
Chapter 6 Using Bulk Data Operations with Collections
471(10)
Looking At a Basic Bulk Data Operation
473(2)
Looking Closer at the Stream Interface
475(3)
Using Parallel Streams
478(3)
BOOK 5 PROGRAMMING TECHNIQUES
481(132)
Chapter 1 Programming Threads
483(28)
Understanding Threads
484(1)
Creating a Thread
485(3)
Understanding the Thread class
485(1)
Extending the Thread class
486(2)
Creating and starting a thread
488(1)
Implementing the Runnable Interface
488(5)
Using the Runnable interface
489(1)
Creating a class that implements Runnable
489(2)
Using the CountDownApp class
491(2)
Creating Threads That Work Together
493(4)
Using an Executor
497(2)
Synchronizing Methods
499(4)
Creating a Lock
503(2)
Coping with Threadus Interruptus
505(6)
Finding out whether you've been interrupted
505(1)
Aborting the countdown
506(5)
Chapter 2 Using Regular Expressions
511(18)
Creating a Program for Experimenting with Regular Expressions
512(3)
Performing Basic Character Matching
515(9)
Matching single characters
515(1)
Using predefined character classes
515(3)
Using custom character classes
518(1)
Using ranges
519(1)
Using negation
520(1)
Matching multiple characters
520(1)
Using escapes
521(1)
Using parentheses to group characters
522(1)
Using the pipe symbol
523(1)
Using Regular Expressions in Java Programs
524(5)
Understanding the String problem
524(1)
Using regular expressions with the String class
525(1)
Using the Pattern and Matcher classes
526(3)
Chapter 3 Using Recursion
529(16)
Calculating the Classic Factorial Example
529(3)
The nonrecursive solution
530(1)
The recursive solution
530(2)
Displaying Directories
532(4)
Writing Your Own Sorting Routine
536(9)
Understanding how Quicksort works
536(1)
Using the sort method
537(1)
Using the partition method
538(2)
Putting it all together
540(5)
Chapter 4 Working with Dates and Times
545(22)
Pondering How Time is Represented
546(1)
Picking the Right Date and Time Class for Your Application
547(1)
Using the now Method to Create a Date-Time Object
548(2)
Using the parse Method to Create a Date-Time Object
550(1)
Using the of Method to Create a Date-Time Object
551(3)
Using the Month enumeration
552(1)
Using the Zoneld class
553(1)
Using the ZoneOffset class
554(1)
Looking Closer at the LocalDate Class
554(2)
Extracting Information About a Date
556(1)
Comparing Dates
557(1)
Calculating with Dates
558(2)
Formatting Dates
560(2)
Looking at a Fun Birthday Calculator
562(5)
Chapter 5 IoT Programming with Raspberry Pi
567(46)
Introducing the Raspberry Pi
568(2)
Setting Up a Raspberry Pi
570(1)
InstallingJava on a Raspberry Pi
571(1)
Installing the Pi4J Library
572(1)
Configuring the Geany Integrated Development Environment for Java Development
572(2)
Examining GPIO Ports
574(2)
Connecting an LED to a GPIO Port
576(5)
Building a Raspberry Pi LED Circuit
581(1)
Parts
581(1)
Steps
582(1)
Examining the Pi4J Library
582(1)
Importing GPIO Types
583(1)
Instantiating a GpioController
584(1)
Provisioning GPIO Pins
584(3)
Controlling the Pin State
587(2)
The Morse Code Program
589(4)
The Cylon Eyes Program
593(5)
Assembling the Cylon Eyes circuit
593(3)
Running the Cylon Eyes program
596(2)
Working with Input Pins
598(6)
Understanding active-high and active-low inputs
599(1)
Provisioning a digital input
600(1)
Reading the state of a digital input pin
601(1)
Building a circuit with a digital input pin
602(2)
Running the Button Switcher Program
604(2)
Finding a Better Way to Handle Input Events
606(7)
Crafting a state change event listener
607(1)
Adding an event handler to a pin
608(1)
Using automatic debounce
609(1)
Working with the EventSwitcher program
610(3)
BOOK 6 JAVAFX
613(138)
Chapter 1 Hello, JavaFX!
615(22)
Perusing the Possibilities of JavaFX
616(2)
Getting Ready to Run JavaFX
618(2)
Looking at a Simple JavaFX Program
620(2)
Importing JavaFX Packages
622(1)
Extending the Application Class
623(1)
Launching the Application
624(1)
Overriding the start Method
625(1)
Creating a Button
626(1)
Handling an Action Event
627(2)
Creating a Layout Pane
629(1)
Making a Scene
630(1)
Setting the Stage
631(1)
Examining the Click Counter Program
632(5)
Chapter 2 Handling Events
637(18)
Examining Events
638(1)
Handling Events
639(2)
Implementing the EventHandler Interface
641(3)
Handling Events with Inner Classes
644(3)
Handling Events with Anonymous Inner Classes
647(2)
Using Lambda Expressions to Handle Events
649(6)
Chapter 3 Setting the Stage and Scene Layout
655(22)
Examining the Stage Class
656(3)
Examining the Scene Class
659(2)
Switching Scenes
661(5)
Creating an Alert Box
666(4)
Exit, Stage Right
670(7)
Creating a Close button
671(1)
Handling the CloseRequest event
672(2)
Putting it all together
674(3)
Chapter 4 Using Layout Panes to Arrange Your Scenes
677(32)
Working with Layout Panes
678(2)
Introducing five JavaFX layout panes
678(1)
Creating layout panes
679(1)
Combining layout panes
680(1)
Using the HBox Layout
680(2)
Spacing Things Out
682(2)
Adding Space with Margins
684(1)
Adding Space by Growing Nodes
685(2)
Using the VBox Layout
687(2)
Aligning Nodes in a Layout Pane
689(1)
Using the Flow Layout
690(4)
Using the Border Layout
694(3)
Using the GridPane Layout
697(12)
Sketching out a plan
697(1)
Creating a grid pane
698(3)
Working with grid pane constraints
701(2)
Examining a grid pane example
703(6)
Chapter 5 Getting Input from the User
709(16)
Using Text Fields
710(7)
Validating Numeric Data
717(2)
Using Check Boxes
719(2)
Using Radio Buttons
721(4)
Chapter 6 Choosing from a List
725(26)
Using Choice Boxes
725(4)
Creating a choice box
727(1)
Setting a default value
728(1)
Getting the selected item
729(1)
Working with Observable Lists
729(3)
Listening for Selection Changes
732(2)
Using Combo Boxes
734(4)
Creating combo boxes
735(1)
Getting the selected item
736(1)
Handling combo box events
737(1)
Using List Views
738(2)
Creating a list view
739(1)
Getting the selected items
740(1)
Using Tree Views
740(11)
Building a tree
742(3)
Creating a TreeView control
745(1)
Getting the selected node
746(2)
Looking at a complete program that uses a tree view
748(3)
BOOK 7 WEB PROGRAMMING
751
Chapter 1 Creating Servlets
753(22)
Understanding Servlets
753(2)
Using Tomcat
755(2)
Installing Tomcat
755(1)
Testing Tomcat
756(1)
Creating a Simple Servlet
757(7)
Creating the folder structure for a servlet
758(1)
Creating the web.xml file
758(2)
Importing the servlet packages
760(1)
Extending the HttpServlet class
760(1)
Printing to a web page
761(1)
Responding with HTML
762(2)
Running a Servlet
764(1)
Improving the HelloWorld Servlet
765(2)
Getting Input from the User
767(2)
Working with forms
767(1)
Using the InputServlet servlet
768(1)
Using Classes in a Servlet
769(6)
Chapter 2 Using JavaServerPages
775(22)
Understanding JavaServer Pages
776(2)
Using UEL Expressions
778(4)
Unified Expression Language
778(2)
JSP Standard Tag Library
780(2)
Looking at Core Tags
782(4)
Using c:out
783(1)
Working with variables
783(1)
Getting conditional
784(1)
Creating loops
785(1)
Formatting Numbers
786(2)
Considering the Controller Servlet
788(2)
Setting request attributes
788(1)
Redirecting to the JSP page
789(1)
The ListMovies Application Meets JSP
790(7)
Chapter 3 Using JavaBeans
797(18)
Getting to Know JavaBeans
797(2)
Looking Over a Sample Bean
799(2)
Using Beans with JSP Pages
801(5)
Creating bean instances
802(1)
Getting property values
803(1)
Setting property values
803(1)
Viewing a JSP page that uses a bean
804(2)
Scoping Your Beans
806(9)
A shopping cart application
807(1)
The shopping cart page
808(2)
The BookCart JavaBean
810(5)
Chapter 4 Using HttpClient
815
Understanding HTTP
815(7)
Diving into HTTP
817(5)
Looking at a simple HTTP exchange
822(1)
Getting Started with Java's HTTP Client Library
822(7)
HttpClient
823(1)
HttpRequest
824(3)
HttpResponse
827(1)
Using the send method
828(1)
Putting It All Together
829(2)
The HTTP Tester Program
831
Index 835
Doug Lowe began writing computer books before Java was invented. He's covered dinosaurs such as COBOL, FORTRAN, and IBM mainframe computers, as well as web programming, Microsoft PowerPoint, and networking. Doug has written more than 30 For Dummies computer guides.
Lisainfo e-raamatute kohta Lisainfo e-raamatute kohta
Püsilink: https://www.kriso.ee/db/97811196805126e.html
Märksõnad: