2019 – 2020
Florida Department of Education
Curriculum Framework 

Program Title:	Java Development & Programming 
Program Type:	Career Preparatory
Career Cluster:	Information Technology

Career Certificate Program 	
Program Number	Y700200	
CIP Number	0511020313	
Grade Level	30, 31 	
Standard Length	1200 hours	
Teacher Certification	Refer to the Program Structure section.	
CTSO	Phi Beta Lambda
BPA
SkillsUSA	
SOC Codes (all applicable) 	15-1151 – Computer User Support Specialists
15-1131 – Computer Programmers	
CTE Program Resources 	http://www.fldoe.org/academics/career-adult-edu/career-tech-edu/program-resources.stml	
Basic Skills Level	Mathematics:	9
Language:	9
Reading: 	9	

Purpose

This program offers a sequence of courses that provides coherent and rigorous content aligned with challenging academic standards and relevant technical knowledge and skills needed to prepare for further education and careers in the Information Technology career cluster; provides technical skill proficiency, and includes competency-based applied learning that contributes to the academic knowledge, higher-order reasoning and problem-solving skills, work attitudes, general employability skills, technical skills, and occupation-specific skills, and knowledge of all aspects of the Information Technology career cluster. 

The content includes but is not limited to the fundamentals of programming and software development; procedural and object-oriented programming; creating regular and specialized applications using the Java programming language, including testing, monitoring, debugging, documenting, and maintaining Java computer applications. 

Additional Information relevant to this Career and Technical Education (CTE) program is provided at the end of this document.

Program Structure

This program is a planned sequence of instruction consisting of four occupational completion points, with OCPs A, B, and C.  

This program is comprised of courses which have been assigned course numbers in the SCNS (Statewide Course Numbering System) in accordance with Section 1007.24 (1), F.S.  Career and Technical credit shall be awarded to the student on a transcript in accordance with Section 1001.44 (3)(b), F.S.

To teach the courses listed below, instructors must hold at least one of the teacher certifications indicated for that course.

The following table illustrates the postsecondary program structure:

OCP	Course Number	Course Title	Teacher Certification	Length	SOC Code	
A	OTA0040	Information Technology Assistant	OTA0040 Teacher Certifications	150 hours	15-1151	
B	CTS0041	Computer Programmer Assistant	BUS ED  1 @2
COMPU SCI  6
COMP PROG 7G	300 hours	15-1131	
C	CTS0044	Computer Programmer		150 hours	15-1131	
D	CTS0031	Java Developer		600 hours	15-1131	

Common Career Technical Core – Career Ready Practices

Career Ready Practices describe the career-ready skills that educators should seek to develop in their students.  These practices are not exclusive to a Career Pathway, program of study, discipline or level of education.  Career Ready Practices should be taught and reinforced in all career exploration and preparation programs with increasingly higher levels of complexity and expectation as a student advances through a program of study. 

1. Act as a responsible and contributing citizen and employee. 

2. Apply appropriate academic and technical skills. 

3. Attend to personal health and financial well-being. 

4. Communicate clearly, effectively and with reason. 

5. Consider the environmental, social and economic impacts of decisions. 

6. Demonstrate creativity and innovation. 

7. Employ valid and reliable research strategies. 

8. Utilize critical thinking to make sense of problems and persevere in solving them. 

9. Model integrity, ethical leadership and effective management. 

10. Plan education and career path aligned to personal goals. 

11. Use technology to enhance productivity. 

12. Work productively in teams while using cultural/global competence. 

Standards

Information Technology Assistant (OTA0040) is the first course in this and other programs within the Information Technology Career Cluster.  Standards 01.0 – 14.0 are associated with this course.

After successfully completing this program, the student will be able to perform the following:

