Get $1 credit for every $25 spent!

Java Developer Course Bundle

Courses
5
Lessons
531
Enrolled
3,693

What's Included

Product Details

Access
Lifetime
Content
8 hours
Lessons
100

Beginner Java Essentials for Android Course

The Java Skills Required for Developing Android Apps

By Udemy | in Online Courses

  • 100 lectures including 8+ hours of high quality content
  • Introduction to Java concepts you will need to develop on Android
  • Covers Java data types, strings, control structures, methods, classes, arrays, and more
  • Lessons use an automated tutor, proven to significantly improve student learning
  • Understand automated testing with JUnit
  • Introduction to Android
  • Understand Eclipse IDE to install the professional tools you need for Java & Android development
  • Certificate of completion
Dr. David Janzen has been teaching students and professionals to program for over 15 years. He is a Professor of Computer Science at Cal Poly in San Luis Obispo, a consultant and trainer with Simex, and co-founder of Steadfast Innovation, LLC, creators of the Papyrus natural note-taking app.

Details & Requirements

  • Length of time users can access this course: lifetime
  • Access options: web streaming
  • Certification of completion included
  • Redemption deadline: redeem your code within 30 days of purchase
  • Experience level required: all level

Compatibility

  • Internet browser required

Course Outline

  • Section 1: Welcome
    • Lecture 1 - Welcome
  • Section 2: Programming Environment
    • Lecture 2 - Programming Playground
  • Section 3: Primitive Data Types
    • Lecture 3 - Java Int Operations
    • Lecture 4 - Int Operations Code (Optional)
    • Lecture 5 - Java Int Operations Lab
    • Lecture 6 - Java Data Types
    • Lecture 7 - Data Type Examples
    • Lecture 8 - Int Examples (Optional)
    • Lecture 9 - Variable Declarations Lecture
    • Lecture 10 - More Primitive Data Types
    • Lecture 11 - Float Examples (Optional)
    • Lecture 12 - Char Examples (Optional)
    • Lecture 13 - Boolean Examples (Optional)
    • Lecture 14 - Java Data Types, Variables, and Assignment Lab
  • Section 4: Constants, Casting and Comments
    • Lecture 15 - Constants
    • Quiz 1 - Constants Quiz
    • Lecture 16 - Constants Examples (Optional)
    • Lecture 17 - Float Division And Math Library
    • Lecture 18 - Math Examples (Optional)
    • Quiz 2 - Floats and Math Library Quiz
    • Lecture 19 - Casting
    • Lecture 20 -Casting Examples (Optional)
    • Lecture 21 - Casting Char Examples (Optional)
    • Quiz 3 - Casting Quiz
    • Lecture 22 - Comments
    • Lecture 23 - Comments Examples (Optional)
  • Section 5: Strings
    • Lecture 24 - String Concatenation
    • Lecture 25 - String Concatenation Examples (Optional)
    • Lecture 26 - Strings
    • Lecture 27 - Strings Examples (Optional)
    • Lecture 28 - String Lecture
    • Lecture 29 - String Lecture Examples (Optional)
    • Quiz 4 - Strings Quiz
  • Section 6: Selection Control Structures
    • Lecture 30 - If Then Else
    • Lecture 31 - If Then Else Examples (Optional)
    • Lecture 32 - More Comparison Operators
    • Lecture 33 - Comparison Operator Examples (Optional)
    • Lecture 34 - Multiple Conditions
    • Lecture 35 - Multiple Condition Examples (Optional)
    • Lecture 36 - Complementing Conditions
    • Lecture 37 - Complement Examples (Optional)
    • Lecture 38 - If Then Else Lab
    • Lecture 39 - Switch
    • Lecture 40 - Switch Examples (Optional)
    • Lecture 41 - If-Then-Else, Nested-If, and Switch Exercises
  • Section 7: Methods
    • Lecture 42 - Methods
    • Lecture 43 - Print Welcome Example (Optional)
    • Lecture 44 - Triple Example (Optional)
    • Lecture 45 - Max Example (Optional)
    • Lecture 46 - Is Positive Example (Optional)
    • Lecture 47 - Testing Methods with JUnit
    • Lecture 48 - Testing Methods With JUnit (Optional)
    • Lecture 49 - More Methods (isOdd)
    • Lecture 50 - isOdd Method (Optional)
    • Lecture 51 - More Methods (isValid)
    • Lecture 52 - isValid Method (Optional)
    • Lecture 53 - Methods with Local Variables
    • Lecture 54 - Get Largest
    • Lecture 55 - Methods Lab
  • Section 8: Programming in Eclipse (Optional - use Android Studio instead for Android)
    • Lecture 56 - Install Eclipse on a Mac
    • Lecture 57 - Eclipse Hello World
    • Lecture 58 - JUnit testing in Eclipse
    • Lecture 59 - Customizing Eclipse Section 9: Classes
    • Lecture 60 - Classes with Static Methods
    • Lecture 61 - Classes with Static Methods (Distance Converter)
    • Lecture 62 - Classes with Instance Methods
    • Lecture 63 - Classes with Instance Methods (Balloon)
    • Lecture 64 - Classes Lecture
    • Lecture 65 - Constructors
    • Lecture 66 - Class Examples In Apps
    • Lecture 67 - Classes Lab Section 10: Inheritance, Interfaces, and Abstract Classes
    • Lecture 68 - Inheritance
    • Lecture 69 - More Inheritance
    • Lecture 70 - Inheritance
    • Lecture 71 - Interfaces
    • Lecture 72 - Interfaces (Weighable)
    • Lecture 73 - Using Existing Java Interfaces
    • Lecture 74 - Interfaces Java API (Burger)
    • Lecture 75 - Interfaces Lecture
    • Lecture 76 - Abstract Classes
    • Lecture 77 - Abstract Classes (Dialer)
    • Lecture 78 - Inner Classes
  • Section 11: Looping Control Structures
    • Lecture 79 - Loops
    • Lecture 80 - Loops Lab
  • Section 12: Arrays
    • Lecture 81 - Arrays
    • Lecture 82 - Using Arrays with Methods
    • Lecture 83 - Arrays Lecture
    • Lecture 84 - Arrays of Objects
    • Lecture 85 - Arrays Lab
  • Section 13: ArrayLists
    • Lecture 86 - ArrayLists
    • Lecture 87 - ArrayLists with Primitive Data Types
    • Lecture 88 - Foreach and Iterators
    • Lecture 89 - Array List Lecture
  • Section 14: Android with Android Studio
    • Lecture 90 - Android Studio Install
    • Lecture 91 - Android Hello World
    • Lecture 92 - Modify Hello World
  • Section 15: Android Labs in WebIDE (Optional)
    • Lecture 93 - Hello World Lab
    • Lecture 94 - Rock, Paper, Scissors Lab
    • Lecture 95 - Tic Tac Toe Lab
  • Section 16: Android with Eclipse (Deprecated - i.e.Not Recommended, but here if you need it)
    • Lecture 96 - Eclipse Android Install (Not Recommended)
    • Lecture 97 - Android Hello World
    • Lecture 98 - Android Eclipse AVD Troubleshooting
    • Lecture 99 - Tour of Hello World
    • Lecture 100 - Rock, Paper, Scissors
    • Lecture 101 - Modify Hello World
    • Lecture 102 - Hello World Modification (Optional)
  • Section 17: Conclusion
    • Lecture 103 - Additional Resources and Conclusion

