Java

[cajones]

So for some reason I decided to do this yesterday... so here goes:


Apparently my board is down... and I don't think it's because of administration, because then it'd redirect me to proboards... so while I wait for server25 to come back (which it had better in the hour), I'm going to try an introductory Java tutorial thingy!

________________

Java says go!

The first thing to know is that java runs using the javaVirtualMachine (jvm), which is designed to allow programs written in java to run on multiple platforms. Naturally microsoft wants to make their own creative modifications, and Sun (java's creator) said no, so now the java runtime environment (jre) is not standard on Windows, so in order to run java programs (not counting applets), one must install the jre.
The java compiler (javac) converts source code into bytecode that the computer can run. The java compiler is found in the java development kit (jdk), which can be downloaded for free at java.sun.com. To avoid crazy path-setting and junk, you can get a version with a program such as netbeans which will make compiling and executing java programs easier (although you'll eventually want to use more native applications such as dos; see the notes for how to use java and javac in dos).

Now, on with the actual programming stuff!

Sourcecode is written in plain text format (notepad, edit, Etc) and saved with a .java extension. (note that some versions of notepad won't save this properly; you can get around this by putting quotes around the file name). A .java file is compiled to a .class file which java can then execute.


And now for a java program...

public class hello {
public static void main(String[] args) {

System.out.println("Yo! This program works, as you can plainly see!");
}
}

So what do we get as a result? The output window (dos, or ... whatever you're using to run java) will show the line

Yo! This program works, as you can plainly see!

Well, you could have guessed that much, so let's explain the weird-looking junk!


public class hello
This is the class definition; without this, java doesn't even recognize the file as a program.

Java programs are classes, and what is inside the class is what happens. Only a few things can be done outside of a class, such as importing other classes for use (which will be pretty useful in the near future).

The {} after the class declaration are the containers for what the class does.

Basically, whenever you have sections of code in java, it'll be contained in braces {}. It is very important to keep track of what braces are open and such, but now I'm just being confusing, so let's move to the next line!


public static void main(String[] args)

This defines the main method of the program; this is the method that is run when the program is executed. There are some confusing things in this declaration, but all you really need to know is what to type there.

But if you want to see what everything in the main declaration means... read this paragraph:

• public - Shows that the method can be invoked by running programs. Necessary for the program to run on its own. (Notice something about the class declaration?).
  
• static - Indicates that the method is static. I don't really know what this means since it's fairly useless in most cases... but it is necessary here.
  
• void - indicates that the method doesn't return anything. For a main program ihat doesn't do much... basically, if you're writing a method that isn't sending a value to another method, you use void. Our main method uses void because it invokes itself and therefore doesn't return anything to anyone.
  
• main - just the name of the method, and the one java uses for the running of an application.
  
• (String[] args) - parameters. Methods come with parentheses () that indicate that they are methods, and apparently main accepts a String[] parameter called args. You'll figure out what String[] is soon enough. And args is just the random name chosen by sun... I'd not risk changing it.
  

Now, for the actual event stuff!

System.out.print

This has three parts, but it's probably the easiest method to remember, so no panicking!

System - accesses the "System" class. We don't really know what it does, but we don't care so long as it works -- one of the advantages to java's object-oriented design.
out - an object in the System class that deals with output. The dots indicate that out is a child of System.
print() - a method of out, connected by the period. print is a method, and we send what we want to display in the parentheses (). Note that the quotes are important!


Notice that at the end of the print line, there is a semicolon (. All commands in java end in a semicolon. (Notice that the opening and closing of braces aren't semicolon'd, because they aren't commands, but blocks of code).


Confused? I hope not!


Notes...

To use the jdk in dos... you'll want to set the path to include the jdk/bin directory. If that's too confusing... you can memorize the path of the javac program, but that's a lot of trouble... (probably c:\"program files"\java\jdk1.6.0\bin\javac ).
If the path is set properly, you do this to compile a program:

javac filename.java
And to run the program...
java filename


Note that class names must match exactly the name of the file!


And if you're interested in a somewhat simplified version of commandline programming, look for acm.jar, which contains a program package. And ... I can't say much else on that unless you ask, so nya.
Program package simplifies several commands in command line programming and is made for beginners, but it seems to me that it might make it harder to understand more complicated programs that involve things like graphics and sound and ... cool things...


So, yeah. This probably sucks.

[cajones]

Dadada, now for the useful stuff!

What's the point of a program in which you can't read information from the user?
With the acm.program package, this is very easy and much less confusing... but hte confusingness about the standard ways are more useful for understanding how to do things better than commandline programs, so we'll focus on buffered readers (the Cajones doesn't know how to use scanners. Buffered readers aren't fun to make.).


Variables! Without variables, making programs that do stuff is pretty tough (though not impossible, I guess...).

Java has two types of variables: Primative types and objects. Objects are ... well... very very big in java (Remember the chaos that is System.out?), but primatives are very useful as well...

The most common primatives are:
int
double
float
boollean (Unless I spelled that wrong, in which case, adjust the number of 'l's).
char
long

Objects are powerful because they can be created to do whatever; or, you can create your own objects for use in a variety of programs.
Some native objects don't require the same syntax as created objects because of how freaking useful they are. In particular, we have the String class.

So here's a declaration of each type, I guess...
Note that two slashes (//) indicates a comment for the rest of the line. I'll use those to add comments on each declaration as necessary.



int num=1; //Integer.
double val=1.5; //double
float pi=3.14; //floating point number... ?
String str="There are mountains over there. *points*."; //Note the quotes.
boollean isFat=true; //Don't ask what we're talking about. .

Now, for input methods...

If you're using acm.program, you can do simple things:
readInt("Put a prompt message here."); //returns an integer.
readLine("Ditto..."); //returns a String
readDouble("More stuff..."); //returns a double

Note that in order to save the results of user input, it has to go to a variable (unless it's used directly in a calculation or something, but that isn't common).
So if we want a miles per gallon type program, we might do this using acm.program:

int miles=0;
int gals=0;
miles=readInt("Enter the number of miles:");
gals=readInt("Enter the number of gallons used:");
int mpg=0;
mpg=miles/gals;
System.out.println(mpg + "miles/gallon.");


Ur, that's lame. It's... a ridiculously common program to begin with input, so nya.


But if we aren't using the dangerous simplicity of acm, this should work if all of the capitals are correct...

Above the class declaration, import the input/output package.
Then inside, create a buffered reader to read text.
I'll just write a program and comment these



import java.io.*;
//inports the entire io package.

public class echo {

public static void main(String[] args) throws IOException {
//the throw statement ensures that the program can handle any errors that occur with input and output.

BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
//Creates a BufferedReader named br
//The construction of the buffered reader requires an InputStreamReader.
/* I have no idea what an input stream reader is, but it works. That is the fun of object oriented programming. System.in refers to the keyboard, which is a subobject of the System class.
*/

System.out.println("Type something and watch in wonder as this lame program shouts it back at you!");
String str="";
str=br.readLine();
System.out.println(str);
}
}


So, the hardest parts of that are probably the creation of hte reader, and the throwing of exceptions. *should debug this program and make sure it actually works*.

If something goes wrong with a program, java needs to do something with the error so it isn't stuck in limbo. This works fin with certain kinds of errors and java will just yell at you with an exception message.
Different packages, however, might have different methods that are dangerous to leave alone. IO is such a package, so you can use a throw statement to have java ... throw the exceptions.
You can also use try and catch to handle exceptions, but I'll get to those later.


So, ok, you can read things and apparently math works somehow... but... what can you really do with all of this?

Well, how about we go over some properties of ints and Strings?

First, how to turn a String into an integer.

This uses another native object called Integer, which is basically a class that holds ints so they have more power. Think of it as the int's mobile suit.

To turn a String into an int, assuming there's an int somewhere in it, you do this.
Assuming you have a variable called str, like so:

System.out.println("Type a number:");
str=br.readLine();
int num=Integer.parseInt(str);


This should give num the value of the number that is in str.

What can you do with ints?
Most of these operations can be used on doubles as well. Note that integers don't have decimals, and do not round correctly if they are used in combination with decimals (which is dangerous in itself).

/ --Division.
* --multiplication
+ --addition. This can also be used to add things to Strings, so if you want to print the sum of two ints without saving them, you should use parentheses ().
- --subtraction, negative if it is the first character in an assignment.
= --sets a value for a variable. This applies to _everything_.
++ --increment. This is a quick way of adding 1 to an int. (For example, you can have an int called num; you could either add 1 to it by saying num=num+1; , or num++; . Clearly the second is easier.).
-- --decrement. Quick means of subtracting 1 from an integer.
+= --Add something to a variable. Use this when you want to change the value of a variable and you are only adding something to it, for example: int num=0;
num=num+5;
and
num+=5;
Would have the same effect.
-= -- Subtract from a variable.
*= --multiplication of a variable. I haven't used this for exponents yet, but it seems like it'd be nice there? But in general, a quick means of changing a variable by a multiplier.
/= --division of a variable. Not that common.
% --get remainder. For example, 5%2 will give a value of 1, because 5/2=2 with a remainder of 1. (Usually said as "mod"). This is useful in some cases, such as if you want to tell if a number is even or odd.
%= --Set a variable to the remainder. If a%=b, a becomes the remainder of a/b. I have no idea when this would be used...

Was that confusing? I hope not, but it probably was...

Strings and chars can be confusing, so I'll address them in a later installment.

One more thing... and that is the power of the if statement!

Programs without ifs are probably calculators... or something. Even then, you probably need ifs for those!

The if statement looks like this:

if(condition) {
results
}

The condition is a conditional statement; this has two values: true or false. If the value is true, the code inside the following braces (or the next single statement if there are no braces) will be executed. If it is false, the braces (or following statement) are skipped, and if there is an else block afterward, it is executed.

For combaring ints and doubles, you can use these operators:

== --see if the values on either side are equal. For example, if you have an int num, if(num==5) would check to see if num is 5. You can compare two variables this way as well, for example if you have two ints num and num2, if(num==num2) would indeed check to see if num and num2 are equal.
< -- Is the first less than the second? if(a<b) would return true if a is less than b.
<= -- Less than or equal. if(a<=b) would return true if a is less than b, or if a equals b.
> --Greater than.
>= --greater than or equal to.
!= --not equal. This returns true if the values are not equal. For example, if you have int num, if(num!=4) would return true if num is anything but 4.

To negate a statement, i.e, to see if it is false, you can put an ! in front of it. For example, if you want to see if a isn't less than b (although >= wouuld work just as well), you could say:
if(!a<b)
The negation method is better used for object conditions than mathematical ones, but is very helpful.

So, if I made sense, you should be able to do something like this...

import java.io.*;

public class average {
public static void main(String[] args) throws IOException {
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
String act;
int num1=0;
int num2=0;
double avg=0.0;

System.out.print("Enter the first number:");
act=br.readLine();
num1=Integer.parseInt(act);
System.out.print("Enter the second number:");
act=br.readLine();
num2=Integer.parseInt(act);

avg=(num1+num2)/2;

System.out.println("The average of " + num1 + " and " + num2 + " is " + avg + ".");

}
}

Hopefully all of that works...!

Speaking of java... class in under 25 minutes!

[cajones]

More on conditionals and how to use them... because that's what makes a program interesting...


So, review...

if(a==b) System.out.print("a = b!");
else if(a>b) System.out.print("a is greater than b!");
else System.out.print("A is less than B!");
if(b!=c) System.out.print("B and C are not equal!");

So, what if you need to do more than one test at a time? You could nest them:

if(a!=b) {
if(b>c) System.out.println("B is greater than C, and B doesn\'t equal A!");
}

But that's ... not very convenient. So you can use these operators:

&& -- both conditions on either side must be true
|| -- Either condition on the left or right must be true.

So, we can rewrite the nested example above (that ... is kind of useless anyway):


if((a!=b)&&(b>c)) System.out.println("B is greater than C, and B isn\'t equal to A!");

Or you could do this. Note that this is a pretty useless statement just to demonstrate the OR operator:

if((a<b)||(a>b)) System.out.print("A is not equal to B!");


So, yay ifs! But what if you want to repeatedly do something until a condition is met? Like, a loop of some kind?

Java has three kinds of loops.

The simplest is the while loop.


while(condition) {
//do stuff
}

It's standard practice to indent inside blocks and such. I typically don't just because it serves no purpose for me... and can in fact be a nuissance when editting. But it's considered very good form to indent, especially in shared projects.

So, the while loop will only execute if the condition inside the parentheses () is true when the program reaches the loop, and will continue until the condition is false. (So, if you've already gone beyond the loop, you won't go back to it if the condition becomes true; you need to have another loop for that.).

So, if you want to read input until the user types an empty string, you'd have a loop like this. This will assume you have a BufferedReader called br and will implement a String method that I'll explain afterward...


String act="-";
while(!act.equals("")) {
System.out.print(">");
act=br.readLine();
}

It doesn't really do anything with the input, but it will still read it until the user pushes enter without typing any text.

So, we have a String declaration:

String act="-";

Act is set to "-" arbitrarily; all that we need is for act to be something other than "". What you set this as would vary depending on what the program does.

Notice the condition of the loop:

while(!act.equals(""))

This uses the 'false' operator (!). So you can at least tell that this means that the condition is that act.equals("") must be false.
You can probably figure out what act.equals("") means, but explaining comes anyway!

the String object is an example of a class. To do things to classes, you use methods. The exceptions are the creation of a String (most objects are created using constructors) and a few other native classes.
To invoke the method of an object, you type . then the method name, then parentheses, with any parameters inside of them. You should remember this from the first post.

So, act.equals(""); calls the String class's equals method and sends it a value of "".
The equals method returns true or false, depending on whether or not the string that is sent matches the String whose method is being called. (In javascript, you can compare Strings using == just like numbers).

What else can we do with Strings?

We can create a char by indicating a position in the String (where the first character is 0):
char c=act.charAt(0);
The above code would create a character c and give it the value of the first character of act. If act is blank (Such as ""), java will throw a StringIndexOutOfBoundsException... or something like that.

So how do you tell how long a string is?
int len=act.length();
Sets len to the length of act. This is the number of characters; note that act.charAt(act.length()); does not exist; the last character is act.charAt(act.length()-1).

Confused? I hope not!

One more string method, and then we move on to the other two loops...

If you want to break a String into sections, use the substring() method.
You send the substring method two values: the starting position (just like charAt), and the size of the substring.

So, say we do this:

act="abcdefg";
String abc=act.substring(0,3);

This should set abc to a value of "abc", as those are the first three characters of act. (If I use the wrong numbers... bad!).


The do-while loop is similar to a while loop, but it is constructed a little differently.

do {
//stuff
}
while(condition);

The difference in execution is minor: the loop runs once before checking to see if the condition is true. This may be necessary in many cases (... menus... or something... I don't know...). I'll note that over a month into a college java class, we haven't mentioned do-while loops yet (unless it was a day I missed, but that seems unlikely).

And finally... the for loop.

The for loop has a confusing syntax, but turns out to be extremely useful. As an example, the 30-second cartoon I made this morning has 8 for loops and no while loops.

The syntax for a for loop:

for(initialization; condition; update) {
//stuff
}

Perhaps a more understandable example?

for(int i=0; i<30; i++) {
System.out.print("*");
}

This would print "*" to the screen 30 times.

The for loop is an easy way to avoid repeating code and is very useful for initializing lists and things.

Breaking it down...

There are two semicolons ( inside the parentheses (). These split it into three parts:

Initialization: Use this to set a variable. This is the state of the variable when the loop begins. Note that if you create the variable here (Such as int i instead of just giving a value to a pre-existing variable), the variable does not exist outside of the loop.
Condition: Just like the conditions for while loops. The loop continues so long as this condition is true.
Update: Change something every time the loop is executed. This happens after the code inside the loop. This is typically used to get closer to the situation where the loop stops, such as counting up (or down if the need is so).


So another example using everything...

import java.io.*;

public class stars {

public static void main(String[] args) throws IOException {
String act="";
int width=0;
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));

System.out.println("Enter a number and a square of stars will be printed with the width that you entered. Enter a width of -1 to stop drawing squares.");

while(width>=0) {
System.out.print("Width:");
act=br.readLine();
width=Integer.parseInt(act);

for(int i=0; i<=width; i++) {
for(int j=0; j<=width; j++) print("*");
println();
}//rows
}//loop

}
}

This program should... umm... work. And print a square of "*" with the dimentions specified by the user until the user gives dimentions less than 0. (Note that only one dimention is required since we're printing squares).


Just one more thing!

How do you type characters such as ', ", or a line break or a tab into a string?

In java, javascript, and probably several other languages... you type special characters using the escape sequence. This is done by typing \, then the sequence. For example:

• \' = '
• 
  \\ = \
  
• \" = "
  
• \n = new line
  
• \r = carriage return
  
• \t = tab
  

There are probably others, but these are the most common ones.

And that's all for today!

[cajones]

And ... en.wikipedia.org/wiki/java(programming_language) , assuming that's the right case in the page name... ur... yeah. The wikipedia article on java is reasonable, and has links to resources (it looks as though it tries to demonstrate some pretty high level stuff that I wouldn't recommend diving into immediately... but is good nonetheless).

Here's a class that is up-to-date as of java 1.5.

ArrayLists Vs. Arrays.

ArrayList is a class in the java.util package. Since it isn't in java.lang (where String and Integer are), you'll have to import either the package or the class itself to use an ArrayList.

ArrayLists are objects that hold a list of objects of a specified type. The advantage to array lists is that you can add as many values as you want (until the computer goes memory-crazy), and can remove them with minimal hastle. Being objects with craji methods and such, they are often times less convenient than Arrays, which I'll get to in the next section... (Both are useful in their own ways; examples at the end!).


To create an ArrayList, you get to use another weirdo special exception trick...

When creating the object, you need to tell it what kind of objects it will hold. But you don't do this through the constructor ... you use <> ... which I don't think I've seen used as grouping symbols in java ever before...

So to create an ArrayList of Strings, you would do this (arbitrary variable name here; you can use whatever is appropriate):

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

That... looks... weird. Especially with the parentheses after the >. But... I think at this point I shouldn't have to explain much about what it does; the <> are used because ... ArrayLists are special... or something.


listOfStrings.add("Here\'s a string to add to the list!");
listOfStrings.add("Cat");
listOfStrings.add(br.readLine()); //assuming br exists. I probably wouldn't read the string inside the parentheses, but I think that's legal.
System.out.println(listOfStrings.get(1)); //should print Cat. I think. ^^.
listOfStrings.remove(0); //I haven't used this, so I'm only guessing that it takes an int.

listOfStrings.size(); //returns an integer containing the size of the list. Ur, an int. But yeah. It's how many items are in the list.

Since I barely know enough to tell you anything here... let's move on to Arrays.


Arrays are some sort of native type rather than classes. You can create arrays of primative types (int, long, boolean, double, float, char), or arrays of objects (String, ArrayList(Why would you need an array of those?), Random(That is indeed an object), Rectangle, JFrame).

To create an Array, you need to know how big the array is going to be beforehand; if we're comparing with javascript, Arrays are completely different... Yes.. Which confused me quite a lot... meh.


Arrays contain a list of variables of the indicated type. Very useful, of course. Arrays in java can have multiple dimentions, or Arrays of Arrays, if you will; but for now, I'll demonstrate a normal array:


int[] nums=new int[10]; //creates an array of ints called nums with 10 elements.

Now, important: remember the 0 first rule! When dealing with size and endpoints, you aren't giving the final slot, but the range. So you have an array with 10 elements from the code above, but the biggest slot you can access is [9].

To access an element of an array, put the number of the slot to access in brackets like so. You can use variables for this, and probably will more often than not...


nums[0]=30;
nums[1]=50;
nums[9]=a/b;
nums=-1;

For loops are very nice for working with arrays. In fact... the odds that one can create a program using arrays without using a forloop (or something that is a whileloop or dowhile with forloop elements that is rewritten just to be contrary) are quite slim.

Let's say we have an array of doubles called points. The following code will... well... you tell me:


double pi=3.1415; //poor precision, but whatever.

for(int i=0; i<points.length; i++) points*=pi;


Notice the use of .length. For arrays, you don't need the parentheses that you would use for a String, because arrays are not created from a class; length is a property, not a method.
The above code multiplies all values in points by our low-precision pi. Umm... calculus?


I feel as though this lesson has been useless so far, so it's time to turn it up a bit...



Methods!

Well, we've been using methods since page 1 with System.out.print();. Typically, if it's got parentheses, it's a method.

public static void main (String[] args)
This is a method that is invoked by the java executer when a program is run, if you'll remember. Any methods that you make inside the same class must be outside of other methods, but inside the class, so methods must be outside of the main function (typically above it).

You'll usually set a method to be public; the concept with public and private variables... umm... is half weird and will not be addressed here. .


So, you have public. Then what?

Methods can be static or not static. I'm not really sure what it means, but java complains sometimes if those aren't properly alligned... so if you have a non-static method and it says something like, "cannot be referenced from a static context", you should probably add the word "static" after public as seen in "public static void main(...)".

After that, we have the return type of the method. The method is either a way to do something quickly that is repeated (like print something? Move an object? Probably lots of really useful stuff in java3d that I don't know?), or it's going to do some operation that would be crazy to retype a lot and give you a value of some kind. Then you give it a name, and then you have a set of parentheses; if you want to send things to the method, you'll need to create blank variables for these inside the parenthese.

Example!:


public int parseInt (String str) {

}

The above code creates a method called parseInt that takes a String as a variable.

Note that variables inside a method are local to that method; they do not exist outside of the method, so you can't reference variables in main from a method outside of main, and variables in a method don't have any effect on main variables.

So ok, that method doesn't do anything. Let's fix that...


public int parseInt(String str) {
return Integer.parseInt(str);
}

That's a pretty simple and useless function that I really just use so I don't have to type Integer.parseInt every time I want to get an int from a string (Very lazy... but I'm used to parsing that in js, so nya. ^^).

So to use the parseInt method from main, you'd have a context like this (assuming of course that br is a bufferedreader that exists...).


String act=br.readLine();
int k=parseInt(act);

To call a method, you say its name, the parentheses, and any parameters that the method needs. In java, missing parameters means different function... which... is kind of annoying... but... yeah.

What if you don't want it to return anything, and just print something? Like.... say you send it an array of ints, and you want it to print the average?


You'd use void as the return type like so:


public void printAverage (int[] data) {
int sum=0;
for(int i=0; i<data.length; i++) sum=sum+data;
System.out.print(sum/data.length);
}

Notice the cumulative-ness!


And if you say printAverage without sending the array, java will say something like "cannot find symbol: method printAverage()". Because... there is no method called printAverage that doesn't take anything to run.

How about... a montage program or something!

Since I'm not feeling this lesson, I'll go ahead and do what the cs1 class did today...

import java.io.*;

public class Mode {

public static int getMode(int[] data) {
int currentMode=-1;
int highest=-1;

for(int i=0; i<data.length; i++) {
int k=0;
for(int j=0; j<data.length; j++) if(data[j]==data) k++;
if(k>highest) {
highest=k;
currentMode=data;
}
}

return currentMode;
}//method for getting the mode

public static void main(String[] args) throws IOException {
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
String act="";
System.out.print("How big is the list?");
act=br.readLine();
int[] nums=new int[parseInt(act)];

for(int i=0; i<nums.length; i++) {
System.out.print("Number " + i + "? : ");
act=br.readLine();
nums=parseInt(act);
}

int mode=getMode(nums);
System.out.print("The mode is " + mode + ".");
}
}

In that example, the use of the method was... kind of unnecessary, because it's only invoked once. But in many cases... ... well... yeah, methods are there to save a lot of code-copying. That and when we get to creating objects, they'll be very necessary... But that's not today!

[Wolfstar]

*hopes there is time next week to do something with this*
*thinks there will be if time is made*

[cajones]

How's about I go over static now that I understand it better...


static defines the method (or variable, whichever) as ... well... static, as opposed to instance.

This is most useful in methods, usually, so let's look at those.


Integer.parseInt(String str); <-- Static.

Static methods are invoked through the name of the class, then the usual .methodName(args); line. They are different from instance methods (most that we've worked with so far) in that instance methods require an instance of the class--an object, if you will.


For example, let's say we have the following class:


public class Ninja {
private String where;
private String weapon;
public Ninja(String inventory) {
weapon=inventory;
where="the shadows";
}

public void attack(String target) {
System.out.println("A Ninja attacks " + target + " with " + weapon + " from " + where + "!");
}

public static String hideNinjas(Ninja[] team) {
for(int i=0; i<team.length; i++) team.moveTo("hiding");
}

public void moveTo(String place) {where=place;}

}

And a class that uses the Ninja:

public class NinjaCustomer {

public static void main (String[] args) {
Ninja shredder=new Ninja("gauntlets");
Ninja[] tmnt=new Ninja[4];
tmnt[0]=new Ninja("katanas");
tmnt[1]=new Ninja("a staff");
tmnt[2]=new Ninja("nunchakus");
tmnt[3]=new Ninja("sais");

shredder.moveTo("an alleyway");
Ninja.hideNinjas(tmnt);
shredder.attack("April");
tmnt[2].attack("Shredder");
}
}

While we could easily use a for loop to move all members of an array of Ninjas, the point may be illustrated... you can't use a specific Ninja to run an operation on all of them, because the array doesn't have any methods of its members (well, they could have the same name, but that's not the point...).

So if we need a method that is related to the class, but doesn't make sense to call through an object from that class, we use static methods. Instead of hiding an array of Ninjas using a for loop at every instance, in every program that will need teams of ninjas to vanish quickly without trace, we can use the Ninja class's static method to hide a whole array--the same code is executed, but it is a lot easier to manage, and easier to read, and... well... more fun in this case. ^^.

Then we have the instance methods, which I hope I explained well enough before... attack() and moveTo() are instance methods that only a specific ninja can perform.

Ok, so to recap: statics don't require an individual ever be created, instances can only be used by an individual. Yay?

I might run this program, now...

[cajones]

Wow, this thread sucks. ^^.

So yeah, someone in java class near the end of the semester said, "I don't see why you'd ever need static methods". Umm... I made a lot of static methods today. or last night. I don't know... I woke up several times in the past 24 hours. v.v.


So java did something odd that ... I didn't expect. It doesn't seem to like running programs that aren't in the directory that is currently active. This really applies only to the command line, I guess... but that's where I do all of my java-ing, so nya. So... yeah, apparently I don't know how to use dos very well. cd/ cd and cd .. are your friends.

What's odd though is that it compiles files in subdirectories just fine... but refuses to run them. Meh, whatever.


Ah, something else worth noting:

When using ArrayLists in object methods, you don't have to specify the object type that the ArrayList will hold, since it will only work with the right type. But java still gives you a warning--a normal javac <filename.java> will say "<filename.java> uses unsafe or unchecked operations.". Which basically means it's possible to send an ArrayList with the wrong objects to the method... or return a bad ArrayList... or... whatever. So the sollution is... urm... just put the types in whenever declaring an ArrayList. It's not necessary, but java won't complain, and it's safer, I guess.

Hence, javascript is easier, but less safe and more messy, since you don't need to declare variable types. Heh, maybe I should make a javascript thingy... since javascript is probably easier to test (well, no... it depends really... but you don't have to download or install or anything with java to get it to run. *slaps IE7 and firefox*).


Ooh, did I go over the Random class in this list?


Umm... Uh... the ?: thing is cool.

[cajones]

I think I'll post one of the simplest examples of Java3d out there... including comments from me...

public class HelloUniverse extends Applet { <-- Forget applets!
public BranchGroup createSceneGraph() { <-- I'll assume we imported javax.media.j3d.*.
// Create the root of the branch graph
BranchGroup objRoot = new BranchGroup(); <-- This tells me branchGroups don't take parameters.

// Create the TransformGroup node and initialize it to the
// identity. Enable the TRANSFORM_WRITE capability so that
// our behavior code can modify it at run time. Add it to
// the root of the subgraph.
<-- That's a lot of bs, you know. -->
TransformGroup objTrans = new TransformGroup();
objTrans.setCapability(
TransformGroup.ALLOW_TRANSFORM_WRITE);
objRoot.addChild(objTrans);
<-- You realize it took four lines of code to make an object (which still has no characteristics at all) that can move, right? Just... checking... -->

// Create a simple Shape3D node; add it to the scene graph.
objTrans.addChild(new ColorCube(0.4)); <-- 0.5 is the side of the cube, presumably. And you Added this to the transform group? So confusing!

// Create a new Behavior object that will perform the
// desired operation on the specified transform and add
// it into the scene graph.
Transform3D yAxis = new Transform3D(); <-- Hey, we already have a transform group!
Alpha rotationAlpha = new Alpha(-1, 4000); <--!!!! What?
RotationInterpolator rotator = new RotationInterpolator(
rotationAlpha, objTrans, yAxis,
0.0f, (float) Math.PI*2.0f); <-- WTPF!!! *dies*.
BoundingSphere bounds =
new BoundingSphere(new Point3d(0.0,0.0,0.0), 100.0); <-- This I get-- the center of the sphere and the radius. Ok.-->
rotator.setSchedulingBounds(bounds); <-- Huh?
objRoot.addChild(rotator); <-- Yeah, you lost me when we needed a transform3d in addition to what we already have.

// Have Java 3D perform optimizations on this scene graph.
objRoot.compile(); <--Oy, that'll be a pain, but understandable.

return objRoot;
}

public HelloUniverse() {
<set layout of applet, construct canvas3d, add canvas3d>
<-- Oh, thanks a lot. -->

// Create the scene; attach it to the virtual universe
BranchGroup scene = createSceneGraph(); <-- Yeah, if that was necessary to remove to another method. Unless we just want to use this to leach rotating cubes.
SimpleUniverse u = new SimpleUniverse(canvas3d); <-- . So the universe takes a canvas3d so it knows what to draw on?-->
u.getViewingPlatform().setNominalViewingTransform(); <-- I think I understand this one. The universe comes with its own viewing platform, and you set it so that it is at the best position and orientation and stuff to view what's in the world. Ok. I think I'll need to play with that some more though if anything actually happens with java3d ... but yeah. -->
u.addBranchGraph(scene); <--Ok. That was easy. *kicks rotation interpilator* *and weird unnecessary words*-->
}
}

What, can't make sense of it? Neither can I!