9_Java_继承与多态

继承

面向对象程序设计语言有三大特性：封装、继承和多态性。继承是面向对象语言的重要特征之一，没有继承的语言只能被称作“使用对象的语言”。继承是非常简单而强大的设计思想，它提供了我们代码重用和程序组织的有力工具。

类是规则，用来制造对象的规则。我们不断地定义类，用定义的类制造一些对象。类定义了对象的属性和行为，就像图纸决定了房子要盖成什么样子。

一张图纸可以盖很多房子，它们都是相同的房子，但是坐落在不同的地方，会有不同的人住在里面。假如现在我们想盖一座新房子，和以前盖的房子很相似，但是稍微有点不同。任何一个建筑师都会拿以前盖的房子的图纸来，稍加修改，成为一张新图纸，然后盖这座新房子。所以一旦我们有了一张设计良好的图纸，我们就可以基于这张图纸设计出很多相似但不完全相同的房子的图纸来。

基于已有的设计创造新的设计，就是面向对象程序设计中的继承。在继承中，新的类不是凭空产生的，而是基于一个已经存在的类而定义出来的。通过继承，新的类自动获得了基础类中所有的成员，包括成员变量和方法，包括各种访问属性的成员，无论是public还是private。当然，在这之后，程序员还可以加入自己的新的成员，包括变量和方法。显然，通过继承来定义新的类，远比从头开始写一个新的类要简单快捷和方便。继承是支持代码重用的重要手段之一。

类这个词有分类的意思，具有相似特性的东西可以归为一类。比如所有的鸟都有一些共同的特性：有翅膀、下蛋等等。鸟的一个子类，比如鸡，具有鸟的所有的特性，同时又有它自己的特性，比如飞不太高等等；而另外一种鸟类，比如鸵鸟，同样也具有鸟类的全部特性，但是又有它自己的明显不同于鸡的特性。

如果我们用程序设计的语言来描述这个鸡和鸵鸟的关系问题，首先有一个类叫做“鸟”，它具有一些成员变量和方法，从而阐述了鸟所应该具有的特征和行为。然后一个“鸡”类可以从这个“鸟”类派生出来，它同样也具有“鸟”类所有的成员变量和方法，然后再加上自己特有的成员变量和方法。无论是从“鸟”那里继承来的变量和方法，还是它自己加上的，都是它的变量和方法。

资料库

和前面的记事本一样，ArrayList里面放的是String ，而资料库放的是 CD 是自己定义的类；

//Datebase.java
package dome;

import java.util.ArrayList;

public class Datebase {
    
    
	private ArrayList<CD> listCD = new ArrayList<>();
	public void add(CD cd)
	{
    
    
		listCD.add(cd);
	}
	public void list()
	{
    
    
		for(CD v : listCD)
		{
    
    
			v.print();
		}
	}
	public static void main(String[] args) {
    
    
		// TODO Auto-generated method stub
		Datebase db = new Datebase();
		db.add(new CD("abc", "abc", 4, 60, "..."));
		db.add(new CD("def", "def", 6, 90, "..."));
		db.list();
	}

}

//CD.java
package dome;

public class CD {
    
    
	private String title;
	private String artist;
	private int numoTracks;
	private int playingTime;
	private boolean gotIt = false;
	private String comment;
	  
	public CD(String title, String artist, int numoTracks, int playingTime, String comment) {
    
    
		super();
		this.title = title;
		this.artist = artist;
		this.numoTracks = numoTracks;
		this.playingTime = playingTime;
		this.comment = comment;
	}

	public static void main(String[] args) {
    
    
		// TODO Auto-generated method stub

	}

	public void print() {
    
    
		// TODO Auto-generated method stub
		System.out.println(title + ":" + artist);
	}

}

当定义好了成员变量的时候，可以让系统为我们创建构造函数，省去麻烦；

便会生成一个构造函数了

package dome;

public class CD {
    
    
	private String title;
	private String artist;
	private int numoTracks;
	private int playingTime;
	private boolean gotIt = false;
	private String comment;
	  
