java编程思想第四版第十一章习题

第一题

package net.mindview.holding.test1;

import java.util.ArrayList;
import java.util.List;

/**
 * 沙鼠
 * @author samsung
 *
 */
public class Gerbil {
    static int counter;
     gerbilNumber;
    
    public Gerbil(){
        this.gerbilNumber = counter ++;
    }
    
     String hop(){
        
        return "沙鼠的号码:"+gerbilNumber + ,正在跳跃"void main(String[] args) {
        List<Gerbil> list = new ArrayList<Gerbil>();
        list.add(new Gerbil());
        list.add( Gerbil());
        for(Gerbil g: list){
            System.out.println(g.hop());
        }
    }
}

运行结果

沙鼠的号码:0123,正在跳跃

第二题

package net.mindview.holding.test2;

import java.util.HashSet;
import java.util.Set;

 SimpleCollection {

     main(String[] args) {
        Set<Integer> c = new HashSet<Integer>();
        for(int i = 0; i < 10; i++){
            c.add(i);
        }
        (Integer i: c){
            System.out.print(i + );
        }
    }

}

第三题

package net.mindview.holding.test3;

import java.util.ArrayList;
import java.util.List;

*
 * 选择器
 interface Selector {
    //是否结束
    boolean end();
    当前
    Object current();
    下一个
     next();
}


*
 * 顺序
  Sequence {
    数组是有限制的,而集合时无限制的.
    private Object[] items;
    private List<Object> items;
    private int next = ;
    定义数组的个数
     Sequence(){
        items = new ArrayList<Object>();
    }
    添加
     add(Object x){
        items.add(x);
    }
    
    内部类--顺序选择器
     SequenceSelector implements Selector {
        选择器最开始指向第一个元素
        ;
        @Override
         boolean end() {
            return i == (items.size());
        }
        *
         * 新增方法: 在内部类中引用外部类
         */
         Sequence outer(){
            return Sequence.this;
        }

        @Override
         Object current() {
            return items.get(i);
        }

        @Override 
         next() {
            if(i<items.size()){
                i++;
            }
        }
    }
    
     Selector selector() {
        return  SequenceSelector();
    }
    
    
    
     main(String[] args) {
        Sequence s =  Sequence();
        int i=0; i<){
            s.add(对象"+i);
        }
        Selector selector = s.selector();
        while(!selector.end()){
            System..print(selector.current());
            selector.next();
        }
    }

}

结果

对象0对象1对象2对象3对象4对象5对象6对象7对象8对象9

分析：这个案例的重点是，数组瘦受限制的，集合是没有元素个数限制的。因此，可以任意添加元素的意思就是：将数组替代为集合。

第四题

package net.mindview.holding.test4;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.TreeSet;
 MoiveNameGenerator {
    String[] moives = {Snow White",Star WarsWhite PrincpleDreamMy MotherThe ForestMy Grandpa};
     next;
     String next(){
        String moive = moives[next];
        电影名用完之后,循环到这个字符列表的开始处
        next = (next+1) % moives.length;
        return moive;
    }
    
}
 MoiveGenerator {
    MoiveNameGenerator moiveNameGenerator =  MoiveNameGenerator();
     String[] fill(String[] arr){
        0; i<arr.length; i++){
            arr[i] = moiveNameGenerator.next();
        }
         arr;
    }
    
     Collection fill(Collection col){
        5; i++){
            col.add(moiveNameGenerator.next());
        }
         col;
    }
    
     main(String[] args) {
        MoiveGenerator moiveGenerator =  MoiveGenerator(); 
        System.out.println(Arrays.toString(moiveGenerator.fill(new String[5])));
        System.out.println(moiveGenerator.fill(new ArrayList<String>()));
        System.new LinkedList<String>new HashSet<String>new LinkedHashSet<String>new TreeSet<String>()));
    }
}

运行结果：

[Snow White,Star Wars,White Princple,Dream,My Mother]
[The Forest,My Grandpa,Snow White,White Princple]
[Dream,My Mother,The Forest,Snow White]
[My Mother,White Princple]
[My Grandpa,Dream]
[My Grandpa,The Forest]

