Understanding the DOM

In order to find and use web elements using By.cssSelector or By.xpath, it is very helpful to understand the DOM.  The DOM (Document Object Model) is simply the interface that is used to interact with HTML and XML documents.  When a JavaScript program manipulates elements on a page, it finds them using the DOM.  If you already understand HTML, it will be very easy to understand how the DOM is organized.  Rather than explaining the differences between the DOM and HMTL source code, I’ll simply direct you to this very helpful webpage:  

https://css-tricks.com/dom.  

If you have little knowledge of HTML, here’s an example of how web elements are organized on a page:
<html>
<head>
<title>My Web Page</title>
</head>
<h1>My Web Page</h1>
<p>This is a paragraph</p>
<a href=”http://www.google.com” >Here’s a link to Google</a>
<table border=”2″>
<tr>
<td>Row 1, Column 1</td>
<td>Row 1, Column 2</td>
</tr>
<tr>
<td>Row 2, Column 1</td>
<td>Row 2, Column 2</td>
</tr>
</table>
</html>
If you’d like to see what this webpage would look like, you can simply copy and paste this html code into a notepad file and save it with the .html extension.  Then find the file in the folder where you’ve saved it and double-click on it.  It should open up as a webpage.  
Now let’s take a look at the various elements on the page.  Note that each element has a beginning and ending tag.  For example, the line that says “This is a paragraph” has a <p> tag to indicate the beginning of the paragraph and a </p> tag to indicate the end of the paragraph. Similarly, the title of the page has a beginning tag: <title> and an ending tag: </title>.  
Notice that elements can be nested within each other.  Look at the <table> tag, and then find the </table> tag several lines below it.  In between the tags, you will see row tags (<tr>) and table data tags (<td>).  Everything in between the <table> and </table> tags is part of the table.  Now look at the first <tr> tag and the first </tr> tag.  Notice that there are two pairs of <td></td> tags in between. Everything between the first <tr> tag and the first </tr> tag is a row of the table.  The <td></td> pairs in the row are elements of data in the row.
Now imagine that this data is organized into tree form:
If you were going to traverse the DOM in order to get at the data in Row 1, Column 1, you’d start by finding the <table> element, then by finding the first <row> element, then you’d find the first <data> element.  This is how we will use css selectors and the xpath to find elements in the next blog post.
If you’d like to find out more about HTML and CSS, I highly recommend the w3schools website.  

Finding an Element With Webdriver: Part II

In my last post, I discussed how to find an element with Webdriver using the element id, class name, or name.  In this post, I will discuss how to find an element using link text, partial link text, or tag name.

Return to www.google.com, and look at the links on the bottom of the page.  Right-click on the link that says “Advertising” and select “Inspect Element”.  You should see something like this:
<a class=”_Gs” href=”//www.google.com/intl/en/ads/?fg=1″>Advertising</a>

The link text is what is found between the >reverse brackets<.  In this case, the link text is “Advertising”.

Return to myFirstTest in Eclipse and replace the findElement command in your test with:
driver.findElement(By.linkText(“Advertising”)).click();

This command tells Webdriver to:
1.  Find the element with the link text “Advertising”
2.  Click on the link


If you followed the instructions in the last post, you should still have a breakpoint set in your test. If not, right-click in the left margin of the “driver.quit();” command and select “Insert Breakpoint”. Then run the test by right-clicking on the test and selecting Debug As->JUnit Test.  The test should run and will stop just after it clicks on the Advertising link.  If the test has run correctly, you should now be on the Google Ads page.  Click on the green arrow to finish the test.  

Now we will find an element using a partial link text.  Return to www.google.com, right-click on the link at the bottom of the page that says “Business”, and select “Inspect Element”.  You should see something like this: 
<a class=”_Gs” href=”//www.google.com/services/?fg=1″>Business</a>
The link text is “Business”.  We will find this link using just a portion of the text: “ness”.  

Return to myFirstTest in Eclipse and replace the findElement command in your test with:
driver.findElement(By.partialLinkText(“ness”)).click();

Run the test by right-clicking on the test and selecting Debug As->JUnit Test.  The test should run and will stop just after it clicks on the Business link.  If the test has run correctly, you should now be on the Google Business Solutions page.  Click on the green arrow to finish the test.  

