Nicht aus der Schweiz? Besuchen Sie lehmanns.de
Für diesen Artikel ist leider kein Bild verfügbar.

Learning Modern Java LiveLessons (Video Training), Downloadable Version

A Crash Course Using Java 8

Marty Hall (Autor)

Video
2015
Addison Wesley (Hersteller)
978-0-13-438356-9 (ISBN)
Preis auf Anfrage
  • Keine Verlagsinformationen verfügbar
  • Artikel merken
17+ Hours of Video Instruction

Java is the world's most popular and widely applied programming language, but it is large, complex, and sometimes difficult to get started with. These LiveLessons supply a practical, hands-on introduction to programming with Java 8, the latest version of the language.


The course provides thorough coverage of the foundational Java topics: basic syntax, object-oriented programming, handling exceptions, core data structures, and generic types. It also gives fast-moving coverage of some of the most important libraries: concurrent programming with Java threads, parallel programming with fork/join, network programming, file I/O, and serialization. Finally, it gives detailed explanation of the syntax and usage of lambda expressions and streams, the most important new features in Java 8.


In each section, it gives details on the most important topics, surveys more advanced or lesser-used topics, stresses best practices, and provides plenty of working examples.


If you are new to Java and want to quickly learn the full range of Java programming, but in the context of the latest version (Java 8), continue on: you are in the right place. If, however, you are already comfortable with previous Java versions and want to learn only the new Java 8 features, see Java 8 Lambda Expressions and Streams LiveLessons (Video Training) instead.


Description


In these LiveLessons, expert Java developer, instructor, and author Marty Hall gives a crash course on Java programming. This fast-moving video series is aimed at developers who have used other languages, but who have little or no Java experience.



The first section looks at installing Java and Eclipse, making projects, and understanding loops, conditionals, and other basic Java syntax.



The second section covers object-oriented programming using the Java 8 style. Topics include classes, methods, constructors, interfaces, abstract classes, enums, and lots of guidance on style and best OOP practices.



The third section looks at exception handling, lists and maps, generic types, printf, inner classes, and unit testing with JUnit.



The fourth section looks at asynchronous event handling, concurrent programming with Java threads, and parallel programming using Java's fork/join framework.



The fifth section looks at the syntax and usage of lambda expressions and streams, with particular emphasis on best practices and the use of parallel streams.



The final section looks at file and network I/O: Java 8 stream-based file reading, network clients, network servers, and serialization.



Please visit http://courses.coreservlets.com/Course-Materials/java.html for the LiveLessons Web site. This site contains complete source code for all examples in the video, as well as exercises and exercise solutions for each topic.


Finally, you can contact the author directly at hall@coreservlets.com with questions or suggestions, or to inquire about customized training courses on Java EE and JavaScript topics to be held onsite at your organization.



The source code repository for this LiveLesson can be downloaded from http://courses.coreservlets.com/Course-Materials/java.html.



Skill Level



Beginner to intermediate

What You Will Learn



Installing Java
Installing and using the Eclipse development environment
Loops and conditionals
Strings, arrays, and other basic Java syntax
Classes
Instance variables (data members, fields)
Methods (member functions)
Overloading
Inheritance
OOP best practices
Use of JavaDoc
Encapsulation
Interfaces using the Java 8 style
Abstract classes
Enums
The toString method
Try/catch blocks
The @Override annotation
Lists and maps
Making your own methods and classes that support generic types
printf
The Arrays utility class
Unit testing with JUnit
Asynchronous event handling
Inner classes
Concurrent programming with Java threads
Recognizing and dealing with race conditions
Parallel programming with the Java fork/join framework
Best practices for parallel applications
Lambda expressions
Method references
Lambda building blocks in the java.util.function package
Methods that return functions
Java 8 streams
Creating streams from lists, arrays, and individual values
Outputting streams as lists or arrays
Core stream methods
The new Optional class
Lazy evaluation and short-circuit stream operations
Streams specialized for numbers
Reduction operations
Parallel streams
Infinite (unbounded) streams
Grouping and partitioning stream elements
Java 8 stream-based file I/O
Network programming: clients
Network programming: servers
Multithreaded network servers
Object serialization

Who Should Take This Course



This LiveLessons course is aimed at developers who have at least moderate experience with other programming languages and want to learn Java as quickly as possible. The course moves too fast for first-time programmers. If you are already comfortable with previous Java versions and only want to learn the new Java 8 features, see Java 8 Lambda Expressions and Streams LiveLessons (Video Training) instead of this LiveLesson.

Course Requirements



Familiarity with fundamental programming concepts
At least moderate experience in programming with another language: C, C++, C#, Objective-C, Python, Perl, Ruby, or JavaScript preferred
No prior Java experience is required


Table of Contents


Lesson 1: Java with Eclipse: Setup and Getting Started
Topics
1.1 Installing Java 8
1.2 Installing and Using Eclipse
Summary