栈在编程语言中,经常用来对表达式求值。请使用net.mindview.util.Stack对下面的表达式求值。其中“+”表示将后面的字母压入栈，“-”表示将栈顶的字母押出栈。并打印他们。

package net.mindview.holding;

import java.util.LinkedList;

*
 * 模拟栈
 class Stack<T> {
    private LinkedList<T> storage = new LinkedList<T>();
    
    推入
     push(T v){
        storage.addFirst(v);
    }
    
     T peek(){
         storage.getFirst();
    }
    
    取出
     T pop(){
         storage.removeFirst();
    }
    
     boolean empty(){
         storage.isEmpty();
    }
    
     String toString(){
         storage.toString();
    }

}

package net.mindview.holding.test15;

import java.util.Stack;

*
 * 栈在编程语言中,经常用来对表达式求值。请使用net.mindview.util.Stack对下面的表达式求值。
 * 其中“+”表示将后面的字母压入栈，“-”表示将栈顶的字母押出栈。并打印他们。
 * @author samsung
 *
  Test15 {
    Stack<Character> stac = new Stack<Character>();
    计算
     eval(String str){
        char[] chars = str.tocharArray();
        0; i<chars.length; i++){
            char c = chars[i++];
            遇到+号把字符入栈
            switch (c){
                case '+':
                    System.out.println(入栈:stac.push(chars[i]));
                    break;
                -出栈:stac.pop());
                     main(String[] args) {
        Test15 t =  Test15();
        String str = +U+n+c---+e+r+t---+a-+i-+n+t+y---+ -+r+u--+l+e+s--;
        t.eval(str);
    }
}

fda
fa
fa
dfa
fa
df
asfd
afa
fa
fa
fa

二十七题

package net.mindview.holding.test27;

import java.util.LinkedList;
import java.util.Queue;

消息
 Command {
    String str;
     Command(String str){
        this.str = str;
    }
     operation(){
        System..println(str);
    }
}

生产者
 Producter{
    生产者生成消息
    public Queue<Command> produce(Queue<Command> qc){
        qc.offer(new Command(A));
        qc.offer(ABABCVFASDA));
         qc;
    }
}

消费者
 Customer {
    消费者消费消息
    void custom(Queue<Command> queue){
        while(queue.peek() != null){
            queue.remove().operation();
        }
    }
}

 Test27 {
     main(String[] args) {
        Queue<Command> qc = new LinkedList<Command>();
        Producter producter =  Producter();
        Queue<Command> qcc = producter.produce(qc);
         Customer().custom(qcc);

    }
}

运行结果:

A
AB
ABC
VFA
SDA

第三十一题

package net.mindview.holding.test31;

import java.util.Iterator;
import java.util.Random;

形状
 Shape {
     draw() {
    }

     erase() {
    }
}

 圆形
 Cycle1 extends Shape {

    @Override
     draw() {
        System.draw cycle);
    }

    @Override
     erase() {
        System.erase cycle);
    }

}

 Square extends Shape {
    @Override
    draw Square);
    }
}

 矩形
 Triangle extends Shape {
    @Override
    draw Triangle 梯形
 Trapezoid extends Shape {
    @Override
    draw Trapezoidclass RandomShapeFactory implements Iterable<Shape> {
    Random random = new Random(47);

    private final  quantity;

    public RandomShapeFactory( quantity) {
        this.quantity= quantity;
    }

     下面画什么形状呢
     Shape nextShape() {
        switch (random.nextInt(4)) {
        default:
        :
             Cycle1();
         Square();
         Triangle();
        3 Trapezoid();
        }
    }

    @Override
    public Iterator<Shape> iterator() {
        new Iterator<Shape>() {
            int count = ;

            @Override
             boolean hasNext() {
                return count < quantity;
            }

            @Override
             Shape next() {
                ++count;
                 nextShape();
            }

            @Override
             remove() {

            }
        };
    }
}

 Shapes {
     main(String[] args) {
        RandomShapeFactory rd = new RandomShapeFactory(9);
         (Shape s : rd) {
            System..println(s.getClass().getSimpleName());
        }

    }

}

运行结果

Triangle
Square
Triangle
Cycle1
Cycle1
Triangle
Cycle1
Square
Triangle

f
afda

java编程思想第四版第十一章习题

猜你在找的Java相关文章