	public CD(String title, String artist, int numoTracks, int playingTime, String comment) {
    
    
		super();
		this.title = title;
		this.artist = artist;
		this.numoTracks = numoTracks;
		this.playingTime = playingTime;
		this.comment = comment;
	}

	public static void main(String[] args) {
    
    
		// TODO Auto-generated method stub

	}

}

和前面一样，我们在CD 的基础上，需要放 DVD类型，那就需要重新定义一个

//Datebase.java
private ArrayList<DVD> listDVD = new ArrayList<>();

现在就是 Datebase 下面有两个 容器，一个CD 另一个 DVD；

package dome;

import java.util.ArrayList;

public class Datebase {
    
    
	private ArrayList<CD> listCD = new ArrayList<>();
	private ArrayList<DVD> listDVD = new ArrayList<>();
	public void add(CD cd)
	{
    
    
		listCD.add(cd);
	}
	public void add(DVD dvd)
	{
    
    
		listDVD.add(dvd);
	}
	public void list()
	{
    
    
		for(CD v : listCD)
		{
    
    
			v.print();
		}
		for(DVD v : listDVD)
		{
    
    
			v.print();
		}
	}
	public static void main(String[] args) {
    
    
		// TODO Auto-generated method stub
		Datebase db = new Datebase();
		db.add(new CD("abc", "abc", 4, 60, "..."));
		db.add(new CD("def", "def", 6, 90, "..."));
		db.add(new DVD("a", "a", 7, "..."));
		db.list();
	}

}

//CD.java
package dome;

public class CD {
    
    
	private String title;
	private String artist;
	private int numoTracks;
	private int playingTime;
	private boolean gotIt = false;
	private String comment;
	  
	public CD(String title, String artist, int numoTracks, int playingTime, String comment) {
    
    
		super();
		this.title = title;
		this.artist = artist;
		this.numoTracks = numoTracks;
		this.playingTime = playingTime;
		this.comment = comment;
	}

	public static void main(String[] args) {
    
    
		// TODO Auto-generated method stub

	}

	public void print() {
    
    
		// TODO Auto-generated method stub
		System.out.println("CD:" + title + ":" + artist);
	}

}

//DVD.java
package dome;

public class DVD {
    
    
	private String title;
	private String director;
	private int playingTime;
	private boolean gotIt = false;
	private String comment;
	
	public static void main(String[] args) {
    
    
		// TODO Auto-generated method stub

	}

	public void print() {
    
    
		// TODO Auto-generated method stub
		System.out.println("DVD:" + title + ":" + director);
	}

	public DVD(String title, String director, int playingTime, String comment) {
    
    
		super();
		this.title = title;
		this.director = director;
		this.playingTime = playingTime;
		this.comment = comment;
	}

}

//Stduent.java
package stduent;

import java.util.ArrayList;

public class Stduent {
    
    
	private ArrayList<STD> listSTD = new ArrayList<>();
	public void add(STD std)
	{
    
    
		listSTD.add(std);
	}
	public void list()
	{
    
    
		for(STD v : listSTD)
		{
    
    
			v.print();
		}
	}
	public static void main(String[] args) {
    
    
		// TODO Auto-generated method stub
		Stduent db = new Stduent();
		db.add(new STD("DL", "语文", 100));
		db.add(new STD("CLL", "数学", 100));
		db.list();
	}

}

//STD.java
package stduent;

public class STD {
    
    
	private String name;
	private String name_b;
	private int score;
	
	public STD(String name, String name_b, int score) {
    
    
		super();
		this.name = name;
		this.name_b = name_b;
		this.score = score;
	}

	public static void main(String[] args) {
    
    
		// TODO Auto-generated method stub

	}

	public void print() {
    
    
		// TODO Auto-generated method stub
		System.out.println(name + ":" + name_b + ":" + score);
	}

}

继承

CD 和 DVD有一些相似，有重复的地方
CD和DVD 是Item的子类，Datebase和Item有联系

CD和DVD得到了Item 的所有东西，子类得到了父类的所有东西，a extends b，就是a继承了b 的所有东西，同时 a 还可以自己有东西；

//Datebase.java
package dome;

import java.util.ArrayList;

