面向对象技术实验指导.doc

面向对象技术实验指导
实验一：solitaire纸牌游戏
单人纸牌游戏，牌桌上有7个堆共28张牌，第一堆1张牌，第二堆2张，。。。第7堆7张，每一堆的第一张牌朝上，其他朝下。牌桌上还有4个suitpiles，一个deck card堆和一个discard card堆，布局如下（参考windows的纸牌游戏）

设计一个简单的CardGames程序，运用面向对象封装、继承、抽象类、抽象方法、多态、动态绑定等概念。
实验二：排序
设计一个负责排序的程序包，实现多种排序算法，至少包括插入排序、冒泡排序和快速排序算法。
要求：
1.可以对任何简单类型和任意对象进行排序
2.可以支持升序、降序、字典排序等多种顺序要求
3.可以随意增加排序算法和顺序要求，保证其他程序不修改
4.减少程序代码中逻辑上的冗余
5.至少用两种方案编程实现该程序包，并说明两个方案的优缺点
6.提交设计报告，包括：使用UML设计的类图；主要程序代码说明；方案优缺点比较。

实验三：上述排序过程演示
要求：
1.可以随机自动生成排序数据，也可以录入、修改排序数据
2. 演示速度可调整
3.可以单步，可以暂停，可以回退

实验四：媒体播放器
模拟实现一个多功能电子设备，它能播放各种音频、视频文件。
1.这个设备有一个屏幕，屏幕界面上面的控件有一个菜单条，上面有一个菜单，菜单里有“播放”、“暂停”和“退出”命令，界面下方有进度条，也能实现“播放”、“暂停”和“退出”功能。
2.该设备配有一个控制器，控制媒体播放，存储播放音频、视频文件的数据和播放状态，并包含播放音频、视频的逻辑。

实验一设计参考：

package solitaire;
import java.awt.Graphics;
import java.util.LinkedList;
import java.util.List;
public abstract class CardPile {
protected List pile;
protected int x;
protected int y;
/ ∗ ∗ ∗ Make an Empty P i l e ∗ /
public CardPile(int x, int y) {
pile = new LinkedList();
this.x = x;
this.y = y;
}
public boolean empty(){
return pile.isEmpty();
}
public Card topCard() {
if (!empty())
return (Card)pile.get(pile.size() − 1);
else
return null;
}
public Card pop() {
if (!empty())
return (Card)pile.remove(pile.size() − 1);
else
return null;
}
public boolean includes(int tx, int ty) {
return x<=tx && tx <= x + Card.width
&& y <= ty && ty <= y + Card.height;
}
public void addCard(Card aCard){
pile.add(aCard);
}
public void draw (Graphics g){
if (empty()) {
g.drawRect(x,y,Card.width,Card.height);
}
else
topCard().draw(g,x,y);
}
public abstract boolean canTake(Card aCard);
public abstract void select ();
}