View Full Curriculum


Access
Lifetime
Content
10 hours
Lessons
64

Dynamic Website Building with Java Course

Understand Servlets & JSPs to Build Interactive Websites

By udemy | in Online Courses

  • 64 lectures and 10+ hours of content
  • Understand the basics of Java in order to build dynamic websites
  • Deploy your newly created website to the Internet
  • Navigate core server-side Java web technologies
  • Use servlets, JSPs, and JSTL to create interactive websites
After working as a software developer and contractor for over 14 years for many companies including CSC, Proquest, SPSS, and AT&T in the UK and Netherlands, John decided to work full-time as a private software trainer. He currently runs the website Cave of Programming.

Details & Requirements

  • Length of time users can access this course: lifetime
  • Access options: web streaming
  • Certification of completion included
  • Redemption deadline: redeem your code within 30 days of purchase
  • Experience level required: all level

Compatibility

  • Basic Java knowledge required
  • Basic HTML and SQL knowledge preferred
  • Internet browser to watch and learn

Course Outline

  • Section 1: Getting Started
    • Lecture 1 - Introduction
    • Lecture 2 - Setting Up Your System
    • Lecture 3 - A "Hello World" Servlet
    • Lecture 4 - A "Hello World" JSP (Java Server Page)
    • Lecture 5 - Deployment Descriptors: the Web.xml File
    • Lecture 6 - Deploying Your Application to a Local Server
    • Lecture 7 - Important Note ...
    • Lecture 8 - Deploying Your Application to the Internet -- For Free
  • Section 2: Nuts and Bolts
    • Lecture 9 - Importing Java Classes Into JSPs
    • Lecture 10 - Getting URL Parameters
    • Lecture 11 - Scripting HTML
    • Lecture 12 - Including Files In Other Files
    • Lecture 13 - Forwarding and Redirecting
    • Lecture 14 - The Declaration Tag
    • Lecture 15 - JSP Tags Summary
    • Lecture 16 - Model 1 vs. Model 2 Architecture
    • Lecture 17 - Using External APIs in Web Applications
    • Lecture 18 - The Servlet Lifecycle
  • Section 3: Beans and Forms
    • Lecture 19 - JSP Beans
    • Lecture 20 - Beans and Scope
    • Lecture 21 - Setting Bean Properties Using Parameters
    • Lecture 22 - Forms
    • Lecture 23 - HTTP Posts
    • Lecture 24 - Using Beans to Store Form Data
    • Lecture 25 - Adding Validation to Beans
    • Lecture 26 - Self-Validating Forms
    • Lecture 27 - Validating Forms Using MVC Architecture
  • Section 4: Some Useful Objects
    • Lecture 28 - The Session Object
    • Lecture 29 - URL Rewriting: Supporting Sessions Without Cookies
    • Lecture 30 - The Servlet Context Object
    • Lecture 31 - Getting Initialisation Parameters from web.xml
    • Lecture 32 - Scoped Objects Review
    • Lecture 33 - Cookies
  • Section 5: Databases
    • Lecture 34 - Connecting to a Database
    • Lecture 35 - Setting Up a JNDI Data Source
    • Lecture 36 - Querying Databases
    • Lecture 37 - Inserting Data Into Databases
  • Section 6: Sending Emails
    • Lecture 38 - Sending Emails: Prerequisites
    • Lecture 39 - Sending Emails with the Mail API
  • Section 7: Simplify Your Code With JSTL
    • Lecture 40 - Beginning JSTL: Hello World JSTL
    • Lecture 41 - Accessing Bean Values in JSTL
    • Lecture 42 - Getting URL Parameters in JSTL
    • Lecture 43 - The JSTL "if" Statement
    • Lecture 44 - The Choose Tag in JSTL
    • Lecture 45 - The foreach loop in JSTL
    • Lecture 46 - Referencing Java Objects in JSTL
    • Lecture 47 - JSTL Implicit Objects
    • Lecture 48 - Using Maps in EL
    • Lecture 49 - Outputting Variables: The c:out Tag vs. Using EL Directly
    • Lecture 50 - forEach: Iterating Through Lists
    • Lecture 51 - Using External Files: Graphics, CSS, etc
    • Lecture 52 - Reusable Fragments Using JSTL c:import
    • Lecture 53 - SQL Queries with JSTL
    • Lecture 54 - Setting Variables in JSTL
    • Lecture 55 - Expressions in EL
    • Lecture 56 - Creating URLs With JSTL
    • Lecture 57 - Wildcards and Getting a Single Row in JSTL
    • Lecture 58 - JSTL Functions
    • Lecture 59 - SQL Updates and Transactions in JSTL
    • Lecture 60 - Formatting Using JSTL
    • Lecture 61 - Custom Tags
  • Section 8: Source Code
    • Lecture 62 - Source Code
  • Section 9: Where Now?
    • Lecture 63 - Some Final Words ....
  • Section 10: Extra!
    • Lecture 64 - Uploading Files: Allowing the User to Upload Images and Other Stuff

