Inheritance

xxxxxxxxxx
 
public class Course {
  public void printName() {
    System.out.println("Some course");
  }
}
public class BestCourse extends Course {
  public void printName() {
    System.out.println("CS 125");
  }
}
public class Example {
  public static void main(String[] unused) {
    Course course = new Course();
    course.printName();
    BestCourse bestCourse = new BestCourse();
    bestCourse.printName();
  }
}

Inheritance
> Click or hit Control-Enter to run Example.main above

Overall the class did well on the midterm–congratulations!

I’ve released two example programming questions to the HW125 problem set.

I’d mainly consider how you did on the programming questions:

3/3: Great job.
2/3: You did well, but plan to continue working hard for the rest of the semester.
1/3: Something about how you are preparing for exams needs to change…
0/3: Please talk to a course staff member.

If you don’t give up and keep working hard, you can succeed in CS 125.

Data from Fall 2019:

Students that scored below 60 on the midterm…
…ended up with a median score of 88.3 in the class overall.
Students that scored below 40 on the midterm…
…ended up with an 83 in the class overall.
How? Get the points for participation, for the homework, and for the MP.

About the midterm, grading, or anything in particular?

						 						public class Course { 					
						 						  public static int count = 0; 					
						 						  public static void printName() { 					
						 						    System.out.println("Name"); 					
						 						  } 					
						 						} 					
						 						public class Example { 					
						 						  public static void main(String[] unused) { 					
						 						    // We can call printName without creating an instance 					
						 						    Course.printName(); 					
						 						    // We can increment count without creating an instance 					
						 						    Course.count++; 					
						 						  } 					
						 						}

static methods and variables belong to the class, not to a specific instance.

						 						public class Course { 					
						 						  public static void printName() { 					
						 						    System.out.println("Name"); 					
						 						  } 					
						 						} 					
						 						public class Example { 					
						 						  public static void main(String[] unused) { 					
						 						    // This works 					
						 						    Course.printName(); 					
						 						    // This also works 					
						 						    Course CS125 = new Course(); 					
						 						    CS125.printName(); 					
						 						  } 					
						 						}

static methods are called directly on the class, rather than on an instance
…but they can be called on the instance as well.

						 						public class Course { 					
						 						  public String name; 					
						 						  public static void printName() { 					
						 						    // This doesn't work 					
						 						    System.out.println(name); 					
						 						  } 					
						 						}

static methods can be called without an instance, and so can’t use this or access instance variables.

						 						public class Course { 					
						 						  public static int count = 0; 					
						 						  public void printCount() { 					
						 						    System.out.println(count); 					
						 						  } 					
						 						} 					
						 						public class Example { 					
						 						  public static void main(String[] unused) { 					
						 						    Course CS125 = new Course(); 					
						 						    Course CS225 = new Course(); 					
						 						    Course.count++; 					
						 						    CS125.printCount(); 					
						 						    CS225.printCount(); 					
						 						  } 					
						 						}

static variables are shared by all instances of a given class

public and private also work on static variables and methods

public: the (static) variable can be read or written by anyone
private: the (static) variable can only read or written by methods defined on that class
public: the (static) method can be called by anyone
private: the (static) method can only be called by other methods on that class

We can also use a class method to be able to return null when creating a new object if invalid parameters are supplied.

xxxxxxxxxx
 
public class Storage {
  private int[] storage;
}
public class Example {
  public static void main(String[] unused) {
  }
}

> Click or hit Control-Enter to run Example.main above

						 						class Example { 					
						 						  /** The number of hours of sleep you should get per night. */ 					
						 						  public static final int HOURS_PER_NIGHT = 8; 					
						 						  ... 					
						 						}

In Java a final variable cannot be modified.

You usually see this done to establish useful constant values—which can be either public or private

​x
 
public class Example {
  public static final int HOURS_PER_NIGHT = 8;
​
  public static void main(String[] unused) {
    HOURS_PER_NIGHT = 4;
    System.out.println(HOURS_PER_NIGHT);
    HOURS_PER_NIGHT = 2;
    System.out.println(HOURS_PER_NIGHT);
    // I will never change!
  }
}

> Click or hit Control-Enter to run Example.main above

xxxxxxxxxx
 
// Why does this work?
public class Example {
  public static void main(String[] unused) {
    Example example = new Example();
    System.out.println(example.toString());
  }
}

> Click or hit Control-Enter to run Example.main above

						 						public class Pet { 					
						 						  protected String name; 					
						 						  protected String type; 					
						 						 					
						 						  public void printMe() { 					
						 						    System.out.println("I'm a " + type + " named " + name); 					
						 						  } 					
						 						} 					
						 						public class Dog extends Pet { 					
						 						  Dog(String setName) { 					
						 						    name = setName; 					
						 						    type = "Dog"; 					
						 						  } 					
						 						} 					
						 						Dog chuchu = new Dog("Chuchu"); 					
						 						chuchu.printMe();

Java allows objects to inherit state and behavior from another class.

						 						public class Pet { } 					
						 						public class Dog extends Pet { } 					
						 						public class Cat extends Pet { }

In Java we establish inheritance using the extends keyword.

Dog extends Pet and so inherits state and behavior from Pet
Cat also extends Pet and so also inherits state and behavior from Pet
We sometimes call Pet Dog's and Cat's parent class
We sometimes call Dog and Cat Pet's children

						 						public class Pet { } 					
						 						public class Dog extends Pet { } 					
						 						public class Mutt extends Dog { }