package solitaire;
import javax.swing. ∗ ;
import java.awt. ∗ ;
public class Solitaire extends JPanel implements MouseListener {
static DeckPile deckPile;
static DiscardPile discardPile;
static TablePile tableau[];
static SuitPile suitPile[];
static CardPile allPiles[];
public Solitaire(){
setBackground(Color.green);
addMouseListener(this);
allPiles = new CardPile[13];
suitPile = new SuitPile[4];
tableau = new TablePile[7];
int deckPos = 600;
int suitPos = 15;
allPiles[0] = deckPile = new DeckPile(deckPos, 5);
allPiles[1] = discardPile =
new DiscardPile(deckPos − Card.width − 10, 5);
for (int i = 0; i < 4; i++)
allPiles[2+i] = suitPile[i] =
new SuitPile(suitPos + (Card.width + 10) ∗ i, 5);
for (int i = 0; i < 7; i++)
allPiles[6+i] = tableau[i] =
new TablePile(suitPos + (Card.width + 10) ∗ i,
Card.height + 20, i+1);
repaint();
}
public void paintComponent(Graphics g) {
super.paintComponent(g);
for (int i = 0; i < 13; i++)
allPiles[i].draw(g);
}
public static void main(String[] args) {
JFrame frame = new JFrame();
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);
frame.setSize(800,600);
frame.setTitle( " S o l i t a i r e " );
Solitaire s = new Solitaire();
frame.add(s);
frame.validate();
s.repaint();
}
public void mouseClicked(MouseEvent e) {
int x = e.getX();
int y = e.getY();
for (int i = 0; i < 12; i++)
if (allPiles[i].includes(x, y)) {
allPiles[i].select();
repaint();
}
}
public void mousePressed(MouseEvent e) { }
public void mouseReleased(MouseEvent e) { }
public void mouseEntered(MouseEvent e) { }
public void mouseExited(MouseEvent e) { }
}
* the DeckPile Class This class extends the CardPile class. It must create
a full deck of cards (stored in its super class’s pile attribute.) The cards
should be shuffled after creation (use Collections.shuffle(...) ). You
never add cards to the DeckPile so its canTake method always returns false.
The select method removes a card from the deckPile and adds it to the
discardPile (In the Solitaire class).
* The DiscardPile Class This maintains a pile of cards that do not go into any
of the other piles. Override the addCard method to check first if the card is
faceUp and flip it if its not. Then add the card to the pile. You never add cards
to the DiscardPile so its canTake method always returns false. The select
method requires careful thought. Remember that this method runs when the
user selects this pile. Now, what happens when the user clicks on the topCard
in the discardPile? We must check if any SuitPile (4 of them) or any TablePile
(7 of them) (all in the Solitaire class) can take the card. If any of these piles can
take the card we add the Card to that pile. If not, we leave it on the discardPile.
* The SuitPile Class The select method is empty (Cards are never removed
from this pile). The canTake method should return true if the Card is the same
suit as all others in the pile and if its rank is one more that its topCard.
* The TablePile Class Write the constructor to initialize the table pile. The
constructor accepts three parameters, the x and y coordinates of the pile, and
an integer that tell it how many cards it contains. (remember that the first
tablePile contains 1 card, the second 2 Cards etc.). It takes Cards from the deck-
Pile. The table pile is displayed differently from the other piles (the cards over-
lap). We thus need to override the includes the method and the draw method.
The canTake method is also different. The table piles will accept a card if its
suit is opposite in color and its rank is one less than the pile’s topCard. The
select method is similar to the one in DiscardPile. We must check if any
SuitPile (4 of them) or any TablePile (7 of them) (all in the Solitaire class) can
take the card. If any of these piles can take the card we add the Card to that
pile otherwise we leave it in this tabePile.

实验二设计参考：

package pattern.strategy.sort;

/**
　* 策略模式:Strategy Pattern
　*
　* 排序算法策略
　*
　*
　*/
public class SortStrategyTest {
　　 　public static void main(String[] args) {
　　 　　　 　Sorter<?> sorter;

　　 　　　 　Integer[] data = new Integer[]{548,85,984,3,2,44,99};
　　 　　　 　sorter = new Sorter<Integer>(data , "QuickSort");
　　 　　　 　sorter.printArray();
　　 　　　 　sorter.sort();
　　 　　　 　sorter.printArray();

　　 　　　 　String[] strs = new String[]{"B","C","D","A","X","F","E"};
　　 　　　 　sorter = new Sorter<String>(strs , "InsertionSort");
　　 　　　 　sorter.printArray();
　　 　　　 　sorter.sort();
　　 　　　 　sorter.printArray();　　 　　　 　
　　 　}
}

class Sorter<T extends Comparable<T>>{
　　 　private T[] data;
　　 　private SortStrategy<T> strategy;

　　 　@SuppressWarnings("unchecked")
　　 　public Sorter(T[] data , String sortStrategy){
　　 　　　 　this.data = data;

　　 　　　 　//利用反射动态加载策略类
　　 　　　 　String pack = this.getClass().getPackage().getName();
　　 　　　 　pack += ".";
　　 　　　 　try {

　　 　　　 　　　 　Class<?> cl = Class.forName(pack + sortStrategy);
　　 　　　 　　　 　strategy = (SortStrategy<T>) cl.newInstance();//unchecked
　　 　　　 　} catch (InstantiationException e) {
　　 　　　 　　　 　e.printStackTrace();
　　 　　　 　} catch (IllegalAccessException e) {
　　 　　　 　　　 　e.printStackTrace();
　　 　　　 　} catch (ClassNotFoundException e) {
　　 　　　 　　　 　e.printStackTrace();
　　 　　　 　}
　　 　}

　　 　public void sort(){
　　 　　　 　strategy.sort(data);
　　 　}

　　 　public void printArray(){
　　 　　　 　for(int i=0;i<data.length;i++){
　　 　　　 　　　 　System.out.print(""+data[i]+" ");
　　 　　　 　}
　　 　　　 　System.out.println("");
　　 　}
}

