nntrn
2/1/2019 - 9:01 PM
Basic Java Revision Notes - Written in Java
Basic Java Revision Notes - Written in Java
/*
*
* / --------------------------------[ NUIM CS141 Java Revision ]------------------------------- \
* || Designed to easily revise everything covered in CS141 by just reading through this code. ||
* || Comments accompany almost every line of code to explain its purpose. ||
* || Some theory we need to know are included in the bottom... ||
* \ ------------------------------------------------------------------------------------------- /
*
*
* ____ _ __ ____ __
* / __ \____ _____ (_)__ / / / __ \____ ___ __/ /
* / / / / __ `/ __ \/ / _ \/ / / /_/ / __ `/ / / / /
* / /_/ / /_/ / / / / / __/ / / ____/ /_/ / /_/ / /
* /_____/\__,_/_/ /_/_/\___/_/ /_/ \__,_/\__,_/_/
*
*
* @version: 1.0
* @author: Daniel Paul
* @web: www.danielpaul.me / www.identitysquare.ie
* @fb: www.facebook.com/groups/nuimcs/
*
*/
// Import packages
import java.util.Scanner;
import java.util.Random;
// import java.util.*; will import all of java util packages. Import must be done before public class...
// public: this is a "modifier" placed before the word class that makes the class visible (accessible) from outside the class.
// - In a private class, methods and variables can only be accessed by methods within the same private class
// The class 'revision' must be contained in the file revision.java (the public class and file name must have the same name).
public class revision
{
// Method signature:
// static: Forces an instance of the main() method to exist so that it can be called from outside the class.
// void: this tells us that the main method (function) does not return any values. Return type can be int, String, arrays[], etc.
// main: this is the method that the JVM looks for and provides the entry point of your program.
// String: is a sequence of text characters. It is the argument for the main() method. Input parameters.
public static void main(String args[])
{
/* Examples of other method signatures:
public static void time() // returns nothing, accepts no parameters
public static void square(int x) // returns nothing, accepts an int number
public static void name(String fname, String lname) // returns nothing, accepts two strings
public static String name(String county) // returns a String, accepts a String
public static char[] result(String s[], int p) // returns char array, accepts a String array and an int number
public static double whoKnows(char c, int x, double b, String s, String p, int y, float f)
// returns a double number type, accepts a char, int, double, string, string, int and a float
*/
// System.out: is an object used for printing to screen.
// println: is a method belonging to the System.out class/object that can print a string to the console...
// Text inside the double quotes is an argument passed to the println() method.
System.out.println("Hello CS141 classmate!");
// All statements in Java end with a semi-colon
// ----- Declaring variables: <type> <identifier> = <value>;
int age = 18; // an integer value
// declaring multiple variables of type integer.
int day = 0, month = 0, year = 0;
// the final keyword tells java that this variable cannot be changed later in the program - it is a constant.
final int myNumber = 7;
// other variable types to store numbers: byte, short, long, float, double. These can store diffent length of numbers.
float sampleFloat = 0.0f; // can store decimal numbers with 7 digit precision
double sampleDouble = 0.0; // can store decimal numbers with 15 digit precision
char you = 'u'; // stores a single character
// we must use single quotes around a character value
boolean validYear = false, validName = false; // stores true or false. Default value if not specified is false.
// A String is a sequence of characters (digits, letters etc). It is anything and everything grouped together between 2 double quotes.
// Notice that String starts with a capital 'S'
String name = "Daniel"; // we must double quotes for strings values
// Another method for declaring a string: String name = new String("Daniel");
String firstName = "", lastName = ""; // initializing variables for later use
/* --------------- Relational Operators --------------- /
* Operator * * Result *
== equal to
!= not equal to
> greater than
< less than
>= greater than or equal to
<= less than or equal to
/* ----------------- Boolean Operators ----------------- /
* Operator * * Result *
& logical AND
| logical OR
^ logical XOR
|| short-circuit OR
&& short-circuit AND
! logical NOT
// Short-circuit AND, &&, only checks the second condition if the first is true.
// Short-circuit OR,||, only checks the second condition if the first is false.
/* ---------------- Operator Precedence ---------------- /
* Operator * * Associativity *
Highest () [] . left to right
++ -- ! right to left
* / % left to right
+ - left to right
> >= < <= left to right
== != left to right
& left to right
^ left to right
| left to right
&& left to right
|| left to right
Lowest = right to left
When there are two operators with the same precedence the expression is evaluated according to its associativity.
/ ----------------------------------------------------- */
/********************* 1.0 - Ask user for a valid full name **********************/
// initialize Scanner class to getting input from user
Scanner scan = new Scanner(System.in); // create an instance of the Scanner class named as scan
// Loops allow your program to do the same thing again and again and again and again.
// The following loop will ask the user for thier name until they enter a valid name.
// the variable validName is currently false. We will set it to true when we get a valid name.
while(!validName)
{
// this loop that will run until the user enters a valid name.
// ask user to enter their name
System.out.println("What's your full name?");
// scan the next line that the user enters and store it in the variable 'name'.
name = scan.nextLine();
/* other important scanner methods:
scan.nextInt(); // reads in the next token as an int
scan.nextFloat(); // reads in the next token as an float
scan.nextDouble(); // reads in the next token as an double
scan.nextLine(); // reads in the next token as an String
scan.hasNextInt(); //returns true if there is another int to read in
scan.hasNextFloat(); //returns true if there is another float to read in
scan.hasNextDouble(); //returns true if there is another double to read in
scan.hasNextLine(); //returns true if there is another String to read in
*/
// check if the user has entered their full name
// we are checking where the space character appears in the name
// we will get -1 if the character does not exist
// use == to compare
if(name.indexOf(' ') == -1)
{
// there is no space in the name, so user has not entered their full name
validName = false; // it's not necessary to set this to false here again since we have not changed it since initializing it
System.out.print("Oops! Looks like you forgot to enter your full name... ");
}
else
{
// there is a space in the name, so the name must be valid
validName = true;
// setting this variable to true will exit out of the while loop
}
}
/*********************************************************************************/
/**************** 1.1 - Split the full name to first and last name ****************/
// indexOf() Returns the index within the string of the first occurrence of the specified character or -1 if the character does not occur
int spaceIndex = name.indexOf(' ');
// Strings are indexed starting from 0
// get the characters from 0 to where the space is
firstName = name.substring(0, spaceIndex);
// consider everything after the first space as the last name
// get the characters one place after space to the end
lastName = name.substring(spaceIndex + 1);
/*********************************************************************************/
/****************** 1.2 - Capitalize the first char of the names *******************/
// lowercase all the char in name
name = name.toLowerCase();
// capitalize the first letter of the names
// get the first char and change that to upper case and then get the rest of the characters after the 1st char
firstName = firstName.substring(0, 1).toUpperCase() + firstName.substring(1); // .toUpperCase() converts a String to uppercase chars
lastName = lastName.substring(0, 1).toUpperCase() + lastName.substring(1);
// greet the user with their first name...
System.out.println("\nHello there " + firstName + "! I hope to help you revise some Java...");
// ----- let's find some interesting things about the name...
// \n prints a new line
System.out.println("\nHere are some interesting facts about your name:");
System.out.println("* Your first name: " + firstName);
System.out.println("* Your last name: " + lastName);
/*********************************************************************************/
/*********************** 1.3 - Find the length of the name ***********************/
// check how long the string is
// .length() gives the length of a String as an <int>
System.out.println("* Your name is " + name.length() + " characters long.");
/********************** 1.4. Check if firstName == lastName **********************/
// check if the first name is the same as the last name
// short hand if statement without the {} brackets
if(firstName.equals(lastName)) System.out.println("* Your first name and last name is the same!");
/*********************************************************************************/
/****************** 1.5 - Find how many vowels are in the name *******************/
// create an array with all the vowels.
// An array is a collection of variables.
char vowels[] = new char[5]; // declare and allocate memory for the array
vowels[0] = 'a'; // arrays are indexed from 0.
vowels[1] = 'e';
vowels[2] = 'i';
vowels[3] = 'o';
vowels[4] = 'u';
// declare and initialise together
char vowelsCaps[] = {'A', 'E', 'I', 'O', 'U'};
/* Arrays have three important properties:
- represent a group of related data.
- all data within an array have the same type.
- size of an array is fixed once it is created.
*/
int vowelsCount = 0; // counter that will keep track of the number of vowels
// create a new string and store the name into this
String highlightedName = name;
// for loop: (initialisation; condition; update)
for(int letter = 0; letter < name.length(); letter++) // outer loop
{
// this outer loop will run for the length of the name
// to get the length of an array, use .length - Note that there are no () in the end.
for(int i = 0; i < vowels.length; i++) // inner loop
{
// this inner loop will run for the length of the array (5 times) everytime the outer loop runs.
// check if char at outer loop count (letter) is equal to the char in vowels array at position of the inner loop count
if(name.charAt(letter) == vowels[i])
{
// increase the count of vowels we have in the name
++vowelsCount; // Increment variable
// capitalize the vowels to highlight them
// replace lowercase vowels in the name with uppercase vowels
// .replace() Replaces the first char specified with the second character specified
highlightedName = highlightedName.replace(vowels[i], vowelsCaps[i]);
}
} // END of inner loop
} // END of outer loop
System.out.println("* Your name has " + vowelsCount + " vowels (" + highlightedName + ").");
/*********************************************************************************/
/********************** 1.6 - Check if name is palindromic ***********************/
// palindrome: a word, phrase, or sequence that reads the same backwards as forwards.
// assume that the name is palindromic - we will set this to false if we find that it is not
boolean palindrome = true;
// convert all char to the same case as A is not equal to a.
String nameUpper = firstName.toUpperCase(); // .toUpperCase() convert a String to uppercase chars
// loop through the name
for(int count = 0; count < nameUpper.length(); count++)
{
// check if the char at count is the same as the char at the other end
if(nameUpper.charAt(count) != nameUpper.charAt(nameUpper.length() - 1 - count))
{
// if the corresponding char is not the same, set boolean to false
palindrome = false;
// break out of the loop once we have found a char that is not palindromic
break;
}
}
if(palindrome)
{
System.out.println("* Your first name is palindromic (reads the same backwards as forwards)!");
}
else
{
System.out.println("* Your first name is not palindromic.");
}
/*********************************************************************************/
/******************* 2.0 - Ask user for a valid month and year ********************/
// while loop to keep asking user for a valid month
while(month == 0)
{
// ask for name of the month
System.out.print("\nName the month were you born in: ");
String monthName = scan.nextLine();
// --------------- get the number of the month
// convert user input to lowercase so we can match uppercase and lowercase input
monthName = monthName.toLowerCase(); // convert String to lowercase chars
// A switch statement gives us the option to test for a range of values for our variables.
// They can be used instead of long, complex if ... else if statements.
switch(monthName)
{
case "january": month = 1; break;
case "february": month = 2; break;
case "march": month = 3; break;
case "april": month = 4; break;
case "may": month = 5; break;
case "june": month = 6; break;
case "july": month = 7; break;
case "august": month = 8; break;
case "september": month = 9; break;
case "october": month = 10; break;
case "november": month = 11; break;
case "december": month = 12; break;
default: month = 0; break; // if we cannot find a valid month
}
// print out error message if not a valid month
if(month == 0) System.out.println("Emmm... that doesn't look like a valid month...");
}
// ------------------------- [ Ask for a valid birth year ] ------------------------- //
int count = 0; // control variable to keep track of how many times the loop has run
// this is a do-while loop. it will run at least once and then check the condition at the bottom to determine if it needs to run again
do
{
// if we are in the loop again...
if(count > 0){
System.out.println("\nEmmm... That doesn't look like a year you could be born in! ");
System.out.println("Try a year between 1930 and 2010... ");
}
// ask for the birth year
System.out.println("What year were you born in?");
year = scan.nextInt();
// check if this is a valid year. must be born on or after 1930 and before 2011.
validYear = (year >= 1930 && year < 2011) ? true : false; // The ternary operator
// if condition is true, set boolean variable validYear to true or else false.
/* The ternary operator takes three arguments:
- a condition, a true value and a false value.
- It tests the condition and then returns one of two values to the variable based on the result of the condition.
*/
// keep track of how many times we are in the loop
count++; // update
/* ----- difference between i++ and ++i
++i will increment the value of i, and then return the incremented value:
i = 1;
j = ++i;
(i is 2, j is 2)
i++ will increment the value of i, but return the original value that i held before being incremented:
i = 1;
j = i++;
(i is 2, j is 1)
--------------- */
} while(!validYear); // condition
/*********************************************************************************/
/*********************** 2.1 - Calculate how old you are ************************/
// ---------- Find some more interesting facts...
System.out.println("\nSome intersting facts about your birthday:");
// print out which month they were born in
if(month == 1)
{
System.out.println("* You were born on the 1st month.");
}
else if(month == 2)
{
System.out.println("* You were born on the 2nd month.");
}
else if(month == 3)
{
System.out.println("* You were born on the 3rd month.");
}
else
{
System.out.println("* You were born on the " + month + "th month.");
}
// calculate their age
age = 2013 - year;
System.out.println("* You are " + age + " years old.");
// check how old they are in different units :P
System.out.println("* You are " + (age * 12) + " months old.");
System.out.println("* You are around " + (age * 52) + " weeks old.");
System.out.println("* You are approximately " + (age * 365) + " days old.");
System.out.println("* You are over " + (age * 356 * 24) + " hours old.");
/*********************************************************************************/
/************************** 2.2 - Odd or Even month? ***************************/
// check if the age is an odd or even number
if(age % 2 == 0)
{
System.out.println("* Your age is an even number.");
}
else
{
System.out.println("* Your age is an odd number.");
}
/********************* 2.3 - Were you born on a leap year? **********************/
// check if the year is divisible by 400 OR (is divisible by 4 AND is NOT divisible by 100)
if((year % 400 == 0) || ((year % 4 == 0) && (year % 100 != 0)))
{
System.out.println("* The year " + year + " is a leap year!");
}
else
{
System.out.println("* You were not born on a leap year.");
}
/*********************************************************************************/
/****************************** 2.4 - Lucky number *******************************/
// initialize Random class to generate random number
Random randomNumber = new Random(); // create an instance of the Random class named as randomNumber
// get a random number between 1 to 12
int luckyNumber = randomNumber.nextInt(12);
// get the digits in the ones, tens, hundreds and thousands place of the birth year
// % means modulus (mod) in Java and it calculates the remainder after division
// e.g. if the year = 2013
int onesDigit = year % 10; // onesDigit = 3
int tensDigit = year / 10 % 10; // tensDigit = 1
int hundredsDigit = year / 100 % 10; // hundredsDigit = 0
int thousandsDigit = year / 1000 % 10; // thousandsDigit = 2
// raise number to the power of 4
double powerDigit = Math.pow(thousandsDigit, 4);
// add and subtract some digits from the birth year
int result = onesDigit - hundredsDigit + tensDigit;
// add result with the randomly generated number
luckyNumber += result; // Addition assignment. Same as: luckyNumber = luckyNumber + result;
System.out.println("* Your lucky number is: " + luckyNumber);
/*********************************************************************************/
/****************************** 2.4 - Lucky Dates *******************************/
// create an int array of length 3
int luckyDates[] = new int[3];
// fill array with random numbers
for(int i = 0; i < luckyDates.length; i++)
{
// generate a random number between 0 and 30 and add 1 so we dont get 0
int randomDate = randomNumber.nextInt(30) + 1;
// store the randomly generated number to array
luckyDates[i] = randomDate;
}
System.out.print("* Your lucky dates are: ");
// loop through the array again and get the values stored
for(int i = 0; i < luckyDates.length; i++)
{
// if we are on the last array position
if(i == luckyDates.length - 1)
{
// print '&' before and full stop in the end.
System.out.print("& " + luckyDates[i] + ". \n\n");
}
else
{
// print number with ',' in the end
System.out.print(luckyDates[i] + ", ");
}
}
/*********************************************************************************/
} // END main
} // public class
/*
-----[ Some Programming Theory ]-----
* A computer program is a collection of instructions that describes a task, or set of tasks, to be carried out by a computer.
* A quality program is...
* Readable
- Other programmers should be able to easily read and understand what your code does.
- You should indent your code.
- Add comments to explain what the program does.
* Modular
- Programs should be broken down into component parts, where each part is subdivided as necessary.
* Robust
- A program should gracefully handle cases when the input is not as expected or some other error has occurred.
- A program should never crash.
-----[ Things you need to know about Java ]-----
* Java is a programming language. It can be used to write applications and applets.
* It is an object-oriented language.
* Platform-independent because of the JVM (Java Virtual Machine).
- "Write once, run anywhere"
-----[ Writing a Java Program ]-----
* Written in plain text format and saved with a .java file extension (like this file).
* But, the machine won't understand this.
* So, we need to compile the program to turn it into Java bytecode.
- The bytecode is stored in .class file (this file will be created if you build this java program).
- Bytecode is a highly optimised set of instructions designed to be executed by a JVM (Java Virtual Machine).
* A JVM interprets the bytecode and runs it on the machine.
* The compiler is called javac and the JVM interpreter is called java.
* JVM = Java Virtual Machine
* JVM is just a software program that allows the same .java files to run on many machines.
* Java is portable because it relies on a layer of Software and Hardware. Each layer only interacts with neighbouring layers.
- Your Java Program <-> JVM <-> Operating System/Embedded Software <-> Hardware of PC/Mobile Phone
* Java is case sensitive.
* All statements in Java end with a semi-colon.
-----[ Steps to writing a program ]-----
1. Develop an algorithm.
2. Write a software implementation of the algorithm - a software program.
3. Compile it.
4. Fix any compilation errors.
5. Test it - try to run it.
6. Fix any runtime errors.
*/
/*
What does this program do?
1.0. Asks for your full name until you enter your full name. Then finds interesting things with your name.
- uses scanner, while loop, boolean variable, if statement.
1.1. Splits your first and last name to separate strings.
- uses for loop, strings, substrings, if statement.
1.2. Capitalize the first char of the names.
- uses strings, substrings and string functions - <string>.toUpperCase(); and <string>.toLowerCase();.
1.3. Finds how long the name is.
- uses string, <string>.length() function.
1.4. Check if your first name is equal to your last name.
- uses <string1>.equals(<string2>); function.
1.5. Finds how many vowels are in your name with a nested loops and arrays of vowels.
Then replaces the the vowels in your name with the same capital char to highlight them.
- uses char arrays, nested for loops, if statement, <string>.replace(<char>, <char>); function.
1.6. Checks if your first name is palindromic.
- uses a for loop, if statement and loop break;
2.0. Repeatedly asks for the month you were born in and for the year until you enter a valid year.
Match the month name to find the month's number.
- uses while loop, do-while loop, scanner, if statement, switch statement, string, int variables.
2.1. Calculates how old you are in different units.
- uses if, else if statements, multiplying numeric operator
2.2. Checks if your age is an odd or even number.
- uses modulus, if statement
2.3. Check if your birth year was a leap year.
- uses modulus, if statement
2.4. Gets each digit of your birth year and randomly finds your lucky number.
- uses random class, modulus to find a single digit, double variables, numeric operators and math.pow(<x>,<y>) function.
2.5. Randomly fills an array with numbers from 1 to 31. These display as your lucky dates.
- uses array, for loop, if else statements.
----- That just about covers everything we have learned in programming so far... -----
*/
/*
____ ___
/\ _`\ __ /\_ \
\ \ \/\ \ __ ___ /\_\ __\//\ \
\ \ \ \ \ /'__`\ /' _ `\/\ \ /'__`\\ \ \
\ \ \_\ \/\ \L\.\_/\ \/\ \ \ \/\ __/ \_\ \_
\ \____/\ \__/.\_\ \_\ \_\ \_\ \____\/\____\
\/___/ \/__/\/_/\/_/\/_/\/_/\/____/\/____/
____ ___
/\ _`\ /\_ \
\ \ \L\ \ __ __ __\//\ \
\ \ ,__/'__`\ /\ \/\ \ \ \ \
\ \ \/\ \L\.\_\ \ \_\ \ \_\ \_
\ \_\ \__/.\_\\ \____/ /\____\
\/_/\/__/\/_/ \/___/ \/____/
www.danielpaul.me
*/