Android Application Development with Java

Professional Android Application Development with Java

Course Objectives:

Advanced Java Programming (Java SE ) is a powerful programming language used in developing cross-platform and object-oriented applications. With an online training in Advanced Java Programming (Java SE ) course from Simplilearn, participants can gain expertise in developing applications.

Course Outline:

  1. Java Basics
  2. Define the scope of variables
  3. Define the structure of a Java class
  4. Create executable Java applications with a main method
  5. Import other Java packages to make them accessible in your code
  6. Working with Java Data Types
  7. Declare and initialize variables
  8. Differentiate between object reference variables and primitive variables
  9. Read or write to object fields
  10. Explain an Object's Lifecycle (creation, "dereference" and garbage collection)
  11. Call methods on objects
  12. Manipulate data using the StringBuilder class and its methods
  13. Creating and manipulating Strings
  14. Using Operators and Decision Constructs
  15. Use Java operators
  16. Use parenthesis to override operator precedence
  17. Test equality between Strings and other objects using == and equals ()
  18. Create if and if/else constructs
  19. Use a switch statement
  20. Creating and Using Arrays
  21. Declare, instantiate, initialize and use a one-dimensional array
  22. Declare, instantiate, initialize and use multi-dimensional array
  23. Declare and use an ArrayList
  24. Using Loop Constructs
  25. Create and use while loops
  26. Create and use for loops including the enhanced for loop
  27. Create and use do/while loops
  28. Compare loop constructs
  29. Use break and continue
  30. Working with Methods and Encapsulation
  31. Create methods with arguments and return values
  32. Apply the static keyword to methods and fields
  33. Create an overloaded method
  34. Differentiate between default and user defined constructors
  35. Create and overload constructors
  36. Apply access modifiers
  37. Apply encapsulation principles to a class
  38. Determine the effect upon object references and primitive values when they are passed into methods that change the values
  39. Working with Inheritance
  40. Implement inheritance
  41. Develop code that demonstrates the use of polymorphism
  42. Differentiate between the type of a reference and the type of an object
  43. Determine when casting is necessary
  44. Use super and this to access objects and constructors
  45. Use abstract classes and interfaces
  46. Handling Exceptions
  47. Differentiate among checked exceptions, Runtime Exceptions and Errors
  48. Create a try-catch block and determine how exceptions alter normal program flow
  49. Describe what Exceptions are used for in Java
  50. Invoke a method that throws an exception
  51. Recognize common exception classes and categories
  52. Java Class Design
  53. Use access modifiers: private, protected, and public
  54. Override methods
  55. Overload constructors and methods
  56. Use the instanceof operator and casting
  57. Use virtual method invocation
  58. Override the hashCode, equals, and to String methods from the Object class to improve the functionality of your class
  59. Use package and import statements
  60. Advanced Class Design
  61. Identify when and how to apply abstract classes
  62. Construct abstract Java classes and subclasses
  63. Use the static and final keywords
  64. Create top-level and nested classes
  65. Use enumerated types
  66. Generics and Collections
  67. Create a generic class
  68. Use the diamond for type inference
  69. Analyze the interoperability of collections that use raw types and generic types
  70. Use wrapper classes, autoboxing and unboxing
  71. Create and use List, Set and Deque implementations
  72. Create and use Map implementations
  73. Use java.util.Comparator and java.lang.Comparable
  74. Sort and search arrays and lists
  75. String Processing
  76. Search, parse and build strings (including Scanner, StringTokenizer, StringBuilder, String and Formatter)
  77. Search, parse, and replace strings by using regular expressions,
  78. Using expression patterns for matching limited to: .(dot), *(star), +(plus), ?, \d, \D, \s, \S, \w, \W, \b. \B, [], ()
  79. Format strings using the formatting parameters: %b, %c, %d, %f, and %s in format string
  80. Exceptions and Assertions
  81. Use throw and throws statements
  82. Develop code that handles multiple Exception types in a single catch block
  83. Develop code that uses try-with-resources statements (including using classes that implement the AutoCloseable interface)
  84. Create custom exceptions
  85. Test invariants by using assertions                
  86. Threads
  87. Create and use the Thread class and the Runnable interface
  88. Manage and control thread lifecycle
  89. Synchronize thread access to shared data
  90. Identify code that may not execute correctly in a multi-threaded environment
  91. Getting Started with Android Programming
  92. What is Android?
  93. Obtaining the Required Tools
  94. Creating Your First Android Application
  95. Anatomy of an Android Application
  96. Activities, Fragments, and Intents
  97. Understanding
  98. Activities
  99. Linking Activities Using Intents
  100. Fragments
  101. Calling Built-In Applications Using Intents
  102. Displaying Notifications
  103. Getting to Know the Android User Interface
  104. Understanding the Components of a Screen
  105. Adapting to Display Orientation
  106. Managing Changes to Screen Orientation
  107. Utilizing the Action Bar
  108. Creating the User Interface Programmatically
  109. Listening for UI Notifications
  110. Designing Your User Interface with Views
  111. Using Basic Views
  112. Using Picker Views
  113. Using List Views to Display Long Lists
  114. Understanding Specialized Fragments
  115. Displaying Pictures and Menus with Views
  116. Using Image Views to Display Pictures
  117. Using Menus with Views
  118. Some Additional Views
  119. Data Persistence
  120. Saving and Loading User Preferences
  121. Persisting Data to Files
  122. Creating and Using Databases
  123. Content Providers
  124. Sharing Data in Android
  125. Using a Content Provider
  126. Creating Your Own Content Providers
  127. Using the Content Provider
  128. Messaging
  129. SMS Messaging
  130. Sending E-mail
  131. Location-Based Services
  132. Displaying Maps
  133. Getting Location Data
  134. Monitoring a Location
  135. Project – Building a Location Tracker
  136. Networking
  137. Consuming Web Services Using HTTP
  138. Consuming JSON Services
  139. Sockets Programming
  140. Developing Android Services
  141. Creating Your Own Services
  142. Establishing Communication between a Service and an Activity
  143. Binding Activities to Services
  144. Understanding Threading
  145. Publishing Android Applications
  146. Preparing for Publishing
  147. Deploying APK Files