01.0	Demonstrate knowledge, skill, and application of information systems to accomplish job objectives and enhance workplace performance.
02.0	Develop an awareness of microprocessors and digital computers.
03.0	Demonstrate an understanding of operating systems.
04.0	Use technology to enhance the effectiveness of communication skills utilizing word processing applications.  
05.0	Use technology to enhance communication skills utilizing presentation applications. 
06.0	Use technology to enhance the effectiveness of communication utilizing spreadsheet and database applications.
07.0	Use technology to enhance communication skills utilizing electronic mail.  
08.0	Investigate individual assessment and job/career exploration and individual career planning that reflect the transition from school to work, lifelong learning, and personal and professional goals. 
09.0	Incorporate appropriate leadership and supervision techniques, customer service strategies, and standards of personal ethics to accomplish job objectives and enhance workplace performance. 
10.0	Demonstrate competence using computer networks, internet and online databases to facilitate collaborative or individual learning and communication. 
11.0	Demonstrate competence in page design applicable to the WWW. 
12.0	Develop an awareness of emerging technologies.
13.0	Develop awareness of computer languages and software applications.
14.0	Demonstrate comprehension and communication skills. 
15.0	Use oral and written communication skills in creating, expressing and interpreting information and ideas.
16.0	Explore the characteristics, tasks, work attributes, options, and tools associated with a career in software development. 
17.0	Demonstrate an understanding of the characteristics, use, and selection of numerical, non-numerical, and logical data types. 
18.0	Distinguish between iterative and non-iterative program control structures.
19.0	Differentiate among high level, low level, procedural, object-oriented, compiled, interpreted, and translated programming languages.
20.0	Describe the processes, methods, and conventions for software development and maintenance.
21.0	Explain the types, uses, and limitations of testing for ensuring quality control.
22.0	Create a program design document using Unified Modeling Language (UML) or other common design tool.
23.0	Solve problems using critical thinking skills, creativity and innovation.
24.0	Use information technology tools.
25.0	Describe the importance of security and privacy information sharing, ownership, licensure and copyright.
26.0	Design a computer program to meet specific physical, operational, and interaction criteria.
27.0	Create and document a computer program that uses a variety of internal and control structures for manipulating varied data types.
28.0	Create and document an interactive computer program that employs functions, subroutines, or methods to receive, validate, and process user input.
29.0	Effectively communicate and collaborate.
30.0	Demonstrate responsible use of technology and information.
31.0	Explain key concepts that distinguish object-oriented programming from procedural programming. 
32.0	Create a project plan that defines requirements, structural design, time estimates, and testing elements.
33.0	Design, document, and create object-oriented computer programs.
34.0	Design a unit test plan for an object-oriented computer program, test and debug the program, and report the results.
35.0	Understand human interactions in intelligence.
36.0	Construct statements that declare, initialize, and modify different types of variables used in Java programs. 
37.0	Describe the types and characteristics of lexical units in the Java programming language. 
38.0	Describe the data types employed in Java programs. 
39.0	Construct Java statements that employ the use of various operators. 
40.0	Write executable statements using Java. 
41.0	Describe variable scope and its implications in Java programming. 
42.0	Apply common Java programming style guidelines and conventions. 
43.0	Demonstrate use of the compiler and interpreter through command line interface. 
44.0	Construct conditional control statements in Java. 
45.0	Construct iterative control statements in Java. 
46.0	Use nested loop iterative control statements in Java. 
47.0	Produce input and output for Java programs. 
48.0	Use packages and import statements in a Java program. 
49.0	Create a Java program that uses methods. 
50.0	Create a Java program that uses parameters in methods. 
51.0	Describe and use recursion in a Java program. 
52.0	Construct Java statements that use the String class to manipulate String data. 
53.0	Construct Java statements that use Classes.
54.0	Manage class relationships. 
55.0	Construct Java statements that illustrate the use of multiplicities in class relationships. 
56.0	Use object references. 
57.0	Describe the types of arrays and construct Java statements that illustrate the use and manipulation of multi-dimensional and jagged arrays. 
58.0	Construct Java statements that illustrate different ways of using inheritance. 
59.0	Construct Java statements that use collections. 
60.0	Write Java code that uses the Iterator and List interfaces. 
61.0	Create Java code that includes exception handling code. 
62.0	Create Java code that uses the Object class. 
63.0	Use standard library classes that comprise the Java API. 
64.0	Create Java code that uses exceptions to improve program quality. 
65.0	Describe Java 2 Micro Edition (J2ME) uses, characteristics, and constraints.
66.0	Create and convert classes using Unified Modeling Language (UML).
67.0	Create programs that use of Remote Method Invocation (RMI) and other server technologies associated with Relational Database Management Systems (RDMS) and Structured Query Language (SQL).   
68.0	Demonstrate an understanding of Java Integration APIs, including Java Message Service (JMS), Enterprise JavaBeans (EJB), and Java Naming and Directory Interface (JNDI).  
69.0	Demonstrate an understanding of Java Client APIs, including the Abstract Window Toolkit (AWT), Swing, and Java applet.  
70.0	Understand and apply Java 2 Enterprise Edition (J2EE) Server Solutions.
71.0	Create a database application using the Java programming language.
72.0	Create a graphical user interface application using the Java programming language.
73.0	Create a web-based application using the Java programming language.
74.0	Write code to perform common and union database queries using SQL and Java.
75.0	Implement Java program statements using objects.
76.0	Utilize debugging tools and write error handlers.
77.0	Demonstrate file I/O.
78.0	Utilize API functions.
79.0	Test and debug databases.
80.0	Successfully work as a member of a software development team.
81.0	Manage time according to a plan.
82.0	Keep acceptable records of progress, problems and solutions.
83.0	Plan, organize and carry out a project plan.
84.0	Manage resources.
85.0	Use tools, materials, and processes in an appropriate and safe manner.
86.0	Demonstrate an understanding of the software development process.
87.0	Research content related to the project and document the results.
88.0	Use presentation skills, and appropriate media to describe the progress, results and outcome of the experience.
89.0	Demonstrate competency in the area of expertise related to developing computer software using the Java programming language.

01.0	

2019 – 2020
Florida Department of Education
Student Performance Standards

Program Title: Java Development and Programming 
Career Certificate Program Number: Y700200

Course Number:  OTA0040 
Occupational Completion Point:  A
Information Technology Assistant – 150 Hours – SOC Code 15-1151	
Information Technology Assistant (OTA0040) is part of several programs across the various CTE career clusters.  To ensure consistency, the standards and benchmarks for this course (01.0 – 14.0) have been placed in a separate document.   To access this document, visit: Information Technology Assistant (OTA0040) - (RTF) 	