public class Datebase {
    
    
//	private ArrayList<CD> listCD = new ArrayList<>();
//	private ArrayList<DVD> listDVD = new ArrayList<>();
	private ArrayList<Item> listItem = new ArrayList<>();
//	public void add(CD cd)
//	{
    
    
//		listCD.add(cd);
//	}
//	public void add(DVD dvd)
//	{
    
    
//		listDVD.add(dvd);
//	}
	public void add(Item item)
	{
    
    
		listItem.add(item);
	}
	public void list()
	{
    
    
//		for(CD v : listCD)
//		{
    
    
//			v.print();
//		}
//		for(DVD v : listDVD)
//		{
    
    
//			v.print();
//		}
		for(Item v : listItem)
		{
    
    
			v.print();
		}
	}
	public static void main(String[] args) {
    
    
		// TODO Auto-generated method stub
		Datebase db = new Datebase();
		db.add(new CD("abc", "abc", 4, 60, "..."));
		db.add(new CD("def", "def", 6, 90, "..."));
		db.add(new DVD("a", "a", 7, "..."));
		db.list();
	}

}

//CD.java
package dome;

public class CD extends Item{
    
    
	private String title;
	private String artist;
	private int numoTracks;
	private int playingTime;
	private boolean gotIt = false;
	private String comment;
	  
	public CD(String title, String artist, int numoTracks, int playingTime, String comment) {
    
    
		super();
		this.title = title;
		this.artist = artist;
		this.numoTracks = numoTracks;
		this.playingTime = playingTime;
		this.comment = comment;
	}

	public static void main(String[] args) {
    
    
		// TODO Auto-generated method stub
		CD cd = new CD("xx", "xx", 4, 5, "...");
		cd.print();
	}

	public void print() {
    
    
		// TODO Auto-generated method stub
		System.out.println("CD:" + title + ":" + artist);
	}

}

//DVD.java
package dome;

public class DVD extends Item{
    
    
	private String title;
	private String director;
	private int playingTime;
	private boolean gotIt = false;
	private String comment;
	
	public static void main(String[] args) {
    
    
		// TODO Auto-generated method stub

	}

	public void print() {
    
    
		// TODO Auto-generated method stub
		System.out.println("DVD:" + title + ":" + director);
	}

	public DVD(String title, String director, int playingTime, String comment) {
    
    
		super();
		this.title = title;
		this.director = director;
		this.playingTime = playingTime;
		this.comment = comment;
	}

}

//Item.java
package dome;

public class Item {
    
    

	public void print() {
    
    
		// TODO Auto-generated method stub
		System.out.println("Item");
	}

}

子类和父类的关系

对理解继承来说，最重要的事情是，知道哪些东西被继承了，或者说，子类从父类那里得到了什么。答案是：所有的东西，所有的父类的成员，包括变量和方法，都成为了子类的成员，除了构造方法。构造方法是父类所独有的，因为它们的名字就是类的名字，所以父类的构造方法在子类中不存在。除此之外，子类继承得到了父类所有的成员。
但是得到不等于可以随便使用。每个成员有不同的访问属性，子类继承得到了父类所有的成员，但是不同的访问属性使得子类在使用这些成员时有所不同：有些父类的成员直接成为子类的对外的界面，有些则被深深地隐藏起来，即使子类自己也不能直接访问。下表列出了不同访问属性的父类成员在子类中的访问属性：

public的成员直接成为子类的public的成员，protected的成员也直接成为子类的protected的成员。Java的protected的意思是包内和子类可访问，所以它比缺省的访问属性要宽一些。而对于父类的缺省的未定义访问属性的成员来说，他们是在父类所在的包内可见，如果子类不属于父类的包，那么在子类里面，这些缺省属性的成员和private的成员是一样的：不可见。父类的private的成员在子类里仍然是存在的，只是子类中不能直接访问。我们不可以在子类中重新定义继承得到的成员的访问属性。如果我们试图重新定义一个在父类中已经存在的成员变量，那么我们是在定义一个与父类的成员变量完全无关的变量，在子类中我们可以访问这个定义在子类中的变量，在父类的方法中访问父类的那个。尽管它们同名但是互不影响。

