THE LEARNING STATUS OF INFORMATION AND

COMMUNICATIONS TECHNOLOGY STUDENTS IN JAVA

PROGRAMMING

Gerald E. Martinez
Norman E. Certifico
Marifier Munoz
Jericho Castro
Group 6
12-zOS

JOAN F. ASTORGA
 CHAPTER I
The Problem and Its Setting

BACKGROUND OF THE STUDY

Java is a computer language that widely used to create, manipulate,

visualize and rearrange applications, programs or software with other computer
languages to establish its compatibility in different digital forms. Some find it hard
to understand because of its distinct codes unlike the other computer languages
but it is essential in building application especially in android devices and
computers. Logical skills and creativity are some of the abilities that can be
develop in learning this computer language.

Programming is a fundamental part of computer science curriculum, but it

is often problematic. The high drop out and failure rates in introductory
programming courses are a universal problem that motivated many researchers
to propose methodologies and tools to help students. Although some of these
tools have been reported to have a positive effect in students learning, the
problem still remains mostly unsolved. There are several reasons that cause this
learning problem. Maybe the most important is the lack of problem solving
abilities that many students show. They don’t know how to program, because
they don’t know how to create algorithms, mainly due to their lack of general
problem solving abilities. This and other causes to student difficulties are
discussed in this paper. Some possible solutions are proposed, so that problems
can be reduced.
 Java programming is popular both in Academia and IT Industry. Further, it
is the maximum usage of programming across the world. There is a wide edge
between industry expectations and knowledge of students in Java programming.

STATEMENT OF THE PROBLEM

General Problem

What percentage of ICT Students consider the use of computer java

language to advance and enhance their skills in programming?

Specific Problem

This study aims to investigate the learning status of information and

communications technology students in java programming as perceived by ICT
students. Specifically, the study attempted to answer the following questions:

 How the students learned in java programming?

 How effective are the methods and strategies best suit in learning the
java?
 What are the factors that affect the ICT student’s learning progress?
 What are the significant difference between the perception of the students
and the different aspects in learning the java?

OBJECTIVES OF THE STUDY

General Objective

To determine the percentage of ICT Students learning the use of

computer java language enough to advance and enhance their skills in
programming

Specific Objectives

 To determine the ways on how the ICT students learned in java programming
 To evaluate the effectiveness of the methods and strategies best suit in
learning the java
 To identify the factors that affect the ICT students’ learning progress
 To clarify and distinguish the significant difference between the perceptions of
the ICT students and the methods of teaching in learning the java

SIGNIFICANCE OF THE STUDY

This study aims to determine the learning status of ICT students in java
programming also to recognize their logical and java skills together with the
recent application of java in making simple program

To the students. It can be used as their guide in learning the java on how a
simple program makes and works, their improvements and potential as
programmers

To the teachers. This study could be the basis in determining on how the
students learned the java and how they understand in making a simple program,
together with the problems and solutions to the problems in learning the java

To the future researchers. Could be useful in making some of the future

research paper works
To those who wants to take ICT PROGRAMMING track. They can use this
study as a guide in learning, making and understanding computer java language

SCOPE AND LIMITATIONS OF THE STUDY

This study was conducted to determine the learning status of information

and communications technology students in java programming as perceived by
ICT students in ICT classes during the school year 2018-2019. The aspects look
into the students’ learning progress, effectiveness of methods and strategies,
factors that affect their learning progress, problems and proposed solutions to the
problems.

Although the research has reached its aims, there were some unavoidable
limitations. First, because of lack of facility, this research conducted only in
available computer units in school computer laboratory and in computer shops
that can be found in the community. Therefore, to enhance the investigation, this
should have effective computer units to pursue and help the researchers in
conducting the study, enough knowledge about java program and worked thesis
related to this study. Second, the ICT students’ knowledge about java in making
simple program and their learning progress might affect the result in conducting
this research because they have different aspects and learning skills in making
java program.
TOPICAL OUTLINE

Title of the Proposed Study:

LEARNING STATUS OF INFORMATION AND COMMUNICATIONS

TECHNOLOGY STUDENTS IN JAVA PROGRAMMING

1. Introduction

2. Definition of Java

3. History of Java Language

3.1 Discovery

3.2 Its Proponent

4. Purpose of Java

4.1 As computer Language

4.2 Advantages of using Java Codes

4.3 Disadvantages of using Java Codes

5. How Java Works

5.1 Basic Principles

5.2 Analyzing and using Java Codes

a. Its Codes and Function

b. Example of Java Program Output

6. Learning Progress of ICT Students in Java

6.1 Cases of ICT Students taking Java

a. Students’ current issues in taking Java Programming

b. Graduate vs. Undergraduate rates of ICT students

7. Suggested/alternative solutions in Addressing the Problem

7.1 In the Philippines

7.1 Global Solutions

 CHAPTER II
Review of Related Literature and Studies

Introduction

Java is the most popular, a high-level language & is the language of

choice for android programming that can be characterized by simple, object
oriented, distributed, multithreaded, dynamic, architecture neutral, portable, high
performance, robust and secure. This programming language is commonly used
to create, manipulate, visualize and rearranged applications, programs or
software with other computer languages to establish its compatibility in different
digital forms. Java is commonly used in making programs that can run smoothly.

History of Java

In the early 1990’s, grunge rock was in its prime and childrens’ cartoons
were reaching their prime as well. In coincidence with these events is the
development of a programming language called Java. James Gosling at Sun
Microsystems had the idea of creating a more readable, universal language than
C++, so he set out to create Java. At first, the target audience for Java was
consumer electronics, but quickly spread to having the title of being the Universal
Programming Language, which would eventually lose momentum. (Vincent,
2014)

Discovery

Java is heavily influenced by C++, and has grown exponentially over the
years. Countless updates have given Java more flexibility and power. To the
present, 2014, Java SE 8 has been released. Previous updates have expanded
the class library from a few hundred classes to over 3,000 and added many
extensions such as for-each loops and lambda expressions. Java has expanded
into one of the most powerful programming languages to ever exist and is still
being developed in order to expand its capabilities and further its power.
(Vincent, 2014)

Java wasn’t very popular when it was released in 1991, but has gained
considerable momentum through the years. The simplicity, extensibility and the
minor difficulty of learning Java has gained it the status of being one of the first
program languages programmers learn in their journey. In addition, the power of
Java has gained it the status of being one of the most widely used programming
languages of today. (Vincent, 2014)

It’s Proponent

Since 1984, Gosling has been with Sun Microsystems, and is generally
known best as the founder of the Java programming language.

A world-class innovator for over 30 years, James A. Gosling’s

development of the Java programming language in 1995 was a major milestone
in computing that has had an immeasurable impact on computer science. Dr.
Gosling combined the best ideas in programming languages with his own ideas
to create the first widely deployed programming language featuring portability to
allow transmission of code over the Internet from one computer to another for
execution while still meeting security requirements. Its features include the
portable "write once, run anywhere" byte-coded platform and libraries that makes
use of a standard class file format that can be loaded and executed by any Java
Virtual Machine; the robust and secure "sand box" approach; type-safe automatic
storage management; just-in-time compilation; and platform scaling from cell
phone to enterprise server. Used by approximately 9 million developers, Java is
one of the most popular programming languages in history and can be found in
servers, mobile phones, and the chips embedded in credit cards and identity
badges. Dr. Gosling has also influenced software engineering methodology with
important contributions during the 1980s. As a graduate student, he created one
of the most widely used versions of the UNIX Emacs text editor. As a contributor
to Carnegie Mellon’s Andrew Project, he developed the first UNIX windows
manager and one of the first modern, multiformat text editors that allowed
placement of tables, pictures, and graphics in a document. This open-source
architecture influenced the evolution of Microsoft Windows. Dr. Gosling has also
impacted the world of embedded systems with his early work on the ISIS II
satellite, a real-time specification for Java, and his current work on autonomous
ocean-going robots.

