Transcript Java L1 - Department of Computer Science

Java Array, Game of Life
Prof. Sin-Min Lee
Department of Computer Science
San Jose State University
Overview - What is Java
•New, general purpose object-oriented programming language
from Sun Microsystems
•Allows users to interact with Web pages beyond simply:
•reading them
•filling out a form
•answering questions
•Allows interaction with program running as an extension to
your Web browser
•May be used to augment web page with both a new protocol
and the program which implements that protocol
•May be used for writing both network-oriented and local
application programs
History of the development of Java
•Started out in 1991 as Project Green
•focussed on O/S software for consumer electronic devices
•James Gosling recognized inadequacy of C++ and initiated
development of Oak language
•Green went through several false starts before dissolving
•Small group decided to adapt Oak (later named Java) to a web
technology -- result was a new web browser, WebRunner (later
named HotJava), operational in 1994
•Paper on Oak byte codes presented by Gosling at Programming
Language Design and Implementation (PLDI) conference in 1995
Highlights of the Java Language
•It's Simple
•It's Object Oriented
•It's Safe
•It's Secure
•It's Portable
•It's Fast (potentially)
•It's Multi-threaded
Java - It's Simple
•Java has only the necessary functionality needed to implement
its feature set.
•It has omitted the features of C and C++ which have been
considered to be "unsafe"
•pointer "forging"
•operator overloading
•static objects
•Memory is managed automatically, relieving the programmer
from being responsible for freeing unused space
•There is no Java preprocessor - the program that you see is the
same program that the Java compiler sees.
Java - It's Object Oriented
•Syntax and semantics inherited from C and C++, but many of
its object management features come from Objective C (e.g.
interfaces).
•Unlike C and C++, there are no stand-alone functions, but only
methods associated with a class.
•Everything (except for the built-in primitive types) is either a
class, a method, or an object.
•Extensive class library comes with Java, to interface with:
•host operating system
•window manager
•network
•Java Applications and Applets may provide their own class
library support
•May not replace "system" classes (for security purposes)
Java - It's Safe
•Four different levels of safety checks and enforcement to
prevent the introduction of viruses
•protect against deleting or modifying files
•protect against corrupting the operator of user's computer
•More strict type model than either C or C++
•Arrays are first class objects
•always range checked
•no visible conversion to pointer plus offset
•No implicit declarations in Java
•Only a minimum number of implicit conversions
Java - It's Fast (potentially)
•Currently, all mainstream implementations of Java are
running Java programs interpretively
•port of the interpreter developed by Sun
•alternative implementation built from the Java Language and
Virtual Machine specifications
•Java byte code is similar to functionality to P-code or U-code
•Several experimental projects translating Java byte codes to
either C or native machine code
•Slower than C or C++, due to mandatory run-time checks
•For many small Java programs, no advantage of compiling
over interpreting
Java - It's Multi-threaded
•Threads of control are an integral part of the Java language,
not a run-time library "add-on"
•Java offers preemptive multi-threading, implemented via
the Thread class
•Especially important when developing applets
•provide the proper dynamics between the Java applet and
the host browser
•prevent applet from usurping most of the compute cycles
Arrays
• One of the most basic data structures, is an array. An
array is just a number of items, of same type, stored in
linear order, one after another. Arrays have a set limit to
their size, they can’t grow beyond that limit. An array in
Java is noted as:
• int array[] = new int [10];
or
int [] array = new int [10];
• This would create an array of integers of size 10. Any
element in that array can be accessed by:
• int value = array[5];
• This would put the value of the 5’th (counting from 0)
element into the variable ‘value’.
• Arrays are very often manipulated in loops.
For example, if you have an array named
"myNumbers" and you'd like to print all of
them, one per line, you'll do something like
this:
• for(int i = 0;i<myNumbers.length;i++)
•
System.out.println(myNumbers[i]);
• Arrays are not just restricted to being int
type, they can be of any type, even of your
own created class.
• Arrays are nice structures, which are
generally faster than other data structures,
but they do have limits.
SOME VARIATIONS IN DECLARING
ARRAYS
• int numbers[10];
• static int numbers[10] = { 34, 27, 16 };
• static int numbers[] = { 2, -3, 45, 79, -14, 5, 9, 28,
-1, 0 };
• static char text[] = "Welcome to New Zealand.";
• static float radix[12] = { 134.362, 1913.248 };
• double radians[1000];
#include <stdio.h>
main()
{
int x;
static int values[] = { 1,2,3,4,5,6,7,8,9 };
static char word[] = { 'H','e','l','l','o' };
for( x = 0; x < 9; ++x )
printf(" Values [%d] is %d\n", x, values[x]);
}
Sample Program Output
Values[0] is 1
Values[1] is 2
....
Values[8] is 9
• The following program shows how to initialise all
the elements of an integer based array to the value
10, using a for loop to cycle through each element
in turn.
#include <stdio.h>
main()
{
int count;
int values[100];
for( count = 0; count < 100; count++ )
values[count] = 10;
}
• 5.Arrays and pointers are very closely
connected. The name of the array is also a
pointer to the beginning of the memory
associated with the array (which is why
• (1) arrays are passed as reference
parameters and
• (2) you can pass an array using only its
name.)
Arrays
• int vec [ 9 ];
•
•
•
•
float mat [ 9] [ 20 ];
vec [ k ] = vec [ k ] * 2;
mat [ k ] [ j ] := mat [ k ] [ j ] * vec [ k ];
Often when solving problems on the computer
you would like to represent and manipulate a set
of data values having similar characteristics
• Arrays provide this capability
Limits of Array
• One of the major limits, is that they're fixed in
size, and can't grow or shrink to accomodate
the data. The Vector class in java, uses an
array, and does make it seem that the array is
growing or shrinking. In reality, Vector class
checks to see if more space is needed, if it is,
then it creates a new array, copies the old
array to the new array, and makes the new
array, it's primary array, thus, giving the
impression that the array "grew" to fit the
data. This approach can get rather slow, if a
lot of growing & shrinking is needed.
Generating a Random Number
The following code snippet demonstrates how to generate a pseudorandom integer number that falls within a specific range.
Random random, random1;
int nbr;
random = new Random();
nbr = someMinValue +
Math.abs(random.nextInt()) %
(someMaxValue - someMinValue);
random1 = new Random(nbr);
// create another randon number generator using
// a specific seed value
There are two constructors for Random() . When invoked
with no argument, then a new pseudo-random
number generator is created using the current
time of day as a seed; otherwise, a pseudo-random
number generator can be created using a specific seed.
MULTI DIMENSIONED
ARRAYS
• Multi-dimensioned arrays have two or more
index values which specify the element in
the array.
•
multi[i][j]
• In the above example, the first index value i
specifies a row index, whilst j specifies a
column index.