/**
　* 抽象排序算法类
　* @author Winty
　*
　* @param <T> 实现了Comparable<T>接口的类
　*/
abstract class SortStrategy<T extends Comparable<T>>{
　　 　public abstract void sort(T[] data);
}

/**
　* 插入排序
　* @author Winty
　*/
class InsertionSort<T extends Comparable<T>> extends SortStrategy<T>{

　　 　@Override
　　 　public void sort(T[] data) {
　　 　　　 　int len;
　　 　　　 　T temp;
　　 　　　 　len=data.length;

　　 　　　 　for(int i=1;i<len;i++){
　　 　　　 　　　 　int k;
　　 　　　 　　　 　k=0;
　　 　　　 　　　 　temp=data[i];
　　 　　　 　　　 　for(int j=i-1;j>=0;j--){
　　 　　　 　　　 　　　 　k=i;
　　 　　　 　　　 　　　 　if(data[j].compareTo(temp) > 0){
　　 　　　 　　　 　　　 　　　 　data[j+1]=data[j];
　　 　　　 　　　 　　　 　　　 　k=j;
　　 　　　 　　　 　　　 　}
　　 　　　 　　　 　　　 　else if(data[j].compareTo(temp) < 0){
　　 　　　 　　　 　　　 　　　 　k=j+1;
　　 　　　 　　　 　　　 　　　 　break;
　　 　　　 　　　 　　　 　}
　　 　　　 　　　 　}
　　 　　　 　　　 　data[k]=temp;
　　 　　　 　}　　 　
　　 　}　　 　
}

/**
　* 快速排序
　* @author Winty
　*/
class QuickSort<T extends Comparable<T>> extends SortStrategy<T>{

　　 　@Override
　　 　public void sort(T[] data) {
　　 　　　 　quick(data , 0 , data.length - 1);　　 　　　 　
　　 　}

　　 　private void quick(T[] data , int p , int r){
　　 　　　 　int q;

　　 　　　 　if (p < r){
　　 　　　 　　　 　q = partition(data , p , r);
　　 　　　 　　　 　quick(data , p , q - 1);
　　 　　　 　　　 　quick(data , q + 1 , r);
　　 　　　 　}
　　 　}

　　 　private int partition(T[] data , int p ,int r){
　　 　　　 　int i;
　　 　　　 　T pivot , temp;

　　 　　　 　i = p - 1;
　　 　　　 　pivot = data[r];

　　 　　　 　for(int j = p; j <= r - 1;j++){
　　 　　　 　　　 　if(data[j].compareTo(pivot) < 0){
　　 　　　 　　　 　　　 　i++;
　　 　　　 　　　 　　　 　temp = data[i];
　　 　　　 　　　 　　　 　data[i] = data[j];
　　 　　　 　　　 　　　 　data[j] = temp;
　　 　　　 　　　 　}
　　 　　　 　}
　　 　　　 　temp = data[i + 1];
　　 　　　 　data[i + 1] = data[r];
　　 　　　 　data[r] = temp;

　　 　　　 　return i + 1;
　　 　}
}
上述方案还没有考虑多种顺序

方案2

SortStrategy
Sort
Sorter
Sort

InsertionSort
QuickSort
Sort

Compare
Size
Swap

Compare
Size
Swap

EmployeeInsertionSort
IntegerInsertionSort
Sort
Compare
Size
Swap

方案3
Sorter
Sort
SortStrategy
Sort
QuickSort
Sort
InsertionSort
Sort
IntegerComparator
StringComparator
Comparator

Compare(o1:object; o2:object)

实验四设计参考：