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