1.  Definition: The ability to derive child classes (sub- classes) from parent classes (super-classes)  Characteristics:  Methods and instance variables in the parent class are directly accessible from child class objects  Child classes can override parent class methods with their own customizations  Demonstrates the concept of reusable code. Prior to object oriented programming, programmers would often cut and paste sections of code. Bugs would then show up in many places in a system

3.  The String class  Overrides the Object class equals method  Adds a variety of its own methods Every class inherits from the Java Object class

4. public class Circle { protected double radius; public Circle() { radius = 0; } public Circle(double radius) {this.radius = radius;} public double area() {return radius * radius * Math.PI;} public String toString() {return "radius=" +radius); } public class Cylinder extends Circle { private double length; public Cylinder(double h, double r) { super(r); length = h; } public double volume() {return area() * length;} public String toString() {return super.toString()+" length="+length;} public double area() { return 2*(super.area()+Math.PI*radius*length); } }

5. public class Parent { private int size; public Parent(int size) { this.size = size; } public String toString() { return " size = " + size; } public int getSize() { return size; } } public class Child extends Parent { private int size; public Child(int size) { super(size); this.size = 0; } public Child(int sizeA, int sizeB) { this(sizeA); size = sizeB; } public @Override int getSize() { return super.getSize() + size; } public String toString() { return " size = " + getSize(); } } Note: The getSize() method of the parent class is overridden in the child class

6.  extends: Create a new class that is an extension of a parent class  super: Access parent class method or instance variable  this: access current class method or instance variable  instanceof: Determine if a variable is a particular child type  final: Class, method, variable cannot be extended or overridden  static: A class method or variable (one copy for all objects)  Scope Related variables/methods:  private : accessible only within class  protected: accessible within class in and to any of its child classes  public: accessible globally  Default (package friendly): accessible to all classes in the package

7. public class Demo { private static int x = 10; private int y = 20; static String out1(){ return “o1”; } String out2() { return “o2”; } public static void main(String[] args) { Demo d = new Demo(); System.out.println(d.y+" " + Demo.x +" " + x); System.out.println(out1() + d.out2() ); } } Question: What’s wrong with System.out.println(y)? Static methods and variables Go with the class, not with individual objects. They can be accessed with dot notation using the class name. There is one copy, even if many objects are instantiated. Instance variables Go with each instantiated object.

8. public class Top{} public class First extends Top {} public class Second extends Top {} public class Test { private Top top; public Test() { if (Math.random()>0.5) top = new First(); else top = new Second(); } public static void main(String[] args) { Test test = new Test(); if (test.top instanceof First) System.out.println("First"); else System.out.println("Second"); } Note: There is an initialization block in the Test class Note: After determining the class, we can cast objects appropriately to access overridden methods

9. public class Test { public static void main(String[] args) { Object o = new GraduateStudent(); System.out.println(o); System.out.println( (GraduateStudent)o ); System.out.println( (Person)o ); System.out.println( new Person()); System.out.println(new Object()); } } class Person { public String toString() { return "Person"; }} class Student extends Person { public String toString() { return "Student"; } } class GraduateStudent extends Student {} Output: Student Student Student Person java.lang.Object@9304b1 Note: Parent objects always reference overridden child methods. Access to overridden child methods is called polymorphism

10.  Create instance variables only when necessary. Variables local to a single method should generally NOT be instance variables  Limit the scope of variables. In general, instance variables should NOT be public. Use protected variables only for those that are needed by child classes.  Static variables and methods should rarely be used.  Polymorphism (next topic) is better than relying on instanceof  Java reflection (not covered in this class) enables programs to determine methods that exist in generic objects inheriting from Object

11.  Arrays  Definition: A table of variables accessed by index  Disadvantage: Arrays have a fixed lengh  ArrayList: A class for expandable arrays  Advantage: Removes array fixed length limitation  Disadvantage: Slower to access  Methods: add, clear, get, remove, size, set, isEmpty, removeRange, toArray, trimToSize  Instantiate: ArrayList data = new ArrayList ();

12.  Why do we need this?  We want to rotate our avatars  Java methods use radians  A radian is the radius distance around a circle  The radius goes around the circle 2π times (Circumference = 2πr)  360 degrees = 2π radians  Radians = π/180 Degrees  Degrees = 180/ π Radians

13.  Purpose: Enables complicated shapes that we can transform  Question: What is a transform?  It is an operation that alters the way the area displays  Examples: scale, rotate, move (translate)  Constructors: new Area() or new Area(Shape s)  Note: Java Polygon, Rectangle, etc. are Shape objects  Method to extend an area: area.add(Area anotherArea)  Perform a transform: area.transform(AffineTransform tx);  Draw an area: Graphics2D g2d= (Graphics2D)graphicsObject; g2d.draw(area); or g2d.fill(area);

14.  Definition: An affine transform is a manipulation of a figure so parallel lines remain parallel  Make a transform object: AffineTransform transform = new AffineTransform();  Edit the transform object; enable translation of coordinates, scaling, and rotation transform.translate(300, 300); transform.rotate(degrees * Math.PI/180.); transform.scale(0.5, 0.5);  Notes  Once the AffineTransform object is configured with multiple transforms, it is ready to be used by Area objects  Important: The last translation is done first  The AffineTransform class has static transform methods if only one type of transform is needed

15. int[] x = {-100,0,100}, y = {-100,0,-100}, r = {-100,0,100}, s = {100,0,100}; Area area=new Area(new Polygon(x,y,3)), area2=new Area(new Polygon(r,s,3)); area.add(area2); AffineTransform tx = new AffineTransform(); tx.translate(100,100); tx.scale(0.5, 0.5); tx.rotate(30 * Math.PI / 180.); area.transform(tx); area2.transform(tx); Graphics2D g2D = (Graphics2D)g; g2D.setColor(Color.RED); g2D.fill(area); area.intersect(area2); g2D.setColor(Color.GREEN); g2D.fill(area2);

16. 1. Design the figure 2. Determine the corresponding Java classes that inherit from Shape (ex: Rectangle, Polygon, Arc2D.Float, Ellipse2D.Float, etc.) 3. Create the shape objects and call the parent Sprite add method 4. Sprite parent class inherits from the Area class. Its add method: a. instantiates an Area object using the Shape object parameter b. calls the super add method with the object just instantiated c. adds the instantiated Area object and color object parameter to the two respective array lists. 5. The Area class has a getBounds, intersects, and transform methods that we will be using in this and future labs