View Full Curriculum


Access
Lifetime
Content
28 hours
Lessons
174

Java Spring Framework Course

Navigate the Popular Java Framework + Spring MVC & Hibernate

By udemy | in Online Courses

  • 174+ lectures and 28+ hours of content
  • Understand the fundamentals of the Java Spring framework, starting with basic setup
  • Introduction to Maven, a great build automation tool
  • Develop web and database applications, and learn to wire together Java objects with Spring
  • Introduction to Hibernate for object-oriented database manipulation using Java
After working as a software developer and contractor for over 14 years for many companies including CSC, Proquest, SPSS, and AT&T in the UK and Netherlands, John Purcell decided to work full-time as a private software trainer. He currently runs the website Cave of Programming.

Details & Requirements

  • Length of time users can access this course: lifetime
  • Access options: web streaming
  • Certification of completion included
  • Redemption deadline: redeem your code within 30 days of purchase
  • Experience level required: advanced

Compatibility

  • Familiarity with Java
  • Knowledge of HTML, servlets, and JSPs recommended
  • Understanding of XML recommended
  • Knowledge of SQL and databases is helpful

Course Outline

  • Section 1: Getting Started
    • Lecture 1 - What is Spring?
    • Lecture 2 - About Spring 4, and bug fix for final project
    • Lecture 3 - Setting Up Your System
    • Lecture 4 - Introducing Maven
    • Lecture 5 - Using Maven on the Command Line
    • Lecture 6 - Spring "Hello World"
    • Lecture 7 - Class Path Contexts
    • Section 2: Basic Bean Configuration
    • Lecture 8 - Constructor Arguments
    • Lecture 9 - Setting Bean Properties
    • Lecture 10 - Dependency Injection
    • Lecture 11 - Bean Scope
    • Lecture 12 - Init and Destroy Methods
    • Lecture 13 - Factory Beans and Methods
    • Lecture 14 - The P Namespace
    • Lecture 15 - Setting List Properties
    • Lecture 16 - Lists of Beans
    • Lecture 17 - Inner Beans
    • Lecture 18 - Property Maps
    • Lecture 19 - Arbitrary Maps as Bean Properties
  • Section 3: Autowiring
    • Lecture 20 - Autowiring by Type
    • Lecture 21 - Autowiring by Name
    • Lecture 22 - Autowiring by Constructor
    • Lecture 23 - Default Autowiring
    • Lecture 24 - Removing Autowire Ambiguities
  • Section 4: Wiring with Annotations
    • Lecture 25 - Adding Support for Annotation-Based Wiring
    • Lecture 26 - The "Autowired" Annotation
    • Lecture 27 - Optional Beans
    • Lecture 28 - Using Qualifiers
    • Lecture 29 - The Resource Annotation (JSR-250)
    • Lecture 30 - Annotation-Based Init and Destroy Methods
    • Lecture 31 - The Inject annotation (JSR-330)
    • Lecture 32 - Automatic Bean Discovery
    • Lecture 33 - Setting Property Values via Annotations
  • Section 5: Spring Expression Language (SPEL)
    • Lecture 34 - Introducing SPEL
    • Lecture 35 - Using SPEL with Annotations
    • Lecture 36 - Some useful SPEL Operators
  • Section 6: Working with Databases
    • Lecture 37 - Creating a Database with MySQL
    • Lecture 38 - Using Property Files
    • Lecture 39 - Implementing the DAO Pattern
    • Lecture 40 - Downloading a Connector Jar
    • Lecture 41 - Configuring Connection Pooling with Apache DBCP
    • Lecture 42 - JDBC Templates
    • Lecture 43 - Querying the Database
    • Lecture 44 - Database Exceptions
    • Lecture 45 - Named Parameters
    • Lecture 46 - Update Statements
    • Lecture 47 - Getting Placeholder Values from Beans
    • Lecture 48 - Adding an Update Method to the DAO
    • Lecture 49 - Batch Updates: Prepared Statements
    • Lecture 50 - Transactions
  • Section 7: Web Application Basics with Spring MVC
    • Lecture 51 - A Basic Non-Spring Web App
    • Lecture 52 - Bringing in Maven
    • Lecture 53 - The Dispatcher Servlet
    • Lecture 54 - Adding a Controller
    • Lecture 55 - View Resolvers
    • Lecture 56 - Adding Data to the Session
    • Lecture 57 - Using Spring Data Models
    • Lecture 58 - Using JSTL (JSP Standard Tag Library)
    • Lecture 59 - Configuring a JNDI Data Source
    • Lecture 60 - Bringing in the DAO Code
    • Lecture 61 - Loading Bean Containers with ContextLoaderListener
    • Lecture 62 - Creating a Datasource Bean
    • Lecture 63 - Adding a Service Layer
    • Lecture 64- Adding a New Controller
    • Lecture 65 - Getting URL Parameters
  • Section 8: Working with Web Forms
    • Lecture 66- -Creating a Form
    • Lecture 67- Getting Form Values
    • Lecture 68 - Adding CSS Styles
    • Lecture 69 - Serving Static Resources
    • Lecture 70- Adding Hibernate Form Validation Support
    • Lecture 71 - More Form Validation Tags
    • Lecture 72 - Making Forms Remember Values
    • Lecture 73 - Displaying Form Validation Errors
    • Lecture 74 - Creating a Custom Validation Annotation
    • Lecture 75 - Hooking Up the Controller and Database Code
    • Lecture 76 - Exception Handling in Spring MVC
  • Section 9: Aspect-Oriented Programming (AOP)
    • Lecture 77 - A Base Project for Working with Aspects
    • Lecture 78- A Simple Aspect Example
    • Lecture 79- Annotation-Based Aspects
    • Lecture 80- Wildcards in Pointcut Expressions
    • Lecture 81- Advice Types: After, Around and Others
    • Lecture 82- Proxies, Interfaces and Aspects
    • Lecture 83- The “Within” Pointcut Designator
    • Lecture 84- “This”, “Target” and Matching Subpackages
    • Lecture 85 - Annotation-Specific PCDs
    • Lecture 86 - The “Bean” PCD
    • Lecture 87 - The “Args” PCD
    • Lecture 88 - Getting Target Method Arguments
    • Lecture 89 - Getting Arguments Using “Args”
    • Lecture 90 - Combining Pointcuts
    • Lecture 91- Introductions: Adding Functionality Using Aspects
  • Section 10: Spring Security and Managing Users
    • Lecture 92 - Servlets Filters: A Review
    • Lecture 93 - Adding a Spring Security Filter
    • Lecture 94 - Adding a Spring Login Form
    • Lecture 95 - Serving Static Resources: Access Rules
    • Lecture 96 - Customising the Login Form
    • Lecture 97 - Displaying Login Errors
    • Lecture 98 - Authorising Users from a Database
    • Lecture 99 - Adding a “Create Account” Form
    • Lecture 100 - Making the “Create Account” Form Work
    • Lecture 101 - Adding Validation to the User Form
    • Lecture 102 - Dealing with Duplicate Usernames
    • Lecture 103 - Storing Validation Messages in a Property File
    • Lecture 104 - Using JQuery to verify the password
    • Lecture 105 - Using Property File Values in JSPs
    • Lecture 106 - Adding a Logout Link
    • Lecture 107 - Working With Roles
    • Lecture 108 - Outputting Text Based on Authentication Status
    • Lecture 109 - Row Mapping with BeanPropertyRowMapper
    • Lecture 110 - Using Custom Authentication Queries: Case Sensitive Usernames
    • Lecture 111 - Method-Level Access Control
    • Lecture 112 - Catching Secure Annotation Violations
    • Lecture 113 - Adding “Remember Me” Functionality
    • Lecture 114 - Encrypting Passwords
  • Section 11: Apache Tiles and Spring MVC
    • Lecture 115 - Tiles Dependencies
    • Lecture 116 - “Hello World” Apache Tiles
    • Lecture 117 - Adding Headers and Footers
    • Lecture 118 - Formatting the Offers Application
    • Lecture 119 - Creating Tiles from JSP Files
  • Section 12: Logging and Testing
    • Lecture 120 - Adding Log4J Logging
    • Lecture 121 - Resolving Logging Conflicts
    • Lecture 122 - Using Logging
    • Lecture 123 - Creating a MySQL Test Database
    • Lecture 124 - Using Spring Profiles
    • Lecture 125 - Creating JUnit Tests
    • Lecture 126 - Coding the JUnit DAO Tests
  • Section 13: Improving the "Offers" Web Application
    • Lecture 127 - Normalizing the Database
    • Lecture 128 - Querying Tables with Foreign Keys and Refactoring the DAO Layer
    • Lecture 129 - Refactoring the Web Layer
    • Lecture 130 - Getting the Username of the Logged-In User
    • Lecture 131 - Deleting from Tables with Foreign Keys and a Little Bugfix
    • Lecture 132 - Custom RowMappers
    • Lecture 133 - Conditional Database-Dependent Text in JSPs
    • Lecture 134 - Editing Database Objects with Forms
    • Lecture 135 - Multiple Form Submits and Optional Parameters
    • Lecture 136 - Adding a Confirm Dialog with JQuery
  • Section 14: Hibernate
    • Lecture 137 - Introducing Hibernate
    • Lecture 138 - A Simple Hibernate Query
    • Lecture 139 - Saving Objects
    • Lecture 140 - Validation Groups and Password Encryption
    • Lecture 141 - Translating Hibernate Exceptions to Spring Exceptions
    • Lecture 142 - Queries with Criteria
    • Lecture 143 - Mapping Many-to-One Relationships
    • Lecture 144 - Restrictions on Joined Tables
    • Lecture 145 - Multiple Criteria
    • Lecture 146 - Updating Objects
    • Lecture 147 - Deleting Objects
    • Lecture 148 - Completing the Offers DAO
  • Section 15: Spring Webflow
    • Lecture 149 - Introducing Webflow
    • Lecture 150 - Creating a Flow Registry
    • Lecture 151 - Hooking Up URLs to Webflows
    • Lecture 152 - Connecting Webflow and Apache Tiles
    • Lecture 153 - Creating a “Messages” Table
    • Lecture 154 - Creating a “Message” Class
    • Lecture 155 - Adding a Message Form
    • Lecture 156 - Transitions
    • Lecture 157 - Action States
    • Lecture 158 - Linking to Webflows
    • Lecture 159 - Validating Webflow Forms
    • Lecture 160 - Accessing User Details in Webflow
  • Section 16: JSON and AJAX
    • Lecture 161 - Creating a JSON Server
    • Lecture 162 - Updating Dynamically with jQuery
    • Lecture 163 - Generating Pages with Javascript
    • Lecture 164 - Adding Reply Boxes
    • Lecture 165 - Showing and Hiding the Reply Forms
    • Lecture 166 - Stopping and Starting the Timer
    • Lecture 167 - Getting the Text from the Right TextArea
    • Lecture 168 - Posting Back JSON Data
    • Lecture 169 - Giving the User Feedback
    • Lecture 170 - Sending Email with Springmail
  • Section 17: Outro
    • Lecture 171 - Some Final Words ...
  • Section 18: Appendix
    • Lecture 172 - Database SQL
    • Lecture 173 - All-in-one source code zip
    • Lecture 174 - Frequently Asked Questions: Problems? Check here ...
    • Lecture 175 - Recommended Books
    • Lecture 176 - 50%+ Discount: Servlets, JSPs and JSTL

