Nanodegree key: nd079
Version: 1.0.0
Locale: en-us
This Nanodegree program is intended to elevate your Java abilities and teach you the fundamental skills used by Java developers to design, code, test and deploy cutting-edge Java software.
Content
Part 01 : Welcome to the Java Programming Nanodegree Program
Welcome to Udacity! We're excited to share more about your nanodegree and start this journey with you!
In this course, you will learn more about the pre-requisites, structure of the program, and getting started!
-
Module 01: Welcome
-
Lesson 01: Java Programming Nanodegree Program Introduction
Welcome to Udacity! We're excited to share more about your Nanodegree and start this journey with you.
-
Lesson 02: Mentor Help, Peer Chat, and Careers
You are starting a challenging but rewarding journey! Take 5 minutes to read how to get help with projects and content.
-
Part 02 : Java Fundamentals
In order to be a great Java developer you must first learn the fundamentals of Java. This course introduces the fundamental concepts and practices of Java programming. These include basic Object-oriented Programming (OOP) concepts such as classes, encapsulation and inheritance, as well as core Java concepts such as collections, exceptions and commonly used Java types.
-
Module 01: Course 2
-
Lesson 01: Introduction to Java
In this lesson, we'll cover some fundamentals—such as why you would want to learn Java, and what prerequisites you'll need to succeed in the course.
- Concept 01: Meet Your Instructor
- Concept 02: Course Overview
- Concept 03: What You'll Build
- Concept 04: What is Java and Why Should I Learn it?
- Concept 05: Prerequisites
- Concept 06: Tools, Environment & Dependencies
- Concept 07: Business Stakeholders
- Concept 08: When to Use Java
- Concept 09: Lesson Review
-
Lesson 02: Java Programing Basics
This lesson covers all the major building blocks we need to create a simple Java app, including keywords, variables, loops, methods, access modifiers, arrays, and Javadoc.
- Concept 01: Lesson Overview
- Concept 02: Java Keywords
- Concept 03: Variables
- Concept 04: Exercise: Getting Started
- Concept 05: Primitives vs Objects
- Concept 06: Type Casting
- Concept 07: Truncation
- Concept 08: Methods
- Concept 09: Exercise: Methods (Part 1)
- Concept 10: Exercise: Methods (Part 2)
- Concept 11: Stack vs Heap
- Concept 12: Access Modifers
- Concept 13: Arrays
- Concept 14: Exercise: Arrays
- Concept 15: Loops
- Concept 16: Exercise: Loops
- Concept 17: Exercise: IntelliJ
- Concept 18: JavaDoc
- Concept 19: Exercise: JavaDoc
- Concept 20: Lesson Review
-
Lesson 03: Defining Classes
In this lesson, we'll learn about what an object is, what a class is, and how we can create (or instantiate) objects from classes.
-
Lesson 04: Object-Oriented Programming
In this lesson, we'll go deeper into objects and classes and learn about some of the advanced concepts of object-oriented programming, including inheritance and polymorphism.
-
Lesson 05: Common Types
We'll learn about some of the important class types provided by the Java API, including Exceptions, Enums, RegEx, Dates and Calendar, and advanced String features.
- Concept 01: Lesson Overview
- Concept 02: Exceptions
- Concept 03: Handling Exceptions
- Concept 04: Exercise: Exceptions
- Concept 05: Enums
- Concept 06: Scanner
- Concept 07: Exercise: Scanner
- Concept 08: Dates and Calendar
- Concept 09: Exercise: Dates and Calendar
- Concept 10: RegEx
- Concept 11: Exercise: RegEx
- Concept 12: String Methods
- Concept 13: Lesson Review
-
Lesson 06: Generics and Collections
Working with multiple types can introduce some challenges. In this lesson we'll learn how two tools—generics and collections—can help us address these challenges and make our code type safe.
-
Lesson 07: Advanced Collections
In this lesson we'll learn about maps, sets and queues. Each of these provides a uniquely powerful data structure that, when used correctly, can solve complex problems efficiently.
-
Lesson 08: Hotel Reservation Application
In this project, you will demonstrate your new Java skills by creating a fully functional hotel reservation app that will allow customers to check room availability and book a room.
-
Part 03 : Advanced Java Programming Techniques
The best Java programs combine excellent software designs with modern language features. This course will teach you some lesser known features of Java, such as functional programming, I/O, serialization, and reflection. Strengthen your software design intuition by exploring the design ideas that underpin understandable, extensible and scalable software systems. Learn the basic concepts and techniques of concurrent programming in Java, so your programs can take advantage of modern, multi-core hardware.
-
Module 01: Course 2
-
Lesson 01: Introduction to Advanced Java Programming Techniques
In this lesson, you'll be introduced to the course and what to expect!
-
Lesson 02: Functional Programming in Java
In this lesson, you'll learn how to implement lambdas, functional interfaces, and other Java functional programming tools.
- Concept 01: Introduction
- Concept 02: Big Picture & Intuition
- Concept 03: Using Lambda Expressions
- Concept 04: Functional Interfaces
- Concept 05: Quiz: Functional Interfaces
- Concept 06: Exercise: Defining a Functional Interface
- Concept 07: Solution: Defining a Functional Interface
- Concept 08: Anonymous Subclasses
- Concept 09: Limitations of Lambdas
- Concept 10: Exercise: Lambdas
- Concept 11: Solution: Lambdas
- Concept 12: Edge Case: Capturing Variables
- Concept 13: Method References
- Concept 14: The Stream API
- Concept 15: Stream API: Collectors
- Concept 16: Optional Type
- Concept 17: Exercise: Stream API
- Concept 18: Solution: Stream API
- Concept 19: Lesson Conclusion
-
Lesson 03: Working with Files & I/O
In this lesson, you'll learn how to use files and streams in Java.
- Concept 01: Introduction
- Concept 02: Big Picture and Intuition
- Concept 03: File & Path APIs
- Concept 04: Input & Output Streams
- Concept 05: Readers & Writers
- Concept 06: Edge Case: Character Encodings
- Concept 07: Buffered Streams
- Concept 08: Exercise: Buffered Streams
- Concept 09: Solution: Buffered Streams
- Concept 10: Preventing Resource Leaks
- Concept 11: Exercise: Preventing Resource Leaks
- Concept 12: Solution: Preventing Resource Leaks
- Concept 13: Representing Data
- Concept 14: Java Object Serialization
- Concept 15: Exercise: Java Object Serialization
- Concept 16: Solution: Java Object Serialization
- Concept 17: Edge Case: Avoid Java Serialization
- Concept 18: Working with JSON
- Concept 19: Exercise: Jackson
- Concept 20: Solution: Jackson
- Concept 21: Lesson Conclusion
-
Lesson 04: Design Patterns
In this lesson, you'll learn about common design patterns and when to use them.
- Concept 01: Introduction
- Concept 02: Big Picture and Intuition
- Concept 03: Creational Patterns
- Concept 04: Edge Case: Singleton Anti-pattern
- Concept 05: Abstract Factory
- Concept 06: Builder
- Concept 07: Exercise: Builder
- Concept 08: Solution: Builder
- Concept 09: Behavioral Patterns
- Concept 10: Strategy
- Concept 11: Template Method
- Concept 12: Structural Patterns
- Concept 13: Adapter Pattern
- Concept 14: Exercise: Adapter Pattern
- Concept 15: Solution: Adapter Pattern
- Concept 16: Decorator Pattern
- Concept 17: Dependency Injection
- Concept 18: Exercise: Dependency Injection
- Concept 19: Solution: Dependency Injection
- Concept 20: Edge Case: Dependency Injection Disadvantages
- Concept 21: Lesson Conclusion
-
Lesson 05: Reflection
In this lesson, you'll learn reflection, the ability of a program to examine its own structure at runtime.
- Concept 01: Introduction
- Concept 02: Big Picture and Intuition
- Concept 03: Annotations
- Concept 04: Defining Custom Annotations
- Concept 05: Exercise: Defining Custom Annotations
- Concept 06: Solution: Defining Custom Annotations
- Concept 07: Reflection API
- Concept 08: Exercise: Reflection API
- Concept 09: Solution: Reflection API
- Concept 10: Dynamic Proxy
- Concept 11: Exercise: Dynamic Proxy
- Concept 12: Solution: Dynamic Proxy
- Concept 13: Aspect Oriented Programming (AOP)
- Concept 14: How Java Loads Classes
- Concept 15: Exercise: Custom ClassLoaders
- Concept 16: Solution: Custom ClassLoader
- Concept 17: Lesson Conclusion
-
Lesson 06: Introduction to Concurrent Programming
In this lesson, you'll be introduced to concurrency and threading in Java.
- Concept 01: Introduction
- Concept 02: Big Picture and Intuition
- Concept 03: Threads
- Concept 04: Exercise: Threads
- Concept 05: Solution: Threads
- Concept 06: Edge Case: Thread Execution Order
- Concept 07: Limits of Parallelism
- Concept 08: Thread Pools and Executors
- Concept 09: ForkJoin Pools
- Concept 10: Parallel Streams
- Concept 11: Exercise: Parallel Streams
- Concept 12: Solution: Parallel Streams
- Concept 13: Synchronization
- Concept 14: Immutable Objects
- Concept 15: The "synchronized" Keyword
- Concept 16: Advanced Synchronization
- Concept 17: Exercise: Synchronization
- Concept 18: Solution: Synchronization
- Concept 19: Lesson Conclusion
- Concept 20: Course Recap
- Concept 21: Congratulations!
-
Lesson 07: Project: Parallel Web Crawler
In this lesson, you will create a parallel web crawler to replace legacy code at a large company.
- Concept 01: Welcome to UdaciSearch!
- Concept 02: Getting Started
- Concept 03: Crawler Configuration
- Concept 04: Crawler Output
- Concept 05: Legacy Crawler
- Concept 06: Parallel Crawler
- Concept 07: Functional Counting
- Concept 08: Performance Profiler
- Concept 09: Let's Run It!
- Concept 10: Written Questions
-
Part 04 : Java Application Deployment
This course introduces Java ecosystem topics that are necessary to develop production-ready applications. It starts by covering the construction and makeup of Java program artifacts. You will learn how Java program code is compiled, packaged and executed. Next, you’ll learn how to use Maven to automate and customize the build process, as well as manage external project dependencies. This course also covers the topic of Modules, introduced in Java 9. In addition to build topics, this course will also teach you to use the tools of JUnit 5 to write unit tests and evaluate code coverage. To expand our testing capabilities for complex applications, the Mockito library and test doubles will be covered as well.
-
Module 01: Java Application Deployment
-
Lesson 01: Introduction to Java Application Deployment
In this lesson, you'll be introduced to the course and what to expect!
-
Lesson 02: Running Java Applications
In this lesson you'll learn how to run and package Java applications.
- Concept 01: Introduction
- Concept 02: Java Bytecode
- Concept 03: Quizzes: Java Bytecode
- Concept 04: Java Development Kit
- Concept 05: Building Java Applications
- Concept 06: Quizzes: Building Java Applications
- Concept 07: Exercise: Building Java Applications
- Concept 08: Solution: Building Java Applications
- Concept 09: Running Java Applications
- Concept 10: Quizzes: Running Java Applications
- Concept 11: JShell
- Concept 12: Exercise: JShell
- Concept 13: Solution: JShell
- Concept 14: JVM Development
- Concept 15: Lesson Conclusion
-
Lesson 03: Dependency Management with Maven
In this lesson, you'll learn about different types of dependencies and how to manage them with Maven.
- Concept 01: Introduction
- Concept 02: Introduction to Maven
- Concept 03: Introduction to XML
- Concept 04: Quizzes: XML
- Concept 05: Exercise: XML
- Concept 06: Solution: XML
- Concept 07: Maven Projects
- Concept 08: Quizzes: Maven Projects
- Concept 09: Exercise: Maven Projects
- Concept 10: Solution: Maven Projects
- Concept 11: Maven Project Structure
- Concept 12: Importing Dependencies
- Concept 13: Dependency Scope and Type
- Concept 14: Exclusions and Transitive Dependencies
- Concept 15: Quizzes: Dependencies
- Concept 16: Exercise: Dependencies
- Concept 17: Solution: Dependencies
- Concept 18: POM Inheritance
- Concept 19: Maven Plugins
- Concept 20: Quizzes: Plugins
- Concept 21: Exercise: Plugins
- Concept 22: Solution: Plugins
- Concept 23: Maven Properties
- Concept 24: Reporting
- Concept 25: Exercise: SpotBugs
- Concept 26: Solution: SpotBugs
- Concept 27: Maven in IntelliJ
- Concept 28: Other Build Tools
- Concept 29: Lesson Conclusion
-
Lesson 04: Java Modules
In this lesson, you'll learn how to divide projects into modules in Java.
- Concept 01: Introduction to Modules
- Concept 02: What is a Module?
- Concept 03: Defining Java Modules
- Concept 04: Module Types
- Concept 05: Quizzes: Module Types
- Concept 06: Exercise: Module Types
- Concept 07: Solution: Module Types
- Concept 08: Java Linker
- Concept 09: Exercise: Java Linker
- Concept 10: Solution: Java Linker
- Concept 11: Migration to Java 9 Modules
- Concept 12: Exercise: Upgrading Your Code
- Concept 13: Solution: Upgrading Your Code
- Concept 14: Lesson Conclusion
-
Lesson 05: Unit Testing With Java
In this lesson, you'll learn how to write unit tests in Java.
- Concept 01: Introduction to Unit Testing
- Concept 02: JUnit
- Concept 03: Writing Unit Tests
- Concept 04: Quiz: Writing Unit Tests
- Concept 05: Exercise: Writing Unit Tests
- Concept 06: Solution: Writing Unit Tests
- Concept 07: Parameterized and Repeated Tests
- Concept 08: Unit Test Lifecycle
- Concept 09: Quizzes: Additional Unit Test Topics
- Concept 10: Exercise: Additional Unit Test Topics
- Concept 11: Solution: Additional Unit Test Topics
- Concept 12: Writing Good Unit Tests
- Concept 13: Code Coverage
- Concept 14: Quizzes: Unit Tests
- Concept 15: Exercise: Code Coverage
- Concept 16: Solution: Code Coverage
- Concept 17: Tests in Maven
- Concept 18: Lesson Conclusion
-
Lesson 06: Test Doubles, Mocking, and Integration Testing
In this lesson, you'll learn how to write more complex tests in Java.
- Concept 01: Introduction
- Concept 02: Testing and Class Design
- Concept 03: Test Doubles
- Concept 04: Quizzes: Test Doubles
- Concept 05: Exercise: Test Doubles
- Concept 06: Solution: Test Doubles
- Concept 07: Mockito
- Concept 08: Argument Matchers
- Concept 09: Quizzes: Mockito and Matchers
- Concept 10: Exercise: Mockito
- Concept 11: Solution: Argument Matchers
- Concept 12: Mockito Verify
- Concept 13: Exercise: Mockito Verify
- Concept 14: Solution: Mockito Verify
- Concept 15: Integration Testing
- Concept 16: Quizzes: Integration Testing
- Concept 17: Exercise: Integration Testing
- Concept 18: Solution: Integration Testing
- Concept 19: Continuous Integration
- Concept 20: Lesson Conclusion
- Concept 21: Course Recap
- Concept 22: Congratulations!
-
Lesson 07: Project: UdaSecurity
In this lesson, you'll create modules, write unit tests, and package your project for others to use.
-
Part 05 : Career Services
The Careers team at Udacity is here to help you move forward in your career - whether it's finding a new job, exploring a new career path, or applying new skills to your current job.
-
Module 01: Career Services
-
Lesson 01: Take 30 Min to Improve your LinkedIn
Find your next job or connect with industry peers on LinkedIn. Ensure your profile attracts relevant leads that will grow your professional network.
- Concept 01: Get Opportunities with LinkedIn
- Concept 02: Use Your Story to Stand Out
- Concept 03: Why Use an Elevator Pitch
- Concept 04: Create Your Elevator Pitch
- Concept 05: Use Your Elevator Pitch on LinkedIn
- Concept 06: Create Your Profile With SEO In Mind
- Concept 07: Profile Essentials
- Concept 08: Work Experiences & Accomplishments
- Concept 09: Build and Strengthen Your Network
- Concept 10: Reaching Out on LinkedIn
- Concept 11: Boost Your Visibility
- Concept 12: Up Next
-
Lesson 02: Optimize Your GitHub Profile
Other professionals are collaborating on GitHub and growing their network. Submit your profile to ensure your profile is on par with leaders in your field.
- Concept 01: Prove Your Skills With GitHub
- Concept 02: Introduction
- Concept 03: GitHub profile important items
- Concept 04: Good GitHub repository
- Concept 05: Interview with Art - Part 1
- Concept 06: Identify fixes for example “bad” profile
- Concept 07: Quick Fixes #1
- Concept 08: Quick Fixes #2
- Concept 09: Writing READMEs with Walter
- Concept 10: Interview with Art - Part 2
- Concept 11: Commit messages best practices
- Concept 12: Reflect on your commit messages
- Concept 13: Participating in open source projects
- Concept 14: Interview with Art - Part 3
- Concept 15: Participating in open source projects 2
- Concept 16: Starring interesting repositories
- Concept 17: Next Steps
-
Part 06 : Congratulations!
Congratulations on finishing your program!
-
Module 01: Congratulations!
-
Lesson 01: Congratulations!
Congratulations on your graduation from this program! Please join us in celebrating your accomplishments.
-