The topics covered include
Module 1: Understanding Declarations and Primitive Data Types
Module 2: Working with Core Text Representations
Module 3: Representing Numbers as Objects
Module 4: Working with Java Arrays
Module 5: Working with Date and Time
Module 6: Working with List Types
About the Instructor
Simon Roberts started his computing career as a programmer in the early 1980s and built several of his own microprocessor-based computers. He joined Sun Microsystems, Inc. in mid-1995 and almost immediately became the lead Java instructor in the United Kingdom. In 1998 Simon moved to Colorado, where he still lives. While at Sun, he created the Sun Certified Programmer, Developer, and Architect certifications and worked in teams on several other certifications. He wrote three books on Java, including two certification study guides: one covering the Programmer and Developer exams, and one covering the Architect exam. He left Sun in 2004 and became an independent instructor, architect, and software engineer.
Skill Level
Intermediate/Advanced
Learn How To
Programmers working to build their understanding of syntax, semantics, and higher concepts and strengthen their skill base and grasp of the details of Java, whether new to the language or not. This course is also well suited for those preparing for interviews or exams.
Course Requirements
An understanding of programming, even if not in Java
Lesson Descriptions
Module 1, “Understanding Declarations and Primitive Data Types,” looks at some core aspects of the Java programming language, starting with simple declarations of variables, initialization, and then the scope of those variables. In looking at scope, the topic of blocks and curly braces are covered. Literal forms for all the primitive types, including the types of those literals, effects of assigning them to variables of other types, and limitations on such assignments are introduced next. Finally, this module covers the use of pseudo-type “var”.
Module 2, “Working with Core Text Representations,” focuses on Java’s core text representations, including classes String and StringBuilder. The module also addresses the issue of immutability in Java’s strings as well as the key elements of String and StringBuilder’s APIs.
Module 3, “Representing Numbers and Objects,” starts with the primitive wrappers and autoboxing, and key elements of those wrapper APIs. The latter part of this module addresses the BigInteger and BigDecimal classes.
Module 4, “Working with Java Arrays,” starts with Array declarations and creation, as well as some techniques for initializing by iteration, and the length and valid indexes of an Array. Then the module digs in to the special syntax that enables an array to be represented as a literal in the source code and shows how this allows for combining declaration and initialization. Creating an array that contains all or part of another array, as well as how to copy from one array to another efficiently, is covered. The syntax elements and usage idioms of arrays are also addressed, along with other details of multi-dimensional arrays. Finally, the module investigates the utilities provided by the Arrays class.
Module 5, “Working with Date and Time,” addresses the powerful features of the date and time API. The module starts with creating objects that represent local dates and times, moving into how to represent changes to a given value, and then moves on to the DateTimeFormatter. Next come some utility classes: Period, Instant, and Duration. The course digs into working with and across timezones. The last lesson investigates how to represent movements in time based on strictly human calendar concepts using the TemporalAdjuster class.
Module 6, “Working with Lists,” investigates the list concept and looks closer at the two most common implementations of the concept, ArrayList and Linked List, along with the List interface. For these, the module looks at declaration, initialization, and key methods, including the static and default methods defined in the interface. One lesson provides an introduction to Java’s generics mechanism as a tool for making the use of lists cleaner. The module investigates how the list interface separates the ways of interacting with a list from the details of any particular implementation being used. Finally, the module investigates performance comparisons between the ArrayList and LinkedList implementations.
About Pearson Video Training
Pearson publishes expert-led video tutorials covering a wide selection of technology topics designed to teach you the skills you need to succeed. These professional and personal technology videos feature world-leading author instructors published by your trusted technology brands: Addison-Wesley, Cisco Press, Pearson IT Certification, Sams, and Que. Topics include IT Certification, Network Security, Cisco Technology, Programming, Web Development, Mobile Development, and more.
Learn more about Pearson Video training at http://www.informit.com/video .
Introduction
Core Java Data Types: Introduction
Module 1: Understanding Declarations and Primitive Data Types
Module Introduction
Lesson 1: Declaring and initializing variables
Learning objectives
1.1 Using the general form of simple declarations
1.2 Using the general form of initialized declarations
Lesson 2: Identifying the scope of variables
Learning objectives
2.1 Understanding of scope, blocks, and curly braces
2.2 Investigating special cases of scope
Lesson 3: Understanding primitive literal forms
Learning objectives
3.1 Understanding integer primitives and literals
3.2 Understanding floating point primitives and literals
3.3 Working with logical and character primitives and literals
Lesson 4: Casting and promoting primitive values
Learning objectives
4.1 Casting primitive types
4.2 Promoting operands
4.3 Special cases of promotion
Lesson 5: Using local variable type inference
Learning objectives
5.1 Introducing the var pseudo-type
5.2 Understanding limitations of var
5.3 Investigating var further
Module 2: Working With Core Text Representations
Module Introduction
Lesson 6: Working with the String class
Learning objectives
6.1 Creating String objects
6.2 Understanding String Immutability
6.3 Using common String method
6.4 Comparing String objects
Lesson 7: Working with the StringBuilder class
Learning objectives
7.1 Understanding the common StringBuilder constructors
7.2 Using methods that modify StringBuilder objects
7.3 Reading, searching, and mutating StringBuilder objects
Lesson 8: More text features
Learning objectives
8.1 Investigating recent additions to text APIs
Module 3: Representing Numbers as Objects
Module Introduction
Lesson 9: Using primitive wrappers
Learning objectives
9.1 Primitive wrappers and autoboxing
9.2 Key elements of wrapper APIs
Lesson 10: Using high precision numbers
Learning objectives
10.1 Working with BigInteger
10.2 Working with BigDecimal–part 1
10.3 Working with BigDecimal–part 2
10.4 Working with BigDecimal–part 3
Module 4: Working with Java Arrays
Module Introduction
Lesson 11: Using single-dimensional arrays
Learning objectives
11.1 Understanding array declarations and variables
11.2 Instantiating an array, array length
11.3 Initializing arrays by iteration, array indexes
11.4 Combining declaration and intialization of arrays
11.5 Using immediate array creation not in a declaration
11.6 Initializing arrays by copying
Lesson 12: Using multi-dimensional arrays
Learning objectives
12.1 Declaring multi-dimensional arrays
12.2 Using literal initialization of multi-dimensional arrays
12.3 Using iterative initialization of multi-dimensional arrays
12.4 Code examples for multi-dimensional arrays
Lesson 13: Working with the Arrays class
Learning objectives
13.1 Using Arrays.asList
13.2 Using Arrays.sort
13.3 Using Arrays.compare and Arrays.mismatch methods
13.4 Searching, copying, and filling with the Arrays class
13.5 Comparing arrays and converting to text
Module 5: Working with Date and Time
Module Introduction
Lesson 14: Working with date and time
Learning objectives
14.1 Creating time and date objects
14.2 Changing times and dates
Lesson 15: Using DateTimeFormatter
Learning objectives
15.1 Using the DateTimeFormatter
Lesson 16: Using Period, Instant, and Duration
Learning objectives
16.1 Comparing times and using Period
16.2 Working with Instant
16.3 Working with Duration
Lesson 17: Working with time zones
Learning objectives
17.1 Working with ZonedDateTime
17.2 ZonedDateTime and timezones
17.3 Investigating Temporal and TemporalAdjuster
Module 6: Working with List Types
Module Introduction
Lesson 18: Introducing ArrayList
Learning objectives
18.1 Understanding benefits of ArrayList
18.2 Declaring and initializing an ArrayList
18.3 Using common methods of ArrayList
18.4 Investigating documentation and code for ArrayList
Lesson 19: Introducing Simple Generics
Learning objectives
19.1 Understanding simple generics with the ArrayList
Lesson 20: Diving Deeper into Lists
Learning objectives
20.1 Understanding the List interface
20.2 Using static and default methods of List
20.3 Comparing ArrayList and LinkedList–part 1
20.4 Comparing ArrayList and LinkedList–part 2
Summary
Core Java Data Types: Summary