Java forces object-oriented programming on you whether you like it or not. Every Java program consists of a class, such as

class programname
{
  public static void main(String args[])
  {
  System.out.println("This is a simple Java program.");
  }
}

Because Java relies on object-oriented programming, a Java program looks more complicated than it should. Basically, the main program is considered a class that has a single main function. To print something, the preceding program uses a println command, which is accessed through the System class. Because Java forces object-oriented thinking on you, Java programs consist of multiple classes.

Like Java, C# also forces object-oriented thinking on every program you write.

using System;
class MyClass
{_static void Main()
  {_Console.WriteLine("This is a simple C# program.");
  }
}

To write a comment in Java/C#, you have two choices. First, you can use the double slash character so that anything that appears to the right of the character is a comment, such as

using System;_
class MyClass _// This is a C# comment
{_static void Main() _
  {_Console.WriteLine("This is a simple C# program.");_
  }
}

The double slash character is handy for adding a comment to a single line. If you want to write a comment over multiple lines, you can use the /* and */ characters, such as

/* This is a multiline comment to show people how
   easy Java can be to learn. */
class programname
{
  public static void main(String args[])
  {
  System.out.println("This is a simple Java program.");
  }
}

Because Java and C# are closely derived from C/C++, they both declare variable data types the same way by first listing the data type and then listing the variable name, such as

datatype VariableName;

VariableName can be any descriptive name. Both Java and C# are case-sensitive, so the variable TeamMembers is a completely different variable than Teammembers. Some programmers use uppercase letters to make variable names easier to find whereas others use all lowercase. To declare multiple variables, cram them all on a single line, separated by a comma, such as

datatype VariableName1, VariableName2, VariableName3;

string variablename;

string variablename = "text";

int variablename;

signed int profit;
unsigned short pets_owned;

boolean variablename;

bool variablename;

The three types of operators used are mathematical, comparison, and logical. Mathematical operators calculate numeric results, such as adding, multiplying, or dividing numbers, as shown in Table 2-4.

Relational operators compare two values and return a True or False value. The six relational operators available are shown in Table 2-5.

Logical operators compare two Boolean values (True or False) and return a single True or False value, as shown in Table 2-6.

j = 5;
i = j + 1;

j = 5;
i = ++j;

j = 5;
i = j++;

j = 5;
i = --j;

j = 5;
i = j--;

i = 59;

The simplest branching statement is an IF statement that only runs one or more commands if a Boolean condition is True, such as

if (condition) {
  Command;
  }

To make the computer choose between two mutually exclusive sets of commands, you can use an IF-ELSE statement, such as

if (condition) {
  Command;
  }
else {
  Command;
  }

Java and C# also offer an IF-ELSEIF statement, which uses two or more Boolean conditions to choose which of two or more groups of commands to run, such as

if (condition1) {
  Command;
  }
else if (condition2) {
  Command;
  }

Although the IF-ELSE statement can only give the computer a choice of two groups of commands to run, the IF-ELSEIF statement can offer the computer multiple groups of commands to run, such as

if (condition1) {
  Command;
  }
else if (condition2) {
  Command;
  }
else if (condition3) {
  Command;
  }

As an alternative to the IF-ELSEIF statement, you can also use the SWITCH statement, such as

switch (expression) {
case value1:
  Command;
  break;
case value2:
  Command;
  break;
default:
  Command;
}

The preceding SWITCH statement is equivalent to the following IF-ELSEIF statement:

if (expression = value1) {
  Command;
  }
else if (expression = value2) {
  Command;
  }
else {
  Command;
  }

To check if a variable matches multiple values, you can stack multiple CASE statements, such as

switch (expression) {
case value1:
case value2:
  Command;
  break;
case value3:
case value4;
  Command;
  break;
default:
  Command;
}

The preceding SWITCH statement is equivalent to the following IF-ELSEIF statement in C++:

if (expression = value1) || (expression = value2) {
  Command;
  }
else if (expression = value3) || (expression = value4) {
  Command;
  }
else {
  Command;
  }

switch (age) {
case 17:
case 18:
case 19;
case 20;
  System.out.println("You're too young to drink.");
case 21:
  System.out.println("You're old enough to drink.");
}

In this example, the SWITCH statement will print the following if the value of age is 17, 18, 19, or 20:

You're too young to drink.
You're old enough to drink.

Because no break command is right above the case 21: statement, the Java program falls-through to the next CASE statement. In C#, you must explicitly define the fall-through (if this is what you want), such as

switch (age) {
case 17:
case 18:
case 19;
case 20;
  System.out.println("You're too young to drink.");
  goto case 21;
case 21:
  System.out.println("You're old enough to drink.");
}