Now we will find an element using a tag name.  Go to www.pinterest.com, right-click on the button that says “Continue with Facebook” and select “Inspect Element”.  You should see something like this:
<button class=”Button Module btn hasText large rounded unAuthFacebookConnect registerLoginButton unauthHomeRegisterButton multiStepRedesign” type=”button”>    

Note that the first word that appears after the “<” is “button”.  This is the tag name of the element.

Return to myFirstTest in Eclipse and replace the String URL line with:
String URL = ‘http://www.pinterest.com’
Next, replace the findElement command in your test with:
driver.findElement(By.tagName(“button”)).click();

This command tells Webdriver to:
1.  Find the element with the tag name “button”
2.  Click on the button

Run the test by right-clicking on the test and selecting Debug As->JUnit Test.  The test should run and will stop just after clicking on the button.  If the test has run correctly, you will see a popup prompting you to log in with Facebook.  Click on the green arrow to finish the test.

You have successfully located a web element by using an link text, a partial link text, and a tag name! Before we proceed to finding a web element by css and xpath, it is first necessary to understand the DOM.  This will be the topic of my next blog post.  


Finding an Element With Webdriver- Part I

The most useful method of Webdriver is the findElement() method.  It can also be the most frustrating:  you can see the element you want on your webpage, but it’s often difficult to figure out how to tell Webdriver to find it!

There are many different ways to find an element with findElement():

By.id
By.className
By.name
By.linkText
By.partialLinkText
By.tagName
By.cssSelector
By.xpath

I will include examples of these in this blog entry, and in the two entries following.  But first you need to know how to inspect an element in order to make the best choice about which By method to use.  Go to www.google.com, right-click in the search text field, and choose “Inspect Element”.  A new window will open up at the bottom of the screen, and you will see the element highlighted:

