Acutally, strictly spearking, this is a class with a default constructor:

1. class StockItem {
2.   int quantityLeft;
3.   float unitPrice;
4. }

The default constructor is the one provided by the compiler, that you invoke when doing StockItem si = new StockItem(); without even declaring it. Now, by extension, lot of people (including me for a time) use the term to indicate the constructor without parameters, but that's improper... Note: if you provide any constructor, there is no default constructor!

The display method can be anything, like drawing a circle of diameter proportional to the total price.
getTotalPrice() should return a float, not an int! (unless the price is in yens...). And, well, it should return the value...
isMoreExpensiveThan() is all wrong: you get an signature, ie. a list of parameters, use it!
And you can do return a > b; it is shorter than this return true / return false business.
You should initialize your objects in setup(), not in draw(). Not really important here, but you generate lot of objects to throw them away immediately.

1. class StockItem {
     int quantityLeft;
     float unitPrice;
2.   //default constructor
     StockItem() {
       quantityLeft = 0;
       unitPrice = 0;
     }
3.   //parameterized constructor  
     StockItem(int _quantityLeft, float _unitPrice) {
       quantityLeft = _quantityLeft;
       unitPrice = _unitPrice;
     }
4.   //Display method
     void display() {
       println();
     }
5.   //totalPrice Method
   
6.   float getTotalPrice() {
   
7.   float totalPrice;
8.  totalPrice = _quantityLeft *  _unitPrice;
     }
9.   //isMoreExpensiveThan Method
     boolean isMoreExpensiveThan(int y1, int m1) {
     }
   }
10. StockItem m1, y1;
    //myItem m = new StockItem(); //@ $4.5 per item
    //yourItem y = new StockItem(); //@ $5.6 per item
11. void setup() {
      size(600, 400);
      background(255);
      m1 = new StockItem(8, 4.5);
      y1 = new StockItem(6, 5.6);
      println(m1.getTotalPrice());
    }
12. void draw() {
      background(255);
      m1.display();
      y1.display();
    }
    
    

I assume that the isMoreExpansiveThan is to compare unit costs of 2 stock items. In which case it is more logical to pass a stock item as a parameter i.e.

1. //isMoreExpensiveThan Method
2. boolean isMoreExpensiveThan(StockItem s) {
3.       return (unitPrice > s.unitPrice);
4. }

The method will compare the unit prices and return true if this stock item is more expensive than that for 's'

Since you are now passing an object reference (StockItem s) it would be safer to test for null values. If you do that the method becomes -

1. //isMoreExpensiveThan Method
2. boolean isMoreExpensiveThan(StockItem s) {
3.       if(s != null)     
4.             return (unitPrice > s.unitPrice);
5.       else               // The other (s) doesn't exist
6.             return true; // so this must be more expensive
   
7. }

Thanks for your reply quarks. However, I dont understand why i should be testing for null values?

" Am i making sense?" Not really...

Look at your method: boolean isMoreExpensiveThan(StockItem.y1)
The boolean part isn't a decoration, it is significant.
It means that return must have a boolean after it. Check what a boolean is if you are not sure, but basically, it is true or false, not some other value.
Here, you try to return m1 or y1 which:
- are of StockItem in your code, so they aren't booleans
- are not parameters of your method: they are global values, and it is bad practice for a class to refer to such global values. Except you redefine y1 as parameter...
- refers to _unitPrice which is a parameter of the constructor, so isn't visible from this method.

isMoreExpensiveThan is not returning the most expensive item, it is returning yes or no, true or false: it compares the price of the given item to the price of the object doing the comparison, and say it one is more expensive than the other.
Read again the code of quarks...