在构造一个子类的对象时，父类的构造方法也是会被调用的，而且父类的构造方法在子类的构造方法之前被调用。在程序运行过程中，子类对象的一部分空间存放的是父类对象。因为子类从父类得到继承，在子类对象初始化过程中可能会使用到父类的成员。所以父类的空间正是要先被初始化的，然后子类的空间才得到初始化。在这个过程中，如果父类的构造方法需要参数，如何传递参数就很重要了。

super

调用父类的构造器，区分有参数；有参数的super直接在父类寻找那个带参数的构造器，而没有super的，也会去父类寻找不带参数的构造器；否则出错；

//Item.java
package dome;

public class Item {
    
    
	private String title;
	
	public Item()
	{
    
    
		
	}
	public Item(String title) {
    
    
		super();
		this.title = title;
	}

	public void print() {
    
    
		// TODO Auto-generated method stub
		System.out.println("Item");
	}

}

//DVD.java
package dome;

public class DVD extends Item{
    
    
	private String title;
	private String director;
	private int playingTime;
	private boolean gotIt = false;
	private String comment;
	
	public static void main(String[] args) {
    
    
		// TODO Auto-generated method stub
		DVD dvd = new DVD("1", "1", 1, "...");
		dvd.print();
	}

	public void print() {
    
    
		// TODO Auto-generated method stub
		System.out.println("DVD:" + title + ":" + director);
	}

	public DVD(String title, String director, int playingTime, String comment) {
    
    
		// super();
		this.title = title;
		this.director = director;
		this.playingTime = playingTime;
		this.comment = comment;
	}

}

//CD.java
package dome;

public class CD extends Item{
    
    
	private String artist;
	private int numoTracks;
	private int playingTime;
	private boolean gotIt = false;
	private String comment;
	  
	public CD(String title, String artist, int numoTracks, int playingTime, String comment) {
    
    
		super(title);
		this.artist = artist;
		this.numoTracks = numoTracks;
		this.playingTime = playingTime;
		this.comment = comment;
	}

	public static void main(String[] args) {
    
    
		// TODO Auto-generated method stub
		CD cd = new CD("xx", "xx", 4, 5, "...");
		cd.print();
	}

	public void print() {
    
    
		// TODO Auto-generated method stub
		System.out.println("CD:" + title + ":" + artist);
	}

}

关于super

关于super()
能在一个构造函数里调用两次super()吗？ 不能，只能调用一次
super()必须在构造函数的第一行吗？必须在第一行，否则会报错

子类和父类的关系—2

整合CD和DVD相同的东西；

//Datebase.java
package dome;

import java.util.ArrayList;

public class Datebase {
    
    
//	private ArrayList<CD> listCD = new ArrayList<>();
//	private ArrayList<DVD> listDVD = new ArrayList<>();
	private ArrayList<Item> listItem = new ArrayList<>();
//	public void add(CD cd)
//	{
    
    
//		listCD.add(cd);
//	}
//	public void add(DVD dvd)
//	{
    
    
//		listDVD.add(dvd);
//	}
	public void add(Item item)
	{
    
    
		listItem.add(item);
	}
	public void list()
	{
    
    
//		for(CD v : listCD)
//		{
    
    
//			v.print();
//		}
//		for(DVD v : listDVD)
//		{
    
    
//			v.print();
//		}
		for(Item v : listItem)
		{
    
    
			v.print();
		}
	}
	public static void main(String[] args) {
    
    
		// TODO Auto-generated method stub
		Datebase db = new Datebase();
		db.add(new CD("abc", "abc", 4, 60, "..."));
		db.add(new CD("def", "def", 6, 90, "..."));
		db.add(new DVD("a", "a", 7, "..."));
		db.list();
	}

}

//Item.java
package dome;

public class Item {
    
    
	private String title;
	private int playingTime;
	private boolean gotIt = false;
	private String comment;
	public Item()
	{
    
    
		
	}
	public Item(String title, int playingTime, boolean gotIt, String comment) {
    
    
		super();
		this.title = title;
		this.playingTime = playingTime;
		this.gotIt = gotIt;
		this.comment = comment;
	}


