Howdy. 

   5  3  4  2  6  1 
   -              -

   1  3  4  2  6  5
      -     -

   1  2  4  3  6  5
         -  - 

   1  2  3  4  6  5
            - 

   1  2  3  4  6  5 
               -  -

   1  2  3  4  5  6
                  -

class Artur {
  public static void main(String[] args) {
    int[] a = { 4, 2, 3, 1, 6, 5 };
    System.out.println( java.util.Arrays.toString( a ) ); 
    Artur.sort( a ); 
    System.out.println( java.util.Arrays.toString( a ) ); 
  }
  public static void sort(int[] numbers) {
    for (int i = 0; i < numbers.length; i = i + 1) { // to the left of i numbers is sorted 
      for (int j = i; j < numbers.length; j = j + 1) { // look for a smaller number to the right 
        if (numbers[i] > numbers[j]) { // swap when you find a good candidate 
          int temp = numbers[i];
          numbers[i] = numbers[j]; 
          numbers[j] = temp; 
        } 
      }
    }
  }
}

So let's try this and in the process we make these changes:

class Artur {
  public static void main(String[] args) {
    int[] a = { 4, 2, 3, 1, 6, 5 };
    System.out.println( java.util.Arrays.toString( a ) );
    Artur.sort( a );
    System.out.println( java.util.Arrays.toString( a ) );
  }
  public static void sort(int[] numbers) {
    for (int i = 0; i < numbers.length; i = i + 1) { // to the left of i numbers is sorted
      for (int j = i; j < numbers.length; j = j + 1) { // look for a smaller number to the right
        if (numbers[i] > numbers[j]) { // swap when you find a good candidate
          int temp = numbers[i];
          numbers[i] = numbers[j];
          numbers[j] = temp;
        }
      }
      System.out.println( i + ": " + java.util.Arrays.toString( numbers ) ); // show me now 
    }
  }
}

This is how this program runs: 

Welcome to DrJava.  Working directory is C:\Users\dgerman\Desktop
> run Artur
[4, 2, 3, 1, 6, 5]
0: [1, 4, 3, 2, 6, 5]
1: [1, 2, 4, 3, 6, 5]
2: [1, 2, 3, 4, 6, 5]
3: [1, 2, 3, 4, 6, 5]
4: [1, 2, 3, 4, 5, 6]
5: [1, 2, 3, 4, 5, 6]
[1, 2, 3, 4, 5, 6]
> 

With two improvements from Yunsheng and Zhichao we now have:

class Artur {
  public static void main(String[] args) {
    int[] a = { 4, 2, 3, 1, 6, 5 };
    System.out.println( java.util.Arrays.toString( a ) );
    Artur.sort( a );
    System.out.println( java.util.Arrays.toString( a ) );
  }
  public static void sort(int[] numbers) {
    for (int i = 0; i < numbers.length-1; i = i + 1) { // to the left of i numbers is sorted
      for (int j = i+1; j < numbers.length; j = j + 1) { // look for a smaller number to the right
        if (numbers[i] > numbers[j]) { // swap when you find a good candidate
          int temp = numbers[i];
          numbers[i] = numbers[j];
          numbers[j] = temp;
        }
      }
      System.out.println( i + ": " + java.util.Arrays.toString( numbers ) ); // show me now 
    }
  }
}

So we setup the following: 

class Artur {
  public static void main(String[] args) {
    int a = 3;
    Artur.jason(a); 
    System.out.println("From main we see a as: " + a); // 3 
  }
  public static void jason(int number) { // arguments are passed by value 
    System.out.println( "I am Jason and I received: " + number ); 
    number = number + 1; // now I make it one bigger
    System.out.println( "Jason reports number is now: " + number );
  }
}

Let's do another experiment:

class Artur {
  public static void main(String[] args) {
    int[] a = { 1, 3, -2, 5 };
    System.out.println( a ); 
    Artur.jordan(a); 
    System.out.println("From main we see a as: " + java.util.Arrays.toString( a )); 
    // write expectation here:  
  }
  public static void jordan(int[] numbers) { // arguments are passed by value 
    System.out.println( "Jordan: " +  numbers ); // jordan sees the same address
    System.out.println( "Jordan: " + numbers[2] );
    numbers[2] = 7; 
    System.out.println( "Jordan: " + numbers[2] );
    System.out.println("From Jordan: " + java.util.Arrays.toString( numbers )); 
    
    numbers = new int[] { 3, 2, 4 };
    System.out.println("From Jordan: " + java.util.Arrays.toString( numbers )); 
        
  }
}

This emulates the previous example and adds a new dimension. 

The output:

Welcome to DrJava.  Working directory is C:\Users\dgerman\Desktop
> run Artur
[I@1052fd
Jordan: [I@1052fd
Jordan: -2
Jordan: 7
From Jordan: [1, 3, 7, 5]
From Jordan: [3, 2, 4]
From main we see a as: [1, 3, 7, 5]
> 

Types in Java: (a) primitive (int, double, char, boolean, float, long, short, byte)
               (b) non-primitive (i.e., user-defined types, reference types, classes)

Values of primitive types fit in the variables of that type. 

Values of reference types don't; addresses to them are kept in the variable(s). 

Thus params are still passed by value but the value passed is an address, structure is shared. 

In lab we start modeling. 

--