Oracle Java Standard Edition - Programma

Explaining Java Technology

  • Describe key concepts of the Java programming language.
  • List the three Java technology product groups.
  • Summarize each of the seven stages of the product life cycle.

Analyzing a Problem and Designing a Solution

  • Analyze a problem using object-oriented analysis.
  • Design classes from which objects will be created.

Developing and Testing a Java Technology Program

  • Identify the four components of a class in the Java programming language.
  • Use the main method in a test class to run a Java technology program from the command line.
  • Compile and execute a Java technology program.

Declaring, Initializing, and Using Variables

  • Identify the use the syntax for variables and define the syntax for a variable.
  • List the eight Java programming language primitive data types.
  • Declare, initialize, and use variables and constants according to Java programming language guidelines and coding standards.
  • Modify variable values using operators.
  • Use promotion and type casting.

Creating and Using Objects

  • Declare, instantiate, and initialize object reference variables.
  • Compare how object reference variables are stored in relation to primitive variables.
  • Use a class (the String class) included in the Java Software Developer Kit (SDK).
  • Use the Java 2 Platform, Standard Edition (J2SE[TM]) class library. specification to learn about other classes in this application programming interface (API)

Using Operators and Decision Constructs

  • Identify relational and conditional operators.
  • Create if and if/else constructs.
  • Use the switch construct.

Using Loop Constructs

  • Create while loops
  • Develop for loops
  • Create do/while loops

Developing and Using Methods

  • Describe the advantages of methods and define worker and calling methods.
  • Declare and invoke a method.
  • Compare object and static methods.
  • Use overloaded methods.

Implementing Encapsulation and Constructors

  • Use encapsulation to protect data.
  • Create constructors to initialize objects.

Creating and Using Arrays

  • Code one-dimensional arrays.
  • Set array values using length attribute and a loop.
  • Pass arguments to the main method for use in a program.
  • Create two-dimensional arrays.

Implementing Inheritance

  • Define and test your use of inheritance.
  • Explain abstraction.
  • Explicitly identify class libraries used in your code.

Java Programming Language (60 ore)

Getting Started

  • Examine Java technology
  • Analyze a simple Java technology application
  • Execute a Java technology application

Object-Oriented Programming

  • Define modeling concepts: abstraction, encapsulation, and packages
  • Discuss Java technology application code reuse
  • Define class, member, attribute, method, constructor, and package
  • Use the access modifiers private and public as appropriate for the guidelines of encapsulation
  • Invoke a method on a particular object
  • Use the Java technology API online documentation

Identifiers, Keywords, and Types

  • Use comments in a source program
  • Distinguish between valid and invalid identifiers
  • Use the eight primitive types
  • Define literal values for numeric and textual types
  • Define the terms primitive variable and reference variable
  • Declare variables of class type
  • Construct an object using new and describe default initialization
  • Describe the significance of a reference variable

Expressions and Flow Control

  • Distinguish between instance and local variables
  • Describe how to initialize instance variables
  • Recognize, describe, and use Java software operators
  • Distinguish between legal and illegal assignments of primitive types
  • Identify boolean expressions and their requirements in control constructs
  • Recognize assignment compatibility and required casts in fundamental types
  • Use if, switch, for, while, and do constructions and the labeled forms of break and continue as flow control structures in a program

Arrays

  • Declare and create arrays of primitive, class, or array types
  • Explain why elements of an array are initialized
  • Explain how to initialize the elements of an array
  • Determine the number of elements in an array
  • Create a multidimensional array
  • Write code to copy array values from one array to another

Class Design

  • Define inheritance, polymorphism, overloading, overriding, and virtual method invocation
  • Use the access modifiers protected and the default (package-friendly)
  • Describe the concepts of constructor and method overloading
  • Describe the complete object construction and initialization operation

Advanced Class Features

  • Create static variables, methods, and initializers
  • Create final classes, methods, and variables
  • Create and use enumerated types
  • Use the static import statement
  • Create abstract classes and methods
  • Create and use an interface

Exceptions and Assertions

  • Define exceptions
  • Use try, catch, and finally statements
  • Describe exception categories
  • Identify common exceptions
  • Develop programs to handle your own exceptions
  • Use assertions
  • Distinguish appropriate and inappropriate uses of assertions
  • Enable assertions at runtime

Collections and Generics Framework

  • Describe the general purpose implementations of the core interfaces in the Collections framework
  • Examine the Map interface
  • Examine the legacy collection classes
  • Create natural and custom ordering by implementing the Comparable and Comparator interfaces
  • Use generic collections and type parameters in generic classes
  • Refactor existing non-generic code
  • Write a program to iterate over a collection
  • Examine the enhanced for loop

I/O Fundamentals

  • Write a program that uses command-line arguments and system properties
  • Examine the Properties class
  • Construct node and processing streams, and use them appropriately
  • Serialize and deserialize objects
  • Distinguish readers and writers from streams, and select appropriately between them

Console I/O and File I/O

  • Read data from the console
  • Write data to the console
  • Describe files and file I/O

Building Java GUIs Using the Swing API

  • Describe the JFC Swing technology
  • Identify the Swing packages
  • Describe the GUI building blocks: containers, components, and layout managers
  • Examine top-level, general-purpose, and special-purpose properties of container
  • Examine components
  • Examine layout managers
  • Describe the Swing single-threaded model
  • Build a GUI using Swing components

Handling GUI-Generated Events

  • Define events and event handling
  • Examine the Java SE event model
  • Describe GUI behavior
  • Determine the user action that originated an event
  • Develop event listeners
  • Describe concurrency in Swing-based GUIs and describe the features of the SwingWorker class

GUI-Based Applications

  • Describe how to construct a menu bar, menu, and menu items in a Java GUI
  • Understand how to change the color and font of a component

Threads

  • Define a thread
  • Create separate threads in a Java technology program, controlling the code and data that are used by that thread
  • Control the execution of a thread and write platform-independent code with threads
  • Describe the difficulties that might arise when multiple threads share data
  • Use wait and notify to communicate between threads
  • Use synchronized to protect data from corruption

Networking

  • Develop code to set up the network connection
  • Understand TCP/IP
  • Use ServerSocket and Socket classes to implement TCP/IP clients and servers

Modulo per contattarci o per candidarti

Compila il Form e sarai ricontattato al più presto dal responsabile del corso che ti interessa.

I dati forniti verranno trattati ai sensi della legge 196/2003 (leggi l'informativa)


(*) Campo obbligatorio