Lesson 2: Basic Java Syntax
Topics
2.1 Setup, Execution, and Most Basic Syntax
2.2 The + Operator, Array Basics, and Command Line Args
2.3 Loops
2.4 Class Structure and Formatting
2.5 Conditionals
2.6 Strings
2.7 More on Arrays
2.8 Math Routines
2.9 Reading Input
Summary

Lesson 3: Basic Object-Oriented Programming in Java
Topics
3.1 Overview
3.2 Basics
3.3 Instance Variables
3.4 Methods
3.5 Constructors
3.6 Interactive Example: Person Class
Summary

Lesson 4: Object-Oriented Programming in Java: More Capabilities
Topics
4.1 Overloading
4.2 OOP Best Practices: Encapsulation and JavaDoc
4.3 Inheritance
4.4 Inheritance Example: Person Class
4.5 The toString Method
Summary

Lesson 5: Object-Oriented Programming in Java: Advanced Capabilities
Topics
5.1 Sample Problem
5.2 Attempted Problem Solutions
5.3 Abstract Classes
5.4 Interfaces
5.5 @Override
5.6 Visibility Modifiers
5.7 Enums
5.8 JavaDoc Options
5.9 The Classpath
Summary


Lesson 6: Applets and Basic Graphics
Topics
6.1 Motivation
6.2 Security Restrictions
6.3 Basic Applet Structure
6.4 Drawing in Applets: Basics
6.5 The Value of @Override
6.6 Applet Life Cycle Methods
6.7 Other Applet Methods
6.8 Attributes of the HTML Applet Tag
6.9 Applet Parameters: Letting the HTML Author Supply Data
6.10 Drawing in Applets: More Details
6.11 Loading and Drawing Images
6.12 Basic Try/Catch Blocks
Summary

Lesson 7: More Syntax and Utilities
Topics
7.1 Lists
7.2 List Operation Performance
7.3 Using Generic Types
7.4 Autoboxing
7.5 Maps
7.6 Building Genericized Methods and Classes
7.7 The Arrays Utility Class
7.8 printf
7.9 Varargs
7.10 StringBuilder
Summary

Lesson 8: Unit Testing with JUnit: A Very Brief Introduction

Topics
8.1 Static Imports
8.2 JUnit Overview
8.3 Modern Approach
8.4 Traditional Approach
Summary

Lesson 9: Asynchronous Event Handling
Topics
9.1 Overview
9.2 Using Separate Listener Classes: Basics
9.3 Using Separate Listener Classes: Drawing
9.4 Implementing a Listener Interface
9.5 Using Named Inner Classes
9.6 Using Anonymous Inner Classes
9.7 Preview: Using Java 8 Lambdas
Summary

Lesson 10: Multithreaded Programming in Java
Topics
10.1 Overview
10.2 Basic Steps for Concurrent Programming
10.3 Approach One: Separate Class that Implements Runnable
10.4 Approach Two: Main App Implements Runnable
10.5 Approach Three: Inner Class that Implements Runnable
10.6 Preview of Approach Four: Lambda Expressions
10.7 Summary of Approaches with Pros and Cons
10.8 Making a Reusable Multithreaded Server: Template
10.9 Race Conditions: Problem
10.10 Race Conditions: Solution
10.11 Helpful Thread-Related Methods
10.12 Brief Summary of Advanced Topics
10.13 Tricky Synchronization Problem
Summary


Lesson 11: Parallel Programming with the Fork/Join Framework
Topics
11.1 Overview
11.2 General Fork/Join Approach
11.3 Aside: Reusable Timing Code
11.4 Summing Large Array of Doubles: Version 1: Code
11.5 Summing Large Array of Doubles Version 1: Verification Step
11.6 Making Reusable Parallel Array Processor
11.7 Summing Large Array of Doubles: Version 2
11.8 Computing Minimum of Expensive Operation
11.9 Generating Large Prime Numbers
Summary

Lesson 12: Lambda Expressions-Part 1: Basics
Topics
12.1 Motivation and Overview
12.2 Lambdas: Most Basic Form
12.3 Type Inferencing
12.4 Expression for Body: Implied Return Values
12.5 Omitting Parens
12.6 Summary: Making Lambdas More Succinct
12.7 Example: Numerical Integration
12.8 Making a Reusable Timing Utility
12.9 A Few More Samples
Summary

Lesson 13: Lambda Expressions in Java 8-Part 2
Topics
13.1 The @FunctionalInterface Annotation
13.2 Method References
13.3 Lambda Variable Scoping in Lambdas
13.4 Effectively Final Local Variables
Summary