	public void print() {
    
    
		// TODO Auto-generated method stub
		System.out.print(title);
	}

}

//CD.java
package dome;

public class CD extends Item{
    
    
	private String artist;
	private int numoTracks;
	  
	public CD(String title, String artist, int numoTracks, int playingTime, String comment) {
    
    
		super(title, playingTime, false, comment);
		this.artist = artist;
		this.numoTracks = numoTracks;
	}

	public static void main(String[] args) {
    
    
		// TODO Auto-generated method stub
		CD cd = new CD("xx", "xx", 4, 5, "...");
		cd.print();
	}

	public void print() {
    
    
		// TODO Auto-generated method stub
		System.out.print("CD:");
		super.print();
		System.out.println(":" + artist);
	}

}

//DVD.java
package dome;

import javax.swing.OverlayLayout;

public class DVD extends Item{
    
    
	private String director;
	
	public static void main(String[] args) {
    
    
		// TODO Auto-generated method stub
		DVD dvd = new DVD("1", "1", 1, "...");
		dvd.print();
	}

	public void print() {
    
    
		// TODO Auto-generated method stub
		System.out.print("DVD:");
		super.print();
		System.out.println(":" + director);
	}

	public DVD(String title, String director, int playingTime, String comment) {
    
    
		super(title, playingTime, false, comment);
		this.director = director;
	}

}

多态变量和向上造型

多态变量

类定义了类型,DVD类所创建的对象的类型就是DVD。类可以有子类,所以由那些类定义的类型可以有子类型。在DoME的例子中,DVD类型就是Item类型的子类型。

子类型类似于类的层次,类型也构成了类型层次。子类所定义的类型是其超类的类型的子类型。

当把一个对象赋值给一个变量时,对象的类型必须与变量的类型相匹配,如:

Car myCar = new Car(); 

是一个有效的赋值,因为Car类型的对象被赋值给声明为保存Car类型对象的变量。但是由于引入 了继承,这里的类型规则就得叙述得更完整些:

一个变量可以保存其所声明的类型或该类型的任何子类型。

对象变量可以保存其声明的类型的对象,或该类型的任何子类型的对象。

Java中保存对象类型的变量是多态变量。“多态”这个术语(字面意思是许多形态)是指一个变量可以保存不同类型(即其声明的类型或任何子类型)的对象。

子类和子类型

• 类定义了类型
• 子类定义了子类型
• 子类的对象可以被当作父类的对象来使用
• • 赋值给父类的对象
• • 传递给需要父类对象的函数
• • 放进存放父类对象的容器里

子类型与赋值

子类和参数传递

子类型和容器

多态变量

• Java的对象变量是多态的，他们能保存不止一种类型的变量；
• 它们可以保存的是声明类型的对象，或声明类型的子类的对象；
• 当把子类的对象赋值给父类的变量的时候，就发生了向上造型；

item就是一个多态变量；CD交给Item就是向上造型；

造型：把一个类型的对象赋值给另一个类型的变量；

造型 cast

• 子类的对象可以赋值给父类的变量
• • Java中不存在对象对对象的赋值
• 父类的对象不能赋值给子类的变量

Vechicle cll;
Car v = new Car();
cll = v;
v = cll;（编译错误）

• 可以用造型：

v = (Car)cll;
//只有当cll这个变量实际管理的是Car才可以

Item item = new Item("a", 8, false, "...");
CD cd = new CD("a", "b", 3, 5, "...");
item = cd;
cd =item;//错误
cd = (CD)item;//强制转换

造型

• 用括号围起类型放在值的前面
• 对象本身并没有发生任何变化
• 所以不是“类型转换”
• 运行时有机制来检查这样的转化是否合理
• ClassCastException

向上造型

• 拿一个子类的对象，当作父类的对象来用
• 向上造型时默认的，不需要运算符
• 向上造型总是安全的

多态

如果子类的方法覆盖了父类的方法，我们也说父类的那个方法在子类有了新的版本或者新的实现。覆盖的新版本具有与老版本相同的方法签名：相同的方法名称和参数表。因此，对于外界来说，子类并没有增加新的方法，仍然是在父类中定义过的那个方法。不同的是，这是一个新版本，所以通过子类的对象调用这个方法，执行的是子类自己的方法。