He is generally credited as the inventor of the Java programming

language in 1991. He did the original design of Java and implemented its original
compiler and virtual machine. For this achievement he was elected to the United
States National Academy of Engineering. He has also made major contributions
to several other software systems, such as NeWS and Gosling Emacs. He also
cowrote the "bundle" program, a utility thoroughly detailed in Brian Kernighan
and Rob Pike's book The Unix Programming Environment.

A member of the US National Academy of Engineering and an Officer of

the Order Canada (second-highest Canadian civilian honor), Dr. Gosling is chief
software architect with Liquid Robotics, Redwood, CA, USA. (Engineering and
Technology History Wiki, Centre for Computing History 2016)
Purpose of Java

According to Vijayalakshmi (2017) The Java language is a key pillar in

Android, an open source mobile operating system. Although Android, built on the
Linux kernel, is written largely in C, the Android SDK uses the Java language as
the basis for Android applications. The bytecode language supported by the
Android SDK is incompatible with Java bytecode and runs on its own virtual
machine, optimized for low-memory devices such as smartphones and tablet
computers. Depending on the Android version, the bytecode is either interpreted
by the Dalvik virtual machine, or compiled into native code by the Android
Runtime.

As Computer Language

Java technology is used to develop applications for a wide range of

environments, from consumer devices to heterogeneous enterprise systems. In
this section, get a high-level view of the Java platform and its components.
(Perry, 2010)

Java is also well known technology which allows software designed and
written only once for a "virtual machine" to run on different computers, supports
various Operating System like Windows PCs, Macintoshes, and Unix computers.
On the web aspect, Java is popular on web servers, used by many of the largest
interactive websites. Java is used to create standalone applications which may
run on a single computer or in distributed network. It is also be used to create a
small application program based on applet, which is further used for Web page.
Applets make easy and possible to interact with the Web page. (Purushotham,
2016)
 Every enterprise uses Java in one way or other. As per Oracle, more than
3 billion devices run applications designed on the development platform. Java is
used to design the following applications:

 Desktop GUI applications

 Embedded systems
 Web applications, including eCommerce applications, front and back office
electronic trading systems, settlement and confirmation systems, data
processing projects, and more
 Web servers and application servers
 Mobile applications including Android applications
 Enterprise applications
 Scientific applications
 Middleware products

According to article written by Mohan (2016), these are the nine (9)
advantages and seven (7) disadvantages of using Java Codes:-

Advantages of Using Java Codes

 Java offers higher cross- functionality and portability as programs written

in one platform can run across desktops, mobiles, embedded systems.
 Java is free, simple, object-oriented, distributed, supports multithreading
and offers multimedia and network support.
 Java is a mature language, therefore more stable and predictable. The
Java Class Library enables cross-platform development.
 Being highly popular at enterprise, embedded and network level, Java has
a large active user community and support available.
 Unlike C and C++, Java programs are compiled independent of platform in
bytecode language which allows the same program to run on any machine
that has a JVM installed.
  Java has powerful development tools like Eclipse SDK and NetBeans
which have debugging capability and offer integrated development
environment.
 Increasing language diversity, evidenced by compatibility of Java with
Scala, Groovy, JRuby, and Clojure.
 Relatively seamless forward compatibility from one version to the next
 Object Oriented Programming, to create modular programs and reusable
code keeping the system extensible as well as flexible.
 Java supports multithreaded. Multithreaded is the path of execution for a
program to perform several tasks simultaneously within a program. The
java come with the concept of Multithreaded Program. In other languages,
operating system-specific procedures have to be called in order to work on
multithreading.

Disadvantages of Using Java Codes

 Java compiler is not well optimized yet compared to C++.

 There is no separation of specification from implementation.
 Memory management, with Java, is a little expensive.
 The lack of templates can limit the ability of Java to create high quality
data structures.
 One can find some bugs in browsers and example programs.
 Performance significantly slower and more memory-consuming than
natively compiled languages such as C or C++.
 The default look and feel of GUI applications written in Java using the
Swing toolkit is very different from native applications. Single-paradigm
language, the addition of static imports in Java 5.0 the procedural
paradigm is better accommodated than in earlier versions of Java.
 How Java Works

On full implementation of the Java platform, it gives the following features:

JDK Tools: The JDK tools provide compiling, Interpreter, running,

monitoring, debugging, and documenting your applications. The main tools used
are the Javac compiler, the javalauncher, and the javadoc documentation tool.

Application Programming Interface (API): The API provides the core

functionality of the Java programming language. It gives a wide collection of
useful classes, which is further used in your own applications. It provides basic
objects and interface to networking and security, to XML generation and
database access, and much more.

Deployment Technologies: The JDK software provides two type of

deployment technology such as the Java Web Start software and Java Plug-In
software for deploying your applications to end users.

Graphical User Interface Toolkits: The Swing and Java 2D toolkits provide
us the feature of Graphical User Interfaces (GUIs).

According to the study conducted by Rongala (2015) entitled “Integrated

Libraries: Integrated with various libraries such as the Java IDL API, JDBC API,
Java Naming and Directory Interface TM ("J.N.D.I.")” API, Java RMI, and Java
Remote Method Invocation over Internet Inter-ORB Protocol Technology (Java
RMI-IIOP Technology) enable database to access and changes of remote
objects.
Basic Principles

OOP (Object Oriented Programming) is a technique that helps in

designing a program more effectively using classes and objects. (Sharma S.,
2013)

. The advantages of OOP (Object Oriented Programming) over procedure-

oriented programming languages are:

 Development of programs is easier; in procedure-oriented languages it's

difficult to manage the coding of the program when the program increases in
size.
 Provides a way to interact with real-world data more effectively.
 Allows development of solutions for real-world problems.
 Provides hiding of codes but in a procedure-oriented language the data can
be accessed from anywhere.

There are four main features of OOP; they are:

Encapsulation

According to the study conducted by Sharma (2013) entitled

“Encapsulation” means binding all methods and classes in a single class.
Encapsulation is the technique of making the fields in a class private and
providing access to the fields via public methods. If a field is declared private
then it cannot be accessed by anyone outside the class, thereby hiding the fields
within the class. The main benefit of encapsulation is the ability to modify our
implemented code without breaking the code of others who use our code.
Encapsulation provides maintainability, flexibility and extensibility of our code.
Inheritance

According to the study conducted by Sharma (2013), the main feature of

Inheritance is code re-usability. So when making a new class we can use a
previously written class and further extend it. In Java, classes may inherit or
acquire the properties and methods of other classes. A class derived from
another class is called a subclass, whereas the class from which a subclass is
derived is called a super class. A subclass can have only one super class,
whereas a super class may have one or more sub-classes. (Sharma S. 2013)

Polymorphism

In Core Java, Polymorphism is an easy concept to understand.

Polymorphism in Greek is a combination of poly, which means many and
morphism which means forms. It refers to the object's ability to be Polymorphic
depending on its type.

There are two types of Polymorphism available in Java.

1) Static Polymorphism

In Java method overloading we define two or more methods with the same
name but different parameters. The methods are said to be overloaded, and the
process is referred to as method overloading.

2) Dynamic Polymorphism
It's run time polymorphism. We can also call it Method Overriding. In a class
hierarchy, when a method in a sub class has the same name and type signature
as a method in its superclass, then the method in the subclass is said to override
the method in the superclass. This feature is called method overriding. (Sharma
S. 2013)

Abstraction

When we hide the unnecessary detail and defining the useful (relevant)
detail, then the procedure is said to be abstraction. An interface or abstract class
is something that is not concrete, something that is incomplete. Another way of
providing a simple explanation is to use a more complex system as an example.
One does not want to understand how an engine works. Similarly one does not
need to understand the internal implementation of the software objects.
Abstraction in Java is done by using an interface and abstract class in Java. In
order to use an interface or abstract class we need to explain the methods of an
interface or abstract class in a sub-class. (Sharma S., 2013)