Course Number:  CTS0041 
Occupational Completion Point:  B
Computer Programmer Assistant – 300 Hours – SOC Code 15-1131	
15.0	Use oral and written communication skills in creating, expressing and interpreting information and ideas. – The student will be able to:	
15.01	Select and employ appropriate communication concepts and strategies to enhance oral and written communication in the workplace.	
15.02	Locate, organize and reference written information from various sources.	
15.03	Construct writings and/or communications using developmentally appropriate terminology.	
15.04	Interpret verbal and nonverbal cues/behaviors that enhance communication.	
15.05	Analyze the positive and negative impacts of technology on popular culture and personal life.	
15.06	Discuss how technology has changed the way people build and manage organizations and how technology impacts personal life.	
15.07	Evaluate ways in which adaptive technologies may assist users with special needs. 	
15.08	Explain how societal and economic factors are affected by access to critical information.	
15.09	Discuss the challenges (e.g., political, social, and economic) in providing equal access and distribution of technology in a global society.	
16.0	Explore the characteristics, tasks, work attributes, options, and tools associated with a career in software development. – The student will be able to:	
16.01	Explore a variety of careers to which computing is central.  	
16.02	Compare and contrast appropriate and inappropriate social networking behaviors.	
16.03	Discuss the impact of computing on business and commerce (e.g., automated inventory processing, financial transactions, e-commerce, virtualization, cloud computing).	
16.04	Evaluate the impacts of irresponsible use of information (e.g., plagiarism, falsification of data) on collaborative projects.	
16.05	Identify tasks performed by programmers.	
16.06	Describe how businesses use computer programming to solve business problems.	
16.07	Investigate job opportunities in the programming field.	
16.08	Explain different specializations and the related training in the computer programming field.	
16.09	Explain the need for continuing education and training of computer programmers.	
16.10	Understand and identify ways to use technology to support lifelong learning.	
16.11	Explain enterprise software systems and how they impact business.	
16.12	Describe ethical responsibilities of computer programmers.	
16.13	Describe the role of customer support to software program quality.	
16.14	Identify credentials and certifications that may improve employability for a computer programmer.	
16.15	Identify devices, tools, and other environments for which programmers may develop software.	
17.0	Demonstrate an understanding of the characteristics, use, and selection of numerical, non-numerical, and logical data types. – The student will be able to:	
17.01	Identify the characteristics (e.g., size, limits) and uses of different numerical and non-numerical data types.	
17.02	Explain the types and uses of variables in programs.	
17.03	Determine the best data type to use for given programming problems.	
17.04	Compare and contrast simple data structures and their uses.	
17.05	Identify the types of operations that can be performed on different data types.	
17.06	Evaluate arithmetic and logical expressions using appropriate operator precedence.	
17.07	Explain how computers store different data types in memory.	
17.08	Demonstrate the difference between "data" and "information".	
17.09	Use different number systems to represent data.	
17.10	Explain how national and international standards (i.e., ASCII, UNICODE) are used to represent non-numerical data.	
17.11	Use Boolean logic to perform logical operations.	
18.0	Distinguish between iterative and non-iterative program control structures–The student will be able to:	
18.01	Create non-iterative programming structures and explain their uses.	
18.02	Create iterative programming structures and explain their uses.	
18.03	Explain how sequence, selection, and iteration are building blocks of algorithms.	
19.0	Differentiate among procedural, object-oriented, compiled, interpreted, and translated programming languages. – The student will be able to:	
19.01	Differentiate between multiple levels of an operating system, translation, and interpretation that support program execution. 	
19.02	Explain the program execution process (by an interpreter and in CPU hardware).	
19.03	Describe object-oriented concepts.	
19.04	Explain the characteristics of procedural and object-oriented programming languages.	
19.05	Compare and contrast programming languages that are compiled, interpreted, and translated.	
19.06	Classify programming languages by paradigm and application domain (e.g., imperative, functional, logic languages and how well suited they are for certain application domains such as web programming, symbolic processing, data/numerical processing).	
20.0	Describe the processes, methods, and conventions for software development and maintenance. – The student will be able to:	
20.01	Describe a software development process that is used to solve problems at different software development stages.	
20.02	Describe and demonstrate ethical and responsible use of modern communication media and devices.	
20.03	Define alternative methods of program development (e.g., rapid prototyping, waterfall, spiral model, peer coding). 	
20.04	List and explain the steps in the program development cycle.	
20.05	Describe different types of documentation used in the program development cycle (e.g., requirements document, program design documents, test plans).	
20.06	Describe different methods used to facilitate version control.	
21.0	Explain the types, uses, and limitations of testing for ensuring quality control. – The student will be able to:	
21.01	Explain the uses and limits of testing in ensuring program quality.	
21.02	Explain testing performed at different stages of the program development cycle (e.g., unit testing, system testing, user acceptance testing).	
21.03	Describe and identify types of programming errors.	
21.04	Analyze and manipulate data collected by a variety of data collection techniques.	
21.05	Explain what tools are applied to provide automated testing environments.	
22.0	Create a program design document using common design tool. – The student will be able to:	
22.01	Describe different design methodologies and their uses (e.g., object-oriented design, structured design, rapid application development).	
22.02	Describe tools for developing a program design (e.g., Unified Modeling Language, flowcharts, design documents, pseudocode).	
22.03	Explain the role of existing libraries and packages in facilitating programmer productivity.	
22.04	Participate and contribute to a design review of a program design developed using a common program design tool (e.g., UML, flowcharts, design documents, pseudocode).	
22.05	Write a program design document using standard design methodology.	
22.06	Define input and output for a program module using standard design methodology.	
23.0	Solve problems using critical thinking skills, creativity and innovation. – The student will be able to:	
23.01	Employ critical thinking skills independently and in teams to solve problems and make decisions.	
23.02	Employ critical thinking and interpersonal skills to resolve conflicts.	
23.03	Identify and document workplace performance goals and monitor progress toward those goals. 	
23.04	Conduct technical research to gather information necessary for decision-making.	
23.05	Discuss digital tools or resources to use for a real-world task based on their efficiency and effectiveness, individually and collaboratively.	
24.0	Use information technology tools. – The student will be able to:	
24.01	Use personal information management (PIM) applications to increase workplace efficiency.	
24.02	Employ technological tools to expedite workflow including word processing, databases, reports, spreadsheets, multimedia presentations, electronic calendar, contacts, email, and internet applications.	
24.03	Employ computer applications to access, create, manage, integrate, and store information.	
24.04	Employ collaborative/groupware applications to facilitate group work.	
24.05	Use a development process in creating a computational artifact, individually and collaboratively, followed by reflection, analysis, and iteration (e.g., data-set analysis program for science and engineering fair, capstone project that includes a program, term research project based on program data). 	
25.0	Describe the importance of security and privacy information sharing, ownership, licensure and copyright. – The student will be able to:	
25.01	Describe security and privacy issues that relate to computer networks including the permanency of data on the Internet, online identity, and privacy.	
25.02	Discuss the impact of government regulation on privacy and security.	
25.03	Describe how different types of software licenses (e.g., open source, proprietary licenses) can be used to share and protect intellectual property.	
25.04	Explain how access to information may not include the right to distribute the information.	
25.05	Describe differences between open source, freeware, and proprietary software licenses, and how they apply to different types of software.	
25.06	Discuss security and privacy issues that relate to computer networks.	
25.07	Identify computer-related laws and analyze their impact on digital privacy, security, intellectual property, network access, contracts, and harassment.	
26.0	Design a computer program to meet specific physical, operational, and interaction criteria. – The student will be able to:	
26.01	Choose appropriate data types depending on the needs of the program.	
26.02	Define appropriate user prompts for clarity and usability (e.g., user guidance for data ranges, data types).	
26.03	Design and develop program for efficiency (e.g., less memory usage, less inputs/outputs, faster processing).	
26.04	Compare techniques for analyzing massive data collections.	
26.05	Identify the software environment required for a program to run (e.g., operating system required, mobile, web-based, desktop, delivery method).	
26.06	Create mobile computing applications and/or dynamic webpages through the use of a variety of design and development tools, programming languages and mobile devices/emulators.	
26.07	Explain the role of an application programming interface (API) in the development of applications and the distinction between a programming language’s syntax and the API.	
26.08	Identify the tools required to develop a program (e.g., editors, compilers, linkers, integrated development environments, APIs, libraries).	
26.09	Use an industrial-strength integrated development environment to implement a program.	
27.0	Create and document a computer program that uses a variety of internal and control structures for manipulating varied data types. – The student will be able to:	
27.01	Use appropriate naming conventions to define program variables and methods.	
27.02	Use a program editor to write the source code for a program.	
27.03	Write programs that use selection structures.	
27.04	Write programs that use repetition structures.	
27.05	Write programs that use nested structures.	
27.06	Use internal documentation (e.g., single-line and multi-line comments, program headers, module descriptions, meaningful variable and function/module names) to document a program according to accepted standards.	
27.07	Compile, run, test and debug programs.	
27.08	Write programs that use standard arithmetic operators with different numerical data types.	
27.09	Write programs that use standard logic operators.	
27.10	Write programs that use a variety of common data types.	
27.11	Write programs that perform data conversion between standard data types.	
27.12	Write programs that define, use, search, and sort arrays.	
27.13	Write programs that use user-defined data types.	
27.14	Demonstrate understanding and use of appropriate variable scope.	
27.15	Explain recursive programming structure.	
27.16	Use global and local scope appropriately in program implementation.	
28.0	Create and document an interactive computer program that employs functions, subroutines, or methods to receive, validate, and process user input. – The student will be able to:	
28.01	Critically examine classical algorithms and implement an original algorithm.	
28.02	Write programs that perform user input and output.	
28.03	Write programs that validate user input (e.g., range checking, data formats, valid/invalid characters).	
28.04	Write program modules such as functions, subroutines, or methods.	
28.05	Write program modules that accept arguments.	
28.06	Write program modules that return values.	
28.07	Write program modules that validate arguments and return error codes.	
28.08	Design and implement a simple simulation algorithm to analyze, represent and understand natural phenomena.	
28.09	Use APIs and libraries to facilitate programming solutions.	
28.10	Participate in a peer code review to verify program functionality, programming styles, program usability, and adherence to common programming standards.	
29.0	Effectively communicate and collaborate. – The student will be able to:	
29.01	Evaluate modes of communication and collaboration.	
29.02	Select appropriate tools within a project environment to communicate with project team members.	
29.03	Utilize project collaboration tools (such as version control systems and integrated development environments) while working on a collaborative software project.	
29.04	Generate, evaluate, and prioritize questions that can be researched through digital resources and online tool.	
29.05	Perform advanced searches to locate information and/or design a data-collection approach to gather original data.	
29.06	Communicate and publish key ideas and details to a variety of audiences using digital tools and media-rich resources.	
30.0	Demonstrate responsible use of technology and information. – The student will be able to:	
30.01	 Explain the principles of cryptography by examining encryption, digital signatures, and authentication methods (e.g. explain why and how certificates are used with https for authentication and encryption).	
30.02	 Implement an encryption, digital signature, or authentication method.	
30.03	 Describe computer security vulnerabilities and methods of attack, and evaluate their social and economic impact on computer systems and people.	
30.04	

