Silkroad Online Forums

Form of a control structure; manipulating data through program control. A block of code's one or more statements enclosed within a pair of braces like so:

{
count++;
System.out.println("Here's your example");
}

Blocks can contrain other blocks so you can nest one block inside another.

ex:

if (age >= 21)
{ g.drawString("You have authorization for the payment", 25, 50);
makePmt(pmt);
}
// rest of program goes here

The two statements in the body of the if execute only if age contains a value equal to 21 or more. If age is less than 21, the block of code does not execute. Whether or not the block executes does not keep the subsequent statements in the program from continuing.

A great use for if is input verification. When you ask the user for a value, you should check the value to make sure the user entered a reasonable answer. For ex: the following code asks the user for their age. If the user enters 0 or a negative value, the program's if statement displays an error msg and prompts the user again...

A class is not an object but rather a description of an object.

All Java programs are actually objects themselves. The entire java program you write is an object. There exists a special highest-level object called the java.lang.Object. Your program is a derivation from that object. When you derive one object from another, or inherit an object from another, the derived object takes on all the properties of its parent object, the higher-level object.

here's a line derived from this special java app object:

public class Main_1 extends java.lang.Object {

In other words, you created a java app, an object from the java.lang.Object object. More specifically, you created a new class by inheriting from the java.lang.Object class. You extended a new object from an existing one that represents a generic java app.

An active data value that has characteristics and properties.

Java is an OOP (object-oriented programming) language, and just about everything you do works with an object of some kind. An object is little more than a place where more than one variable resides. Objects give their variables special treatment such as protecting variables' details from the rest of the code, but still, an object is a place where two or more variables often appear together in a group.

ex:

public class Employee {
protected String firstName[15] = new String
protected String lastName[15] = new String;
protected float salary;
protected int age;
//rest of obj's declaration
}

Set of all values of variables within a program during any point of its execution.

Procedures embedded in an object.

Methods perform work. Methods operate on class data by using a controlling statement by utilizing variables to hold data. A method's argument list inside the method's parentheses may contain values or the list may be empty. If arguments exist, the code that calls the method must initialize those values and send the expected arguments and types.

Think of an argument as a variable that's passed from one statement to a method. Arguments act like variables.

Ex of how code in one method calls another method and sends that called method two arguments. Java sends a copy of the argument but does not really send the argument variables themselves. Therefore, if the called method changes an argument in any way, the change is not noticed when the calling code regains control.

Ex:

Called Method:

void myMethod(float x, double y)
{
x *= 45.6;
y /= 0.0034;
System.out.println("In method...");
System.out.println("a =" + a);
System.out.println("b =" + b);
return; //goes back
}

Calling Program:

//beginning of calling program
float a = 10.0;
double b = 20.0;

//send the 2 values
myMethod(a,b);

//a and b are unchanged
System.out.println("/n In calling class..);
System.out.println("a =" + b);
System.out.println("b =" + b);
//code goes on

The called method takes 2 values, computes with them, prints their newly computed values, and then returns control to the calling class.

Output from the method:

In method...
a = 456.00
b = 4608.294930876

In calling class...
a = 10.0
b = 20.0

The called method receives the 2 values, changes those values, but the changes only last inside the method. The calling class code's variables are not, and cannot be changed by the method.

The arguments are named x and y even though the calling program names those variables a and b. The received names might or might not match those in the calling code because only values are passed and not variables. A main concern with calling methods is getting the number of arguments and data types correctly.

The passing of data between code and methods is not strictly one-way. A method can return a value to the calling code. Although you can send 0, 1, or multiple arguments to a method, it can only return one value.

You can generally tell a method from the parentheses:

doubleIt()

think you get the point for methods, won't go more into unless you ask

Method that alters a variable.

some people set them up w/ "set" in the method's name

ex:

class Cat {
private static String animalType = "feline";
private String catColor;
Cat(String colorIn)
{
setCatsColor(colorIn);
}
public String getCatsColor()
{
return this.catColor;
}
public String setCatsColor()
{
this.catColor; }

public static void main (String[] argsIn) {
Cat patches = new Cat("calico");
}
}

To cause the execution of a particular block of code, usually a procedure or subprocedure. Invoke, also, is used to indicate application of a method to an object.

Reflection is commonly used by programs which require the ability to examine or modify the runtime behavior of apps running in java virtual machine, as well as used to invoke a method when the name of the method is supplied at run time.

Methods are invoked with java.lang.reflect.Method.invoke(). The 1st argument's the object instance on which the particular method is to be invoked. The following arguments are the method's parameters.

Consider a test suite which uses reflection to invoke private test methods in a class. Deet (in the code below) searches for public methods in a class which begin with the string "test", have a boolean return type, and a single Locale parameter. It then invokes each matching method.

ex:

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Type;
import java.util.Locale;
import static java.lang.System.out;
import static java.lang.System.err;

public class Deet<T> {
private boolean testDeet(Locale l) {
// getISO3Language() may throw a MissingResourceException
out.format("Locale = %s, ISO Language Code = %s%n", l.getDisplayName(), l.getISO3Language());
return true;
}

private int testFoo(Locale l) { return 0; }
private boolean testBar() { return true; }

public static void main(String... args) {
if (args.length != 4) {
err.format("Usage: java Deet <classname> <langauge> <country> <variant>%n");
return;
}

try {
Class<?> c = Class.forName(args[0]);
Object t = c.newInstance();

Method[] allMethods = c.getDeclaredMethods();
for (Method m : allMethods) {
String mname = m.getName();
if (!mname.startsWith("test")
|| (m.getGenericReturnType() != boolean.class)) {
continue;
}
Type[] pType = m.getGenericParameterTypes();
if ((pType.length != 1)
|| Locale.class.isAssignableFrom(pType[0].getClass())) {
continue;
}

out.format("invoking %s()%n", mname);
try {
m.setAccessible(true);
Object o = m.invoke(t, new Locale(args[1], args[2], args[3]));
out.format("%s() returned %b%n", mname, (Boolean) o);

// Handle any exceptions thrown by method to be invoked.
} catch (InvocationTargetException x) {
Throwable cause = x.getCause();
err.format("invocation of %s failed: %s%n",
mname, cause.getMessage());
}
}

// production code should handle these exceptions more gracefully
} catch (ClassNotFoundException x) {
x.printStackTrace();
} catch (InstantiationException x) {
x.printStackTrace();
} catch (IllegalAccessException x) {
x.printStackTrace();
}
}
}

Deet invokes getDeclaredMethods() which will return all methods explicitly declared in the class.

can read up more about it here:
http://java.sun.com/developer/technical ... eflection/

Gotta look at the "structure" of a program.

Just because a program is well written and easily read doesn't necessarily mean it's structured. Structured programming is a specific approach to programming that generally produces well-written and easily read programs. Nothing can make up for a programmer rushing to finish a program by proceeding in what he thinks is the fastest way. People use the program until one day, when changes have to be made, the changes turn out to take as long as or longer than it would take to scrap the entire program and rewrite it from scratch.

Things to consider for structure:

Sequence, Decision (a.k.a selection), and Looping (a.k.a repetition / iteration)

A construct is a building block of a language and one of the language's fundamental operations. As long as a programming language's fundamental operations. As long as a programming language supports these three constructs, you can write structured programs. The opposite of a structured program is called spaghetti code. It flows and swirls all over the place with little or no structure. An unstructured program contains lots of branching. A branch occurs when a program goes this way and that with no particular order.