<input id=”lst-ib” class=”gsfi” type=”text” value=”” autocomplete=”off” name=”q” style=”border: medium none; padding: 0px; margin: 0px; height: auto‚Ķ; width: 100%; background: url(‘” dir=”ltr” spellcheck=”false”></input>

Look at the id attribute:  id = “lst-ib”.  This is what we will use for our first findElement() exercise.
(Note that the id for this element changes periodically.  Substitute whatever you see listed as the element id in the steps below.)

Return to myFirstTest in Eclipse and add the following text below the driver.get(URL) command:
driver.findElement(By.id(“lst-ib”)).sendKeys(“Hello World”);

This command tells Webdriver to:
1.  Find the element with the id “lst-ib”
2.  Type “Hello World” into the element

You will also need to add the following to the import section of your test:
import org.openqa.selenium.By;

Insert a breakpoint into your test so that you can see if the commands were executed correctly.  To do this, right-click in the left margin of the “driver.quit();” command and select “Insert Breakpoint”.  Then to run the test, right-click on the test, and select Debug As->JUnit Test.  The test should run and will stop just after it has typed “Hello World” into the text field.  If this is what you see, then you have used findElement() correctly!  Click on the green arrow at the top of the screen to finish the test.

We now have an example of findElement(By.id()).  Now let’s try By.className.  Look back at the html that describes the text field.  You should see the class attribute:  class=”gsfi”.  (Note that the class name for this element changes periodically.  Substitute whatever you see listed as the class in the steps below.)Let’s change our test to find the element by className.  Replace the findElement command in your test with:
driver.findElement(By.className(“gsfi”)).sendKeys(“Hello World”);

Run the test in debug mode again, and you should again see that “Hello World” has been typed into the text field.  The result is the same, but this time the element was located by the class name instead of by the id! Click on the green arrow to finish the test.

Finally, let’s try to find the element by its name.  Look at the html again and see the attribute name=”q”. Replace the findElement command in your test with:
driver.findElement(By.name(“q”)).sendKeys(“Hello World”);

Run the test in debug mode again, and you should see that once again, “Hello World” has been typed into the text field.  Click on the green arrow to finish the test.

You have successfully located a web element by using an id, a class name, and a name!  The next blog entry will discuss finding elements by link text, partial link text, and tag name.

Installing Webdriver

Webdriver is an API that enables testers to find and use web elements in their automated tests.  To get set up, you will need to find out what the latest version of Webdriver is.  Navigate to this link:  http://docs.seleniumhq.org/download and in the section called Selenium Client and Webdriver Language Bindings, find the Java entry and make a note of the latest client version.

Next, you will need to add this text to your project’s POM file:
<dependency>
   <groupId>org.seleniumhq.selenium</groupId>
   <artifactId>selenium-java</artifactId>
   <version>2.39.0</version>  //replace the version number here with the most current version number
 </dependency>

Add the text after the JUnit dependency, so that the dependencies section now looks like this:

<dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.8.1</version>
    </dependency>
    <dependency>
<groupId>org.seleniumhq.selenium</groupId>
<artifactId>selenium-java</artifactId>
<version>2.39.0</version>
</dependency>
  </dependencies>

In the command line, navigate to your project folder.  Then type:
clean install
This will download all of the dependencies needed to run Webdriver in your project.

Let’s set up a new test using Webdriver:

1. Right-click on the myFirstTests package and select New->Class
2. Give the class a name of secondTest
3. The SecondTest class should open in the center pane, and should look like this:
package myFirstTests;
public class SecondTest {
}

4. In between the brackets, add the following:
@Test
public void test() {
}

5. Add the following to the import section:
import org.junit.Test;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.firefox.FirefoxDriver;

6.  In between the brackets following test(), add this code:
driver = (WebDriver) new FirefoxDriver();
String URL = “http://www.google.com”;
driver.get(URL);
driver.quit();

7.  Right-click on the test name secondTest and choose Run As-> JUnit Test.  You should see a Firefox browser open, navigate to Google, and close again, and on the JUnit tab of Eclipse, you should see that the test has passed.

Congratulations!  You are now all set up to begin writing your own automated Webdriver tests!  In my next post, I will discuss the Webdriver syntax.

Understanding the POM

A POM file is necessary for any automated testing with Maven.  It can seem daunting at first, especially if you don’t usually work with XML files, but it’s actually very simple.  

POM stands for “Project Object Model”.  It contains instructions about where to look for the source code for your tests, and what versions of JUnit, Maven, and Webdriver to use.  
Here is an example of a POM file, which should look very similar to the file you created for your First Java Project:
<project xmlns=”http://maven.apache.org/POM/4.0.0″ xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance” xsi:schemaLocation=”http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd”>
  <modelVersion>4.0.0</modelVersion>
  <groupId>MyFirstJavaProject</groupId>
  <artifactId>MyFirstJavaProject</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <build>
    <sourceDirectory>src</sourceDirectory>
    <plugins>
      <plugin>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>2.3.2</version>
        <configuration>
          <source>1.7</source>
          <target>1.7</target>
        </configuration>
      </plugin>
    </plugins>
  </build>
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.8.1</version>
    </dependency>
    <dependency>
<groupId>org.seleniumhq.selenium</groupId>
<artifactId>selenium-java</artifactId>
<version>2.32.0</version>
</dependency>
  </dependencies>
</project>
Let’s look at the file one section at a time:  
<project xmlns=”http://maven.apache.org/POM/4.0.0″ xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance” xsi:schemaLocation=”http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd”>
</project>

This is information that describes the schema for the Maven project.  This will be automatically generated for you.
 <modelVersion>4.0.0</modelVersion>
 <groupId>MyFirstJavaProject</groupId>
 <artifactId>MyFirstJavaProject</artifactId>
 <version>0.0.1-SNAPSHOT</version>

This is required information for every POM file-
The version number of Maven
The groupId (can be any name you like)
The artifactId (should match the name of your project)
The version number of your project (can be any number you like, and it’s easy to just leave it at the default of 0.0.1-SNAPSHOT)
<build>
    <sourceDirectory>src</sourceDirectory>
    <plugins>
    </plugins>
</build>

The build section defines what will be necessary to build the project-
The sourceDirectory defines where Maven should look for your source files.  If you ever have trouble with a build, check to make sure this value is correct.  In this case, the source files will be found in the src folder.
The plugins section defines what plugins are necessary in order for your tests to run.

<plugin>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>2.3.2</version>
        <configuration>
          <source>1.7</source>
          <target>1.7</target>
        </configuration>
</plugin>

The plugin that is needed in this case is the Maven compiler plugin.  The compiler version is specified, and the source and target Java versions are specified.  
<dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.8.1</version>
    </dependency>
    <dependency>
<groupId>org.seleniumhq.selenium</groupId>
<artifactId>selenium-java</artifactId>
<version>2.32.0</version>
     </dependency>
  </dependencies>

Finally we need the dependencies; any extra software that the code needs in order to run properly.  In the case of this example, we need JUnit and Selenium to run our tests.  
As you become adept at test automation, you will probably run into situations where a test that ran without difficulty suddenly won’t run at all.  This is often because of browser/Selenium incompatibility; for instance, a new version of Firefox may have been released, and you will need the latest version of Selenium in order for your tests to run in the new browser.  Rather than downloading and replacing files yourself, all you need to do is alter the version number of Selenium in your POM file, and the next time you do a Maven build, the project will fetch and download the new files for you!  
This is far from an exhaustive list of all the information that a POM file can contain; it is merely a brief description to help demystify what the file does and how it can be used.  For more information, see these helpful links:
  

Setting up Maven

In order to use Webdriver, you will need to have Maven installed and set up.  Fortunately, the helpful people at Apache Software have created an excellent tutorial about how to set up Maven:

http://maven.apache.org/guides/getting-started/maven-in-five-minutes.html

It probably won’t take you five minutes as advertised, but it will take you less than a day.  Don’t worry too much about what you are doing as you are running these commands; once Maven is set up, we only have to think about the commands we need to run our automated tests.

Now let’s return to Eclipse.  The last time we were in Eclipse we created a project called MyFirstJavaProject.  Right-click on this project and select “Configure-> Convert to Maven project”.  A popup window will appear.   Click “Finish” on the window, and wait for the configuration to complete.  When it’s done, you’ll notice that your project icon now has a little M next to the J.  You’ll also notice that you have a pom.xml file in your project folder.  We’ll learn more about the POM in a future blog post.

Let’s create a JUnit test.  First we’ll run it from Eclipse, then we’ll run it from the command line using Maven.

1. Right-click on the MyFirstJavaProject and select New->Source Folder
2. Give the new folder a name of src/test/java (click the “Update exclusion filters” checkbox if needed)
3 Right-click on the new folder and select New->Package
4. Give the package a name of myFirstTests
5. Now right-click on the myFirstTests package and select New->Class
6. Give the class a name of FirstTest
7. The FirstTest class should open in the center pane, and should look like this:
package myFirstTests;
public class FirstTest {
}
8. In between the brackets, add the following:
@Test
public void test() {
int x = 2;
int y = 3;
int total = x+y;
assertEquals(total, 5);
}
9. Right-click on the Project name (MyFirstJavaProject) and choose Build Path->Add Libraries
10. Select JUnit
11. Choose JUnit 4 and click Finish
12. Look again at the lines of code you added to the FirstTest class.  There will be two lightbulb icons on the left side of the code.
13. Right-click on the one next to “@Test” and choose Add JUnit4 to Build Path
14. Right-click on the one next to “assertEquals(total,5)” and choose Import org.junit.Assert;
15. Now near the top of the page, you will see
import static org.junit.Assert.*;
import org.junit.Test;
16. Save your changes by clicking on the disk icon in the toolbar
17. Right-click on the FirstTest.java file in the left pane, and choose Run As-> JUnit Test
18. Your test should run, and a new tab named JUnit should appear in the left pane
19. Click on the left tab and notice that the window displays what test has been run, and that there is a green bar across the pane indicating that the test has passed

Now let’s try running the test from the command line. First we’ll need to make a change to the pom.xml file:

1. Double-click on the pom.xml file to open it in the center pane
2. Click the tab at the bottom of the pane that says pom.xml
3. You should now be viewing the file in xml format
4. Add this text to the xml file, right underneath </build>:
<dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.8.1</version>
    </dependency>
  </dependencies>
5. Save your changes
6. Now open the command window
7. Change directories until you are in your project folder (MyFirstJavaProject)
8. Run this command:
mvn clean test
9. Your project should build, your test should run from the command line, and you should be notified that the build is successful

Congratulations!  You have run your first test from Maven!

Introduction to the Command Line

In order to run Maven (which we will discuss in the next post), it is necessary to know how to run commands from the command line.  If you are not familiar with using the command window, this post will explain the two most important commands.  My instructions will refer to the Windows command line, but they can be adapted without too much difficulty to Linux or Mac.

To bring up the command line, go to the Start menu and type “cmd” in the search field.  Click the return key and a command window should open.

cd:
cd stands for “change directory”.  You will use this to navigate through your file system.  When you opened your command window, you probably saw something like this:  C:UsersYourName>.  This is your user folder.  If you were to navigate to it in the File Explorer, you would go to Computer->Windows7_OS (C:)
->Users->YourName.  (The OS will vary based on your computer, and the YourName will be your user name.)

Let’s try navigating to the Users folder.  In the command window, type “cd Users” and click return key.  Note that the command prompt now says C:Users>.

There is another way to navigate up one folder.  First, let’s return to your folder.  Type “cd YourName” (replacing the words YourName with your actual user name) and click Return.  Now the command prompt should say C:UsersYourName.  Now type “cd ..” and click Return.  Notice that you have returned to the Users folder.  The two dots send the instruction to go up one level.  If you type “cd..” and Return again, you will see C:> in the command prompt.

You can also navigate through more than one folder at a time.  Type “cd Users/YourName” (replacing the YourName with your user name) and click Return.  Now the command prompt will say C:UsersYourName.  You’ve navigated down two levels, from the C: level to the YourName level.

dir:
dir is the command used to list all the files in a particular location.  This really comes in handy when you can’t remember what you named a file.

Let’s try using the dir command.  In the command window, verify that the command prompt currently reads C:UsersYourName.  If it doesn’t, use the cd command to navigate there.  Now type “dir” and click Return.  You should get a list of all the files in your personal folder.

Let’s add a new file to this location.  It’s possible to do this through the command line, but that is beyond the scope of this tutorial.  Instead, create a simple Word or Notepad file called MyCommandFile, and save it in your folder.  Now return to the command window and type the “dir” command again.  You should see your new file in the directory.

Another shortcut to navigation when you have forgotten a file name is the tab key.  In the command line, type “cd My” and then click the tab key.  You should see the file name auto-complete for you.

Bonus command:  
One more helpful command to use is the up arrow key.  This key will go back through your most recent commands.  This really comes in handy if you have typed a particularly long command and would rather not type it again.

The command window is very helpful, and there are a number of good tutorials available if you would like to learn more about what it can do for you.

Setting Up Your Java Environment

In order to write your automated tests in Java, you will need the Java Development Kit, or JDK.  Here are instructions for downloading and installing the JDK:

1. Navigate to http://www.oracle.com/technetwork/java/javase/downloads/index.html

2. Click on the download button for the JDK

3. Click the radio button that signifies that you have accepted the license agreement

4.  Find your operating system and click on the download link.  If you are a Windows user and trying to determine whether you should use Windows x86 or Windows x64, go to the start menu, right-click on “Computer” and click “Properties”.  A popup window should appear.  Look at the entry next to “System type”.  A 32-bit operating system means you should use x86; a 64-bit operating system means you should use x64.

5.  Follow the installation prompts, and if prompted to do so, restart your computer

Next, you will need an Integrated Development Environment (IDE), like Eclipse.  Here’s how to download and install it:

1. Navigate to http://www.eclipse.org/downloads/

2. Use the dropdown at the top of the page to select your operating system

3. Find the entry for Eclipse IDE for Java Developers, and click on the link for either 32-bit or 64-bit, depending on your operating system

4. Follow the installation prompts

Now you are all ready to begin coding in Java!  Let’s write a program:

1. Open Eclipse

2. You will be prompted to name your workspace; give this space whatever file name and filepath you prefer, such as C:UsersYourNameworkspace.

3. The Eclipse window should open

4. Select File-> New-> Java Project

5. Give your project a name, such as MyFirstJavaProject, and click Finish

6. Look in the leftmost window, in the section called Package Explorer.  You should see a folder icon with the letter J above it, and your project name.

7. Right-click on the project name and choose New-> Package

8. Give your package a name, such as myFirstPackage, and click Finish

9. In the Package Explorer section you should now see a folder called src under the project name, with an icon that shows a folder with a package inside it.  You should also see a package icon under the src folder with your package name.  You also should see that the JRE System Library has been added to the project file.

10. Right-click on the package name and choose New->Class

11. Give the class a name, such as MyFirstClass, and click Finish

12. In the Package Explorer section you should now see a file called MyFirstClass.java.  The file will have an icon that looks like a sheet of paper with a J on it.

13. Look in the center section of the Eclipse window.  You should see that the class file you created is open, and has this text in it:

package myFirstPackage;
public class MyFirstClass {
}

14. Paste the following code in between the curly braces found after the class name:

public static void main(String[ ] args){
System.out.println(“Hello world!”);
}

15.  If you have done step 14 correctly, the whole class file should look like this:

package myFirstPackage;
public class MyFirstClass {
public static void main(String[ ] args){
System.out.println(“Hello world!”);
}
}

16. Save the changes you made by clicking on the disk icon in the toolbar

17. Right-click on the class name in the Package Explorer and choose Run As-> Java Application

18.  Look in the the bottommost pane of the Eclipse window- you should see a section called Console.  In this section, you should now see the message Hello world!

19.  Congratulations!  You have successfully set up Eclipse and run your first Java program!


Introduction to Java: Passing Parameters

When I first started learning Java, I was fairly perplexed by the parentheses found after every method.  Sometimes they were empty, and sometimes they had values in them, and I didn’t understand why.  Plus, in the declaration of a method, there was a variable mentioned before the method name, and I didn’t know why that was there.  I’ve found it’s easiest to think about parameters and methods in terms of input and output.   Here’s an example:

output Square (input) {

}

The green output describes what kind of result you are going to return from the method.  The green input describes what kind of input I put into the method.  This method is going to take a number, square it, and return the result of the squaring.  I would like the input number to be an integer, so I will declare that here:

output Square (int input) {

}

The word “input” is what I’m calling the variable that I’m going to pass into the method.  Because I know that if I square an integer, I will get an integer as a result, I’m going to declare that the output will be an integer:

int Square (int input) {

}

Note that I don’t need to create a variable name for the output when I’m declaring the method.  Now let’s add in the steps for the method:

int Square (int input) {

int output = input * input;
return output;

}

So what this function does is take the variable called input, squares it, sets it to equal an int variable called output, and then returns the output.

It’s also possible to have more than one input parameter:

String Square (int input, String name) {

int output = input * input;
String result = “Hi ” + name + “!  Your result is ” + ” output;
return result;

}

This is a little more confusing, so I will explain it in more detail.  The first line of the method is taking the input variable and squaring it, and setting it to a variable called output, just as it did before.  But in the second line we’re creating a String.  The characters in between the quote marks are entered into the string.  These are concatenated (added) with our int output and the String name that we entered in the parameters, using plus signs to add the characters:

Hi ” + name + “!  Your result is ” + ” output

So if I called the function like this:

Square(2, Kristin);

The result String would be set to:

Hi Kristin!  Your result is 4

Then if my main program wanted to output the result, I would use the instruction:

System.out.println (result);

And my result would be printed to the console.

Now, what about methods that don’t pass in any parameters?  It would seem as if parameters would be needed to run a method, but they aren’t.  Here’s an example:

void MyParameterlessMethod () {

System.out.println (“I can print something out without even passing in a parameter!”);

}

All this method is going to do is run the print instruction inside, which doesn’t need any parameter. You may have noticed the void before my method name.  This says that the method isn’t going to return anything to the main program.

Is it possible to have a method that doesn’t pass in any parameters, but still returns something? Sure!

int MyParameterlessMethod () {

int result = 4;
return result;

}

This method assigns the number 4 to the variable called result, and then returns it to the main program.

In my next post, I will discuss setting up Eclipse and writing a simple program.

Introduction to Java: Definitions

Another thing I struggled with when learning Java was what the difference was between a Class, an Object, and a Method.  Through personal experience and web searches, I have come up with this explanation:

A class is the basic building block in Java.  It consists of variables and methods.  Here’s an example:

public class Cat {  //this is the class

//these are the variables in the Cat class
String name;
int age;
int weight;
String color;

//these are the methods in the Cat class
public void eat() {
}

public void sleep() {
}

public void meow() {
}

}

A variable is a little bit of memory that stores a value to be used in a program.  A String is a bit of text, like “Hello!” or “rainbow”.  In the Cat class, the String variables we have are name (the name of the cat), and color (the color of the cat).  An int is an integer, like 7 or 13.  In the Cat class, the int variables we have are age (the age of the cat) and weight (the weight of the cat).

An Object is an instance of a class.  If we want our program to create and use a cat, we need to create a Cat object:

public void main() {  //this is the main method of our program

//this is where we create the new Cat Object
Cat Fluffy = new Cat;  //Fluffy is the variable name given to the Cat Object

}

method is a task or group of tasks.  If you are familiar with mathematical functions, you might want to think of a method as a function.  In the Cat class, the methods are eat(), sleep(), and meow().  The parentheses after the method name indicate what kind of parameter will be passed into the method.  In this case, eat(), sleep(), and meow() do not require a parameter.  In the next blog post I will give some examples of methods with parameters and how they work.