View Full Curriculum


Access
Lifetime
Content
5 hours
Lessons
102

Java Data Structures & Algorithms Course

Introduction to the Fundamentals of Data Structures & Algorithms

By udemy | in Online Courses

  • 102 lectures with 5+ hours of content
  • Basic data structures: arrays, linked lists, stacks, queues, trees and heaps
  • Basic algorithms: various sorting algorithms, algorithms for operations on binary search trees, and heaps
  • Graphics and animations make the lectures easy to digest
  • Write your own algorithms and understand their quality of performance
A graduate of the Indian Institute of Technology, Raghavendra Dixit is a professional technical architect with about 14 years of programming experience. He has worked with languages like Perl, Java, Objective C, Scala, and JavaScript, as well as various framework and platforms like Spring, Play, Cocoa, and Android.

Details & Requirements

  • Length of time users can access this course: lifetime
  • Access options: web streaming
  • Certification of completion included
  • Redemption deadline: redeem your code within 30 days of purchase
  • Experience level required: all level

Compatibility

  • Knowledge of Java suggested
  • Internet browser

Course Outline

  • Section 1: Introduction to Algorithms
    • Lecture 1 - Introduction
    • Lecture 2 - Euclid's algorithm
    • Lecture 3 - Bubble Sort algorithm
    • Lecture 4 - Why study data structures & algorithms
    • Lecture 5 - Correctness of an algorithm
    • Quiz 1 - Chapter Quiz
  • Section 2: Analysis of Algorithms
    • Lecture 6 - Note on this section
    • Lecture 7 - Introduction
    • Lecture 8 - How to calculate the time complexity
    • Lecture 9 - The RAM model of computation
    • Lecture 10 - Time complexity of Bubble sort algorithm
    • Lecture 11 - Pseudo code : Bubble sort algorithm
    • Lecture 12 - The Big O notation
    • Lecture 13 - Big O notation : Examples
    • Lecture 14- Comparison of running times
    • Quiz 2 - Chapter Quiz
  • Section 3: Basic Sorting and Search Algorithms
    • Lecture 15 - Selection Sort
    • Lecture 16 - Selection Sort : Pseudocode
    • Lecture 17 - Introduction to Insertion Sort
    • Lecture 18 - Applying Insertion Sort algorithm to cue balls
    • Lecture 19 - Insertion Sort: Pseudocode
    • Lecture 20 - O(n²) sorting algorithms - Comparison
    • Lecture 21 - In place sorting
    • Lecture 22 - Stable Vs Unstable Sorts
    • Lecture 23 - Searching elements in an un ordered array
    • Lecture 24 - Searching elements in an ORDERED array
    • Lecture 25 - Searching elements in an ORDERED array - contd.
    • Lecture 26 - Inserting and Deleting items in an ORDERED array
    • Lecture 27 - Sorting any type of object
    • Quiz 3- Chapter Quiz
    • Lecture 28 - Assignment
  • Section 4: Linked Lists
    • Lecture 29 - What is a Linked List?
    • Lecture 30 - Implementing a Linked List in Java
    • Lecture 31 - Inserting a new Node
    • Lecture 32 - Length of a Linked List
    • Lecture 33 - Deleting the head node
    • Lecture 34 - Searching for an Item
    • Lecture 35 - Using java generics to parameterize the LinkedList
    • Lecture 36 - Doubly Ended Lists
    • Lecture 37 - Inserting data in a sorted Linked List
    • Lecture 38 - Doubly Linked List
    • Lecture 39 - Insertion Sort revisited
    • Quiz 4 - Chapter Quiz
    • Lecture 40 - Assignment
  • Section 5: Stacks and Queues
    • Lecture 41 - Stacks
    • Lecture 42 - Abstract Data Types
    • Lecture 43 - Implementing Stacks using Arrays
    • Lecture 44 - Queues
    • Lecture 45 - Queues using Arrays
    • Lecture 46 - Double Ended Queues
    • Lecture 47 - Double Ended Queues using Arrays
    • Quiz 5 - Chapter Quiz
    • Lecture 48 - Assignment
  • Section 6: Recursio
    • Lecture 49 - Introduction
    • Lecture 50 - Understanding Recursion
    • Lecture 51 - Tail recursion
    • Lecture 52 - Tower of Hanoi
    • Lecture 53 - Tower of Hanoi - Implementation
    • Lecture 54 - Merge Sort
    • Lecture 55 - Merge Sort - Pseudocode
    • Lecture 56 - Merge Step - Pseudocode
    • Lecture 57 - Time Complexity of Merge Sort
    • Quiz 6 - Chapter Quiz
    • Lecture 58 - Assignment
  • Section 7: Binary Search Trees
    • Lecture 59 - The Tree Data structure
    • Lecture 60- Binary Trees
    • Lecture 61 - Binary Search Trees
    • Lecture 62 - Finding an item in a Binary Search Tree
    • Lecture 63 - Implementing the find method
    • Lecture 64 - Inserting an item in a Binary Search Tree
    • Lecture 65 - Deleting an Item : Case 1
    • Lecture 66 - Deleting an Item - Case 2
    • Lecture 67 - Deleting an Item - Case 3
    • Lecture 68 - Deleting an Item - Soft Delete
    • Lecture 69 - Finding smallest & largest values
    • Lecture 70 - Tree Traversal : In Order
    • Lecture 71 - Tree Traversal : Pre Order
    • Lecture 72 - Tree Traversal : Post Order
    • Lecture 73 - Unbalanced Trees Vs Balanced Trees
    • Lecture 74 - Height of a Binary Tree
    • Lecture 75 - Time Complexity of Operations on Binary Search Trees
    • Quiz 6 - Chapter Quiz
    • Lecture 76 - Assignment
  • Section 8: More Sorting Algorithms
    • Lecture 77 - Introduction
    • Lecture 78 - QuickSort
    • Lecture 79 - QuickSort: The partition step
    • Lecture 8 - Shell Sort
    • Lecture 8 - Shell Sort: Example
    • Lecture 82 - Counting Sort
    • Lecture 83 - Radix Sort
    • Lecture 84 - Bucket Sort
    • Quiz 8 - Chapter Quiz
    • Lecture 85 - Assignment
  • Section 9: Heaps
    • Lecture 86 - Introduction
    • Lecture 87 - Deleting the root
    • Lecture 88 - Inserting an item in a heap
    • Lecture 89 - Heaps as Priority Queues
    • Lecture 90 - Representing heaps using Arrays
    • Lecture 91 - Heap Sort
    • Lecture 92 - Building a heap
    • Quiz 9 - Chapter Quiz
    • Lecture 93 - Assignment
  • Section 10: Hashtables
    • Lecture 94 - Introduction
    • Lecture 95 - Direct Access Tables
    • Lecture 96 - Hashing
    • Lecture 97 - Resolving collisions through chaining
    • Lecture 98 - The Hash function
    • Lecture 99 - Open Addressing to resolve collisions
    • Lecture 100 - Strategies for Open Addressing
    • Lecture 101 - Time Complexity: Open Addressing
    • Quiz 10 - Chapter Quiz
    • Lecture 102 - Assignment
    • Lecture 103 - Conclusion