Course Number:  CTS0044
Occupational Completion Point:  C
Computer Programmer – 150 Hours – SOC Code 15-1131	
31.0	Explain key concepts that distinguish object-oriented programming from procedural programming. – The student will be able to:	
31.01	Demonstrate the understanding and use of classes, objects, attributes, and behaviors. 	
31.02	Demonstrate the understanding and use of inheritance.	
31.03	Demonstrate the understanding and use of data encapsulation.	
31.04	Demonstrate the understanding and use of polymorphism.	
31.05	Use predefined functions and parameters, classes, and methods to divide a complex problem into simpler parts by using the principle of abstraction to manage complexity (e.g., by using searching and sorting as abstractions).	
32.0	Create a project plan for an object-oriented programming project that defines requirements, structural design, time estimates, and testing elements. – The student will be able to:	
32.01	Write a project plan for completion of a project that includes gathering program requirements, developing the program, and testing it.	
32.02	Write a program requirements document that identifies business purpose, functional requirements, system requirements, and other common components of a requirements document.	
32.03	Design an object-oriented program using standard design methodology.	
32.04	Work with other team members to develop a project plan for a program.	
32.05	Work with other team members to write a design document for a program with multiple functions and shared data.	
32.06	Participate in design meetings that review program design documents for conformance to program requirements.	
32.07	Estimate the time to develop a program or module.	
32.08	Evaluate algorithms by their efficiency, correctness, and clarity (e.g., by analyzing and comparing execution times, testing with multiple inputs or data sets, and by debugging).	
33.0	Design, document, and create object-oriented computer programs. – The student will be able to:	
33.01	Compare and contrast recursive functions to iterative methods.	
33.02	Understand the implementation of character strings in the programming language.	
33.03	Write programs that perform string processing (e.g., manipulating, comparing strings, concatenation).	
33.04	Write programs that implements user-defined data types.	
33.05	Decompose a problem by defining new functions and classes.	
33.06	Write object-oriented programs that implement inheritance.	
33.07	Write object-oriented programs that implement polymorphism.	
33.08	Develop class constructors.	
33.09	Write programs that define and use program constants.	
33.10	Write programs that perform error handling.	
33.11	Participate in program code review meetings to evaluate program code for validity, quality, performance, data integrity, and conformance to program design documents.	
33.12	Describe the concept of parallel processing as a strategy to solve large problems.	
33.13	Demonstrate concurrency by separating processes into threads of execution and dividing data into parallel streams.	
33.14	Update a program module to implement enhancements or corrections and demonstrate appropriate documentation (internal and external) related to version control. 	
33.15	Write programs that use complex data structures (e.g., stacks, queues, trees, linked list).	
33.16	Write programs that are event-driven.	
33.17	Write programs that perform file input and output (i.e., sequential and random access file input/output).	
33.18	Explain intractable problems and understand that problems exists that are computationally unsolvable (undecidable) (e.g., classic intractable problems include Towers of Hanoi, TSP).	
33.19	Explain the value of heuristic algorithms to approximate solutions for intractable problems (e.g., a heuristic solution to TSP).	
34.0	Design a unit test plan for an object-oriented computer program, test and debug the program, and report the results. – The student will be able to:	
34.01	Develop a test plan for an object-oriented program.	
34.02	Write test plans for event-driven programs.	
34.03	Write test plans for programs that perform file input and output.	
34.04	Perform test and debug activities on object-oriented programs, including those written by someone else.	
34.05	Perform test and debug activities on an event-driven program.	
34.06	Perform test and debug activities on programs that perform file input and output and verify the correctness of output files.	
34.07	Document the findings of testing in a test report.	
35.0	Understand human interactions in intelligence. – The student will be able to:	
35.01	Describe the unique features of computers embedded in mobile devices and vehicles.	
35.02	Describe the common physical and cognitive challenges faced by users when learning to use software and hardware.	
35.03	Describe the process of designing software to support specialized forms of human-computer interaction.	
35.04	Explain the notion of intelligent behavior through computer modeling and robotics.	
35.05	Describe common measurements of machine intelligence (e.g., Turing test).	
35.06	Describe a few of the major branches of artificial intelligence (e.g., expert systems, natural language processing, machine perception, machine learning).	
35.07	Describe major applications of artificial intelligence and robotics, including, but not limited to, the medical, space, and automotive fields.	