Analyzing and Using Java Codes

According to the journal Conducted by Vincent (2014), Java offers a vast

and fairly simple way for naming variables. Names in Java have no length limit,
so they can be however long the user wishes. They are case-sensitive, which
means PEAR and pear are two different variables. In addition, Java uses
keywords, like real, int, byte, new, and this. The user also has the option to use
imported Java names to assist them in naming.

For example,
private ClassName obj1 = null;

private com.yourpackage.second.ClassName obj2 = null; is a basic

implementation of importing Java names.

As for bindings in Java, static and dynamic bindings are both possible. If
a variable needs to be static, the user must explicitly declare the variable as
static. For example:

static int i = 0;

All other variables are stack-dynamic variables, unless they are objects, in which
case they are explicit heap-dynamic variables.

Java only utilizes static scoped variables throughout its programming

syntax. Instance variables scope the entire class definition. Parameter variables
scope only the method body in which they were used. In addition, local variables
scope from the point of declaration to the end of the method body. (Vincent,2014)

Its Codes and Functions

Like any programming language, the Java language designates certain

words that the compiler recognizes as special. For that reason, you're not
allowed to use them for naming your Java constructs. The list of reserved words
(also called keywords) is surprisingly short:
 abstract
 assert
 boolean
 break
 byte
 case
 catch
 char
 class
 const
 continue
 default
 do
 double
 else
 enum
 extends
 final
 finally
 float
 for
 goto
 if
 implements
 import
 instanceof
 int
 interface
 long
  native
 new
 package
 private
 protected
 public
 return
 short
 static
 strictfp
 super
 switch
 synchronized
 this
 throw
 throws
 transient
 try
 void
 volatile
 while

A class is a blueprint for a discrete entity (object) that contains attributes

and behavior. The class defines the object's basic structure; at runtime, your
application creates an instance of the object. An object has a well-defined
boundary and a state, and it can do things when correctly asked. Every object-
oriented language has rules about how to define a class.

package packageName;
import ClassNameToImport;

