Úplné zobrazení záznamu

Toto je statický export z katalogu ze dne 30.06.2018. Zobrazit aktuální podobu v katalogu.

Bibliografická citace

.
0 (hodnocen0 x )
BK
AKVIZICE
McGraw-Hill Education, 2017.


ISBN 978-1259589331
001463043
Contents at a Glance // Parti The Java Language // 1 The History and Evolution of Java 3 // 2 An Overview of Java 19 // 3 Data Types, Variables, and Arrays 37 // 4 Operators 63 // 5 Control Statements 83 // 6 Introducing Classes 111 // 7 A Closer Look at Methods and Classes 131 // 8 Inheritance 163 // 9 Packages and Interfaces 189 // 10 Exception Handling 217 // 11 Multithreaded Programming 237 // 12 Enumerations, Autoboxing, and Annotations 267 // 13 I/O, Try-with-Resources, and Other Topics 305 // 14 Generics 335 // 15 Lambda Expressions 379 // 16 Modules 409 // Part II The Java Library // 17 String Handling 439 // 18 Exploring java.lang 467 // 19 java.util Part 1: The Collections Framework 527 // 20 java.util Part 2: More Utility Classes 609 // 21 Input/Output: Exploring java.io 669 // 22 Exploring NIO 717 // 23 Networking 749 // 24 Event Handling 769 // 25 Introducing the AWT: Working with // Windows, Graphics, and Text 801 // 26 Using AWT Controls, Layout Managers, and Menus 829 // 27 Images 879 // 28 The Concurrency Utilities 905 // 29 The Stream API 955 // 30 Regular Expressions and Other Packages 981 // v // VÍ Java: The Complete Reference // Part III // 31 // 32 // 33 // Part IV // 34 // 35 // 36 // PartV // 37 // 38 // Part VI // A // ? // C // D // Introducing GUI Programming with Swing // Introducing Swing 1011 // Exploring Swing 1029 // Introducing Swing Menus 1059 // Introducing GUI Programming with JavaFX // Introducing JavaFX GUI Programming 1095 // Exploring
JavaFX Controls 1115 // Introducing JavaFX Menus 1161 // Applying Java // Java Beans 1189 // Introducing Servlets 1201 // Appendixes // Using Javas Documentation Comments 1227 // An Overview of Java Web Start 1235 // Introducing JShell 1245 // Applet Basics 1255 // Index 1263 // Contents // Preface... // Part I The Java Language // Chapter 1 The History and Evolution of Java...3 // Javas Lineage... // The Birth of Modern Programming: C...4 // C++: The Next Step...5 // The Stage Is Set for Java...6 // The Creation of Java...6 // The C# Connection...8 // How Java Impacted the Internet...8 // Java Applets... // Security...9 // Portability...9 // Java’s Magic: The Bytecode...? // Moving Beyond Applets...? // Servlets: Java on the Server Side...11 // The Java Buzzwords...12 // Simple... // Object-Oriented...12 // Robust... // Multithreaded...I3 // Architecture-Neutral...13 // Interpreted and High Performance...13 // Distributed... // Dynamic... // The Evolution of Java...14 // Java SE 9...ly // A Culture of Innovation...18 // Chapter 2 An Overview of Java... // Object-Oriented Programming...19 // Two Paradigms...I9 // Abstraction...20 // The Three OOP Principles...20 // viii Java: The Complete Reference // A First Simple Program...25 // Entering the Program...25 // Compiling the Program...25 // A Closer Look at the First Sample Program...26 // A Second Short Program...28 // Two Control Statements...30 // The if Statement...30 // The for Loop...31 // Using Blocks of Code...32 // Lexical
Issues...34 // Whitespace...34 // Identifiers...34 // Literals...34 // Comments...34 // Separators...35 // The Java Keywords...35 // The Java Class Libraries...36 // Chapter 3 Data Types, Variables, and Arrays...37 // Java Is a Strongly Typed Language...37 // The Primitive Types...37 // Integers...38 // byte...38 // short...39 // int...39 // long...39 // Floating-Point Types // float... // double... // Characters...41 // Booleans...42 // A Closer Look at Literals...43 // Integer Literals...43 // Floating-Point Literals...44 // Boolean Literals...45 // Character Literals...45 // String Literals...46 // Variables...46 // Declaring a Variable...46 // Dynamic Initialization...47 // The Scope and Lifetime of Variables...47 // Type Conversion and Casting...50 // Java’s Automatic Conversions...50 // Casting Incompatible Types...50 // Automatic Type Promotion in Expressions...52 // The Type Promotion Rules...52 // č é č // Contents // Arrays...53 // One-Dimensional Arrays...53 // Multidimensional Arrays...56 // Alternative Array Declaration Syntax...60 // A Few Words About Strings...60 // Chapter 4 Operators...63 // Arithmetic Operators...63 // The Basic Arithmetic Operators...64 // The Modulus Operator...65 // Arithmetic Compound Assignment Operators...65 // Increment and Decrement...66 // The Bitwise Operators...68 // The Bitwise Logical Operators...69 // The Left Shift...71 // The Right Shift...73 // The Unsigned Right Shift...74 // Bitwise Operator Compound Assignments...75
Relational Operators...76 // Boolean Logical Operators...77 // Short-Circuit Logical Operators...79 // The Assignment Operator...79 // The ? Operator...80 // Operator Precedence...81 // Using Parentheses...81 // Chapter 5 Control Statements...83 // Java’s Selection Statements...83 // if ...83 // switch...86 // Iteration Statements...91 // while...91 // do-while...92 // for...95 // The For-Each Version of the for Loop...99 // Nested Loops...103 // Jump Statements...104 // Using break...104 // Using continue...108 // Chapter 6 Introducing Classes...Ill // Class Fundamentals...Ill // The General Form of a Class...Ill // A Simple Class...112 // Declaring Objects...115 // A Closer Look at new...115 // X Java: The Complete Reference // Assigning Object Reference Variables...116 // Introducing Methods...117 // Adding a Method to the Box Class...118 // Returning a Value...120 // Adding a Method That Takes Parameters...121 // Constructors...123 // Parameterized Constructors...125 // The this Keyword...126 // Instance Variable Hiding...127 // Garbage Collection...127 // A Stack Class...128 // Chapter 7 A Closer Look at Methods and Classes...131 // Overloading Methods...131 // Overloading Constructors...134 // Using Objects as Parameters...136 // A Closer Look at Argument Passing...138 // Returning Objects...140 // Recursion...141 // Introducing Access Control...143 // Understanding static...147 // Introducing final...148 // Arrays Revisited...149 // Introducing Nested and Inner Classes...151
// Exploring the String Class...154 // Using Command-Line Arguments...156 // Varargs: Variable-Length Arguments...157 // Overloading Vararg Methods...160 // Varargs and Ambiguity...161 // Chapter 8 Inheritance...163 // Inheritance Basics...163 // Member Access and Inheritance...165 // A More Practical Example...166 // A Superclass Variable Can Reference a Subclass Object...168 // Using super...169 // Using super to Call Superclass Constructors...169 // A Second Use for super...172 // Creating a Multilevel Hierarchy...173 // When Constructors Are Executed...176 // Method Overriding...177 // Dynamic Method Dispatch...180 // Why Overridden Methods?...181 // Applying Method Overriding...182 // Contents Xi // Using Abstract Classes...183 // Using final with Inheritance...186 // Using final to Prevent Overriding...186 // Using final to Prevent Inheritance...187 // The Object Class...187 // Chapter 9 Packages and Interfaces...189 // Packages...189 // Defining a Package...190 // Finding Packages and CLASSPATH...190 // A Short Package Example...191 // Packages and Member Access...192 // An Access Example...193 // Importing Packages...196 // Interfaces...198 // Defining an Interface...199 // Implementing Interfaces...200 // Nested Interfaces...202 // Applying Interfaces...203 // Variables in Interfaces...206 // Interfaces Can Be Extended...208 // Default Interface Methods...209 // Default Method Fundamentals...210 // A More Practical Example...212 // Multiple Inheritance Issues...212
Use static Methods in an Interface...213 // Private Interface Methods...214 // Final Thoughts on Packages and Interfaces...215 // Chapter 10 Exception Handling...217 // Exception-Handling Fundamentals...217 // Exception Types...218 // Uncaught Exceptions...219 // Using try and catch...220 // Displaying a Description of an Exception...222 // Multiple catch Clauses...222 // Nested try Statements...224 // throw...226 // throws...227 // finally...228 // Javas Built-in Exceptions...230 // Creating Your Own Exception Subclasses...231 // Chained Exceptions...234 // Three Additional Exception Features...235 // Using Exceptions...236 // xii Java: The Complete Reference // Chapter 11 Multithreaded Programming...237 // The Java Thread Model...238 // Thread Priorities...239 // Synchronization...239 // Messaging...240 // The Thread Class and the Runnable Interface...240 // The Main Thread...241 // Creating a Thread...242 // Implementing Runnable...243 // Extending Thread...245 // Choosing an Approach...246 // Creating Multiple Threads...246 // Using isAlive( ) and join( )...248 // Thread Priorities...250 // Synchronization...251 // Using Synchronized Methods...251 // The synchronized Statement...253 // Interthread Communication...255 // Deadlock...260 // Suspending, Resuming, and Stopping Threads...262 // Obtaining a Thread’s State...264 // Using a Factory Method to Create and Start a Thread...265 // Using Multithreading...266 // Chapter 12 Enumerations, Autoboxing, and Annotations...267
Enumerations...267 // Enumeration Fundamentals...268 // The values( ) and valueOf( ) Methods...270 // Java Enumerations Are Class Types...271 // Enumerations Inherit Enum...273 // Another Enumeration Example...275 // Type Wrappers...276 // Character...277 // Boolean...277 // The Numeric Type Wrappers...278 // Autoboxing...279 // Autoboxing and Methods...280 // Autoboxing/Unboxing Occurs in Expressions...281 // Autoboxing/Unboxing Boolean and Character Values...282 // Autoboxing/Unboxing Helps Prevent Errors...283 // A Word of Warning...284 // Annotations...284 // Annotation Basics...285 // Specifying a Retention Policy...285 // Obtaining Annotations at Run Time by Use of Reflection...286 // Contents xiii // The AnnotatedElement Interface...291 // Using Default Values...292 // Marker Annotations...293 // Single-Member Annotations...294 // The Built-In Annotations...295 // Type Annotations...297 // Repeating Annotations...302 // Some Restrictions...304 // Chapter 13 I/O, Try-with-Resources, and Other Topics...305 // I/O Basics...305 // Streams...306 // Byte Streams and Character Streams...306 // The Predefined Streams...308 // Reading Console Input...309 // Reading Characters...309 // Reading Strings...310 // Writing Console Output...312 // The Print Writer Class...312 // Reading and Writing Files...313 // Automatically Closing a File...319 // The transient and volatile Modifiers...322 // Using instanceof...323 // strictfp...325 // Native Methods...326 // Using assert...326 // Assertion
Enabling and Disabling Options...328 // Static Import...329 // Invoking Overloaded Constructors Through this( )...331 // A Word About Compact API Profiles...334 // Chapter 14 Generics...335 // What Are Generics?...336 // A Simple Generics Example...336 // Generics Work Only with Reference Types...340 // Generic Types Differ Based on Their Type Arguments...340 // How Generics Improve Type Safety...340 // A Generic Class with Two Type Parameters...343 // The General Form of a Generic Class...344 // Bounded Types...344 // Using Wildcard Arguments...347 // Bounded Wildcards...350 // Creating a Generic Method...354 // Generic Constructors...357 // Generic Interfaces...358 // Raw Types and Legacy Code...360 // // xiv Java: The Complete Reference // Generic Class Hierarchies...362 // Using a Generic Superclass...363 // A Generic Subclass...365 // Run-Time Type Comparisons Within a Generic Hierarchy...366 // Casting...368 // Overriding Methods in a Generic Class...369 // Type Inference with Generics...370 // Erasure... // Bridge Methods... // Ambiguity Errors... // Some Generic Restrictions...375 // Type Parameters Cant Be Instantiated...375 // Restrictions on Static Members...375 // Generic Array Restrictions...375 // Generic Exception Restriction...377 // Chapter 15 Lambda Expressions...379 // Introducing Lambda Expressions...379 // Lambda Expression Fundamentals...380 // Functional Interfaces...381 // Some Lambda Expression Examples...382 // Block Lambda Expressions...385 // Generic
Functional Interfaces...387 // Passing Lambda Expressions as Arguments...389 // Lambda Expressions and Exceptions...392 // Lambda Expressions and Variable Capture...393 // Method References...394 // Method References to static Methods...394 // Method References to Instance Methods...395 // Method References with Generics...399 // Constructor References...402 // Predefined Functional Interfaces...406 // Chapter 16 Modules... // Module Basics...409 // A Simple Module Example...410 // Compile and Run the First Module Example...414 // A Closer Look at requires and exports...416 // java.base and the Platform Modules...417 // Legacy Code and the Unnamed Module...417 // Exporting to a Specific Module...418 // Using requires transitive...420 // Use Services... // Service and Service Provider Basics...424 // The Service-Based Keywords...425 // A Module-Based Service Example...425 // Contents // Module Graphs...432 // Three Specialized Module Features...433 // Open Modules...433 // The opens Statement...433 // requires static...434 // Introducing jlink and Module JAR Files...434 // Linking Files in an Exploded Directory...434 // Linking Modular JAR Files...435 // JMOD Files...435 // A Brief Word About Layers and Automatic Modules...436 // Final Thoughts on Modules...436 // Part II The Java Library // Chapter 17 String Handling...439 // The String Constructors...440 // String Length...442 // Special String Operations...442 // String Literals...442 // String Concatenation...443 // String
Concatenation with Other Data Types...443 // String Conversion and toString( )...444 // Character Extraction...445 // char At ( )...445 // getChars( )...445 // getBytes( )... 446 // toCharArray( )...*...446 // String Comparison...446 // equals( ) and equals!gnoreCase( )...447 // regionMatches( )...447 // startsWith( ) and endsWith( )...448 // equals( ) Versus ...448 // compareTo( )...449 // Searching Strings...450 // Modifying a String...452 // substring( )...452 // concat( )...453 // replace( )...453 // trim( )...454 // Data Conversion Using valueOf( )...454 // Changing the Case of Characters Within a String...455 // Joining Strings...456 // Additional String Methods...457 // StringBuifer...458 // StringBuffer Constructors...458 // length( ) and capacity( )...459 // XVI Java: The Complete Reference // ensureCapacity( )... // setLengthO... // charAt( ) and setCharAt( )...460 // getChars( )... // append( )... // inserti )...461 // reversei )... // deletei ) and deleteCharAt( )...462 // rephce( )...463 // substringi )... // Additional StringBuffer Methods...464 // StringBuilder... // Chapter 18 Exploring java Jang... // Primitive Type Wrappers... // Number... // Double and Float... // Understanding islnfinite( ) and isNaN( )...472 // Byte, Short, Integer, and Long...473 // Character... // Additions to Character for Unicode Code Point Support...484 // Boolean... // Void...485 // Process... // Runtime... // Memory Management...437 // Executing Other Programs...491 // Runtime.Version...
// ProcessBuilder... // System... // Using currentTimeMillisi ) to Time Program Execution...497 // Using arraycopyi )... // Environment Properties...493 // System.Logger and System.LoggerFinder...499 // Object... // Using clone( ) and the Cloneable Interface...499 // Class...501 // ClassLoader... // Math...505 // Trigonometric Functions...505 // Exponential Functions...5O6 // Rounding Functions...5O6 // Miscellaneous Math Methods...507 // StrictMath... // Compiler... // Contents XVII // Thread, ThreadGroup, and Runnable...509 // The Runnable Interface...509 // Thread...510 // ThreadGroup...512 // ThreadLocal and InheritableThreadLocal...517 // Package...517 // Module...518 // ModuleLayer...519 // RuntimePermission...519 // Throwable...519 // SecurityManager...519 // StackTraceElement...520 // StackWalker and StackWalker.StackFrame...521 // Enum...521 // ClassValue...522 // The CharSequence Interface...522 // The Comparable Interface...522 // The Appendable Interface...523 // The Iterable Interface...523 // The Readable Interface...524 // The AutoCloseable Interface...524 // The Thread.UncaughtExceptionHandler Interface...524 // The java.lang Subpackages...524 // java.lang.annotation...525 // java.lang.instrument...525 // java.lang.invoke...525 // java.lang.module...525 // java.lang.management...525 // java.lang.ref...525 // java.lang.reflect...525 // Chapter 19 java.util Part 1: The Collections Framework...527 // Collections Overview...528 // The Collection Interfaces...530
The Collection Interface...530 // The List Interface...533 // The Set Interface...535 // The SortedSet Interface...536 // The NavigableSet Interface...537 // The Queue Interface...538 // The Deque Interface...539 // The Collection Classes...540 // The ArrayList Class...541 // The LinkedList Class...545 // The HashSet Class...546 // xviii Java: The Complete Reference // The LinkedHashSet Class... // The TreeSet Class... // The PriorityQueue Class...549 // The ArrayDeque Class... // The EnumSet Class...551 // Accessing a Collection via an Iterator...551 // Using an Iterator... // The For-Each Alternative to Iterators...555 // Spliterators... // Storing User-Defined Classes in Collections...558 // The RandomAccess Interface...560 // Working with Maps... // The Map Interfaces...551 // The Map Classes...568 // Comparators... // Using a Comparator...575 // The Collection Algorithms... // ???8... // The Legacy Classes and Interfaces...592 // The Enumeration Interface...592 // Vector...593 // Stack... 597 // Dictionary... // Hashtable...600 // Properties...603 // Using store( ) and load( )...606 // Parting Thoughts on Collections...608 // Chapter 20 java.util Part 2: More Utility Classes...609 // StringTokenizer...609 // BitSet...;... // Optional, OptionalDouble, Optionallnt, and OptionalLong...614 // Date...616 // Calendar... 618 // GregorianCalendar...621 // TimeZone... 623 // SimpleTimeZone...624 // Locale...625 // Random...626 // Timer and TimerTask...628 // Currency... // Formatter...632
// The Formatter Constructors...632 // The Formatter Methods...633 // Formatting Basics...633 // Contents XIX // Formatting Strings and Characters...635 // Formatting Numbers...635 // Formatting Time and Date...637 // The %n and %% Specifiers...639 // Specifying a Minimum Field Width...639 // Specifying Precision...641 // Using the Format Flags...642 // Justifying Output...642 // The Space, +, 0, and ( Flags...643 // The Comma Flag...644 // The # Flag...644 // The Uppercase Option...644 // Using an Argument Index...645 // Closing a Formatter...646 // The Java printf( ) Connection...647 // Scanner...64-7 // The Scanner Constructors...647 // Scanning Basics...647 // Some Scanner Examples...651 // Setting Delimiters...655 // Other Scanner Features...656 // The ResourceBundle, ListResourceBundle, and // PropertyResourceBundle Classes...657 // Miscellaneous Utility Classes and Interfaces...662 // The java.util Subpackages...663 // java.util.concurrent, java.util.concurrent.atomic, and // java.util.concurrent.locks...663 // java.util.function...663 // java.util.jar... // java.util.logging...666 // java.util.prefs...666 // java.util.regex...667 // java.util.spi...667 // java.util.stream...667 // java.util.zip...667 // Chapter 21 Input/Output: Exploring java.io...669 // The I/O Classes and Interfaces...670 // File...671 // Directories...673 // Using FilenameFilter...674 // The listFiles( ) Alternative...675 // Creating Directories...676 // The AutoCloseable, Closeable, and Flushable Interfaces...676
// I/O Exceptions...677 // XX Java: The Complete Reference // Two Ways to Close a Stream... // The Stream Classes... // The Byte Streams... // InputStream... // OutputStream... // FilelnputStream... // FileOutputStream... // ByteArraylnputStream... // ByteArrayOutputStream... // Filtered Byte Streams... // Buffered Byte Streams... // SequencelnputStream... // PrintStream... // DataOutputStream and DatalnputStream...696 // Random AccessFile... // The Character Streams... // Reader... // Writer... // FileReader... // FileWriter... // CharArrayReader... // CharArrayWriter... // BufferedReader... // BufferedWriter... // PushbackReader... // PrintWriter... // The Console Class... // Serialization... 7? // Serializable... // Externalizable... // ObjectOutput... // ObjectOutputStream... // Objectlnput... // ObjectlnputStream... // A Serialization Example... // Stream Benefits... // Chapter 22 Exploring NIO... // The NIO Classes... // NIO Fundamentals... // Buffers... 713 // Channels... // Charsets and Selectors...722 // Enhancements Added by N10.2...722 // The Path Interface... // The Files Class... // Contents XXI // The Paths Class...725 // The File Attribute Interfaces...726 // The FileSystem, FileSystems, and Filestore Classes...728 // Using the NIO System...728 // Use NIO for Channel-Based I/O...729 // Use NIO for Stream-Based I/O...738 // Use NIO for Path and File System Operations...740 // Chapter 23 Networking...749 // Networking Basics...749 // The Networking Classes and Interfaces...750
// InetAddress...751 // Factory Methods...751 // Instance Methods...752 // Inet4Address and InetóAddress...753 // TCP/IP Client Sockets...753 // URL...757 // URLConnection...758 // HttpURLConnection...761 // The URI Class...763 // Cookies...763 // TCP/IP Server Sockets...763 // Datagrams...764 // DatagramSocket...764 // DatagramPacket...765 // A Datagram Example...766 // Chapter 24 Event Handling...769 // Two Event Handling Mechanisms...769 // The Delegation Event Model...770 // Events...770 // Event Sources...770 // Event Listeners...771 // Event Classes...771 // The ActionEvent Class...772 // The AdjustmentEvent Class...774 // The ComponentEvent Class...774 // The ContainerEvent Class...775 // The FocusEvent Class...775 // The InputEvent Class...776 // The ItemEvent Class...777 // The KeyEvent Class...778 // The MouseEvent Class...779 // The MouseWheelEvent Class...780 // The TextEvent Class...781 // The WindowEvent Class...781 // XXII Java: The Complete Reference // Sources of Events... // Event Listener Interfaces... // The ActionListener Interface...783 // The AdjustmentListener Interface...784 // The ComponentListener Interface...784 // The ContainerListener Interface...784 // The FocusListener Interface...784 // The ItemListener Interface...784 // The KeyListener Interface...784 // The MouseListener Interface...785 // The MouseMotionListener Interface...785 // The MouseWheelListener Interface...785 // The TextListener Interface...785 // The WindowFocusListener Interface...785
// The WindowListener Interface...786 // Using the Delegation Event Model...786 // Some Key AWT GUI Concepts...786 // Handling Mouse Events...787 // Handling Keyboard Events...790 // Adapter Classes... // Inner Classes... // Anonymous Inner Classes...798 // Chapter 25 Introducing the AWT: Working with Windows, // Graphics, and Text...801 // AWT Classes...802 // Window Fundamentals...804 // Component...804 // Container...805 // Panel... // Window...805 // Frame...805 // Canvas...805 // Working with Frame Windows...805 // Setting the Window’s Dimensions...806 // Hiding and Showing a Window...806 // Setting a Windows Title...806 // Closing a Frame Window...806 // The paint( ) Method...807 // Displaying a String...807 // Setting the Foreground and Background Colors...807 // Requesting Repainting...808 // Creating a Frame-Based Application...809 // Introducing Graphics...810 // Drawing Lines...810 // Drawing Rectangles...810 // Contents XXIII // Drawing Ellipses and Circles...811 // Drawing Arcs... 811 // Drawing Polygons... 811 // Demonstrating the Drawing Methods...812 // Sizing Graphics...813 // Working with Color...815 // Color Methods...815 // Setting the Current Graphics Color...816 // A Color Demonstration Program...816 // Setting the Paint Mode...818 // Working with Fonts...819 // Determining the Available Fonts...821 // Creating and Selecting a Font...822 // Obtaining Font Information...824 // Managing Text Output Using FontMetrics...825 // Chapter 26 Using AWT Controls, Layout
Managers, and Menus...829 // AWT Control Fundamentals...830 // Adding and Removing Controls...830 // Responding to Controls...830 // The HeadlessException...831 // Labels...831 // Using Buttons...833 // Handling Buttons...833 // Applying Check Boxes...837 // Handling Check Boxes...838 // CheckboxGroup...839 // Choice Controls...841 // Handling Choice Lists...842 // Using Lists...844 // Handling Lists...845 // Managing Scroll Bars...847 // Handling Scroll Bars...848 // Using a TextField...850 // Handling a TextField...851 // Using a TextArea...853 // Understanding Layout Managers...854 // FlowLayout...855 // BorderLayout...856 // Using Insets...858 // GridLayout...860 // CardLayout...861 // GridBagLayout...864 // Menu Bars and Menus...869 // Dialog Boxes...874 // A Word About Overriding paint()...878 // XXiv Java: The Complete Reference // Chapter 27 Images...879 // File Formats...879 // Image Fundamentals: Creating, Loading, and Displaying...880 // Creating an Image Object...880 // Loading an Image...880 // Displaying an Image...881 // Double Buffering...882 // ImageProducer...885 // MemorylmageSource...885 // ImageConsumer...886 // PixelGrabber...887 // ImageFilter...889 // CropImageFilter...890 // RGBImageFilter...892 // Additional Imaging Classes...904 // Chapter 28 The Concurrency Utilities...905 // The Concurrent API Packages...906 // java.util.concurrent...906 // java.util.concurrent.atomic...907 // java.util.concurrent.locks...907 // Using Synchronization Objects...908
// Semaphore...908 // CountDownLatch...913 // CyclicBarrier...915 // Exchanger...917 // Phaser...920 // Using an Executor...927 // A Simple Executor Example...928 // Using Callable and Future...929 // The TimeUnit Enumeration...932 // The Concurrent Collections...933 // Locks...934 // Atomic Operations...936 // Parallel Programming via the Fork/Join Framework...938 // The Main Fork/Join Classes...938 // The Divide-and-Conquer Strategy...942 // A Simple First Fork/Join Example...943 // Understanding the Impact of the Level of Parallelism...945 // An Example that Uses RecursiveTask<V>...948 // Executing a Task Asynchronously...951 // Cancelling a Task...951 // Determining a Task s Completion Status...952 // Restarting a Task...952 // Contents XXV // Things to Explore...952 // Some Fork/Join Tips...954 // The Concurrency Utilities Versus Javas Traditional Approach...954 // Chapter 29 The Stream API...955 // Stream Basics...955 // Stream Interfaces...956 // How to Obtain a Stream...959 // A Simple Stream Example...959 // Reduction Operations...963 // Using Parallel Streams...965 // Mapping...968 // Collecting...972 // Iterators and Streams...976 // Use an Iterator with a Stream...976 // Use Spliterator...977 // More to Explore in the Stream API...980 // Chapter 30 Regular Expressions and Other Packages...981 // Regular Expression Processing...981 // Pattern...982 // Matcher...982 // Regular Expression Syntax...983 // Demonstrating Pattern Matching...983 // Two Pattern-Matching Options...989
// Exploring Regular Expressions...989 // Reflection...99O // Remote Method Invocation (RMI)...994 // A Simple Client/Server Application Using RMI...994 // Formatting Date and Time with java.text...997 // DateFormat Class...997 // SimpleDateFormat Class...999 // The java.time Time and Date API...1001 // Time and Date Fundamentals...1002 // Formatting Date and Time...1003 // Parsing Date and Time Strings...1006 // Other Things to Explore in java.time...1007 // Part III Introducing GUI Programming with Swing // Chapter 31 Introducing Swing...1011 // The Origins of Swing...1011 // Swing Is Built on the AWT...1012 // Two Key Swing Features...1012 // Swing Components Are Lightweight...1012 // Swing Supports a Pluggable Look and Feel...1012 // XXVi Java: The Complete Reference // The MVC Connection...1013 // Components and Containers...1014 // Components...1014 // Containers...1015 // The Top-Level Container Panes...1015 // The Swing Packages...1016 // A Simple Swing Application...1016 // Event Handling...1021 // Painting in Swing...1024 // Painting Fundamentals...1024 // Compute the Paintable Area...1025 // A Paint Example...1026 // Chapter 32 Exploring Swing...1029 // JLabel and Imagelcon...1029 // JTextField...1031 // The Swing Buttons...1033 // JButton...1033 // JToggleButton...1035 // Check Boxes...1038 // Radio Buttons...1039 // JTabbedPane...1042 // JScrollPane...1044 // JList...1046 // JComboBox...1049 // Trees...1051 // JTable...1055 // Chapter 33 Introducing Swing Menus...1059
// Menu Basics...1059 // An Overview of JMenuBar, JMenu, and JMenuItem...1061 // JMenuBar...1061 // JMenu...1062 // JMenuItem...1063 // Create a Main Menu...1064 // Add Mnemonics and Accelerators to Menu Items...1068 // Add Images and Tooltips to Menu Items...1070 // Use JRadioButtonMenuItem and JCheckBoxMenuItem...1071 // Create a Popup Menu...1073 // Create a Toolbar...1077 // Use Actions...1079 // Put the Entire MenuDemo Program Together...1085 // Continuing Your Exploration of Swing...1091 // Contents XXVii // part IV Introducing GUI Programming with JavaFX // Chapter 34 Introducing JavaFX GUI Programming...1095 // JavaFX Basic Concepts...1096 // The JavaFX Packages...1096 // The Stage and Scene Classes...1096 // Nodes and Scene Graphs...1097 // Layouts...1097 // The Application Class and the Life-cycle Methods...1097 // Launching a JavaFX Application...1098 // A JavaFX Application Skeleton...1098 // Compiling and Running a JavaFX Program...1101 // The Application Thread...1102 // A Simple JavaFX Control: Label...1102 // Using Buttons and Events...1104 // Event Basics...1105 // Introducing the Button Control...1105 // Demonstrating Event Handling and the Button...1106 // Drawing Directly on a Canvas...1109 // Chapter 35 Exploring JavaFX Controls...1115 // Using Image and ImageView...1115 // Adding an Image to a Label...1118 // Using an Image with a Button...1120 // ToggleButton...1123 // RadioButton...1125 // Handling Change Events in a Toggle Group...1128 // An Alternative
Way to Handle Radio Buttons...1129 // CheckBox...1132 // List View...1136 // List View Scroll Bars...1139 // Enabling Multiple Selections...1140 // ComboBox...1141 // TextField...1144 // ScrollPane...1147 // TreeView...1150 // Introducing Effects and Transforms...1154 // Effects...1155 // Transforms...1156 // Demonstrating Effects and Transforms...1157 // Adding Tooltips...1160 // Disabling a Control...1160 // XXViii Java: The Complete Reference // Chapter 36 Introducing JavaFX Menus...1161 // Menu Basics...1161 // An Overview of MenuBar, Menu, and Menultem...1163 // MenuBar...1163 // Menu...1164 // Menultem...1164 // Create a Main Menu...1165 // Add Mnemonics and Accelerators to Menu Items...1170 // Add Images to Menu Items...1172 // Use RadioMenuItem and CheckMenuItem...1173 // Create a Context Menu...1175 // Create a Toolbar...1179 // Put the Entire MenuDemo Program Together...1181 // Continuing Your Exploration of JavaFX...1186 // PartV Applying Java // Chapter 37 Java Beans...

Zvolte formát: Standardní formát Katalogizační záznam Zkrácený záznam S textovými návěštími S kódy polí MARC