Course Number:  CTS0031
Occupational Completion Point:  D 
Java Developer – 600 Hours – SOC Code 15-1131	
36.0	Construct statements that declare, initialize, and modify different types of variables used in Java programs. – The student will be able to:	
36.01	Describe how variables are used in programs.	
36.02	Identify the eight Java primitive data types.	
36.03	Identify the minimum and maximum ranges of primitive data types.	
36.04	Identify which data type should be used for a given situation.	
36.05	Identify the syntax for using variables.	
36.06	Declare and initialize variables.	
36.07	Assign new values to variables.	
36.08	Create and use constant variables.	
37.0	Describe the types and characteristics of lexical units in the Java programming language. – The student will be able to:	
37.01	Describe the types of lexical units.	
37.02	Describe identifiers and identify valid and invalid identifiers.	
37.03	Describe and identify reserved words, delimiters, literals, and comments.	
38.0	Describe the data types employed in Java programs. – The student will be able to:	
38.01	Describe the data type categories.	
38.02	Give examples of primitives, reference data types.	
38.03	Identify and use enumerations.	
38.04	Understand the use of Wrapper Classes in programs.	
38.05	Describe the difference between real and integer data types.	
39.0	Construct Java statements that employ the use of various operators. – The student will be able to:	
39.01	Construct statements using arithmetic operators.	
39.02	Construct statements using relational operators.	
39.03	Construct and use statements using logical operators.	
39.04	Construct and use statements using assignment operators. 	
39.05	Construct and execute statements using operator precedence.	
40.0	Write executable statements using Java. – The student will be able to:	
40.01	Construct variable assignment statements.	
40.02	Construct statements using built-in math functions.	
40.03	Differentiate between implicit and explicit data type conversions.	
40.04	Describe when implicit data type conversions take place.	
40.05	List the drawbacks of implicit data type conversions.	
40.06	Describe the process of autoboxing and promotion.	
40.07	Construct statements using functions to explicitly convert data types.	
41.0	Describe variable scope and its implications in Java programming. – The student will be able to:	
41.01	Understand the scope and visibility of variables.	
41.02	Write programs using local variables.	
41.03	Describe the scope of a variable.	
41.04	Describe the default value of local, instance, and static scope of variables.	
41.05	Describe how compiler uses scope to identify variables with the same name.	
42.0	Apply common Java programming style guidelines and conventions. – The student will be able to:	
42.01	List examples of good programming practices.	
42.02	Insert comments into code.	
42.03	Follow formatting guidelines when writing code.	
42.04	Understand the different types of errors produced by programs.	
43.0	Demonstrate use of the compiler and interpreter through command line interface. – The student will be able to:	
43.01	Describe the use of the Java compiler (javac) and Java interpreter (Java VM).	
43.02	Demonstrate the use of the - classpath flag and –d flag to the compiler.	
43.03	Identify the environmental variables of PATH and CLASSPATH.	
43.04	Describe the process of command line arguments to the program.	
43.05	Create programs that take in multiple command line arguments.	
44.0	Construct conditional control statements in Java. – The student will be able to:	
44.01	Construct and use an if statement.	
44.02	Construct and use a switch statement.	
44.03	Construct and use a while, do while, and for loop.	
44.04	Construct and use a conditional operator.	
45.0	Construct iterative control statements in Java. – The student will be able to:	
45.01	Describe the types of loop statements and their uses.	
45.02	Construct and use the while and do while loop.	
45.03	Construct and use the for loop.	
45.04	Construct and use the enhanced for loop.	
45.05	Describe when a while loop is used.	
45.06	Describe when a for loop is used.	
46.0	Use nested loop iterative control statements in Java. – The student will be able to:	
46.01	Construct and execute a program using nested loops.	
46.02	Construct and execute a loop using break and continue.	
46.03	Evaluate a nested loop construct and sentinel value.	
47.0	Produce input and output for Java programs. – The student will be able to:	
47.01	Describe and use classes (e.g., Scanner, System) to input data into programs.	
47.02	Demonstrate the use of different ways to input data into programs using Scanner or System class.	
47.03	Describe and demonstrate the use of the System class to produce output to the console.	
47.04	Explain the difference between print and println functions in the System class.	
47.05	Create and use escape sequences.	
48.0	Use packages and import statements in a Java program. – The student will be able to:	
48.01	Describe the use of import statements.	
48.02	Describe the use of packages.	
48.03	Create code that uses package statements to avoid class conflict.	
48.04	Create packages that abide by standard Java naming convention.	
48.05	Demonstrate the use of Java-API to search for classes and packages.	
49.0	Create a Java program that uses methods. – The student will be able to:	
49.01	Differentiate between anonymous blocks and methods.	
49.02	Identify the benefits of using methods.	
49.03	Describe a method signature.	
49.04	Create a method.	
49.05	Describe how a method is invoked.	
49.06	Describe the purpose of overloading methods.	
49.07	Create overloaded methods in programs.	
50.0	Create a Java program that uses parameters in methods. – The student will be able to:	
50.01	Describe how parameters are passed into functions.	
50.02	Define a parameter.	
50.03	Create a method using a parameter.	
50.04	Invoke a method that has parameters.	
50.05	Distinguish between formal and actual parameters.	
50.06	Demonstrate the use of reference parameters in methods.	
51.0	Describe and use recursion in a Java program. – The student will be able to:	
51.01	Describe the use of recursion in solving problems.	
51.02	Describe the difference of iterative and recursive methods.	
51.03	Demonstrate the use of direct recursion.	
51.04	Demonstrate the use of indirect recursion.	
52.0	Construct Java statements that use the String class to manipulate String data. – The student will be able to:	
52.01	Explain the use of the String class.	
52.02	Create code to concatenate strings using the concatenation operator.	
52.03	Demonstrate how to search a string using indexOf method of the String class.	
52.04	Explain the effect of immutability of Strings.	
52.05	Create Strings using string literals, and through new keyword.	
52.06	Demonstrate the use of the following string manipulation methods of the String class:  charAt,length, trim, substring, replace, startsWidth and endsWith. 	
53.0	Construct Java statements that use Classes. – The student will be able to:	
53.01	Describe and identify abstract data types.	
53.02	Describe the difference between an object and a class.	
53.03	Identify class attributes.	
53.04	Create instance variables for a class.	
53.05	Use visibility modifiers for attributes.	
53.06	Identify constructors and describe their use.	
53.07	Describe encapsulation.	
53.08	Write class using encapsulation.	
53.09	Apply data abstraction through the use of accessor or and mutator methods. 	
53.10	Describe the equals method.	
53.11	Demonstrate the use of classes in methods as both parameters and return types.	
53.12	Describe the garbage collection process.	
53.13	Demonstrate reusability and extensibility in class creation.	
53.14	Demonstrate the use of Comparable interface to compare objects.	
54.0	Manage class relationships. – The student will be able to:	
54.01	Explain the association relationship among classes.	
54.02	Explain the direct association relationship among classes.	
54.03	Explain the composition and aggregation relationship among classes.	
54.04	Explain the direct association relationship among classes.	
54.05	Write programs that use composition, association.	
54.06	Write programs that use direct association.	
55.0	Construct Java statements that illustrate the use of multiplicities in class relationships. – The student will be able to:	
55.01	Describe how multiplicities affect class relationships.	
55.02	Describe one-to one, one-to-many, and many-to-many relationships.	
55.03	Write programs that use multiplicities in class relationships.	
56.0	Use object references. – The student will be able to:	
56.01	Identify reference aliases.	
56.02	Understand and use null reference.	
56.03	Explain the this reference and its use in class creation.	
57.0	Describe the types of arrays and construct Java statements that illustrate the use and manipulation of multi-dimensional and jagged arrays. – The student will be able to:	
57.01	Declare and initialize and array.	
57.02	Demonstrate the use of initializer lists.	
57.03	Demonstrate the use of arrays in methods.	
57.04	Demonstrate the updating, populating and destroying arrays.	
57.05	Explain linear and binary searching.	
57.06	Sort arrays using selection sort, insertion sort, and bubble sort.	
57.07	Demonstrate the use of multidimensional arrays.	
57.08	Demonstrate the use of jagged arrays.	
57.09	Demonstrate basic hashing using arrays.	
58.0	Construct Java statements that illustrate different ways of using inheritance. – The student will be able to:	
58.01	Explain the purpose and use of inheritance in object oriented programming.	
58.02	Explain the difference between single and multiple inheritance.	
58.03	Create parent and child classes.	
58.04	Create overloaded methods.	
58.05	Describe the has-a and is-a relationship.	
58.06	Create class hierarchies.	
58.07	Explain the process of generalization to specification.	
58.08	Demonstrate the use of abstract classes.	
58.09	Explain polymorphism.	
58.10	Create a program that uses polymorphism.	
58.11	Demonstrate the use of the instanceof method.	
59.0	Construct Java statements that use collections. – The student will be able to:	
59.01	Describe data structure of linked lists.	
59.02	Create a linked list manually.	
59.03	Use the ArrayList class.	
59.04	Create a stack and Queue manually.	
59.05	Use the Stack and Queue standard class.	
59.06	Identify which data structure is best fitted for a situation.	
59.07	Use iterators with collections.	
59.08	Identify how to insert, delete, update, and traverse data structures.	
60.0	Write Java code that uses the Iterator and List interfaces. – The student will be able to:	
60.01	Describe the purpose of interfaces.	
60.02	Create and use interfaces in programs.	
60.03	Use the Comparable interface.	
60.04	Use the Iterator interface and List Interface in programs.	
60.05	Understand the program to the interface principle.	
61.0	Create Java code that includes exception handling code. – The student will be able to:	
61.01	Describe the advantages of including exception handling code.	
61.02	Describe the purpose of an EXCEPTION section in a program block.	
61.03	Create code to include an EXCEPTION section.	
61.04	List the guidelines for exception handling.	
62.0	Create Java code that uses the Object class. – The student will be able to:	
62.01	Understand the Object class relationship to other classes.	
62.02	Demonstrate the use of toString method.	
62.03	Demonstrate the use of clone and finalize methods.	
62.04	Write program to use Object class functionality.	
63.0	Use standard library classes that comprise the Java API. – The student will be able to:	
63.01	Describe the classes and methods in the basic input/output package.	
63.02	Describe the classes and methods in the utilities package.	
63.03	Describe the classes and methods in the utilities package.	
63.04	Describe the classes and methods in the networking package.	
63.05	Describe the classes and methods in the AWT and swing package.	
63.06	Describe the classes and methods in the SQL and SQLX package.	
64.0	Create Java code that uses exceptions to improve program quality. – The student will be able to:	
64.01	Explain how exception handling works in Java.	
64.02	Trap exceptions using try and catch.	
64.03	Explain when to use the finally clause.	
64.04	Demonstrate handling exceptions through throwing and catching.	
64.05	Create and Exception and manage the exception.	
64.06	Explain the use of inheritance and exceptions.	
65.0	Describe Java 2 Micro Edition (J2ME) uses, characteristics, and constraints. – The student will be able to:	
65.01	Understand midlets.	
65.02	Explain CLDC and profiles.	
65.03	Explain the constraints specific to J2ME programming when compared to J2SE.	
65.04	Understand the high architectural goal of J2ME.	
65.05	Create user-defined functions.	
66.0	Create and convert classes using Unified Modeling Language (UML). – The student will be able to:	
66.01	Identify UML elements Classes, abstract Classes, Interfaces.	
66.02	Identify UML attributes, operators, visibility modifiers and UML associations.	
66.03	Given a set of classes be able to convert the classes to a UML diagram.	
66.04	Given a UML diagram be able to create classes.	
67.0	Create programs that use of Remote Method Invocation (RMI) and other server technologies associated with Relational Database Management Systems (RDMS) and Structured Query Language (SQL). – The student will be able to:	
67.01	Understand and describe RMI.	
67.02	Write a program to use RMI.	
67.03	Understand RDMS and SQL technologies.	
67.04	Use the Java Database Connectivity API to connect and execute SQL statements to RDMS.	
68.0	Demonstrate an understanding of Java Integration APIs, including Java Message Service (JMS), Enterprise JavaBeans (EJB), and Java Naming and Directory Interface (JNDI). – The student will be able to:	
68.01	Understand and describe JMS.	
68.02	Understand and describe EJB technology.	
68.03	Understand and describe JNDI technology.	
69.0	Demonstrate an understanding of Java Client APIs, including the Abstract Window Toolkit (AWT), Swing, and Java applet. – The student will be able to:	
69.01	Understand and describe AWT and GUI interface.	
69.02	Understand and describe the use of Swing components and GUI.	
69.03	Understand and describe the use of applet technology.	
70.0	Understand and apply Java 2 Enterprise Edition (J2EE) Server Solutions. – The student will be able to:	
70.01	Understand java Web Services.	
70.02	Underrated and use SMTP and Java Mail technologies.	
70.03	Understand how to use JSP and Servlets.	
71.0	Create a database application using the Java programming language. – The student will be able to:	
71.01	Utilize loop statements.	
71.02	Given a scenario, use arithmetic, comparison, and pattern-matching operators.	
71.03	Create user-defined functions.	
71.04	Utilize common built-in functions.	
71.05	Declare variables in modules and procedures.	
71.06	Declare arrays, and initialize elements of arrays.	
71.07	Declare and use object variables and collections, and use their associated properties and methods.	
71.08	Declare symbolic constants, and make them available locally or publicly.	
71.09	Respond to events.	
72.0	Create a graphical user interface application using the Java programming language. – The student will be able to:	
72.01	Utilize loop statements.	
72.02	Given a scenario, use arithmetic, comparison, and pattern-matching operators.	
72.03	Create user-defined functions.	
72.04	Utilize common built-in functions.	
72.05	Declare variables in modules and procedures.	
72.06	Declare arrays, and initialize elements of arrays.	
72.07	Declare and use object variables and collections, and use their associated properties and methods.	
72.08	Declare symbolic constants, and make them available locally or publicly.	
72.09	Use the Java Event model to handle user inputs from events.	
72.10	Use JComponents and layout managers to create the GUI.	
73.0	Create a web-based application using the Java programming language. – The student will be able to:	
73.01	Utilize loop statements.	
73.02	Given a scenario, use arithmetic, comparison, and pattern-matching operators.	
73.03	Create user-defined functions.	
73.04	Utilize common built-in functions.	
73.05	Declare variables in modules and procedures.	
73.06	Declare arrays, and initialize elements of arrays.	
73.07	Declare and use object variables and collections, and use their associated properties and methods.	
73.08	Declare symbolic constants, and make them available locally or publicly.	
73.09	Write JSP pages to process user input.	
73.10	Write Servlets to provide input and output processing for the web solution. 	
74.0	Write code to perform common and union database queries using SQL and Java. – The student will be able to:	
74.01	Utilize SQL to write common queries.	
74.02	Refer to objects by using SQL.	
74.03	Utilize union queries.	
75.0	Implement Java program statements using objects. – The student will be able to:	
75.01	Determine when to use data access objects.	
75.02	Differentiate between objects and collections.	
75.03	Write statements that access and modify database objects, EJB objects.	
75.04	Select appropriate methods and property settings for use with specified objects.	
76.0	Utilize debugging tools and write error handlers. – The student will be able to:	
76.01	Trap errors.	
76.02	Utilize debugging tools to suspend program execution, and to examine, step through, and reset execution of code.	
76.03	Debug code samples.	
76.04	Utilize the Debugger to monitor variable values.	
76.05	Write an error handler.	
77.0	Demonstrate file input/output (I/O). – The student will be able to:	
77.01	Read from sequential and random access files.	
77.02	Write to sequential and random access files.	
77.03	Use file serialization.	
78.0	Utilize API functions. – The student will be able to:	
78.01	Properly declare functions.	
78.02	Use the by value and by reference parameters.	
79.0	Test and debug databases. – The student will be able to:	
79.01	Implement error handling.	
79.02	Test and debug library databases.	
80.0	Successfully work as a member of a software development team. – The student will be able to:	
80.01	Accept responsibility for specific tasks in a given situation.	
80.02	Document progress, and provide feedback on work accomplished in a timely manner.	
80.03	Complete assigned tasks in a timely and professional manner.	
80.04	Reassign responsibilities when the need arises.	
80.05	Complete daily tasks as assigned on one’s own initiative.	
81.0	Manage time according to a plan. – The student will be able to:	
81.01	Set realistic time frames and schedules.	
81.02	Keep a written time sheet of work accomplished on a daily basis.	
81.03	Meet goals and objectives set by the team.	
81.04	Identify individual priorities.	
81.05	Complete a weekly evaluation of accomplishments, and reevaluate goals, objectives and priorities as needed.	
82.0	Keep acceptable records of progress problems and solutions. – The student will be able to:	
82.01	Develop a record keeping system in the form of a log book to record daily progress.	
82.02	Use a project journal to identify problem statement.	
82.03	Develop a portfolio of work accomplished to include design drawings, flowcharts, drawings and plans, and prototypes.	
83.0	Plan, organize, and carry out a project plan. – The student will be able to:	
83.01	Determine the scope of a project.	
83.02	Organize the team according to individual strengths.	
83.03	Assign specific tasks within a team.	
83.04	Determine project priorities.	
83.05	Identify required resources.	
83.06	Plan research, design, development, and evaluation activities as required.	
83.07	Carry out the project plan to successful completion.	
84.0	Manage resources. – The student will be able to:	
84.01	Identify required resources for each stage of the project plan.	
84.02	Determine the methods needed to acquire needed resources.	
84.03	Demonstrate good judgment in the use of resources.	
84.04	Recycle and reuse resources where appropriate.	
84.05	Demonstrate an understanding of proper legal and ethical treatment of copyrighted material.	
85.0	Use tools, materials, and processes in an appropriate and safe manner. – The student will be able to:	
85.01	Identify the proper tool for a given job.	
85.02	Use tools and machines in a safe manner.	
85.03	Adhere to laboratory or job site safety rules and procedures.	
85.04	Identify the application of processes appropriate to the task at hand.	
85.05	Identify materials appropriate to their application.	
86.0	Demonstrate an understanding of the software development process. – The student will be able to:	
86.01	State the goals of the software application clearly.	
86.02	Identify and write a plan to achieve each goal.	
86.03	Develop a list of materials and content required for each goal.	
86.04	Develop a step by step procedure for developing the application.	
86.05	Follow a written procedure.	
86.06	Record data from evaluation activities.	
86.07	Document conclusions and solutions based on evaluation results, observations and data.	
86.08	Document progress using a project log.	
86.09	Write an abstract describing the project plan.	
87.0	Research content related to the project and document the results following industry conventions. – The student will be able to:	
87.01	Identify the basic research needed to develop the project plan.	
87.02	Identify available resources for completing background research required in the project plan.	
87.03	Demonstrate the ability to locate resource materials in a library, data base, internet and other research resources.	
87.04	Demonstrate the ability to organize information retrieval.	
87.05	Demonstrate the ability to prepare a topic outline.	
87.06	Write a draft of the research report.	
87.07	Edit and proof the research report. Use proper form for a bibliography, footnotes, quotations, and references.	
87.08	Prepare an electronically composed research paper in proper form.	
87.09	Conduct an alpha and beta evaluation of the project’s product.	
87.10	Write a report on the evaluations, documenting results, data, observations, and design changes based on the results.	
88.0	Use presentation skills, and appropriate media to describe the progress, results and outcomes of the experience. – The student will be able to:	
88.01	Prepare a multi-media presentation on the completed project.	
88.02	Make an oral presentation, using multi-media materials.	
88.03	Review the presentation, and make changes in the delivery method(s) to improve presentation skills.	
89.0	Demonstrate competency in the area of expertise related to developing computer software using the Java programming language. – The student will be able to:	
89.01	Demonstrate a mastery of the content of the selected subject area.	
89.02	Demonstrate the ability to use related technological tools, materials and processes related to the specific program area.	
89.03	Demonstrate the ability to apply the knowledge, experience and skill developed in the previous program completion to the successful completion of this demonstration.	

