Our goal remains modeling:

; A Point is a (make-point Number Number)
(define-struct point (x y))

; A Circle is a (make-circl Point Number)
(define-struct circl (center radius))

; A ManyCircl is one of:
;   -- empty

;   -- (cons Circle ManyCircl)

; A World is a ManyCircl 

Can I define Point in Java?

public class Point {
  private int x, y; // can't be accessed from the outside 
  public int getX() {
    return x;
  }  
  public int getY() {
    return x;
  }  
}

(define-struct point (x y))

(check-expect (point-x (make-point 4 9)) 4)

Can I define Circle in Java? 

public class Circle {
  private Point center; // default value is null 
  private int radius; // default value is 0 (zero)
  public Point getCenter() {
    return center;
  } 
  public int getRadius() {
    return radius;
  } 
}

So perhaps all of these could be intuitive or become intuitive. 

public class Wednesday {
  public static void main(String[] args) {
    Student molly = new Student("Molly"); 
    // molly.name = "Molly"; 
    System.out.println( molly.talk() ); 
  }
}

public class Student {
  private String name; // instance variable 
  public Student(String n) { // constructor 
    name = n;  
  }
  public String talk() { // instance method 
    return "Hello, my name is " + name;  
  }
}

That's basic modeling. 

One rule about constructors. 

If you define no constructor in a class you will given a constructor. 

It is called the no-args default constructor. 

If you define one or or more constructors that's all you get. 

public class Horse {
  public Horse() { // this is the default no arg constructor 
    
  }
  public void talk() {
    System.out.println( "Howdy." );  
  }
}

public class Wednesday {
  public static void main(String[] args) {
    Horse a = new Horse(); 
    System.out.println( a ); 
    
  }
}

For this reason if I modify to

public class Horse {
  private String name; 
  public Horse(String n) { 
    name = n; 
  }
  public void talk() {
    System.out.println( "Howdy." );  
  }
}

When I compile this

public class Wednesday {
  public static void main(String[] args) {
    Horse a = new Horse(); 
    System.out.println( a ); 
    
  }
}

I get an error. 

Now we have alonger discussion that boils down to this:

public class Wednesday {
  public static void main(String[] args) {
    Horse a = new Horse("Seabiscuit"); 
    System.out.println( a ); 
    a.talk(); 
    Horse b, c;
    b = new Horse("War Admiral"); 
    System.out.println( b ); 
    b.talk(); 
    c = new Horse("Storm Cat"); 
    System.out.println( c ); 
    c.talk();     
  }
}

public class Horse {
  private String name; 
  public Horse(String name) { 
    this.name = name; 
  }
  public void talk() {
    System.out.println( "Howdy, it's " + this + " I go by " + this.name );  
  }
}

Last comment for the day:

import java.util.Arrays; 

class One {
  public static void main(String[] args) {
    int[] a = { 3, 5, 4, 6, 1, 2 }; 
    int[] b = One.sort(a); 
    System.out.println( Arrays.toString( a ) );     
    System.out.println( Arrays.toString( b ) );     
  }
  public static int[] sort(int[] a) {
    int[] result = new int[a.length]; 
    for (int i = 0; i < a.length; i++)
      result[i] = a[i]; 
    Arrays.sort( result ); 
    return result; 
  }
}

The basic idea behind non-destructive sort. 

--