java.txt

translates our English into 0s and 1s for the processor to understand

Human written code

a class file, which contains 0s and 1s also called machine code

Capital letters and lowercase letters are interpreted differently

The start of every Java program and contains the code: public class {}

public static void main(String[ ] args) {}

System.out.println(“text”);

What a computer uses to store information it needs

is placeholder for data in a computer program

The name of a variable

Words that are set aside for use in the Java language

Whole Numbers (5, 10, 100,-50)

Decimal Numbers (5.5,10.0583)

A single Character (‘A’,‘b’, ‘&’)

Text

=

Giving a variable an initial value

+

The right side of the equal sign is computed first.

The remainder so the answer would be 1.

grammatical problem with the source code.

when your source code compiles, but when you execute it an error occurs

is when the code has correct syntax, causes no errors during execution, but it produces undesired results

are sections of our source code that are ignored by the compiler

// comment

/* comment */

• /**
• *
• *
• */

Java

main method

When we divide two numbers where one is an int and the other is a double, the integer value is temporarily changed into a double for the operation.

• When we want to force Java to temporarily change a value’s type, we can cast the type into something else.
• (double) 5 // Casts 5 into 5.0

is a variable whose value can not be changed. Any attempt to do so will cause a syntax error.

• we use the keyword final before the declaration
• final double PI = 3.14;

is a group of code that performs a single task

public static void ( ) {}

New methods you write must be told to run from the main method which is invoking or calling the method.

When a method needs information to complete its task, it accepts that information through the use of parameters

public static void method(int x)

The value you provide in the parenthesis gets stored into the parameter in the method. The value you provide is known as an argument

Java will “promote” an integer value into a double value if an integer is given where a double is expected

Any variable declared inside a method only exists inside that method

local

kinds of variables that may be used across every method

public static void method_name(){}

returning a value

void is written when the method does not return a value

This portion of the method signature is called the method’s return type

To return a value, we use the keyword return, followed by the value to be returned.

contained in a Javadoc and begins with @ and followed by author or version

javadoc

public static (params) {….

• Where return_type: is the type of value that the method returns. If nothing is returned, we use the keyword void
• method_name: is the name of your method
• params: are all the parameters the method uses to accept value

• we simply write the method name followed by parenthesis
• public static void main(String[ ] args){methodName();}

• It is no different than calling a method from within the main method.
• public static void method1(){method2();}

Have two methods in a class that have the same name as long as they accept a unique set of parameters, which allows a user to call a method to calculate the area of a circle and specify their own precision for PI, but also allow them to call it and use a default value of 3.14

The method with only one parameter will execute because in method overloading the set of arguments we give determines which method gets called.

Variables declared inside a method are local to that method. They do not exist in any other method.

are variables that can be used in all methods of the class they are declared and is declared inside the class, but not inside a method

Immediately following the class line of code you would write: public static int x = 10;

• First look for a local variable with the name we specified, and if it finds it, it will assume we are talking about the local variable
• If it does not find a local variable, it then looks for a class variable with the name we specified and assume we want to use it
• If it finds neither; then there is no variable with that name, and Java gives a syntax error

We can tell Java to use the class variable by writing the name of the class first, followed by a period, followed by the variable name: Class_name.variable_name

All you have to do is write the name of the class that contains the method or class variables that you want to access, and then write a period and the name of what you want to access: Class_Name.method_name() Class_Name.class_variable

• The class you want to use code from must be in the same directory as the class you are currently writing in order to compile
• One exception is that you can also compile by setting your class path to know the location of the external code you wish to use

class variables and methods

they make use of each other’s methods and variables to complete their individual tasks

The method or variable should be scoped as private

refers to the context in which something is visible in programming

refers to whether or not something in our program can be accessed from a given context

is the scope we give a class, method, or variable when we want it to visible and thus accessible by all classes everywhere

We can keep outside classes from being able to see or access methods and variables in a class by giving them the

The scope allows the given class, method, or variable to only be visible to other classes within the same package as the class they are declared in

In Java, we have the ability to group a set of classes together

Java, by default, gives classes, methods, and variables a default scope of protected

belongs only to the class they are associated with

The variables used when a class is called without being specified static

variables that no longer belong to the class as objects

a specific instance of a class

To declare an object, we write the name of the class we are instantiating, then a variable name for the object, followed by a semicolon: Person myself;

To create an object, we set the variable name equal to the keyword new, followed by the name of the class again with parenthesis after it: Person myself = new Person();

we can use its instance variables the same way we used to use class variables, with the difference being we specify the object name, and not the class name

Person myself = new Person(); myself.name = “Dan Longo”; myself.age = 21;

logic that evaluates to either true or false

two values with a boolean operator in between

= =

! =

>

<

> =

< =

When we only want a part of our code to be executed under a certain condition

if ( <condition> ) {// code to be executed}

The only time the code in the {} is executed is when the conditon is true.

boolean <variable> = true;

boolean x = 8 > 5; // x is equal to true

• boolean x = 8 > 5;
• if( x )

public static void example(boolean x)

• public static boolean isLarger(int x, int y)
• if(x > y)
• {
• return true;
• }
• return
• false;

• if(d != 0)
• {
• denominator = d;
• }
• else
• {
• System.out.println(“You entered 0”);
• }

• if(x > 50)
• {
• if(y < 20)
• {
• System.out.println(“yes”);
• }
• }
• else
• {
• System.out.println(“no”);
• }

• int x = 5;
• if(x == 10)
• {
• System.out.println(“X is 10”);
• }
• else
• {
• if(x == 5)
• {
• System.out.println(“X was 5, not 10”);
• }
• }

and boolean operator: if( x > 10 && x< 20)

False AND False = False

False AND True = False

True AND False = False

True AND True = True

When the && operator is used, and the first condition evaluates to false, Java does not even look at the second condition:

if( 5 > 10 && 6 == 6)….

• if(x >5 || x < 0)
• {
• // only one of the above need to be
• // true for this to execute
• System.out.println(“yes”);
• }

true^ true – evaluates to FALSE

true^ false – evaluates to TRUE

false^ true – evaluates to TRUE

false^ false – evaluates to FALSE

False or False = False

True or False = True

False or True = True

True or True = True

^

InJava, the NOT operator is represented by the ! symbol, placed directly before a boolean equation

boolean tf = false;

• if(!tf)
• {
• System.out.println(“TRUE!”);
• }

• A switch statement is a structure that looks at the value of a variable and goes through a list of possible values
• Based on the value and the list of possible cases, it will jump to the part of your code where that value is in the list

cases

switch(month)

{

case 1:

case 2:

}

default:

• switch(month)
• {
• case 1: date = date + 0;
• break;
• case 2: date = date + 3;
• break;
• default: System.out.println(“no match”);
• break;
• }

break; The keyword break tells Java to immediately exit the switch statement

• A switch statement can be
• rewritten as an if/else structure

• An if/else structure (for this specific
• scenario) can be rewritten as a switch statement

When converting an if/else to a switch, each of your if statements would be a case, ending with a break

If you have an if statement that uses the || (or) operator, you would have two cases together without a break in the middle. There would be a break after both the cases.

&& (and) can not be applied here since a switch only looks at a single variable, which has a single value

• if/else:
• if(month == 1)
• {
• date = date + 0;
• }
• if(month == 4 || month == 7)
• {
• date = date + 5;
• }
• switch:
• switch(month)
• {
• case 1: date = date + 0;
• break;
• case 4:
• case 7: date = date + 5;
• break;
• }