View Full Curriculum


Access
Lifetime
Content
14 hours
Lessons
91

All-Level Java Swing Course

Create Desktop & Internet GUI Programs

By udemy | in Online Courses

  • 91 lectures and 14+ hours of content
  • Learn how to write GUI (graphical user interface) applications in Java
  • Build desktop and web-based applications using Java Swing, Java's built-in user interface toolkit
  • Build two complete applications step by step
  • Explore Swing widgets, JDBC for database access, the graphics API, model-view-controller (MVC) architecture, serialization for saving data, the listener-event model, and basic animation
After working as a software developer and contractor for over 14 years for many companies including CSC, Proquest, SPSS, and AT&T in the UK and Netherlands, John Purcell decided to work full-time as a private software trainer. He currently runs the website Cave of Programming.

Details & Requirements

  • Length of time users can access this course: lifetime
  • Access options: web streaming
  • Certification of completion included
  • Redemption deadline: redeem your code within 30 days of purchase
  • Experience level required: all level

Compatibility

  • Internet browser required

Course Outline

  • Section 1: Desktop Applications
    • Lecture 1 - Introduction: About the Course, Plus Some Useful Resources
    • Lecture 2 - Creating a Basic Swing Application
    • Lecture 3 - Adding Components: Layouts, Buttons and Text Areas
    • Lecture 4 - Responding to Button Clicks
    • Lecture 5 - Custom Components
    • Lecture 6 - Simple Toolbars
    • Lecture 7 - Communication Between Components
    • Lecture 8 - Listeners and Events: Using Interfaces to Cleanly Separate Components
    • Lecture 9 - Setting Component Sizes
    • Lecture 10 - Setting Borders
    • Lecture 11 - Text Fields and Labels
    • Lecture 12- Laying Out Controls with GridBagLayout
    • Lecture 13 - Custom Events and Form Submission
    • Lecture 14 - List Boxes
    • Lecture 15 - Working With List Box Data
    • Lecture 16 - Combo Boxes
    • Lecture 17 - Checkboxes
    • Lecture 18 - Radio Buttons
    • Lecture 19 - Menus
    • Lecture 20 - Using Checkboxes in Menus
    • Lecture 21 - Mnemonics and Accelerators
    • Lecture 22 - Message Boxes
    • Lecture 23 - Open/Save File Dialogs
    • Lecture 24 - Filtering File Choosers
    • Lecture 25 - Model-View-Controller: Creating a Data Model
    • Lecture 26 - Model-View-Controller: Creating a Controller
    • Lecture 27 - Creating Tables
    • Lecture 28 - Serialization: Saving Objects to Files
    • Lecture 29 - Popup Menus
    • Lecture 30 - Selecting Rows in Tables
    • Lecture 31 - Deleting Rows in Tables
    • Lecture 32 - Dialogs
    • Lecture 33 - Spinners: Specialised Controls for Entering Numbers
    • Lecture 34 - Password Fields
    • Lecture 35 - Saving Program Data: Preferences
    • Lecture 36 - Arranging and Designing Dialogs and Forms :58
    • Lecture 37 - JDBC: Connecting to a SQL Database
    • Lecture 38 - JDBC: Retrieving Values from Databases
    • Lecture 39 - JDBC: Saving to a Database
    • Lecture 40 - JDBC: Updating Databases
    • Lecture 41 - JDBC: Loading Data from Databases
    • Lecture 42 - Wiring in the Database Code: Bringing It All Together
    • Lecture 43 - Intercepting the Window Closing Event
    • Lecture 44 - Using Images and Icons
    • Lecture 45 - Draggable Toolbars: Using the JToolbar class
    • Lecture 46 - Split Panes: Creating Resizeable Separate Areas
    • Lecture 47 - Tabs: Using Tabbed Panes
    • Lecture 48 - Tree Views Using JTree
    • Lecture 49 - Tree Selection Events
    • Lecture 50 - Associating Data With Tree Nodes
    • Lecture 51 - Tree Node Icons
    • Lecture 52 - Custom Tree Cell Renderers: Using Checkboxes in Trees
    • Lecture 53 - Custom Tree Cell Editors: Editing Tree Nodes Using Checkboxes
    • Lecture 54 - Detecting Tree Node Editor Changes
    • Lecture 55 - A Simulated Message Server
    • Lecture 56 - Multithreading in Swing: The SwingWorker class
    • Lecture 57 - Modal Dialogs
    • Lecture 58 - Progress Bars
    • Lecture 59 - Distributing Your Application: Runnable Jars
    • Lecture 60 - Adding Text to Progress Bars
    • Lecture 61 - Cancelling SwingWorker Threads
    • Lecture 62 - Setting the Cursor
    • Lecture 63 - Multiple Nested Split Panes
    • Lecture 64 - Responding to Tab Selections
    • Lecture 65 - Custom List Renderers
    • Lecture 66 - Responding to List Selections
    • Lecture 67 - Changing the Font Using Logical Fonts
    • Lecture 68 - Loading Font Files
    • Lecture 69 - Configuring the Database Connection
    • Lecture 70 - Editable Tables
    • Lecture 71 - Using Checkboxes in Table Cells
    • Lecture 72 - Custom Table Cell Renderers
    • Lecture 73 - Using Custom Editors in Table Cells
  • Section 2: Applets and Animation
    • Lecture 74 - About Applets and the Following Section
    • Lecture 75 - Applets: Creating a Simple Swing Program that Runs in a Webpage
    • Lecture 76 - Drawing Custom Components
    • Lecture 77 - Drawing Shapes: Exploring the Graphics API
    • Lecture 78 - Deploying Applets
    • Lecture 79 - Timers: Using the Swing Timer Class
    • Lecture 80 - Basic Animation
    • Lecture 81 - Smoothing Your Animations With Double Buffering
    • Lecture 82 - Mouse Listeners
    • Lecture 83 - Hiding the Cursor
    • Lecture 84 - Key Listeners
    • Lecture 85- Detecting Component Resizing
    • Lecture 86 - Using Visual Designers: The Free Window Builder Pro Plugin
    • Lecture 87 - CardLayout: Switching Between Completely Different Views
    • Lecture 88 - Detecting Collisions Between Shapes
    • Lecture 89- Turning an Applet into a Desktop App
  • Section 3: Appendix
    • Lecture 90 - Setting the Look and Feel
    • Lecture 91 - Source Code - Complete Projects
    • Lecture 92 - Projects -- The Source Code Projects You See in the Tutorials
    • Lecture 93 - "Swing Test" Database

View Full Curriculum



Terms

  • All sales final
  • Instant digital download
  • Deal price in US Dollars (USD)