Additional Information

Laboratory Activities

Laboratory investigations that include scientific inquiry, research, measurement, problem solving, emerging technologies, tools and equipment, as well as, experimental, quality, and safety procedures are an integral part of this career and technical program/course. Laboratory investigations benefit all students by developing an understanding of the complexity and ambiguity of empirical work, as well as the skills required to manage, operate, calibrate and troubleshoot equipment/tools used to make observations. Students understand measurement error; and have the skills to aggregate, interpret, and present the resulting data. Equipment and supplies should be provided to enhance hands-on experiences for students.

Special Notes

MyCareerShines is an interactive resource to assist students in identifying their ideal career and to enhance preparation for employment. Teachers are encouraged to integrate this resource into the program curriculum to meet the employability goals for each student.  Access MyCareerShines by visiting: www.mycareershines.org.

Career and Technical Student Organization (CTSO)

Phi Beta Lambda and Business Professionals of America (BPA) are the intercurricular student organizations providing leadership training and reinforcing specific career and technical skills. Career and Technical Student Organizations provide activities for students as an integral part of the instruction offered.   

Cooperative Training – OJT

On-the-job training is appropriate but not required for this program. Whenever offered, the rules, guidelines, and requirements specified in the OJT framework apply. 

Basic Skills 

In a Career Certificate Program offered for 450 hours or more, in accordance with Rule 6A-10.040, F.A.C., the minimum basic skills grade levels required for postsecondary adult career and technical students to complete this program are: Mathematics 9, Language 9, and Reading 9. These grade level numbers correspond to a grade equivalent score obtained on a state designated basic skills examination.  