覆盖关系并不说明父类中的方法已经不存在了，而是当通过一个子类的对象调用这个方法时，子类中的方法取代了父类的方法，父类的这个方法被“覆盖”起来而看不见了。而当通过父类的对象调用这个方法时，实际上执行的仍然是父类中的这个方法。注意我们这里说的是对象而不是变量，因为一个类型为父类的变量有可能实际指向的是一个子类的对象。

当调用一个方法时，究竟应该调用哪个方法，这件事情叫做绑定。绑定表明了调用一个方法的时候，我们使用的是哪个方法。绑定有两种：一种是早绑定，又称静态绑定，这种绑定在编译的时候就确定了；另一种是晚绑定，即动态绑定。动态绑定在运行的时候根据变量当时实际所指的对象的类型动态决定调用的方法。Java缺省使用动态绑定。

函数调用的绑定

• 当通过对象变量调用函数的时候，调用那个函数这件事情叫做绑定
• • 静态绑定：根据变量的声明类型来决定
• • 动态绑定：根据变量的动态类型来决定
• 在成员函数中调用其他成员函数也是通过this这个对象变量来调用的

覆盖 override

• 子类和父类中存在名称和参数表完全相同的函数，这一对函数构成覆盖关系
• 通过父类的变量调用存在覆盖关系的函数时，会调用变量当时所管理的对象所属的类的函数

类型系统

OBJECT 类

Object类的函数

- toString()
- equals()

做自己的toString()

package dome;

public class CD extends Item{
    
    
	private String artist;
	private int numoTracks;
	  
	public CD(String title, String artist, int numoTracks, int playingTime, String comment) {
    
    
		super(title, playingTime, false, comment);
		this.artist = artist;
		this.numoTracks = numoTracks;
	}
	
	@Override
	public String toString() {
    
    
		return "CD [artist=" + artist + ", numoTracks=" + numoTracks + "]";
	}

	public static void main(String[] args) {
    
    
		// TODO Auto-generated method stub
		CD cd = new CD("xx", "xx", 4, 5, "...");
		System.out.println(cd);//直接输出 需要toString()
		cd.print();
	}

	public void print() {
    
    
		// TODO Auto-generated method stub
		System.out.print("CD:");
		super.print();
		System.out.println(":" + artist);
	}

}

做自己的equals

package dome;

public class CD extends Item{
    
    
	private String artist;
	private int numoTracks;
	  
	public CD(String title, String artist, int numoTracks, int playingTime, String comment) {
    
    
		super(title, playingTime, false, comment);
		this.artist = artist;
		this.numoTracks = numoTracks;
	}
	
	@Override
	public String toString() {
    
    
		return "CD [artist=" + artist + ", numoTracks=" + numoTracks + "]";
	}
	
	@Override
	public boolean equals(Object obj) {
    
    
		// TODO Auto-generated method stub
		CD cc = (CD)obj;
		return artist.equals(cc.artist);//这样会在同一个类里比较
	}

	public static void main(String[] args) {
    
    
		// TODO Auto-generated method stub
		CD cd = new CD("xx", "xx", 4, 5, "...");
		CD cd1 = new CD("xx", "xx", 4, 5, "...");
		System.out.println(cd.equals(cd1));
//		System.out.println(cd);
//		cd.print();
	}

	public void print() {
    
    
		// TODO Auto-generated method stub
		System.out.print("CD:");
		super.print();
		System.out.println(":" + artist);
	}

}
//true

增加新的媒体类型

实现这个需求：

//Datebase.java
package dome;

import java.util.ArrayList;

