CS62 - Spring 2021 - Lab 1
Example code in this lecture
ClassBasics
Lecture notes
admin
- examples from class posted on course web page (including today's examples)
- notes posted
today
- 30 minutes of lecture
- lab 1: setting up Eclipse, etc. and some basic Java programs
- You can leave when you're done
- normally we'd start the assignment, but I'm waiting until tomorrow's class to release it!
classes
- A class is a template for an object
- a class defines:
- the types of things you can do to/with an object of that class (i.e. methods)
- how you can create new objects
- what data we need to keep track of for an object
- Let's say we want to come up with a template (i.e. class) for balls
- What questions might we ask about a ball? What types of things might we do to a ball?
- how big is it?
- what is it filled with?
- what's it's color?
- where is it?
- move it?
- throw it?
- ...
- What information might we need to keep track of about a ball?
- size
- color
- what it's filled with
- location
- all this information defines the category of ball
- we can instantiate the class (i.e. create a new ball object) by setting all of the attributes
- each ball we create will have it's own individual attributes
- changing the attributes of one ball (e.g. the location) will NOT affect the other balls
- The class then describes all the things we can do with a particular instance of a ball (any ball!):
- throw it
- ask about it's color
- ...
designing a class in Java
- three key things when designing a class:
- what are the methods we want the object to have?
- what types of things do we want the object to do?
- what types of questions might we want to ask about the object?
- what data do we need to keep track of *per* object?
- what differentiates one object of the class from another?
- what information do we need to make or create a new object of that class?
let's design a card class to represent a playing card
- what methods do we want the object to have?
- what suit?
- what number?
- maybe:
- face-up/face-down?
- change suit/number?
- location?
- what data do we need to keep track of per card?
- number
- suit
- maybe: location, face-up/face-down
- what information do we need to know to create a new card?
- number
- suit
writing a class in Java
- first, we tell Java that we're declaring a new class
public class ClassName{
}
- this goes in a file that has the same name as the class with the extension .java
- by convention, class names are capitalized
- for all of the data that we want to store, we create "instance variables"
- these are just variables declared inside of the class
- they are available to methods declared inside the class
- for each bit of functionality we want, we write methods
- the "constructor" of a class is a method that has the same name as the class and NO return type
- it's used to create (or construct) a new object
look at the BasicCard class in the
ClassBasics code
- two instance variables: number and suit
- each card object will have its own copy of these variables
- 4 methods (including the constructor)
- all are very simple!
- BasicCard is the constructor and is called when we're creating a new card
- it takes two parameters
- all it does is store these two parameters away
- getSuit and getNumber
- just give data back
- cheat()
- doesn't take any parameters or give anything back
- alters the state of the card
creating a new object
- now that we have defined out class, we can create a new object that is an instance of that class
- creating a new class also creates a new type
BasicCard card = new BasicCard(10, "hearts")
- BasicCard is the type
- card is the name of the variable
- this first part is just like what we've been doing all along
- = (assignment)
- new: keyword that tells Java to create a new object
- BasicCard(...) is the call to the constructor
- Java creates a new object
- that object has its own copies of the instance variables
- the constructor code is then called
main
- ALL Java programs have to start in a "main" method
- the syntax for the main method is:
public static void main(String[] args){
...
}
- To run a program, you click on the green arrow button
- Eclipse will look for a main method in the currently open class
- and the program will start executing there
look at the main method in the BasicCard class in the
ClassBasics code
- constructs two different card objects
- prints out the number and suit for the two cards
- calls the cheat method on card1
- then prints out the number and suit for the two cards again
- when you run the code:
- you see each of the cards gets their own copies of the instance variables
- each object has it's own state
- the cheat method changes the state of card1, but card2 is unaffected
Arrays in java
- In the example above, we created two cards
- What if we wanted to create 10 cards? 20?
- We'd have to have variables for each one!
- Arrays (kind of like lists) allow us to store multiple objects in a single variable
- creating lists
BasicCard[] cards = new BasicCard[10];
- The type of the contents variable is an *array* of BasicCards
- it holds exactly 10 cards
- by default, the values in the array will be empty, so be careful
- length: you can tell the number of elements in it using .length
cards.length
- would give us 10
- indexing: like in python, we use square brackets to get at items in the arry
cards[0] // first item
cards[3] // fourth item
- arrays are NOT lists
- lists start out empty and we can fill them up, e.g., via append (or add)
- arrays are always the same size!
- the values start out as empty (more on this later)
- often we'll have a for loop to initialize the cards
for( int i = 0; i < cards.length; i++ ){
cards[i] = new BasicCard(i+1, "hearts");
}