# Random Numbers

`Math.random()` returns a random double between 0 and <1. Examples are 0.3332, 0.77777779 and 0.1113

To find a random number between 1 and 100, you’d need to do something like this:

```double num = Math.random()*100;
int ran = (int)num+1;
System.out.println(ran);```

# Rounding and Formatting Decimals

```double d = 3122.656774;
double roundUp = Math.round(d);
System.out.println(roundUp);

//Roundup to two decimal places
double roundUp2dp = Math.round(d*100)/100.0;
System.out.println(roundUp2dp);

//Formatting a number
//Note that the output is a string
DecimalFormat f = new DecimalFormat("#,###.00");
System.out.println(f.format(d));```

# Exercise: Fahrenheit to Celsius

Here are the formulas to convert from Fahrenheit to Celsius and back again.

• °F to °C: Deduct 32, then multiply by 5, then divide by 9
• °C to °F: Multiply by 9, then divide by 5, then add 32
1. Write a program to convert Fahrenheit to Celsius. Use the test data below to check your program.
2. Now write a program to convert Celsius to Fahrenheit. Again, use the test data to check your program.

# Integers

```// declare variables
int x;
int y;

// Instantiate Scanner
Scanner scan = new Scanner(System.in);

// Perform operation
System.out.println("Enter x?");
x = scan.nextInt();
System.out.println("Enter y?");
y = scan.nextInt();
System.out.println("x x y ="+ x*y);```

# Casting and Converting

Java is a statically, strongly typed language. You have to declare variable types before you use them (statically typed) and once declared, the variables cannot hold another type.

But sometimes you need to change the type. For example, in the code

```int i =4;
System.out.println(i);```

`System.out.println(i)` converts the `int i` into a String before printing out.

You can make an explicit conversion from int to String as follows

```int i =4;
String s = Integer.toString(i);
System.out.println(s);```

You can covert Double, Float etc to Strings similarly.

To convert the other way, e.g. from a String to an integer use the following

```String s = "34"
int i = Integer.parseInt(s);```

The fact that you can’t simply use `i.toString()` is an interesting one and part of a big debate about the way Java is put together. Briefly, Java doesn’t treat types like int and double as classes. That means you have to put them in a class wrapper when you want to perform some operations on them. Languages such as Scala treat all types as classes.

The following code will print out int c as a number and a char, depending on cast.

```int c = 67;
System.out.println(c);
System.out.println((char)c);```

# Exercise: operations on int and double

1. Write a program with two variables, length and width, that outputs the perimeter of a rectangle. Test it with length = 5 and width = 4.
2. At the time of writing, the exchange rate for pounds to euros is 1 GBP = 1.19984 Euros. Write a program that will convert pounds to euros. Test it using the data GBP4.50
3. Now write a program to convert euros to pounds. Test it using the data Euro 7.40
4. Prompt the user to input a number. Output the square of that number.
5. Prompt the user to input two numbers. Output the average of those two numbers.
6. Prompt the user to input three numbers. Output the sum and the average of those three numbers.
7. Assume pi = 3.1415. Prompt the user to input the radius of a circle. Output the circumference and the diameter of that circle

# Good Practice

What’s the purpose of the following two code snippets? Which is better programming practice? Give some reasons why.

```double x = 35.51*1.17;
System.out.println(x);```

or

```double pounds = 35.51;
double euroRate = 1.17;
double euros = pounds * euroRate;

System.out.println("£"+ pounds + " = " + euros + " euros");
System.out.println("at an rate of "+ euroRate + " euros to the pound");```

## Java Course 1: Input Output

The basic Java program is called a class.  A class is much more than a program, you’ll see why as we go on.

﻿Classes contain methods, which are a little like functions in other languages.  The first function to run is called main().  You will notice it is written

`public void main(String [] args)`

I’ll explain what those other words mean later on.

Every part of a java program is contained in a block – surrounded by `{}`

Here is a basic java program.  See if you can run it.  Note the use of escape characters when printing.  Notice that `\n` gives a new line and `\"` literally prints `"`

```public class JavaApplication1 {

public static void main(String[] args) {
System.out.println("This is really \n... \"groovy!\"");
}
}```

Be careful typing a backslash in Java. It indicates that the next character will be a special code. Be especially careful when writing file paths if you’re a Windows user. Follow the Apple/Linux pattern and use forward slashes, e.g. “C:/Java/Spoons”

Here’s how you read in text. Notice the import scanner line at the beginning.

```import java.util.Scanner;

public class JavaApplication1 {

public static void main(String[] args) {
Scanner scan = new Scanner(System.in);