Nov 2, 2020 Notes

IT 212 -- Nov 2, 2020

Review Exercises

Explain how these Python re module methods work:
match search findall split sub Ans:
match -- Returns a Match object for a match to the regular expression if the match starts at the beginning of the input string,
search -- Returns a Match object for the first match to the regular expression in the input string, None otherwise.
findall -- Finds all matches to the regular expressons.
split -- Extracts fields (substrings) using the matches as the delimiters.
sub -- Replaces all matches with the substitution character.
What is the difference between an interpreted language and a compiled language?
Ans: the source code of the interpreted language is interpreted directly by the interpreter; the source code of a compiled language is compiled into a binary executable file, which can be run directly on the CPU (native executable for C and C++) or on a virtual machine (bytecode executable for Java, C#, Python). See the table a the end of the Oct 28 Notes.
When is a Python script compiled? Where is the executable file located?
Ans: A Python script is only compiled if it is an imported module; the compiled executable (.pyc extension) is placed in the __pycache__ folder.
How do you compile and run the Java program HelloWorld.java?
Ans:
```
javac HelloWorld.java
java HelloWorld
```
What is the name of the Java startup method?
Ans: main
Look at the Greeter and Cel2Fahr Examples. See the section An Online Java Compiler below if you don't have Java installed on your machine.

Write a Java application that inputs the rest mass (m0) and velocity (v), then computes and outputs the actual mass using Einstein's relativity formula:
m = m0 / √(1 - (v / c)²)
where c is the velocity of light 2.998 × 10⁵ km/sec. Validate the input to insure that the rest mass is non-negative and the input velocity is less than the speed of light. Translate this Python script into Java:

import sys
import math

# Define speed of light as constant C.
# The units are km/sec.
C = 2.998e5
m0 = input("Enter rest mass: ")

if m0 < 0:
    print("Rest mass must be nonnegative.")
    sys.exit( )

v = input("Enter velocity: ")
if v > abs(c):
    print("Velocity cannot be > c.")
    sys.exit( )

m = m0 / Math.sqrt(1 - (v / c) ** 2)
print("Relativistic mass is", m)

// Here is the translated Java version:
import java.util.Scanner;
public class Relativity
{
    public static void main(String[ ] args)
    {
        Scanner input = new Scanner(System.in);
        final double c = 2.998e5;
        System.out.println("Enter rest mass: ");
        double m0 = Double.parseDouble(input.nextLine( ));  
        if (m0 < 0)
        {
            System.out.println("Rest mass must be nonnegative.");
            System.exit(0);
        }
        System.out.println("Enter velocidy: ");
        double v = Double.parseDouble(input.nextLine( ));  
        if (v > c)
        {
            System.out.println("Velocity must be < c.");
            System.exit(0);
        }
        m = m0 / Math.sqrt(1 - Math.pow(v / c, 2));
        System.out.println("Relativistic mass is " + m + ".")
    }
}

An Online Java Compiler

In case you don't have Java installed on your computer, you may want to use this online Java compiler:
https://www.tutorialspoint.com/compile_java_online.php
This Python script converts a Celsius temperature into Fahrenheit:
```
cel = int(input('Input a Celsius temperature: '))
fahr = 9 * cel / 5 + 32
print('Fahrenheit temperature: ', fahr)
```
Translate this script into Java and test it in a Shell script and in the Tutorials Point Online Compiler. ,

Shell Commands

For a Mac, the equivalent of the DOS Command Window is the Terminal Window.
The software that executes commands in the DOS Command Window or the Terminal Window is called the Shell.
The following table shows some useful Shell commands.

DOS Shell commands are executed on Windows; Unix Shell commands are executed on Mac machines.

DOS	Unix	Meaning
cd	cd	Change directory.
cls	clear	Clear Screen.
copy	cp	Copy file or directory.
del	rm	Delete file.
dir	ls	List files in current directory.
echo	echo	Echo a string to the DOS Command or Terminal Window.
exit	exit	Close the DOS Command or Terminal Window.
java	java	Execute Java executable file.
javac	javac	Compile Java source code file.
py	py	Execute Python source code file.
mkdir	mkdir	Make new directory.
rmdir	rmdir	Remove directory.
rename	mv	Rename file or directory.
type	cat	Type file to the screen.

Java Constants

A constant is a value that cannot be changed.
Some integer (int) constants:
```
57  -325  0  567654  2000000000
```
The minimium and maximum values for int constants are -2³¹ = -2147483648 and 2³¹ - 1 = 2147483647.
Some double (double precision floating point) constants:
```
3.546  -32.234  5.98e24  9.11e-31 
```
Some character constants:
```
'A'  'y'  '8'  '*'  ' '  '\n'
```
Java uses some of the same escape characters as Python:
```
'\n' '\t' '\v' '\r' '\f' 

'\\' '\'' '\"' '\0'
```
This escape character is used in Python, but not in Java:
```
'\a' (audible bell) 
```

Some String constants:

"elephant"  "@#$%^&*)("  "345"   ""

"This\nis\na\ntest.\n"

boolean constants:
```
true  false
```

Java Variables

A Java variable has these attributes:
Name Must start with a letter and consist of letters and digits. Variables are case sensitive, which means that capitalization matters. The naming convention for variables is lower camel casing. For example: numberOfCustomers.

Value The binary data contained in memory. The value is interpreted according to the variable's datatype.

Address Location in memory where the value is stored. An address is an 8 byte hex value, for example 0x29483f8ea87b37ef.

Size The number of bytes that the variable occupies in memory.

Datatype The interpretation of the value. Some important datatypes are listed in the next section.

Range The minimum and maximum values of the variable. The range of a variable depends on its size. The bigger the size in bytes, the bigger the range.

Two styles for declaring and using variables:

Separate declaration and assignment:

int n, m;
double x, y;
char a, b;
String s, t, u;
n = 342;
m = -81;
x = 23.432;
y = -76.312;
a = 'A';
b = 't'; 
s = "Hello, World!";

Combined declaration and initialization:

int n = 342, m = -81;
float x = 23.432, y = -76.312;
char a = 'A', b = 't';
String s = "dog", t = "cat", u = "";

All variables must be declared in Java.

Java Primitive Datatypes

We only discuss the starred primitive datatypes in the following table: int, double, char, boolean.

Datatype	Meaning	Size in Bytes	Minimum	Maximum	Significant Digits
byte	Integer	1	-128	127
short	Integer	2	-32,768	32,767
*int	Integer	4	-2.1×10⁹	2.1×10⁹
long	Integer	8	-9.2×10¹⁸	9.2×10¹⁸
float	Floating Point	4	-3.4×10³⁸	3.4×10³⁸	7
*double	Floating Point	8	-1.8×10³⁰⁸	1.8×10³⁰⁸	15
*char	Character	2	Any Unicode Character
*boolean	Logical	1	false	true

In Python, every datatype is a class. In Java, primitive datatypes are not represented by classes.

String Objects

A string in Java is not a primitive data type. It is an object instantiated from the system defined class String.

A string can be declared and initialized using long and short methods:

// Long method:
String s = new String("dog");

// Short method:
String s = "dog";

Java Operators

Here are some operators that are the same in Python and Java:

+  -  %  =  ==  <  <=  >

>=  !=  &  |  ^  ~

+=  -=  *=  /=  &=  |=  ^=

Differences between Python and Java

Python: * can mean either multiplication or repetition;
Java: * only means multiplication.

Python: / means floating point division; // means integer division;
Java: x / y means integer division if both x and y are int;
x / y means floating point division if either x or y are double.

Java: n++ means add one to the value of n;
n-- means subtract one from the value of n;