Adult students with disabilities, as defined in Section 1004.02(7), Florida Statutes, may be exempted from meeting the Basic Skills requirements (Rule 6A-10.040). Students served in exceptional student education (except gifted) as defined in s. 1003.01(3)(a), F.S., may also be exempted from meeting the Basic Skills requirement. Each school district and Florida College must adopt a policy addressing procedures for exempting eligible students with disabilities from the Basic Skills requirement as permitted in Section 1004.91(3), F.S.

Students who possess a college degree at the Associate of Applied Science level or higher; who have completed or are exempt from the college entry-level examination; or who have passed a state, national, or industry licensure exam are exempt from meeting the Basic Skills requirement (Rule 6A-10.040, F.A.C.) Exemptions from state, national or industry licensure are limited to the certifications listed on the Basic Skills and Licensure Exemption List which may be accessed from the CTE Program Resources page.

Accommodations

Federal and state legislation requires the provision of accommodations for students with disabilities to meet individual needs and ensure equal access. Postsecondary students with disabilities must self-identify, present documentation, request accommodations if needed, and develop a plan with their counselor and/or instructors. Accommodations received in postsecondary education may differ from those received in secondary education. Accommodations change the way the student is instructed. Students with disabilities may need accommodations in such areas as instructional methods and materials, assignments and assessments, time demands and schedules, learning environment, assistive technology and special communication systems. Documentation of the accommodations requested and provided should be maintained in a confidential file.

Note: postsecondary curriculum and regulated secondary programs cannot be modified.

Additional Resources

For additional information regarding articulation agreements, Bright Futures Scholarships, Fine Arts/Practical Arts Credit and Equivalent Mathematics and Equally Rigorous Science Courses please refer to:
http://www.fldoe.org/academics/career-adult-edu/career-tech-edu/program-resources.stml