This C# SWITCH statement explicitly tells the computer to fall-through to the case 21: statement. If you omit the goto case 21 statement, the preceding C# SWITCH statement won't work. By forcing you to explicitly define the fall-through in a SWITCH statement, C# helps prevent mistakes in writing a SWITCH statement incorrectly.

A looping statement repeats one or more commands for a fixed number of times or until a certain Boolean condition becomes True. To create a loop that repeats for a fixed number of times, use the FOR loop, which looks like this:

for (startvalue; endvalue; increment) {
  Command;
  }

If you wanted the FOR loop to run five times, you could set the Start value to 1 and the End value to 5, such as

for (i = 1; i <= 5; i++) {
  Command;
  }

If you don't know how many times you need to repeat commands, use a WHILE loop, which looks like this:

while (condition) {
  Command;
}

If the condition is True, the loop runs at least once. If this condition is False, the loop doesn't run.

A variation of the WHILE loop is the DO-WHILE loop, which looks like this:

do {
  Command;
} while (condition);

The main difference between the two loops is that the WHILE loop may run zero or more times, but the DO-WHILE loop will always run at least once.

In Java/C#, every subprogram is a function that can return a value. The format of a typical Java function looks like this:

Datatype functionname (Parameter list)
  {
  Commands;
  Return value;
  }

The three parts of a C/C++ function are

If a function doesn't return a value or require any data, it might look like this:

void myfunction ()
  {
  Command;
  }

If the function needs to return an integer value, it might look like this:

int myfunction ()
  {
  Command;
  return value;
  }

In the preceding example, value represents any integer value.

To accept data, a function needs a parameter list, which simply lists a variable to hold data along with its specific data type, such as an integer or character. To create a function that accepts an integer and a character, you could do something like this:

int myfunction (int mynumber, char myletter)
  {
  Command;
  return value;
  }

The preceding function accepts two values by value, so the function can change the values of variables in its parameter list, but those changed values won't appear outside that function.

If you want a function to change the values of its parameters, define a parameter list by identifying which variables accept values by reference. To identify values passed by reference in C#, use the ref keyword, such as

int myfunction (ref int mynumber, char myletter)
  {
  Command;
  return value;
  }

Through built-in libraries, Java and C# offer a variety of data structures beyond most programming languages. In Java, the most common data structures are arrays and linked lists. In C#, the .NET framework provides a variety of data structures including structures, arrays, collections, dictionaries, queues, and stacks.

struct name {
  public datatype variable;
};

struct MyGrades {
  public char grade;
  public int class_number;
};

struct geology = MyGrades();

struct geology = MyGrades();
geology.grade = "A";
geology.class_number = 302;

datatype [] arrayname = new datatype[arraysize];

int [] mynumbers = new int[10];

int [] mynumbers = new int[4] {25, 81, 4, 712};

int [] mynumbers = new int[4];
mynumber[0] = 25;
mynumber[1] = 81;
mynumber[2] = 4;
mynumber[3] = 712;

LinkedList listname = new LinkedList();

LinkedList <datatype>listname = new LinkedList<datatype>();

LinkedList shopping_list = new LinkedList();
shopping_list.add("Eggs");
shopping_list.addFirst("Milk");
shopping_list.addLast("Bacon");

LinkedList shopping_list = new LinkedList();
shopping_list.add("Eggs");
shopping_list.addFirst("Milk");
System.out.println("First = " + shopping_list.removeFirst());
System.out.println("First = " + shopping_list.getFirst());

First = "Milk"
First = "Eggs"

Queue queuename = new Queue();
Stack stackname = new Stack();
Hashtable tablename = new Hashtable();

Both Java and C# are true object-oriented programming languages (unlike C++), so you have no choice but to create and use objects in your programs. To create an object, you must define a class stored in its own file. A typical class definition looks like this:

class ClassName
  {
  datatype propertyname;

  void methodname()
    {
     Commands;
    }
};

The class lists one or more properties and the type of data that property can hold, such as an integer or a floating point number. A class also lists one or more method names, which contains code for manipulating an object in some way.

After you define a class, you can create an object from that class by declaring a variable as a new class type, such as

className objectname = new className();

So if you created a furniture class, you could create a table object from that class as follows:

furniture table = new furniture();

To use inheritance in Java, use the extends keyword, such as

class className extends classtoinheritfrom
  {
  // Code goes here
  };

To use inheritance in C#, use the colon to identify the class to inherit from, such as

class className : classtoinheritfrom
  {
  // Code goes here
  };