Lesson 14: Lambda Expressions in Java 8-Part 3: Lambda Building Blocks in java.util.function
Topics
14.1 Overview: Lambda Building Blocks
14.2 Simply-Typed Building Blocks
14.3 Generic Building Blocks: Predicate
14.4 Generic Building Blocks: Function
14.5 Other Generic Building Blocks
Summary

Lesson 15: Lambda Expressions in Java 8-Part 4
Topics
15.1 Java 8 Interfaces: Static Methods
15.2 Java 8 Interfaces: Default Methods
15.3 Resolving Conflicts with Default Methods
15.4 Higher Order Functions: Methods that Return Functions
15.5 Higher Order Functions in Predicate
15.6 Higher Order Functions in Function
15.7 Higher Order Functions in Consumer
15.8 Higher Order Functions in Your Own Code
Summary

Lesson 16: Streams in Java 8-Part 1
Topics
16.1 Overview of Streams
16.2 Getting Standard Data Structures into and out of Streams
16.3 Core Stream Methods: Overview
16.4 forEach: Calling a Lambda on Each Element of a Stream
16.5 map: Transforming a Stream by Passing Each Element through a Function
16.6 filter: Keeping Only the Elements That Pass a Predicate
16.7 findFirst: Returning the First Element of a Stream while Short-Circuiting Earlier Operations
16.8 Lazy Evaluation
Summary

Lesson 17: Streams in Java 8-Part 2
Topics
17.1 Operations that Limit the Stream Size: limit, skip
17.2 Operations that Use Comparisons: sorted, min, max, distinct
17.3 Operations that Check Matches: allMatch, anyMatch, noneMatch, count
17.4 Number-Specialized Streams
17.5 The reduce Method and Related Reduction Operations
Summary

Lesson 18: Streams in Java 8-Part 3
Topics
18.1 Grouping Stream Elements: Fancy Uses of collect
18.2 Parallel Streams
18.3 Infinite (Unbounded On-the-Fly) Streams
Summary

Lesson 19: Simplified File I/O: Applying the Power of Streams
Topics
19.1 More on try/catch Blocks
19.2 Paths
19.3 Simple File Reading
19.4 File Reading Examples
19.5 Simple File Writing
19.6 Exploring Folders
19.7 Faster and More Flexible File Writing
Summary


Lesson 20: Network Programming: Clients

Topics
20.1 Overview
20.2 Basic Steps for a Client to Connect to a Server
20.3 A Reusable Network Client Base Class
20.4 Aside: String Formatting and Parsing
20.5 Problems with Blocking IO
20.6 Talking to Web Servers: General
20.7 Talking to Web Servers: A Java Client
Summary


Lesson 21: Network Programming: Servers

Topics
21.1 Basics
21.2 Simple Warmup: A Single-Threaded Server
21.3 A Base Class for a Multithreaded Server
21.4 A Simple Multithreaded HTTP Server
Summary

Lesson 22: Serialization: Sending Complex Java Data Structures to Files or Over the Network

Topics
22.1 Overview
22.2 Sending Data
22.3 Receiving Data
22.4 Example: Sending Entire Window to File or Socket
Summary

Summary


About LiveLessons Video Training

The LiveLessons Video Training series publishes hundreds of hands-on, expert-led video tutorials covering a wide selection of technology topics designed to teach you the skills you need to succeed. This professional and personal technology video series features world-leading author instructors published by your trusted technology brands: Addison-Wesley, Cisco Press, IBM Press, Pearson IT Certification, Prentice Hall, Sams, and Que. Topics include IT certification, programming, Web development, mobile development, home and office technologies, business and management, and more. View all LiveLessons on InformIT at http://www.informit.com/livelessons.

Marty Hall is president of coreservlets.com, a training and consulting company focusing on server-side Java technology, Android development, and Rich Internet Apps with Ajax. In addition to long Java development and consulting experience, Marty has an extensive background in teaching and training, having given training courses on Java 8, JSF 2, PrimeFaces, Android, Ajax/jQuery, and other Java EE topics in dozens of US venues and nine other countries. A popular and entertaining speaker, Marty has also spoken at conferences and user groups around the world, including Comdex, the Web 2.0 Expo, and five times at JavaOne. Marty is also adjunct faculty in the Johns Hopkins University part-time graduate program in Computer Science, where he directs the Java and Web-related concentration areas. Marty Hall is also the lead author of six popular Java EE books from Pearson, including Core Servlets and JSP, and is the co-author of the upcoming JSF 2.3 edition of Core JSF. You can see more details on Marty's bio page: http://courses.coreservlets.com/about-instructor.html.

Erscheint lt. Verlag 24.9.2015
Verlagsort Boston
Sprache englisch
Gewicht 1 g
Themenwelt Informatik Programmiersprachen / -werkzeuge Java
ISBN-10 0-13-438356-7 / 0134383567
ISBN-13 978-0-13-438356-9 / 9780134383569
Zustand Neuware
Haben Sie eine Frage zum Produkt?