CS62 - Fall 2020 - Class 4
Example code in this lecture
Inheritance
Graphics
GraphicalCard
Lecture notes
admin
- quiz!
- how did the lab go?
- assignment 2 out later today and due on Tuesday
- if you struggled on the lab, come see us!
- there are mentor hours this evening already
JavaDoc: documentation in Java
- JavaDoc is a way of commenting your code that *also* allows for html documentation to be generated!
-
http://www.oracle.com/technetwork/java/javase/documentation/index-137868.html
- a way for you to communicate the "interface" to other programmers/users
- /** is the beginning comment delimiter for classes/methods
- if you type this above the class or a method and hit return, Eclipse will automatically generate a template for you!
- Two basic parts
- The document comment, which is written in HTML and is the first non-whitespace-line chunk of text
- block tags. The main ones we'll use are below, but many more online
- @author
- @param
- @return
- @throws
- We can generate the HTML from the comments using eclipse (or on the command line)
- In Eclipse: Project->Generate Javadoc...
- in the left window, select the classes that you want to generate the javadoc for (generally, you should do one project at a time)
- select the destination (the "doc" folder within the project is a good place)
- click "finish" (or "next" if you'd like other options)
- generate HTML output with the documentation!
inheritance revisited
- we can build a new class that is an extension of another class
- the original class is said to be the superclass (or parent class) and the new class the subclass (or child class)
- to do this, in the class header, you use the keyword "extends", e.g.
public class B extends A{
...
}
- the subclass:
- inherits all public methods from the superclass
- e.g. given an object of type B, we can call any method that A had on B
- can access any instance variables that are declared public *or* protected
- can call any methods that are declared as public *or* protected
- additions in the subclass
- you can then add any additional instance variables and methods in the subclass
- these will be available normally in the subclass, but NOT in the superclass
- if you define a method with the same "signature" as in the superclass, it will override it
Look at
Inheritance code
- We have a class called A that has a private and protected instance variable
- Two public methods
- B is a class that inherits from A
- we indicate this with the keyword "extends"
- B has all of the instance variables of A
- however, it can only access those that are protected or public
- in the resetInt method, we can access number
- if we tried to access the text variable, we would get an error
look at test2 in the B class in
Inheritance code
- Why can't I call a.resetInt()
- Java can't guarantee that there will be an object of type B in there, so it can't know that it's a safe call
look at test3 in the B class in
Inheritance code
- What will be printed out?
A1: I'm an A
B1: I'm a B
A2: I'm a B
- Since A2 references an object of type B, then B's toString method gets called!
- When the methods are called, they are based on the object
look at the shape package in the
Inheritance code
- The Shapes class defines basic behavior
- The Square and Rectangle classes extend the Shape class
- they both override the getArea method
- they both add methods particular to the class
look at ShapeMaker class in
Inheritance code
- What does the getShapes method do?
- prompts the user for a number
- then prompts them for that number of shapes
- if the user enters a rectangle or square it creates one
- otherwise creates a generic shape
- Where does it store these shapes?
- in an ArrayList of Shapes
- Why does that work?
- Rectangles and Squares are both shapes!
- What does the printShapes method do?
- goes through the Shape ArrayList and prints each shape out (i.e. calls the toString method)
Graphics/GUIs in Java
- A way to represent windows and things that go inside windows
- can be a bit tedious, but not particularly complicated
- makes heavy used of inheritance
look at BasicGraphics class from
Graphics code
- The basic window is called a JFrame (imported from javax.swing:
https://docs.oracle.com/javase/7/docs/api/javax/swing/JFrame.html
)
- It's a top-level window with a title and a border
- We can add things to the inside of this frame
- It has a single constructor that takes a string representing the title
- What does 'super("this is my awesome title")' do?
- call the JFrame constructor. You can always look at the documentation if you need to:
https://docs.oracle.com/javase/7/docs/api/javax/swing/JFrame.html
- What do you think the other four lines in the constructor do?
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // set it so that if you click close, the window actually closes
setSize(500, 300); // set the size of the window
setLocation(100,100); // set the location of the window
setVisible(true); // make it visible
- by default windows/frames are not visible, so this last line is critical
look at BasicGraphics2 class from
Graphics code
- All these set methods are public methods and can either be called in the class or externally. Either way is fine for this class.
look at MyGraphicsDemo class from
Graphics code
- The JFrame is a container that we can add stuff to
- Use constants!
- constructor
- graphic objects are not displayed when they are created. They must be drawn in the paint() method using the Graphics object.
- For most of the graphics objects there is both a float version and a double version
- Line2D.Double
- Line2D.Float
- The only differences is whether the coordinates are specified as floats or doubles
- Graphic objects in java are laid out based on an x and y coordinate system starting with 0, 0 at the top left corner of the window
- positive x is right
- positive y is down
- See the JavaDoc online for details for these classes
- Line2D.Double
- Ellipse2D.Double
- Rectangle.Double
paint(Graphics g) method
- the key method for drawing graphics
- invoked implicitly whenever another object calls this frame’s repaint() method or whenever the screen manager requires it, e.g. when a portion of this frame is revealed by the movement of another frame
- The Graphics object passed in gives us a handle on an object to actually display on the screen
- First thing to do is typecast the Graphics object as a Graphics2D object
- Until we "draw" an object using the Graphics2D class, it won't be displayed
- draw: to draw any Shape object we've created (like a line, rectangle or ellipse)
- drawString: For putting text on the screen
- fill: fills the interior of the shape
- Attributes like line color, fill color and font are NOT set at the Shape object level, but are set on the Graphics2D object before it is used to draw the Shape object
interfaces
- There are two main ways we can indicate shared behavior. The first is through inheritance.
- The second is through interfaces. Interfaces define methods that a class must define. E.g.,
public interface InterfaceName{
public void method1();
public int method2(int number);
public ArrayList<String> anotherMethod(String myString);
}
- A class can then "implement" these methods by adding "implements" in the class definition:
public class A implements InterfaceName{
}
- we must then implement ALL of the methods described in the interface, or our code will not compile
- Why might this be useful?
- interfaces define a type, i.e., we can declare variables and parameters of that type
- allows us to group objects together with similar functionality
- public void example(InterfaceName obj){...}
- we know that we can call any methods defined in the interface from that object
- we can say, the only thing that's important to me is that the class implement method x, y and z
Handling mouse events
- Two commonly used interfaces:
- MouseListener (
https://docs.oracle.com/javase/7/docs/api/java/awt/event/MouseListener.html
)
- for taking actions based on mouse presses, releases, clicks, enters and exits
- MouseMotionListener (
https://docs.oracle.com/javase/7/docs/api/java/awt/event/MouseMotionListener.html
)
- for taking actions based on mouse moves or drags
- moving/dragging is continuous in the real world. How does this translate to method calls?
show MouseEvents class in
Graphics code
- beginning code in main is the generic code to setup a frame
- private classes
- you can only have ONE public class in a file
- however, you can have private helper classes
- we'll see these frequently in this class
- again, useful for compartmentalizing functionality
- the MouseEventsHelper class implements both the MouseListener interface and MouseMotionListener class
- notice that if you comment out one of the methods, the compiler will complain, because you have not satisfied your contractual obligation of the interface
- each method is passed a MouseEvent object giving some information about the mouse event that triggered/called the method
- we'll use the getX() and getY() method to get the x and y coordinates of the event
private classes
- you can only define one high-level class per file
- sometimes it can be helpful to have another class in a file that is only used internally
- these are called private classes
- private classes are not accessible outside of the outer class
- they're common for doing things like providing support for handling mouse events
run MouseEvents class
look at GraphicalCard class in
GraphicalCard code
- extends Rectangle2D
- constructor
- makes a card at x, y with a fixed with and size dependent on the number of the card
- getColor
- red or black
look at BasicCardDisplay class in
GraphicalCard code
- just draws our GraphicalCard (in this case, 11 of diamonds
- we construct the card in the constructor
- then draw it with fill in the paint method
look at CardDisplay class in
GraphicalCard code
- instead of a single card, generate multiple cards (save them in an ArrayList)
- in paint, paint all of the cards
look at MoveableCard class in
GraphicalCard code
- extends GraphicalCard
- this is the power of inheritance!!!
- only add a moveCard method
- setFrame is an inherited method from Rectangle2D which changes the location and size
look at MoveableCardDisplacy class in
GraphicalCard code