public class Datebase {
    
    
	private ArrayList<Item> List = new ArrayList<>();
	public void add(Item item)
	{
    
    
		List.add(item);
	}
	public void printlist()
	{
    
    
		for(Item v : List)
		{
    
    
			v.print();
			System.out.println();
		}
	}
	public static void main(String[] args) {
    
    
		// TODO Auto-generated method stub
		CD cd = new CD("CD", 0, true, "xxxx", "cd", 0);
		DVD dvd = new DVD("DVD", 0, true, "xxxx", "dvd");
		VideoGame videogame = new VideoGame("Video", 0, true, "xxxx", 0, "2.0");
		BoardGame boardgame = new BoardGame("Board", 0, true, "xxxx", 0, "4.0", 0);
		Datebase db = new Datebase();
		db.add(cd);
		db.add(dvd);
		db.add(videogame);
		db.add(boardgame);
		db.printlist();
	}

}

//Item.java
package dome;

public class Item {
    
    
	private String title;
	private int playingTime;
	private boolean gotlt;
	private String  comment;
	
	public Item(String title, int playingTime, boolean gotlt, String comment) {
    
    
		super();
		this.title = title;
		this.playingTime = playingTime;
		this.gotlt = gotlt;
		this.comment = comment;
	}
	public void print()
	{
    
    
		System.out.print(title + " : ");
	}
	public static void main(String[] args) {
    
    
		// TODO Auto-generated method stub

	}

}

//CD.java
package dome;

public class CD extends Item {
    
    
	private String artist;
	private int numberOfTracks;
	
	public CD(String title, int playingTime, boolean gotlt, String comment, String artist, int numberOfTracks) {
    
    
		super(title, playingTime, gotlt, comment);
		// TODO Auto-generated constructor stub
		this.artist = artist;
		this.numberOfTracks = numberOfTracks;
	}
	
	@Override
	public void print() {
    
    
		// TODO Auto-generated method stub
		System.out.print(artist + " : ");
		super.print();
		System.out.print(numberOfTracks);
	}

	public static void main(String[] args) {
    
    
		// TODO Auto-generated method stub

	}

}

//DVD.java
package dome;

public class DVD extends Item {
    
    
	private String director;
	
	public DVD(String title, int playingTime, boolean gotlt, String comment, String director) {
    
    
		super(title, playingTime, gotlt, comment);
		// TODO Auto-generated constructor stub
		this.director = director;
	}
	
	@Override
	public void print() {
    
    
		// TODO Auto-generated method stub
		System.out.print(director + " : ");
		super.print();
	}

	public static void main(String[] args) {
    
    
		// TODO Auto-generated method stub

	}

}

//Game.java
package dome;

public class Game extends Item {
    
    
	private int numberOfPlayers;
	
	public Game(String title, int playingTime, boolean gotlt, String comment, int numberOfPlayers) {
    
    
		super(title, playingTime, gotlt, comment);
		// TODO Auto-generated constructor stub
		this.numberOfPlayers = numberOfPlayers;
	}
	
	@Override
	public void print() {
    
    
		// TODO Auto-generated method stub
		super.print();
		System.out.print(numberOfPlayers + " : ");
	}

	public static void main(String[] args) {
    
    
		// TODO Auto-generated method stub

	}

}

//VideoGame.java
package dome;

public class VideoGame extends Game {
    
    
	private String platform;
	
	public VideoGame(String title, int playingTime, boolean gotlt, String comment, int numberOfPlayers, String platform) {
    
    
		super(title, playingTime, gotlt, comment, numberOfPlayers);
		// TODO Auto-generated constructor stub
		this.platform = platform;
	}
	
	@Override
	public void print() {
    
    
		// TODO Auto-generated method stub
		super.print();
		System.out.print(platform);
	}

	public static void main(String[] args) {
    
    
		// TODO Auto-generated method stub

	}

}

//BoardGame.java
package dome;

public class BoardGame extends Game {
    
    
	private String platform;
	private int num;
	
	public BoardGame(String title, int playingTime, boolean gotlt, String comment, int numberOfPlayers, String platform, int num) {
    
    
		super(title, playingTime, gotlt, comment, numberOfPlayers);
		// TODO Auto-generated constructor stub
		this.platform = platform;
		this.num = num;
	}
	
	@Override
	public void print() {
    
    
		// TODO Auto-generated method stub
		super.print();
		System.out.print(platform + " " + num);
	}

	public static void main(String[] args) {
    
    
		// TODO Auto-generated method stub

	}

}