accessSpecifier class ClassName {

accessSpecifier dataType variableName [= initialValue];

accessSpecifier ClassName([argumentList]) {

constructorStatement(s)

accessSpecifier returnType methodName ([argumentList]) {

methodStatement(s)

// This is a comment

/* This is a comment too */

/* This is a

multiline

comment */

Above code contains various types of constructs, including package in line

1, import in line 2, and class in line 3. Those three constructs are in the list of
reserved words, so they must be exactly what they are. Notice that lines 11
through 15 are comment lines. In most programming languages, programmers
can add comments to help document the code. Java syntax allows for both
single-line and multiline comments:

// This is a comment
/* This is a comment too */

/* This is a

multiline

comment */

A single-line comment must be contained on one line, although you can

use adjacent single-line comments to form a block. A multiline comment begins
with /*, must be terminated with */, and can span any number of lines.

With the Java language, you can choose the names for your classes, such as
Account, Person, or LizardMan. At times, you might end up using the same name
to express two slightly different concepts. This situation, called a name collision,
happens frequently. The Java language uses packages to resolve these
conflicts.

A Java package is a mechanism for providing a namespace— an area

inside of which names are unique, but outside of which they might not be. To
identify a construct uniquely, you must fully qualify it by including its namespace.

Packages also give you a nice way to build more-complex applications

with discrete units of functionality.

To define a package, use the package keyword followed by a legal

package name, ending with a semicolon. Often package names follow this de
facto standard scheme:

package orgType.orgName.appName.compName;
This package definition breaks down as:

 orgType is the organization type, such as com, org, or net.

 orgName is the name of the organization's domain, such as makotojava,

oracle, or ibm.

 appName is the name of the application, abbreviated.

 compName is the name of the component.

Up next in the class definition is the import statement. An import statement

tells the Java compiler where to find classes that you reference inside of your
code. Any nontrivial class uses other classes for some functionality, and the
import statement is how you tell the Java compiler about them.

An import statement usually looks like this:

import ClassNameToImport;

Importing an entire package can make your code less readable, however,
so I recommend that you import only the classes that you need, using their fully
qualified names.
 To define an object in the Java language, you must declare a class. Think
of a class as a template for an object, like a cookie cutter.

Example that includes this class declaration:

accessSpecifier class ClassName {

accessSpecifier dataType variableName [= initialValue];

accessSpecifier ClassName([argumentList]) {

constructorStatement(s)

accessSpecifier returnType methodName([argumentList]) {

methodStatement(s)

A class's accessSpecifier can have several values, but usually it's public.
You'll look at other values of accessSpecifier soon.

May name classes pretty much however, but the convention is to use
camel case: Start with an uppercase letter, put the first letter of each
concatenated word in uppercase, and make all the other letters lowercase. Class
names should contain only letters and numbers. Sticking to these guidelines
ensures that your code is more accessible to other developers who are following
the same conventions.
Classes can have two types of members—variables and methods.

The values of a class's variables distinguish each instance of that class

and define its state. These values are often referred to as instance variables. A
variable has:

 An accessSpecifier

 A dataType

 A variableName

 Optionally, an initialValue

The possible accessSpecifier values are:

Public: Any object in any package can see the variable. (Don't ever use this
value; see the Public variables sidebar.)

Protected: Any object defined in the same package, or a subclass (defined

in any package), can see the variable.

No specifier (also called friendly or package private access): Only objects

whose classes are defined in the same package can see the variable.
 Private: Only the class containing the variable can see it.

A variable's dataType depends on what the variable is — it might be a

primitive type or another class type. By convention, variable names use the
camel case convention, except that they begin with a lowercase letter

Here's an example that summarizes a class definition for Person.

package com.makotojava.intro;

public class Person {

private String name;

private int age;

private int height;

private int weight;

private String eyeColor;

private String gender;

A class's methods define its behavior.

 Methods fall into two main categories: constructors; and all other methods,
which come in many types. A constructor method is used only to create an
instance of a class. Other types of methods can be used for virtually any
application behavior.

The class definition shows the way to define the structure of a

method, which includes elements like:

 accessSpecifier
 returnType
 methodName
 argumentList

The combination of these structural elements in a method's definition is

called the method's signature.

Using constructors will specify how to instantiate a class. Example

shows the constructor-declaration syntax in abstract form, and here it is
again:

accessSpecifier ClassName([argumentList]) {

constructorStatement(s)

Constructors are optional

 If you don't use a constructor, the compiler provides one for you,
called the default (or no-argument or no-arg) constructor. If you use a
constructor other than a no-arg constructor, the compiler doesn't
automatically generate one for you.

A constructor's accessSpecifier is the same as for variables. The

name of the constructor must match the name of the class. So if you call
your class Person, the name of the constructor must also be Person.

For any constructor other than the default constructor (see the
Constructors are optional sidebar), you pass an argumentList, which is one
or more of:

argumentType argumentName

Arguments in an argumentList are separated by commas, and no

two arguments can have the same name. argumentType is either a
primitive type or another class type (the same as with variable types).

See what happens when you add the capability to create a Person
object in two ways: by using a no-arg constructor and by initializing a
partial list of attributes.
package com.makotojava.intro;

public class Person {

private String name;

private int age;

private int height;

private int weight;

private String eyeColor;

private String gender;

public Person() {

// Nothing to do...

public Person(String name, int age, int height, int weight String eyeColor, String
gender) {

this.name = name;

this.age = age;

this.height = height;

this.weight = weight;

this.eyeColor = eyeColor;

this.gender = gender;

}
}

The “this” keyword is Java shorthand for "this object," and you must use it
when you reference two variables with the same name. In this case, age is both
a constructor parameter and a class variable, so the this keyword helps the
compiler to tell which is which.

Generally, two types of (nonconstructor) methods are used: instance

methods and static methods. Instance methods depend on the state of a specific
object instance for their behavior. Static methods are also sometimes called
class methods, because their behavior isn't dependent on any single object's
state. A static method's behavior happens at the class level.

Static methods are used largely for utility; you can think of them as being
global methods (à la C) while keeping the code for the method with the class that
defines it.

For example, throughout this tutorial, you'll use the JDK Logger class to
output information to the console. To create a Logger class instance, you don't
instantiate a Logger class; instead, you invoke a static method named
getLogger().

The syntax for invoking a static method on a class is different from the
syntax used to invoke a method on an object. You also use the name of the class
that contains the static method, as shown in this invocation:
Logger l = Logger.getLogger("NewLogger");

In this example, Logger is the name of the class, and getLogger(...) is the
name of the method. So to invoke a static method, you don't need an object
instance, just the name of the class.

A dataType can be either a primitive type or a reference to another object.

For example, notice that Age is an int (a primitive type) and that Name is a String
(an object). The JDK comes packed full of useful classes like java.lang.String,
and those in the java.lang package do not need to be imported (a shorthand
courtesy of the Java compiler). But whether the dataType is a JDK class such as
String or a user-defined class, the syntax is essentially the same.

Table shows the eight primitive data types that likely to see on a regular basis,
including the default values that primitives take on if doesn’t explicitly initialize a
member variable's value.

Default
Type Size value Range of values

boolean n/a false true or false

byte 8 bits 0 -128 to 127

char 16 (unsigned) \u0000' \u0000' to \uffff' or 0 to 65535

 Default
Type Size value Range of values

bits

16
short bits 0 -32768 to 32767

32
int bits 0 -2147483648 to 2147483647

64 -9223372036854775808 to
long bits 0 9223372036854775807

32
float bits 0.0 1.17549435e-38 to 3.4028235e+38

64
double bits 0.0 4.9e-324 to 1.7976931348623157e+308

When calling the getLogger() method, you pass it a String. For now, just
get in the habit of passing the name of the class that the code is located in. From
any regular (that is, nonstatic) method, the preceding code always references the
name of the class and passes that to the Logger.
 In making a Logger call inside of a static method, reference the name of
the class inside of:

Logger l = Logger.getLogger(Person.class.getName());

Invoking — or calling— methods is easy. The testPerson method in Listing 6, for

example, invokes the various getters of Person to return their values. Now you'll
learn the formal mechanics of making method calls.

Method invocation with and without parameters

To invoke a method on an object, you need a reference to that object. Method-

invocation syntax comprises:

The object reference

A literal dot

The method name

Any parameters that need to be passed

The syntax for a method invocation without parameters is:

objectReference.someMethod();

Here's an example:

Person p = new Person("Joe Q Author", 42, 173, 82, "Brown", "MALE");

p.getName();

The syntax for a method invocation with parameters is:

objectReference.someOtherMethod(parameter1, parameter2, . . ., parameterN);

And here's an example (setting the Name attribute of Person):

Person p = new Person("Joe Q Author", 42, 173, 82, "Brown", "MALE");

p.setName("Jane Q Author");

Remember that constructors are methods, too. And using constructors, it

can separate the parameters with spaces and newlines. The Java compiler will
do nothing. The next two method invocations are equivalent:

new Person("Joe Q Author", 42, 173, 82, "Brown", "MALE");

new Person("Joe Q Author",// Name

42, // Age

173, // Height in cm

82, // Weight in kg

"Brown",// Eye Color

"MALE");// Gender

Notice how the comments in the second constructor invocation make it

more readable for the next person who might work with this code. At a glance,
that developer can tell what each parameter is for.
Method invocations can also be nested:

Logger l = Logger.getLogger(Person.class.getName());

l.info("Name: " + p.getName());

after here, pass the return value of Person.class.getName() to the

getLogger() method. Remember that the getLogger() method call is a static
method call, so its syntax differs slightly. (You don't need a Logger reference to
make the invocation; instead, use the name of the class as the left side of the
invocation.)

In the Java language, strings are first-class objects of type String, with
methods that help you manipulate them.

Here are a couple of ways to create a String, using the example of

creating a String instance named greeting with a value of hello:

greeting = new String("hello");

String greeting = "hello";

Because Strings are first-class objects, may can use new to instantiate
them. Setting a variable of type String to a string literal has the same result,
because the Java language creates a String object to hold the literal, and then
assigns that object to the instance variable.
 Using with String, many things can do and the class has many helpful
methods. Without even using a method, the code already done something
interesting within the Person class's testPerson() method by concatenating, or
combining, two Strings:

l.info("Name: " + p.getName());

The plus (+) sign is shorthand for concatenating Strings in the Java
language.

//private String name;

private String firstName;

The Java language uses two types of operators:

 Unary: Only one operand is needed.

 Binary: Two operands are needed.

Table 2. Java language's arithmetic operators

Operator Usage Description

+ a + b Adds a and b
Operator Usage Description

+ +a Promotes a to int if it's a byte, short, or char

- a - b Subtracts b from a

- -a Arithmetically negates a

* a * b Multiplies a and b

/ a / b Divides a by b

% a % b Returns the remainder of dividing a by b (the modulus operator)

++ a++ Increments a by 1; computes the value of a before incrementing

++ ++a Increments a by 1; computes the value of a after incrementing

-- a-- Decrements a by 1; computes the value of a before decrementing

-- --a Decrements a by 1; computes the value of a after decrementing

Operator Usage Description

+= a += b Shorthand for a = a + b

-= a -= b Shorthand for a = a - b

*= a *= b Shorthand for a = a * b

%= a %= b Shorthand for a = a % b

Several other symbols that are called operators in the Java language,
including:

Period (.), which qualifies names of packages and invokes methods

Parentheses (()), which delimit a comma-separated list of parameters to a

method

new, which (when followed by a constructor name) instantiates an object

The Java language syntax also includes several operators that are used
specifically for conditional programming — that is, programs that respond
differently based on different input. Look at those in the next section.
 The Java language gives operators and control statements that can use to
make decisions in the code. Most often, a decision in code starts with a Boolean
expression— that is, one that evaluates to either true or false. Such expressions
use relational operators, which compare one operand to another, and conditional
operators.

Operator Usage Returns true if...

> a > b a is greater than b

>= a >= b a is greater than or equal to b

< a < b a is less than b

<= a <= b a is less than or equal to b

== a == b a is equal to b

!= a != b a is not equal to b

&& a && b a and b are both true, conditionally evaluates b (if a is false, b is not evaluated)

|| a || b a or b is true, conditionally evaluates b (if a is true, b is not evaluated)

Operator Usage Returns true if...

! !a a is false

& a & b a and b are both true, always evaluates b

| a | b a or b is true, always evaluates b

^ a ^ b a and b are different

The following codes shows what happens when adding some logic to the
Person object's getHeight() accessor:

public int getHeight() {

int ret = height;

// If locale of the computer this code is running on is U.S.,

if (Locale.getDefault().equals(Locale.US))

ret /= 2.54;// convert from cm to inches

return ret;

If the current locale is in the United States (where the metric system isn't
in use), it might make sense to convert the internal value of height (in
centimeters) to inches. This (somewhat contrived) example illustrates the use of
the if statement, which evaluates a Boolean expression inside parentheses. If
that expression evaluates to true, the program executes the next statement.

In this case, only need to execute one statement if the Locale of the
computer the code is running on is Locale.US. If need to execute more than one
statement, may can use curly braces to form a compound statement. A
compound statement groups many statements into one — and compound
statements can also contain other compound statements.

Every variable in a Java application has scope, or localized namespace,

where you can access it by name within the code. Outside that space the
variable is out of scope, and can get a compile error if you try to access it. Scope
levels in the Java language are defined by where a variable is declared, as
shown:

public class SomeClass {

private String someClassVariable;

public void someMethod(String someParameter) {

String someLocalVariable = "Hello";

if (true) {

String someOtherLocalVariable = "Howdy";

someClassVariable = someParameter; // legal

 someLocalVariable = someClassVariable; // also legal

someOtherLocalVariable = someLocalVariable;// Variable out of scope!

public void someOtherMethod() {

someLocalVariable = "Hello there";// That variable is out of scope!

Within SomeClass, someClassVariable is accessible by all instance (that

is, nonstatic) methods. Within someMethod, someParameter is visible, but
outside of that method it isn't, and the same is true for someLocalVariable. Within
the if block, someOtherLocalVariable is declared, and outside of that if block it's
out of scope. For this reason shown that Java has block scope, because blocks
(delimited by { and }) define the scope boundaries.

Sometimes in a program's control flow, if wanted to take action only, a

particular expression fails to evaluate to true. That's when else comes in handy:

public int getHeight() {

int ret;

if (gender.equals("MALE"))

ret = height + 2;

else {
 ret = height;

Logger.getLogger("Person").info("Being honest about height...");

return ret;

The else statement works the same way as if, in that the program
executes only the next statement that it encounters. In this case, two statements
are grouped into a compound statement (notice the curly braces), which the
program then executes.

May can also use else to perform an additional if check:

if (conditional) {

// Block 1

} else if (conditional2) {

// Block 2

} else if (conditional3) {

// Block 3

} else {

// Block 4

} // End
 If conditional evaluates to true, Block 1 is executed and the program
jumps to the next statement after the final curly brace (which is indicated by //
End). If conditional does not evaluate to true, then conditional2 is evaluated. If
conditional2 is true, then Block 2 is executed, and the program jumps to the next
statement after the final curly brace. If conditional2 is not true, then the program
moves on to conditional3, and so on. Only if all three conditionals fail is Block 4
executed.

A loop is a programming construct that executes repeatedly while a

specific condition (or set of conditions) is met. For instance, ask a program to
read all records until the end of a data file, or to process each element of an
array in turn.

Three loop constructs make it possible to iterate over code or execute it

more than once:

for loops

while loops

do...while loops

The basic loop construct in the Java language is the for statement. May
can use a for statement to iterate over a range of values to determine how many
times to execute a loop. The abstract syntax for a for loop is:

for (initialization; loopWhileTrue; executeAtBottomOfEachLoop) {

 statementsToExecute

At the beginning of the loop, the initialization statement is executed

(multiple initialization statements can be separated by commas). Provided that
loopWhileTrue (a Java conditional expression that must evaluate to either true or
false) is true, the loop executes. At the bottom of the loop,
executeAtBottomOfEachLoop executes.

For loop

public static void main(String[] args) {

Logger l = Logger.getLogger(Person.class.getName());

for (int aa = 0; aa < 3; aa++)

Person p = new Person("Joe Q Author", 42, 173, 82, "Brown", "MALE");

l.info("Loop executing iteration# " + aa);

l.info("Name: " + p.getName());

l.info("Age:" + p.getAge());

l.info("Height (cm):" + p.getHeight());

l.info("Weight (kg):" + p.getWeight());

l.info("Eye Color:" + p.getEyeColor());

l.info("Gender:" + p.getGender());

}
}

The local variable aa is initialized to zero at the beginning of Listing 8. This

statement executes only once, when the loop is initialized. The loop then
continues three times, and each time aa is incremented by one.

Shown in the next section that an alternative for loop syntax is available
for looping over constructs that implement the Iterable interface (such as arrays
and other Java utility classes).

The syntax for a while loop is:

while (condition) {

statementsToExecute

As might suspect, if condition evaluates to true, the loop executes. At the

top of each iteration (that is, before any statements execute), the condition is
evaluated. If the condition evaluates to true, the loop executes. So it's possible
that a while loop will never execute if its conditional expression is not true at least
once.

public static void main(String[] args) {

Logger l = Logger.getLogger(Person.class.getName());
 int aa = 0;

while (aa < 3) {

Person p = new Person("Joe Q Author", 42, 173, 82, "Brown", "MALE");

l.info("Loop executing iteration# " + aa);

l.info("Name: " + p.getName());

l.info("Age:" + p.getAge());

l.info("Height (cm):" + p.getHeight());

l.info("Weight (kg):" + p.getWeight());

l.info("Eye Color:" + p.getEyeColor());

l.info("Gender:" + p.getGender());

aa++;

A loop that always executes once and then checks its conditional
expression, may use a do...while loop

int aa = 0;

do {

Person p = new Person("Joe Q Author", 42, 173, 82, "Brown", "MALE");

l.info("Loop executing iteration# " + aa);

l.info("Name: " + p.getName());

 l.info("Age:" + p.getAge());

l.info("Height (cm):" + p.getHeight());

l.info("Weight (kg):" + p.getWeight());

l.info("Eye Color:" + p.getEyeColor());

l.info("Gender:" + p.getGender());

aa++;

} while (aa < 3);

The conditional expression (aa < 3) is not checked until the end of the loop.

At times, programs need to bail out of — or terminate— a loop before the

conditional expression evaluates to false. This situation can occur in searching
an array of Strings for a particular value, and once find it, it doesn’t mean ignore
about the other elements of the array. For the times when need to bail, the Java
language provides the break statement:

public static void main(String[] args) {

Logger l = Logger.getLogger(Person.class.getName());

int aa = 0;

while (aa < 3) {

if (aa == 1)

break;

Person p = new Person("Joe Q Author", 42, 173, 82, "Brown", "MALE");

 l.info("Loop executing iteration# " + aa);

l.info("Name: " + p.getName());

l.info("Age:" + p.getAge());

l.info("Height (cm):" + p.getHeight());

l.info("Weight (kg):" + p.getWeight());

l.info("Eye Color:" + p.getEyeColor());

l.info("Gender:" + p.getGender());

aa++;

The break statement takes the program to the next executable statement
outside of the loop in which it's located.

To execute the loop only once and then bail. May also skip a single
iteration of a loop but continue executing the loop. For that purpose, the program
need the continue statement:

public static void main(String[] args) {

Logger l = Logger.getLogger(Person.class.getName());

int aa = 0;

while (aa < 3) {

aa++;
 if (aa == 2)

continue;

Person p = new Person("Joe Q Author", 42, 173, 82, "Brown", "MALE");

l.info("Loop executing iteration# " + aa);

l.info("Name: " + p.getName());

l.info("Age:" + p.getAge());

l.info("Height (cm):" + p.getHeight());

l.info("Weight (kg):" + p.getWeight());

l.info("Eye Color:" + p.getEyeColor());

l.info("Gender:" +

p.getGender());

Skip the second iteration of a loop but continue to the third. Continue
comes in handy when the program are, say, processing records and come
across a record in a program don't want to process. Skip that record and move
on to the next one.

Most real-world applications deal with collections of things like files,

variables, records from files, or database result sets. The Java language has a
sophisticated Collections Framework that can use to create and manage
collections of objects of various types.
 Most programming languages include the concept of an array to hold a
collection of things, and the Java language is no exception. An array is basically
a collection of elements of the same type.

May declare an array in one of two ways:

 Create the array with a certain size, which is fixed for the life of the array.

 Create the array with a certain set of initial values. The size of this set
determines the size of the array — it's exactly large enough to hold all of
those values, and its size is fixed for the life of the array.

In general, may declare an array like this:

new elementType [arraySize]

May create an integer array of elements in two ways. This statement

creates an array that has space for five elements but is empty:

// creates an empty array of 5 elements:

int[] integers = new int[5];

This statement creates the array and initializes it all at once:

// creates an array of 5 elements with values:

int[] integers = new int[] { 1, 2, 3, 4, 5 };

or

// creates an array of 5 elements with values (without the new operator):

int[] integers = { 1, 2, 3, 4, 5 };

The initial values go between the curly braces and are separated by
commas.

Another way to create an array is to create it and then code a loop to

initialize it:

int[] integers = new int[5];

for (int aa = 0; aa < integers.length; aa++) {

integers[aa] = aa+1;

The preceding code declares an integer array of five elements. If you try to
put more than five elements in the array, the Java runtime will throw an
exception.

To load the array, a loop through the integers from 1 through the length of
the array (which can get by calling .length on the array — more about that in a
minute). In this case, the program stop when hits 5.

Once the array is loaded, may access it as before:

Logger l = Logger.getLogger("Test");

for (int aa = 0; aa < integers.length; aa++) {

l.info("This little integer's value is: " + integers[aa]);

This syntax also works, and (because it's simpler to work with) using it
throughout this section:

Logger l = Logger.getLogger("Test");

for (int i : integers) {

l.info("This little integer's value is: " + i);

Think of an array as a series of buckets, and into each bucket goes an

element of a certain type. Access to each bucket is gained via an element index:

element = arrayName [elementIndex];

To access an element, need the reference to the array (its name) and the
index that contains the element that needed.
 Every array has a length attribute, which has public visibility, that you can
use to find out how many elements can fit in the array. To access this attribute,
use the array reference, a dot (.), and the word length, like this:

int arraySize = arrayName.length;

Arrays in the Java language are zero-based. That is, for any array, the first
element in the array is always at arrayName[0], and the last is at
arrayName[arrayName.length - 1].

Creating an array of java.lang.Integer objects isn't much different from

creating an array of primitive types and, again, you can do it in two ways:

// creates an empty array of 5 elements:

Integer[] integers = new Integer[5];

// creates an array of 5 elements with values:

Integer[] integers = new Integer[] {

Integer.valueOf(1),

Integer.valueOf(2),

Integer.valueOf(3),

Integer.valueOf(4),

Integer.valueOf(5)

};
 Every primitive type in the Java language has a JDK counterpart class

Primitive JDK counterpart

boolean java.lang.Boolean

byte java.lang.Byte

char java.lang.Character

short java.lang.Short

int java.lang.Integer

long java.lang.Long

float java.lang.Float

double java.lang.Double

Each JDK class provides methods to parse and convert from its internal
representation to a corresponding primitive type. For example, this code converts
the decimal value 238 to an Integer:

int value = 238;

Integer boxedValue = Integer.valueOf(value);

 This technique is known as boxing, because putting the primitive into a
wrapper, or box.

Similarly, to convert the Integer representation back to its int counterpart,

must unbox it:

Integer boxedValue = Integer.valueOf(238);

int intValue = boxedValue.intValue();

Strictly speaking, no need to box and unbox primitives explicitly. Instead, use the
Java language's autoboxing and auto-unboxing features:

int intValue = 238;

Integer boxedValue = intValue;

//

intValue = boxedValue;

A List is an ordered collection, also known as a sequence. Because a List

is ordered, may have complete control over where in the List items go. A Java
List collection can only hold objects (not primitive types like int), and it defines a
strict contract about how it behaves.
 List is an interface, so it can't instantiate it directly. Must work with its most
commonly used implementation, ArrayList. Make the declaration in two ways.
The first uses the explicit syntax:

List<String> listOfStrings = new ArrayList<String>();

The second way uses the "diamond" operator (introduced in JDK 7):

List<String> listOfStrings = new ArrayList<>();

Notice that the type of the object in the ArrayList instantiation isn't
specified. This is the case because the type of the class on the right side of the
expression must match that of the left side.

Note that it assigned the ArrayList object to a variable of type List. With
Java programming, may assign a variable of one type to another, provided the
variable being assigned to is a superclass or interface implemented by the
variable being assigned from.

The second way uses the "diamond" operator (introduced in JDK 7):

List<String> listOfStrings = new ArrayList<>();

 Notice that the type of the object in the ArrayList instantiation isn't
specified. This is the case because the type of the class on the right side of the
expression must match that of the left side.

The <Object> in the preceding code snippet is called the formal type.
<Object> tells the compiler that this List contains a collection of type Object,
which means that any can pretty much put whatever the likes in the List.

If decided to tighten up the constraints on what can or cannot go into the

List, may can define the formal type differently:

List<Person> listOfPersons = new ArrayList<Person>();

Now the List can only hold Person instances.

Example of Java Program Output

The following is a Java program that simulates a Hangman game.

import java.util.Scanner;

public class Assignment_9_1

public static void main(String[] args)

char reply = 'y';

while(reply == 'y' || reply == 'Y')

String[] words = {"hitman", "final", "fantasy", "cloud", "squall", "cyan"};

String word = words[(int) (Math.random() * 6)];

StringBuilder unknown = new StringBuilder();

for(int i = 0; i < word.length(); i++)

unknown.append("*");

Scanner input = new Scanner(System.in);

int j = 0;

while(j < 6)

if(unknown.toString().indexOf("*") == -1)

break;

System.out.printf("(Guess) Enter a letter in word %s > ", unknown);

String in = input.next();

String guess = in.substring(0,1);

if(word.indexOf(guess) == -1)

System.out.printf("\t%s is not in the word.\n", guess);

j++;

else
 {

if(unknown.indexOf(guess) >= 0)

System.out.printf("\t%s is already in the word.\n", guess);

else

for(int k = 0; k < word.length(); k++)

if(word.substring(k, k + 1).equalsIgnoreCase(guess))

unknown.replace(k, k + 1, guess);

if( j == 6)

System.out.println("You Lost!");

System.out.printf("The word is %s. You missed %d time(s).\n", word, j);

System.out.print("Do you want to guess another word? Enter y or n > ");

reply = input.next().charAt(0);

Learning Progress of ICT Students in Java

 According to study conducted by Gomez, et.al. (2014) Several
approaches and tools have been proposed aiming to support programming
learning in different ways. Although we find reports of positive results as an
outcome of some tools [1], none of them has a general use. In fact, the problem
remains relatively unchanged as we continue to find reports about the difficulties
many students experience when learning basic programming. Experience shows
that the problem starts for many students in the initial phase of learning, when
they have to understand and apply abstract programming concepts, like control
structures, to create algorithms that solve concrete problems. Particular attention
is necessary in this initial stage, not only in the development of programming
specific abilities, but also (and maybe above all) in the improvement and/or
consolidation of knowledge and abilities that should have been acquired in
previous years. These include generic problem solving abilities, logic reasoning
and so on.

Cases of ICT Students taking Java

According to study conducted by Gomez, et.al. (2014) Students highly

stated that less effective in teaching methodology which leads them to perform
poorly while learning Java programming. Less real world examples in class room
teaching and less examples in practical use were also the major factors for poor
performance. The factors like, lack of interest to learn Java, the wide coverage of
syllabus, less examples towards OOPs, presentation of instructor and attention,
learning environment were also rated in the study as a poor performer in Java
programming. The improper working condition of the computers in lab was
considered as a less factor that leads for poor performance in learning of Java
programming.

Students’ Current Issues In taking Java Programming

 The traditional teaching methods do not seem adequate for many
students’ needs, for different reasons:

 Teaching is not personalized. It would be desirable to have a teacher

always available to allow more personalized student supervision.
 Teachers’ strategies don’t support all students’ learning styles. People
learn in several ways and have different preferences to approach new
materials.
 The teaching of dynamic concepts through static materials. Programming
involves several dynamic concepts that many times are taught through
static means (projected presentations, verbal explanations, diagrams,
blackboard drawings, texts, and so on).
 Teachers are more concentrated on teaching a programming language
and its syntactic details, instead of promoting problem solving using a
programming language. The purpose of an introductory programming
course should be to increase students’ programming abilities.

The researchers consider that the study methods followed by many students are
not suitable for programming learning. The researchers also identify several
aspects where improvement could happen:

 Students use incorrect study methodologies. Many students are used to

solve problems from other disciplines through the memorization of
formulas or procedures.

 Students don’t work hard enough to acquire programming competences.

They are used to subjects where assisting classes and studying a text
 book is enough. However programming demands intense work extra
classes.
 Students don’t know how to solve problems.The researchers think that the
most important cause to the difficulties many freshmen feel to learn
programming is their lack of generic problem solving skills.
 Many students don’t have enough mathematical and logical knowledge.
 Students lack specific programming expertise. Many students’
programming difficulties are also caused by programming specific errors
and misconceptions.
 Programming demands a high level of abstraction. Programming learning
requires skills like abstraction, generalization, transfer and critical thinking,
among others.
 Programming languages have a very complex syntax. Programming
languages were developed for professional use and not to support
learning.
 Students don’t have motivation. Many students don’t have enough
motivation to study programming, because there is an extremely negative
connotation associated with programming that passes from student to
student.
 Students have to learn programming in a difficult period of their life.
Programming is normally taught as a basic subject in the beginning of a
higher education course, coinciding with a period of transition and
instability in the student’s life. (Gomez, A., et. al. 2014)

Graduate vs. Undergraduate rates of ICT students

According to the article written by Leijen et. Al (2016) A high dropout rate
among ICT students is a big problem in many countries. Motivation is one of the
characteristics which influence how students approach their learning and is
important in academic achievement. Motivation could be influenced by prior
experience, such as learning ICT at the general education level and working in
the ICT field. Some differences were found in the motivation of students who had
and those who did not have experience in programming.

Dropout in ICT related curricula is a problem in many countries. The

average student dropout rate for computer science students in Europe is at
around 19%. In Estonia, the dropout rate in ICT studies is around 40%, which is
much higher than the European average. ICT students’ dropout is also a problem
in Asia and the United States. One factor that may influence dropout in all
disciplines is learning motivation. Learning motivation could be measured during
student recruitment, so that candidates who are more likely to finish their studies
will be accepted.

In the European Union, the forecast in 2013 suggests that the unmet
demand for ICT practitioners could rise to 372,000–864,000 by 2015 and to
481,000–1,685,000 by 2020 (according to different scenarios). Unfortunately, the
number of computer science graduates in the European Union has been
decreasing since 2006. In Estonia, the forecast suggests that by the year 2020,
the number of higher education graduates needed in the ICT sector and other
sectors of the economy will be between 6,661 and 8,456. If the number of ICT
student positions in higher education does not change compared with the years
2010–2012, the number of ICT graduates will be around 8,400 by the year 2020,
which will probably meet the demand. However, it is only the case if all students
who start studies will finish them as well. Unfortunately, many students will drop
out already in the first year of their studies. So the problem is not a low number of
ICT students but a high dropout rate. Many of the students who drop out will still
enter the labor market and, therefore, more and more ICT workers will not have a
degree in ICT. However, the number of student candidates in ICT is about 2.6
times higher than the number of student positions. It means that the researchers
have to understand which characteristics of the candidates should be taken into
account, in order to avoid dropout. Previous experience with ICT either in studies
or at work might be an important factor to consider.

Suggested/Alternative Solutions in Addressing the Problem

 As teaching is not personalized the environment needs to provide

permanent student supervision.
 The environment must adapt activities to each student preferential
learning style.
 The environment includes dynamic computational models representing
programming concepts. However these models should be in accordance
with the preferential learning style of the student.
 The environment includes multimedia tools focused on problem solving
and algorithm development.
 To help in this area the environment must be attractive and include
activities that may interest students. It has many practical problem solving
activities, giving students the possibility to practice with a lot of diversified
activities.
 This environment must incorporate the following characteristics: For each
problem, the environment must verify that the student understood what
was asked. The problems proposed have an increasing difficulty level
maintaining, when possible, some connection with previous problems.
When the student proposes a solution to a particular problem, she/he will
have to face a set of questions or mini-activities in order to reflect on the
proposed solution. Integrating mechanisms that prevent the students from
giving up solving problems.
  The environment includes a set of challenges that include implicit or
explicit mathematical concepts, especially those concepts that are
important for typical programming problems.
 It is necessary that the environment helps students to make this transition.
This can be done essentially in two ways, namely: Helping and giving
hints to students, teaching them certain aspects of programming problem
solving. Allowing students to test their principles, theories and reasoning.
 It is important that the environment helps to develop the student’s
abstraction capacity.
 The environment minimizes aspects inherent to language syntaxes,
emphasizing the algorithmic and problem solving processes.
 A multimedia environment that includes several types of problem solving
activities as a way to attract students.
 Programming should be preceded by an intensive training in problem
solving.

In the Philippines

DepEd's Bureau of Curriculum Development Director Jocelyn DR. Andaya

said in a speech during the Education Summit last December 5, that closing the
technological gaps in ICT is the first step to enhancing the quality of education in
the Philippines.

According to DepEd, school heads must have enough capacity and

appreciation of the benefits of ICT through proper resource management. They
also stressed the importance of strategic external partnerships from private
sectors.
 To address this, they suggested that a regular training program for
teachers be developed and periodic ICT fora be held where teachers across all
levels can exchange ideas to advance the quality of ICT education in the country.

To kickstart the integration of the ICT program, DepEd initiated the

Learners’ Information System (LIS) that shows real-time registration of learners
enrolled in public schools.

LIS is a tool to manage information and seeks to promote transparency,

informed decision making, and empowerment at different levels of the
organization. (READ: The Philippines needs an ICT revolution, now)

Since its installation, LIS has allowed DepEd to generate total public
school enrollment based on the actual registration of learners.

To fully realize this, Andaya said that teachers should understand that ICT
is both a platform and tool for delivering instructions.

"ICT integration in digital literacy focuses on learning about ICT itself, how
the technology works, and how it is used in addressing the need for inclusive
education," she added. (Santisteban B. 2017)

Global Solutions

IBE sets the standards and guidelines for what must be regarded as
quality curricula. If countries must benefit from the true development value of the
curriculum, we must look beyond traditional conceptions, where the curriculum is
viewed simply as a collection of syllabi, study plans, and textbooks. Instead,
stakeholders must come to realise the more encompassing role of curriculum in
supporting development through education. IBE is a global intellectual leader in
this regard, as we continuously promote and support policy and technical
dialogue on a renewed understanding of curriculum. (International Bureau of
Education 2016)

In the past, infoDev worked with ICT and education. While our programs
do support some entrepreneurs and start-ups that develop educational
technologies (like Afroes and ListenMi), ICT and education are no longer the
focus of our mission.

"Accessing information" is the main use of ICTs in education "Access to

information" is considered to be one of the most important benefits of the uses of
ICTs in education. Accessing information -- not using ICTs for communication
purposes -- is the most common use of the Internet in schools beyond providing
a tool for the development of basic computer literacy skills.

Learning materials in electronic format are most useful when they are
directly linked to the curriculum The absence of educational content directly
linked to curricula is one of the key inhibiters of ICT use by teachers and
learners.

Creating digital/electronic content is difficult, and expensive Adapting

and/or digitizing curricular content for access via ICTs is a lengthy and expensive
process. This holds for digitized content accessible on PCs, and is especially true
with regards to educational television and video production. Radio dissemination
may offer cost savings. The large up-front costs related to the adaptation and/or
digitization of curricular content for access via ICTs may make such initiatives
attractive for donor aid.

Simply importing educational content is to be avoided Where indigenous

educational content expertise familiar with the uses of ICT does not exist, it is
necessary to have international and local groups work together. Simply importing
existing educational content and expertise from abroad is fraught with difficulties;
total reliance on local companies and organizations is often not practical in the
early stages.

Digital clearing houses and evergreen curricula are useful Establishing a

clearing house or digital libraries of ready-to-use and customizable ICT-based
resources promotes better use of ICT in teaching and facilitates quick and easy
access to resources for making lesson plans and for teaching.

Evaluation of ‘imported’ content for cultural relevance must not be

neglected Guidelines, resources and mechanisms for evaluation of content are
critical if such content is to be culturally relevant.

Digitizing content has important equity implications because of large up-

front costs in digitizing content, minority language use may suffer when ICTs are
introduced in education and minority language users are at risk of becoming
further marginalized. Because of limitations in using minority languages to
disseminate content via the Internet, radio may provide a more appropriate
mechanism for disseminating content in minority languages.
 ICT use in testing requires new processes When ICTs are introduced into
the testing and assessment processes and procedures, such processes and
procedures need to be evaluated and possibly reconfigured.

Public-private partnerships can be key Public-private partnerships are

often crucial for the development of digital content.

ICT use often promotes English language use ICT-enabled teaching and
learning is often seen as an important vehicle for the development of English
(and other linguas francas) language competencies by teachers and learners.
This is especially true with science and mathematics instruction, which are
delivered in English in many countries where English is not an indigenous or
dominant local language. This raises important issues related to learner equity
and access to education.

Intellectual property issues are very real Intellectual property issues are of
tremendous importance when developing digital content for use in education.
Ownership of content developed is a key issue to consider. Licensing of content
is often an option, but may contain hidden costs.

Official guidelines and directives enhance use of ICT-enabled content

Guidelines from the Ministry of Education relating to the integration of ICTs in
and with the curriculum greatly facilitate the use of ICTs in schools.(Trucano,
2005)
BIBLIOGRAPHY

Internet Resources:

Gomez, A., et. al. (2014)

Learning to program – difficulties and solutions

https://www.researchgate.net/profile/Anabela_Gomes2/publication/228328491_L
earning_to_program_-
_difficulties_and_solutions/links/02e7e52389017b9984000000.pdf(July 19, 2018)

Sivasakthi, M., et. al. (2011)

Learning difficulties of ‘object-oriented programming paradigm using Java’:

students’ perspective

http://www.indjst.org/index.php/indjst/article/view/30906 (July 19, 2018)

Vincent S. (2014)

Java

https://www.google.com/books?hl=en&lr=&id=4NZaDwAAQBAJ&oi=fnd&pg=PA5
83&dq=history+of+java&ots=BwDhSoBP5p&sig=UyaNhQ5nhj0mrL35BD5efiwTy
dE (July 19, 2018)

Perry S. J. (2010)

Java language basics

https://www.ibm.com/developerworks/java/tutorials/j-introtojava1/index.html (July
19, 2018)
Engineering and Technology History Wiki (2016)

James A. Gosling: Biography

https://ethw.org/James_A._Gosling (August 7, 2018)

Centre for Computing History (2016)

James Gosling

http://www.computinghistory.org.uk/det/1793/James-Gosling/ (August 7, 2018)

Purushotham S. (2016)

What is the use of Java programming language?

https://www.quora.com/What-is-the-use-of-Java-programming-language (August
7, 2018)

Vijayalakshmi K. (2017)

What is Java programming used for?

https://www.quora.com/What-is-Java-programming-used-for (August 7, 2018)

Rongala A. (2015)

Benefits of Java over Other Programming Languages

https://www.invensis.net/blog/it/benefits-of-java-over-other-programming-
languages/ (August 7, 2018)
Mohan S. (2016)

All You Need to Know About Java – Advantages and Disadvantages

https://www.weblineindia.com/blog/all-you-need-to-know-about-java-advantages-
and-disadvantages/ (August 7, 2018)

Sharma S. (2013)

OOP Principles In Java

https://www.c-sharpcorner.com/UploadFile/fd0172/oops-principle-in-java/ (August
7, 2018)

Sedgewick R. et al (2018)

Appendix D: Java Programming Cheatsheet

https://introcs.cs.princeton.edu/java/11cheatsheet/ (August 29, 2018)

 Conceptual Model of the Study

On the basis of the foreign concepts, theories, and findings of related

literature, studies presented, and insights taken from them, a conceptual
framework is developed as shown

The Learning Status of Information and Communications Technology Students in

Java Programming

INPUT PROCESS OUTPUT

Knowledge Requirements -Data Gathering The Learning

Procedures Status of
 Java Encoding
Information and
 Java Language -Data Analysis and
Communications
Information Interpretation
Technology
 Problem Addressing -Coding Students in Java
Programming
-Testing and
Software Requirements Debugging

 Java Eclipse Oxygen -Implementation

Hardware Requirements
 Cellphones
 Computer/Laptop

Figure 1: Conceptual Framework

 This study adopted the input-process-output model of the project
development.

The Input section are classified into Knowledge Requirements, Software

Requirements, and Hardware Requirements.

The Knowledge requirements consists of Java Encoding, Java Language

Information and Problem Addressing.

Software requirements consist of Java Eclipse Oxygen.

Hardware requirements consists of Cellphones, Computer/Laptop.

The Process section identifies the activities involved, such as: Data
Gathering Procedures, Data Analysis and Interpretation, Coding, Testing and
Debugging, Implementation.

The output of the study is “The Learning Status of Information and

Communications Technology Students in Java Programming”.
Definition of Terms

Application – a program that performs one of the major tasks for which a
computer is used.

Codes – a set of letters, numbers, symbols, that is used to secretly send

messages.

Computer – an electronic machine that can store and work with large amounts of
information.

Hardware – equipment used for a particular purpose.

Java – a computer language that is widely used to create, manipulate, visualize,

and rearrange applications, programs or software with other computer languages
to establish its compatibility in different digital forms.

Learning – activity or process of gaining knowledge.

Programming – the act or job of creating computer programs.

Software – programs that can run on a computer and perform certain function.

Technology – the use of science in industry.

 CHAPTER III
Methodology of the Studies

METHOD OF RESEARCH USED

The True Experimental method of research was used in the study. True
Experimental method of research is a bias-free selection that ensures objectivity
of results in the study. The strength of true experiment lies in the fact that
researcher can achieve greater confidence in the genuineness of casual
relationships because they are observed under controlled conditions. Since the
present study or investigation was concerned about the learning status of
information and communications technology students in java programming, a
true experimental research was the most appropriate method to use.

METHOD OF COLLECTING DATA

The method of collecting data used was the normative survey. This is
concerned with looking into the commonality of some elements. Since the
present research is a status study, the normative survey was the appropriate
method to use in gathering data.

The instrument used to collect data was the questionnaire. This was used
because it gathers data faster than any other method. Besides, the respondents
were students and so they are very literate. They could read and answer the
questionnaires with ease.

DEVELOPMENT OF THE RESEARCH INSTRUMENT

After reading and studying samples from the related literature and studies,
the researchers prepared their own questionnaires. They also consulted some
knowledgeable people about how to prepare one. The researcher wrote down
several questions to make up for a survey questionnaire. The researchers saw it
that there were enough items to collect data to cover all aspects of the problem
and to answer all the questions. It includes name, gender and certain questions
under the statement of the problem. Then the researchers prepare the system to
be tested by the respondents in conducting the study using the java eclipse
oxygen. The questionnaire soon will deploy if the system was done and finalized.

The copies of the questionnaire will then distributed personally by the

researchers to the respondents. Afterwards, testing the system and answering all
the questionnaires, the researchers will claim it personally.

THE SAMPLE DESIGN

The population of CZSHS Students is_____ , only ______ CZSHS ICT

Students are included as the target population and only 50 ICT students are
chosen as samples for the actual study.

The technique of sampling used is simple random sampling. The simple

random sampling was used because it is convenient and easy to use in the
study. The simple random sampling is a subset of a statistical population in
which each member of the subset has an equal probability of being
chosen. A simple random sampling is meant to be an unbiased
representation of a group.

STATISTICAL TREATMENT OF THE DATA

The statistical treatment data in application of our research in terms of

investigating the learning status of Information and Communications Technology
Students in Java Programming is by using simple random sampling. On this
data, we put how the data will presented statistically through putting the formula
in getting the survey:

Formula:

Simple random sampling formula:

P = F/n X 100

Where:

P = Percentage (%)

F = Frequency

n = Sample size (50); and 100 constant.