Java¶

Brief History of Object Oriented Programming¶

SIMULA 67, an extension of ALGOL, was the first PL to introduce the idea of data abstraction
- It's influence is often not recognized
The frist fully object-oriented langauge was Smalltalk, which was developed in the 70's
- Not widely adopted
C++ started out as C with Classes in the early 80s, and became a fully separate language
- The first version of C++ were released in 1985
Since then Object Oriented Programming Languages have continued to grow in popularity

OOP is a fuzzy concept and programming languages can adhere to it to differing degrees
Can be broken down into three concepts. Various languages may not support all equally well
- Polymorphism
- Inheritence
- Encapsulation

The idea of bundling and object'ss state (variables) and methods together
Through use of methods, access to the object's can be controlled
- Theoretically the programmer using an existing method should need to know or care about the internals of a class
- All functions can be handled through a method
- Some languages, like Python, allow this bundling, but have no way to prevent direct manipulation of the state
When done right, can lead to cleaner code and improved reusability

While OOP languages are often based on imperative languages, it is not a good idea to use them like one
The difference is in the design of a program
- With OOP we need to figure out what objects are involved in our project
- With imperative languages, we figure out what steps are involved

Invented a Sun Microsystems in 1991 by James Gosling and others
- Not officialy released until 1996
The invetors wanted to fix what they saw as problems in C++ (ie, memory management)
Was designed to be runnable on many different devices, not just traditional computers
The current version is Java 8

Java in an interpreted language
- Compiled down to Java byte code, which is the same for every device
- The Java Virtual Machine ( JVM ) interperets the bytes code into machine code
  - In order to run Java, a JVM must have been constructed for your type of machine
Every Java program must have at least one class with a method named main

In a file named HelloWorld.java

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

%%bash
cd java
java HelloWorld.java

%%bash
cd java
javac HelloWorld.java
java HelloWorld

%load java/Scope.java

%load java/ScopeMain.java

%%bash
cd java
javac ScopeMain.java

While, Java is an OOP language, it still has a few primitive types that do not behave like objects
- Although since Java 5, the compiler can convert primatives to their associated objects through a process known as boxing
The primitive types are
- boolean
- char
- 6 varities of numbers
  - float, double
  - byte, short, int , long
Strings, arrays, and everything else are objects

Java supports compound assignment on numbers as well as increment and decrement operators
- ```
int x = 0
 x += 1
 x++
 x -= 20
```
Only five basic arithmatic operations are supported
- + , - , * , / , %
- Exponent is a method in the math library, Math.pow

While strings are objects in Java, they can be declared with out using a constructor
- ```
String str = "This is a fine way to do things";
```
The + sign has been overloaded, and is used for concatenation
- += is also available
Array syntax cannot be used with strings
- Must use the methods charAt and substring
- Both of these methods are read-only

Similarly to strings, arrays can be be declared with out using a constructor
```
int[] arr = {10, 20, 30};
```
To create a empty array of a given length , use the new keyword, which hints at its objectness
```
int [] = new int[100];
```

Multidimensional arrays are easy to declare!

int [][][] tensor = new int[100][100][100];

To convert a string to one of the primitve classes we must use a wrapper class.
```
String numString = "100";
int number = Integer.parseInt(numString);
```
What a user defined object can be casted to depends on what it inherits from
- We will talk more about inheritence later

The relational operators work as expected with primitive types
- > , < , >=, <= , == , !=
For objects == does not work as you might expect
- == compares the references of objects, it will only be true when the are the same object
- To compare objects, we use the method equals

Objects have an additional operator, instanceof

String s = "String";
       s instanceof String == true

Java provides two for loops, a while loop, and a do-while loop
The standard counter based foor loop has the following syntax:
```
for(int i =0; i < 100; i ++){
}
```
Starting with Java 5, a generic for loop was added, it is called an enhanced for loop in java
```
int[] toLoop = {10,20,30,40,50,60};
for(int number: toLoop){
}
```

For if statements, there is no then keyword

int x;
if(x > 0){
}
else if(x < -100){
}
else{
}

Since Java 7, switch can be used with strings

String str;
switch(str){
  case "Monday":
      <>
      break;
  case "Tuesday":
      <>
      break;
  default:
      <>
      break;
}