In Java we can have have multiple levels of inheritance.

Dog extends Pet and so inherits state and behavior from Pet
Mutt extends Dog and so inherits state and behavior from Dog and Pet
We sometimes call Pet and Dog Mutt's ancestors
We sometimes call Dog and Mutt Pet's descendants

						 						public class Pet { 					
						 						  public String name; // Anyone can set me 					
						 						  private String secret; // Only I can set this value 					
						 						  protected String type; // My descendants can use this value 					
						 						} 					
						 						public class Dog extends Pet { 					
						 						  Dog(String setName) { 					
						 						    name = setName; 					
						 						    type = "Dog"; 					
						 						  } 					
						 						}

public: the variable can be read or written by anyone
private: the variable can only read or written by methods defined on that class
protected: the variable can only read or written by methods defined on that class or its descendants

xxxxxxxxxx
 
public class Pet {
  protected String name;
  protected String type;
​
  public void printMe() {
    System.out.println("I'm a " + type + " named " + name);
  }
}
public class Dog extends Pet {
  Dog(String setName) {
    name = setName;
    type = "Dog";
  }
}
public class Example {
  public static void main(String[] unused) {
    Dog chuchu = new Dog("Chuchu");
    chuchu.printMe();
  }
}

> Click or hit Control-Enter to run Example.main above

						 						public class Pet { 					
						 						  protected String name; 					
						 						} 					
						 						public class Dog extends Pet { 					
						 						  Dog(String setName) { 					
						 						    name = setName; 					
						 						  } 					
						 						} 					
						 						public class Example { 					
						 						  public static void main(String[] unused) { 					
						 						    Dog chuchu = new Dog("Chuchu"); 					
						 						    chuchu.name = "Xyz"; // This works... 					
						 						  } 					
						 						}

protected: the variable can read or written by methods defined on that class or its descendants… in any package
protected: the variable can also be read and written by any method in the same package

Variables:

public: the variable can be read or written by anyone
private: the variable can only read or written by methods defined on that class
protected: the variable can be read or written by methods defined on any descendant of that class in any package or any class in the same package

Methods:

public: the method can be called by anyone
private: the method can only be called by other methods on that class
protected: the method can be called by other methods defined on any descendant of that class in any package or any class in the same package

No class this Friday (2/28)! Enjoy the morning off.
I have office hours from 4–5PM today. Please stop by and say hi!

Midterm Review

Interpreting Your Midterm Result

There Is Hope

Questions?

Review: The `static` Keyword

Review: `static` Methods

Review: `static` Methods and `this`

Review: `static` Variables

Review: `static` and `public`

`static` Object Creation Method

`final` and Constants

Questions About `static` or `final`?

Inheritance

Inheritance Terminology

More Inheritance Terminology

`protected`

The Dirty Truth About `protected`

`public`, `private`, and `protected`

Announcements

	public class Course {
	public static int count = 0;
	public static void printName() {
	System.out.println("Name");
	}
	}
	public class Example {
	public static void main(String[] unused) {
	// We can call printName without creating an instance
	Course.printName();
	// We can increment count without creating an instance
	Course.count++;
	}
	}

	public class Course {
	public String name;
	public static void printName() {
	// This doesn't work
	System.out.println(name);
	}
	}

	public class Course {
	public static int count = 0;
	public void printCount() {
	System.out.println(count);
	}
	}
	public class Example {
	public static void main(String[] unused) {
	Course CS125 = new Course();
	Course CS225 = new Course();
	Course.count++;
	CS125.printCount();
	CS225.printCount();
	}
	}

	class Example {
	/** The number of hours of sleep you should get per night. */
	public static final int HOURS_PER_NIGHT = 8;
	...
	}

	public class Pet {
	protected String name;
	protected String type;

	public void printMe() {
	System.out.println("I'm a " + type + " named " + name);
	}
	}
	public class Dog extends Pet {
	Dog(String setName) {
	name = setName;
	type = "Dog";
	}
	}
	Dog chuchu = new Dog("Chuchu");
	chuchu.printMe();

	public class Pet { }
	public class Dog extends Pet { }
	public class Cat extends Pet { }

	public class Pet { }
	public class Dog extends Pet { }
	public class Mutt extends Dog { }

	public class Pet {
	public String name; // Anyone can set me
	private String secret; // Only I can set this value
	protected String type; // My descendants can use this value
	}
	public class Dog extends Pet {
	Dog(String setName) {
	name = setName;
	type = "Dog";
	}
	}

Midterm Review

Interpreting Your Midterm Result

There Is Hope

Questions?

Review: The static Keyword

Review: static Methods

Review: static Methods and this

Review: static Variables

Review: static and public

static Object Creation Method

final and Constants

Questions About static or final?

Inheritance

Inheritance Terminology

More Inheritance Terminology

protected

The Dirty Truth About protected

public, private, and protected

Announcements

Review: The `static` Keyword

Review: `static` Methods

Review: `static` Methods and `this`

Review: `static` Variables

Review: `static` and `public`

`static` Object Creation Method

`final` and Constants

Questions About `static` or `final`?

`protected`

The Dirty Truth About `protected`

`public`, `private`, and `protected`