精华内容
下载资源
问答
  • 2021-03-06 23:34:47

    1.1计算机是一种电子装置,存储和处理数据。一台计算机包括硬件和软件。在一般情况下,硬件是可以看到的计算机的物理方面的,而软件是无形的指令,控制硬件和它的工作。

    1.2一台计算机的硬件包括一个CPU,高速缓存,内存,硬盘,软盘,显示器,打印机,通信设备。

    1.3机器语言是每个计算机中内置的一组基本指令。汇编语言是一种低级别的编程语言,是用一个助记符来表示各机器语言指令。高级程序设计语言是像英语那样的易于学习和运行。

    1.4源程序是指用高级语言编写的程序。编译器是一个程序,它把高级语言源程序翻译成等价的低级语言目标程序。

    1.5Java源程序被编译成字节码。JVM是Java字节码解释器。

    1.6操作系统是一个程序(OS),用来管理和控制计算机的活动,OS的例子有Windows 98, NT, 2000, XP, or ME. Windows。应用程序像网页浏览器和文字处理器等运行于操作系统上。

    1.7Developed by a team led by James Gosling at Sun Microsystems in 1991. Originally called Oak, it became Java in 1995 when it was redesigned for developing Internet applications。

    java可以在任何装有java虚拟机的平台上运行,最低要求是有java运行环境。

    1.8输入的是Java源代码,输出的是Java字节码(如果编译成功)。

    1.9JBuilder by Borland, Sun ONE Studio by Sun, Café by WebGain, Visual Age for Java by IBM are the tools for developing Java programs, 这些语言不是java的方言,这些工具使得开发java程序更容易更高效。

    1.10 HTML是一种标记语言,用于显示静态的网页。 Java是一种成熟的编程语言,可以用来开发动态Web页面。在Web浏览器中运行的Java程序,被称为小应用程序。 Java小应用程序必须用标记嵌入在html文件中。

    1.11关键字对编译器来说有特殊的含义,不能在程序中用于其他目的,像变量或方法名都不能用。 Examples of keywords are class, static, and void.

    1.12Java区分大小写。java关键字都是小写的。

    1.13java源程序扩展名是.java。java字节码扩展名是.class。

    1.14注释用于记录程序是什么,以及如何构建一个程序。注释帮助程序员或用户理解程序。注释不是程序是被编译器忽略的。注释行// ,注释段 /* and */。

    1.15

    System.out.println(...)        JOptionPane.showMessageDialog(null, "Hello world");

    1.16

    public class Welcome{

    public static void main(String[] args){

    System.out.printlin("morning");

    System.out.println("afternoon");

    }

    }

    1.17line2:缺少main,static

    line3:Welcome to java!应该用双引号括起来,、

    line5:不是)而是}

    1.18编译java:javac     运行java用:java

    1.19无法找到.class文件,或者是package名字不正确。

    1.20class没有main方法,或者是main方法名不正确。

    1.21System类在java.lang包中,这个包默认被导入,这里不需要再导入。

    1.22性质上没有不同处。

    1.23 Output is   3.5 * 4 / 2 – 2.5 is 4.5

    更多相关内容
  • 使用的是TSC TX600打印机,使用别的打印机也一样只要装有驱动电脑能识别到打印机,设置好打印尺寸就可以打印,打印材料根据打印机选择,亚银纸,硬质类标签纸都可以。里面有源码、操作说明书,驱动等文件。JDK太大了...
  • java调用打印机打印的相关教程

    热门讨论 2011-03-11 17:41:14
    所以,在以前用Java/Applet/JSP/Servlet设计程序中,较复杂的打印都是通过调用ActiveX/OCX控件或者VB/VC程序来实现的,非常麻烦。实际上,SUN公司也一直致力于Java打印功能的完善,而Java2平台则终于有了一个健壮...
  • [Java]打印机服务程序

    千次阅读 2016-06-10 17:36:06
    打印机服务程序,采取动态优先级方案,有三种调度策略。 动态优先级方法: 任何时刻, 用户都可以向服务器发送打印请求 每个请求包含打印文件的文件名字, 页数. 服务器根据文件页数初始化该请求的优先级, 并将该...
    一、 问题描述:


    打印机服务程序,采取动态优先级方案,有三种调度策略。


    动态优先级方法:

    • 任何时刻, 用户都可以向服务器发送打印请求
      • 每个请求包含打印文件的文件名字, 页数.
    • 服务器根据文件页数初始化该请求的优先级, 并将该打印请求放入对应的队列中.
      • 具体的初始化优先级算法见后续描述
    • 如果打印机空闲, 则从优先级最高的非空队列中选择请求进行打印
    • 如果打印机忙, 则让其继续打印
    • 当一个打印任务完成, 服务器将进行以下操作
      • 如果所有队列为空, 则等待新的任务到来.
      • 如果存在队列非空, 则从优先级最高的非空队列中选择一个请求. 同时, 如果一个队列 qi qi 已经被访问过  k k 次, 则选择优先级最高非空队列  qj,j>i qj,j>i, 从  qj qj 中选择一个任务将其放入  qi qi 中, 并清空  qi qi的访问次数.
    调度策略:

    1. 所有请求赋予相同优先级, 放入  q0 q0 中. 等价于只有一个队列的 FIFS.
    2. 使用 n 个队列, 根据文档页数分配优先级
      • 页数在 1 到 10 之间, 则进入队列  q0 q0
      • 页数在 11 到 20, 则进入队列  q1 q1
      • ...
      • 页数在 10(n-2)+1 到 10(n-1) 之间, 则进入队列  qn2 qn−2
      • 页数超过 10(n-1), 则进入队列  qn1 qn−1
    3. 使用 n 个队列, 若文件页数为 t, 则进入队列  qt%n


    二、打印请求PrintRequest类:


    a) 数据成员:

    i. private String filename:打印文件名
    ii. private int pageNumber:文件页数
    iii. private int requestTime:请求时间

    iv. private int waitingTime:等待时间


    b) 构造函数PrintRequest(String fn, int pn, int rt):
    需指定打印文件名fn,文件页数pn和请求时间rt。


    c) 获取打印页数public int getPageNumber();


    d) 计算等待时间public void calcWaitingTime(int t):

    当前时间t,waitingTime = t- requestTime


    e) 获取等待时间public int getWaitingTime();


    f) toString方法。


    public class PrintRequest {
    	private String fileName;
    	private int pageNumber;
    	private int requestTime;
    	private int waitingTime;
    	PrintRequest(String fn, int pn, int rt) {
    		this.fileName = fn;
    		this.pageNumber = pn;
    		this.requestTime = rt;
    	}
    	// PrintRequest(PrintRequest pr) {
    	// 	this.fileName = pr.fileName;
    	// 	this.pageNumber = pr.pageNumber;
    	// 	this.requestTime = pr.requestTime;
    	// }
    	public int getPageNumber() {
    		return this.pageNumber;
    	}
    	public void calcWaitingTime(int t) {
    		waitingTime = t-requestTime;
    	}
    	public int getWaitingTime() {
    		return waitingTime;
    	}
    	// public void setPageNumber(int pn) {
    	// 	this.pageNumber = pn;
    	// }
    	public String toString() {
    		return fileName+" was requested at "+requestTime+" with "+pageNumber+" pages";
    	}
    }


    三、打印机Printer类:


    a) 数据成员:
    i. private boolean isIdle = true:当前打印机是否空闲
    ii. private PrintRequest origJob:当前打印机正在打印的文件请求
    iii. private int pageLeft:当前打印的文件剩余页数


    b) 获取打印机状态public boolean printIdle():返回isIdle;


    c) 在t时刻产生r打印请求public boolean printFile(PrintRequest r, int t):

    i. 如果当前打印机忙,返回false;
    ii. 否则将origJob置为r,计算r的等待时间,pageLeft即为r的页数,isIdle状态置为false,返回true。


    d) 打印一页public int printOnePage():

    i. pageLeft减一;
    ii. 如果pageLeft为0,则将状态isIdle置为true;
    iii. 返回剩余页数pageLeft。


    e) 获取当前打印结束的文件public PrintRequest processForOneUnit():

    i. 如果打印机空闲, 或者当前正在打印的文档还剩余超过1页则返回 null;
    ii. 如果当前文档已完成, 则返回当前的打印任务对象

    public class Printer {
    	private boolean isIdle = true;
    	// private int currTime = 0;
    	// private int startTime;
    	private PrintRequest origJob;
    	private int pageLeft;
    	public boolean printIdle() {
    		return isIdle;
    	}
    	public boolean printFile(PrintRequest r, int t) {
    		if (this.printIdle()) {
    			origJob = r;
    			r.calcWaitingTime(t);
    			pageLeft = r.getPageNumber();
    			// startTime = currTime;
    			isIdle = false;
    			return true;
    		}
    		else return false;
    	}
    	public int printOnePage() {
    		pageLeft--;
    		if (pageLeft == 0) {
    			isIdle = true;
    		}
    		return pageLeft;
    	}
    	public PrintRequest processForOneUnit() {
    		if (this.printIdle() || pageLeft > 1) {
    			return null;
    		}
    		else return origJob;
    	}
    	public String toString() {
    		if (isIdle) {
    			return "The printer is idle now.";
    		}
    		return origJob+" is working, "+pageLeft+" pages not finished.";
    	}
    }


    四、打印队列PrintQueue类public class PrintQueue<E> extends AbstractQueue<E> implements Queue<E>:


    a) 数据成员:

    i. private int hasCalledTime = 0:该队列已被访问次数
    ii. private int size = 0:队列大小
    iii. private int priority:队列优先级
    iv. transient private Entry<E> header = new Entry<E>(null, null, null):队首元素,不含数据


    b) 内部静态私有类private static class Entry<E>:

    i. 含有一个元素element,一个next指针指向下一个元素,一个befo指针指向前一个元素;
    ii. 构造函数Entry(E elem, Entry<E> befo, Entry<E> next)


    c) 构造函数PrintQueue(int p):

    优先级为p,初始化队首header,header的next和befo分别指向自己,size清零。


    d) 获取队列的访问次数public int getCalledTime()和清零队列的访问次数public void resetCalledTime()。


    e) 添加元素public boolean add(E e)和public boolean offer(E e):

    两者方法相同,只是在e为空的时候add抛出NoSuchElementException的异常,offer返回false。
    i. 为e创建一个Entry对象tmp,并将其befo置为原本队列的最后一个元素,next置为队首元素;
    ii. 将原队尾元素的next置为tmp;
    iii. 将队首元素的befo置为tmp;
    iv. 队列大小size加一;
    v. 返回true。


    f) 获取队首元素public E peek()和public E element():

    两者方法相同,只是在队列为空的时候element抛出NoSuchElementException的异常,peek返回null。
    队列非空时返回header.next.element。


    g) 获取并删除队首元素public E remove()和public E poll():

    两者方法相同,只是在队列为空的时候remove抛出NoSuchElementException的异常,poll返回null。
    i. 获取队首元素tmp;
    ii. header的next指向tmp的next;
    iii. tmp的next的befo指向header;
    iv. 队列大小size减一,访问计数器加一;
    v. 返回tmp.element; 

    import java.util.*;
    public class PrintQueue<E> extends AbstractQueue<E> implements Queue<E> {
    	private int hasCalledTime = 0;
    	private int size = 0;
    	private int priority;
    	transient private Entry<E> header = new Entry<E>(null, null, null);
    	private static class Entry<E> {
    		E element;
    	    Entry<E> next;
    	    Entry<E> befo;
    
    	    Entry(E elem, Entry<E> befo, Entry<E> next) {
    			this.element = elem;
    			this.befo = befo;
    			this.next = next;
    		}
    	}
    	PrintQueue(int p) {
    		priority = p;
    		header = new Entry<E>(null, null, null);
    		header.next = header;
    		header.befo = header;
    		size = 0;
    	}
    	public int getCalledTime() {
    		return this.hasCalledTime;
    	}
    	public void resetCalledTime() {
    		this.hasCalledTime = 0;
    	}
    	public boolean add(E e) {
    		if (e == null) {
    			throw new NoSuchElementException();
    		}
    		Entry<E> tmp = new Entry<E>((E)e, header.befo, header);
    		tmp.befo.next = tmp;
    		header.befo = tmp;
    		size++;
    		return true;
    	}
    	public boolean offer(E e) {
    		if (e == null) {
    			return false;
    		}
    		Entry<E> tmp = new Entry<E>((E)e, header.befo, header);
    		tmp.befo.next = tmp;
    		header.befo = tmp;
    		size++;
    		return true;
    	}
    	public E peek() {
    		if (size == 0) return null;
    		return this.element();
    	}
    	public E element() {
    		if (size == 0) {
    			throw new NoSuchElementException();
    		}
    		final Entry<E> tmp = header.next;
    		return tmp.element;
    	}
    	public E poll() {
    		if (size == 0) {
    			return null;
    		}
    		E tmp = (E)(header.next.element);
    		header.next = header.next.next;
    		header.next.befo = header;
    		size--;
    		hasCalledTime++;
    		return tmp;
    	}
    	public E remove() {
    		if (size == 0) {
    			throw new NoSuchElementException();
    		}
    		return poll();
    	}
    	public String toString() {
    		String ans = "  Priority "+priority+" PrintQueue has been called for "+hasCalledTime+" times, and its size is "+size+"\r\n";
    		Entry tmp = header.next;
    		for (int i = 0; i < size; i++) {
    			ans += "    "+tmp.element.toString()+"\r\n";
    			tmp = tmp.next;
    		}
    		return ans;
    	}
    	// not use methods:
    	public void clear() {
    		header = new Entry<E>(null, null, null);
    		header.next = header;
    		header.befo = header;
    		size = 0;
    	}
    	public boolean retainAll(Collection c) {
    		return true;
    	}
    	public int size() {
    		return size;
    	}
    	public Iterator<E> iterator() {
    		return new Iterator<E>() {
    			public boolean hasNext() {
    				return true;
    			}
    			public E next() {
    				return (E)(header.next.element);
    			}
    			public void remove() {
    				return;
    			}
    		};
    	}
    }


    五、打印机调度器PrintDispatcher类public class PrintDispatcher extends AbstractCollection implements Queue:


    a) 数据成员:

    i. private int queueNumber = 0:内部队列数
    ii. private int type = 0:调度策略,A~C分别对应0~2
    iii. private int threshold = 0xFFFFFFF:访问次数阈值
    iv. private Entry header = new Entry(null, null, null):队首元素


    b) 内部静态私有类private static class Entry:

    该类与PrintQueue基本一致,只是元素element的类型已经确定下来了,为PrintQueue<PrintRequest>。


    c) 构造函数PrintDispatcher(int qn, int thre, int t):

    i. 指定优先级队列数目qn,调度策略t,访问次数阈值thre;
    ii. 队首header的next和befo均指向自己;
    iii. 创建qn个优先级队列PrintQueue<PrintRequest> pq,优先级依次为0~qn-1,插入header中。


    d) 获取当前优先级最高的任务public PrintRequest peek()和public PrintRequest element():

    两者方法基本一致,区别在于如果当前没有等待任务时,peek返回null,而element抛出NoSuchElementException异常。
    i. 遍历所有优先级队列,找到第一个非空优先级队列tmp;
    ii. 返回tmp.element.peek()/element()。


    e) 获取当前优先级最高的任务并从队列中移除public PrintRequest poll ()和public PrintRequest remove /dequeue():

    两者方法基本一致,区别在于如果当前没有等待任务时,poll返回null,而remove/dequeue抛出NoSuchElementException异常。
    i. 遍历所有优先级队列,找到第一个非空优先级队列tmp;
    ii. 返回tmp.element.poll()/remove()。


    f) 添加新任务public boolean offer/enqueue(Object pr)和public boolean add(Object pr):

    两者方法基本一致,区别在于如果pr为空时,offer/dequeue返回false,而add抛出NoSuchElementException异常。
    i. 根据当前调度程序的类型type:
    1. 如果type==0:直接加入第一个优先级队列;
    2. 如果type==1:计算该任务的优先级pn = (((PrintRequest)pr).getPageNumber()-1)/queueNumber,把任务归到第pn的优先级队列队尾;
    3. 如果type==2:计算该任务的优先级pn = (((PrintRequest)pr).getPageNumber()-1)%queueNumber,把任务归到第pn的优先级队列队尾;


    g) 饥饿检测public boolean detectHungry():

    i. 遍历每个优先级队列,如果找到一个优先级队列其访问次数tmp.element.getCalledTime()大于threshold,则记录该队列为tmp;
    ii. 从它之后找出第一个非空的优先级队列hungryQueue,取出其队首元素hungryRequest;
    iii. 将hungryRequest出队并放入tmp的队尾,并将该tmp的访问次数请0。
    h) 检测是否有任务在等待public boolean hasRequestWaiting():
    i. 遍历每个优先级队列,判断其大小是否为0;
    ii. 如果存在一个优先级队列大小大于0,返回true;否则返回false。

    import java.util.*;
    public class PrintDispatcher extends AbstractCollection implements Queue {
    	private int queueNumber = 0;
    	private int type = 0;
    	private int threshold = 0xFFFFFFF;
    	private Entry header = new Entry(null, null, null);
    	private static class Entry {
    		PrintQueue<PrintRequest> element;
    	    Entry next;
    	    Entry befo;
    
    	    Entry(PrintQueue<PrintRequest> elem, Entry befo, Entry next) {
    			this.element = elem;
    			this.befo = befo;
    			this.next = next;
    		}
    	}
    	PrintDispatcher(int qn, int thre, int t) {
    		queueNumber = qn;
    		type = t;
    		threshold = thre;
    		header = new Entry(null, null, null);
    		header.next = header;
    		header.befo = header;
    		for (int i = 0; i < queueNumber; i++) {
    			PrintQueue<PrintRequest> pq = new PrintQueue<PrintRequest>(i);
    			Entry e = new Entry(pq, header.befo, header);
    			e.befo.next = e;
    			header.befo = e;
    		}
    	}
    	public PrintRequest peek() {
    		Entry tmp = header.next;
    		for (int i = 0; i < queueNumber; i++) {
    			if (tmp.element.size() > 0) {
    				return tmp.element.peek();
    			}
    			tmp = tmp.next;
    		}
    		return null;
    	}
    	public PrintRequest element() {
    		Entry tmp = header.next;
    		for (int i = 0; i < queueNumber; i++) {
    			if (tmp.element.size() > 0) {
    				return tmp.element.peek();
    			}
    			tmp = tmp.next;
    		}
    		throw new NoSuchElementException();
    	}
    	public PrintRequest poll() {
    		Entry tmp = header.next;
    		for (int i = 0; i < queueNumber; i++) {
    			if (tmp.element.size() > 0) {
    				return tmp.element.poll();
    			}
    			tmp = tmp.next;
    		}
    		return null;
    	}
    	public PrintRequest remove() {
    		Entry tmp = header.next;
    		for (int i = 0; i < queueNumber; i++) {
    			if (tmp.element.size() > 0) {
    				return tmp.element.remove();
    			}
    			tmp = tmp.next;
    		}
    		throw new NoSuchElementException();
    	}
    	public PrintRequest dequeue() {
    		return this.remove();
    	}
    	public boolean offer(Object pr) {
    		if (pr == null) {
    			return false;
    		}
    		Entry tmp = header.next;
    		int pn;
    		switch (type) {
    			case 0:
    				tmp.element.offer((PrintRequest)pr);
    				break;
    			case 1:
    				pn = (((PrintRequest)pr).getPageNumber()-1)/10;
    				// System.err.println("pr = "+pr);
    				// System.err.println("queueNumber = "+queueNumber);
    				// System.err.println("pn = "+pn);
    				if (pn >= queueNumber) {
    					header.befo.element.offer((PrintRequest)pr);
    					break;
    				}
    				for (int i = 0; i < pn; i++) {
    					tmp = tmp.next;
    				}
    				tmp.element.offer((PrintRequest)pr);
    				break;
    			case 2:
    				pn = (((PrintRequest)pr).getPageNumber())%queueNumber;
    				for (int i = 0; i < pn; i++) {
    					tmp = tmp.next;
    				}
    				tmp.element.offer((PrintRequest)pr);
    				break;
    		}
    		return true;
    	}
    	public boolean add(Object pr) {
    		if (pr == null) {
    			throw new NoSuchElementException();
    		}
    		return this.offer(pr);
    	}
    	public boolean enqueue(PrintRequest pr) {
    		return this.offer(pr);
    	}
    	public boolean detectHungry() {
    		Entry tmp = header.next;
    		for (int i = 0; i < queueNumber; i++) {
    			if (tmp.element.getCalledTime() > threshold) {
    				Entry hungryQueue = tmp;
    				for (int j = i+1; j < queueNumber; j++) {
    					hungryQueue = tmp.next;
    					if (hungryQueue.element.size() > 0) {
    						PrintRequest hungryRequest = hungryQueue.element.remove(); // hungry Queue hasCalledTime++
    						tmp.element.offer(hungryRequest);
    						tmp.element.resetCalledTime();
    						break;
    					}
    				}
    				return true;
    			}
    			tmp = tmp.next;
    		}
    		return false;
    	}
    	public boolean hasRequestWaiting() {
    		Entry tmp = header.next;
    		for (int i = 0; i < queueNumber; i++) {
    			if (tmp.element.size() > 0) {
    				return true;
    			}
    			tmp = tmp.next;
    		}
    		return false;
    	}
    	public String toString() {
    		String ans = "";
    		Entry tmp = header.next;
    		for (int i = 0; i < queueNumber; i++) {
    			ans += tmp.element.toString()+"\r\n";
    			tmp = tmp.next;
    		}
    		return ans;
    	}
    	// not use:
    	public Iterator iterator() {
    		return new Iterator() {
    			public boolean hasNext() {
    				return true;
    			}
    			public PrintQueue<PrintRequest> next() {
    				return header.next.element;
    			}
    			public void remove() {
    				return;
    			}
    		};
    	}
    	public int size() {
    		return queueNumber;
    	}
    }


    六、打印环境模拟PrintSimulation类:


    a) 数据成员:

    i. private double probability:当前模拟环境中每个时刻产生新打印任务的概率
    ii. private int queueNumber:当前模拟环境中的优先级队列数
    iii. private int callThreshold:当前模拟环境中的优先级队访问阈值
    iv. private char priorityType:当前模拟环境中的采取的优先策略
    v. ArrayList<Integer[]> waitingTimeArray = new ArrayList<Integer[]>():获取的任务页数-等待时间数组
    vi. int maxWaitingTime = 0:所有任务中的最大等待时间
    vii. double averageWaitingTime = 0:所有任务的平均等待时间
    viii. int sumWaitingTime = 0:总等待时间:
    ix. PrintDispatcher pd:任务调度器
    x. Printer printer:打印机


    b) 构造方法PrintSimulation(double p, int n, int k, String a):

    i. P为概率,n为队列数,k为阈值,a为优先策略;
    ii. 创建任务调度器new PrintDispatcher(n, k, a.charAt(0)-'A');
    iii. 创建打印机。


    c) 生成请求private static PrintRequest generateRequest(double p, int clock, int requestNumber):

    i. 产生随机数rnd∈[0,1);
    ii. 如果rnd大于p,则返回null;
    iii. 否则,随机成生一个打印请求,页数为1~100的随机数,名字为当前请求号requestNumber,时间为当前模拟环境时间clock。


    d) 模拟场景public void simulate(int simulateTime):simulateTime为模拟的时间

    i. 对每个时刻clock,
        1. 调用generateRequest()生成一个请求newRequest,如果非空说明生成成功,将requestNumber加一,并将newRequest放入任务调度器中;
        2. 判断当前打印机printer是否空闲,如果空闲,则打印一页printer.printOnePage();
        3. 否则,从调度器pd中取出队首请求pr,放入打印机打印printer.printFile(pr, clock),更新最大等待时间和总等待时间,将pr的页数-等待时间加入waitingTimeArray中;

        4. 检测饥饿pd.detectHungry();

        5. Clock加一。
    ii. 如果当前调度器中还有任务在等待或者打印机还没有空闲:
        1. 如果打印机不空闲,则打印一页printer.printOnePage();

        2. 否则,从调度器pd中取出队首请求pr,放入打印机打印printer.printFile(pr, clock),更新最大等待时间和总等待时间,将pr的页数-等待时间加入waitingTimeArray中;

    import java.io.*;
    import java.util.*;
    public class PrintSimulation {
    	private double probability;
    	private int queueNumber;
    	private int callThreshold;
    	private char priorityType;
    	ArrayList<Integer[]> waitingTimeArray = new ArrayList<Integer[]>();
    	int maxWaitingTime = 0;
    	double averageWaitingTime = 0;
    	int sumWaitingTime = 0;
    	PrintDispatcher pd;
    	Printer printer;
    	private static PrintRequest generateRequest(double p, int clock, int requestNumber) {
    		double rnd = Math.random();
    		if (rnd > p) {
    			return null;
    		}
    		int pagenumber = (int)(1+Math.random()*100);
    		String filename = "Request"+String.valueOf(requestNumber);
    		return new PrintRequest(filename, pagenumber, clock);
    	}
    	PrintSimulation(double p, int n, int k, String a) {
    		probability = p;
    		queueNumber = n;
    		callThreshold = k;
    		priorityType = a.charAt(0);
    		pd = new PrintDispatcher(n, k, a.charAt(0)-'A');
    		printer = new Printer();
    	}
    	public void simulate(int simulateTime) {
    		int requestNumber = 0;
    		for (int clock = 0; clock < simulateTime; clock++) {
    			// generate a new PrintRequest
    			PrintRequest newRequest = generateRequest(this.probability, clock, requestNumber);
    			if (newRequest != null) {
    				requestNumber++;
    				System.out.println("New request generated: "+newRequest);
    				pd.enqueue(newRequest);
    			}
    			// printer is idle or not
    			if (!printer.printIdle()) {
    				printer.printOnePage();
    			}
    			else {
    				if (pd.hasRequestWaiting()) {
    					PrintRequest pr = pd.dequeue();
    					printer.printFile(pr, clock); //next clock start printing
    
    					Integer[] pageWaiting = new Integer[]{pr.getPageNumber(), pr.getWaitingTime()};
    					maxWaitingTime = maxWaitingTime>pr.getWaitingTime() ? maxWaitingTime:pr.getWaitingTime();
    					sumWaitingTime += pr.getWaitingTime();
    					waitingTimeArray.add(pageWaiting);
    				}
    				pd.detectHungry();
    			}
    			System.out.println("Time "+clock+" State:");
    			System.out.println(pd);
    			System.out.println(printer);
    		}
    		int t = simulateTime;
    		while (pd.hasRequestWaiting() || !printer.printIdle()) {
    			if (!printer.printIdle()) {
    				printer.printOnePage();
    			}
    			else {
    				PrintRequest pr = pd.dequeue();
    				printer.printFile(pr, t);
    				Integer[] pageWaiting = new Integer[]{pr.getPageNumber(), pr.getWaitingTime()};
    				maxWaitingTime = maxWaitingTime>pr.getWaitingTime() ? maxWaitingTime:pr.getWaitingTime();
    				sumWaitingTime += pr.getWaitingTime();
    				waitingTimeArray.add(pageWaiting);
    			}
    			System.out.println("Time "+t+" State:");
    			System.out.println(pd);
    			System.out.println(printer);
    			t++;
    			averageWaitingTime = (double)sumWaitingTime/waitingTimeArray.size();
    		}
    	}
    
    }


    七、 结果分析:由DrawResult.java生成

    import java.io.*;
    import java.awt.*;
    import java.util.*;
    import java.awt.event.*;
    import java.text.*; 
    public class DrawResult extends Canvas {
    	ArrayList<PrintSimulation> aps = new ArrayList<PrintSimulation>();
    	ArrayList<ArrayList<Integer[]>> waitingTimeArray = new ArrayList<ArrayList<Integer[]>>();
    	ArrayList<Integer> maxWaitingTime = new ArrayList<Integer>();
    	ArrayList<Double> averageWaitingTime = new ArrayList<Double>();
    	ArrayList<String[]> storeArgs = new ArrayList<String[]>();
    	DrawResult() {
    		setSize(800, 600);
    	}
    	public void paint(Graphics g) {
    		int n = Integer.parseInt(storeArgs.get(storeArgs.size()-1)[1]);
    		g.drawLine(100, 500, 730, 500);
    		g.drawString("Page Number/page", 650, 530);
    		g.drawLine(100, 500, 100, 70);
    		g.drawString("Average Waiting Time/ln(AWT)", 50, 50);
    		g.drawString("0", 90, 515);
    		for (int i = 1; i <= n; i++) {
    			g.drawString(String.valueOf(i*(100/n)), 90+i*(600/n), 515);
    		}
    		double ceil = Math.log(maxWaitingTime.get(maxWaitingTime.size()-1));
    		System.out.println(ceil);
    		int seg = 400/(int)Math.ceil(ceil);
    		for (int i = 1; i <= Math.ceil(ceil); i++) {
    			g.drawString(String.valueOf(i), 80, 500-i*seg);
    		}
    		// change probability
    		// g.drawString("Queue Number = "+n, 500, 300);
    		// g.drawString("Call Threshold = "+storeArgs.get(storeArgs.size()-1)[2], 500, 320);
    		// g.drawString("Priority Type = "+storeArgs.get(storeArgs.size()-1)[3], 500, 340);
    		
    		// change queue number
    		// g.drawString("Probability = "+storeArgs.get(storeArgs.size()-1)[0], 500, 300);
    		// g.drawString("Call Threshold = "+storeArgs.get(storeArgs.size()-1)[2], 500, 320);
    		// g.drawString("Priority Type = "+storeArgs.get(storeArgs.size()-1)[3], 500, 340);
    
    		// // change threshold
    		// g.drawString("Probability = "+storeArgs.get(storeArgs.size()-1)[0], 500, 300);
    		// g.drawString("Queue Number = "+storeArgs.get(storeArgs.size()-1)[1], 500, 320);
    		// g.drawString("Priority Type = "+storeArgs.get(storeArgs.size()-1)[3], 500, 340);
    
    		// change type
    		g.drawString("Probability = "+storeArgs.get(storeArgs.size()-1)[0], 500, 300);
    		g.drawString("Queue Number = "+storeArgs.get(storeArgs.size()-1)[1], 500, 320);
    		g.drawString("Call Threshold = "+storeArgs.get(storeArgs.size()-1)[2], 500, 340);
    
    		g.drawRect(500, 20, 200, 90);
    
    		System.err.println(storeArgs.get(0)[3]);
    		System.err.println(storeArgs.get(1)[3]);
    		System.err.println(storeArgs.get(2)[3]);
    		for (int j = 0; j <aps.size(); j++) {
    			// change queue number, others should be commented
    			n = Integer.parseInt(storeArgs.get(j)[1]);
    
    			switch (j) {
    				case 0:
    					g.setColor(Color.RED);
    					break;
    				case 1:
    					g.setColor(Color.BLUE);
    					break;
    				case 2:
    					g.setColor(new Color(0x009966));
    					break;
    				case 3:
    					g.setColor(new Color(0x660000));
    					break;
    				case 4:
    					g.setColor(new Color(0xFF9933));
    					break;
    				default:
    					g.setColor(Color.BLACK);
    			}
    			
    			// // change probability:
    			// g.drawString("Prob="+(new DecimalFormat("0.0").format(0.1+0.1*j)), 510, 40+j*15);
    			// g.drawLine(570, 35+j*15, 680, 35+j*15);
    
    			// // change queue number:
    			// g.drawString("Queue Number="+(j*2+1), 510, 40+j*15);
    			// g.drawLine(620, 35+j*15, 680, 35+j*15);
    
    			// change queue number:
    			// g.drawString("Threshold="+(j*5+5), 510, 40+j*15);
    			// g.drawLine(620, 35+j*15, 680, 35+j*15);
    
    			// change type:
    			g.drawString("Priority Type="+((char)(j+'A')), 510, 40+j*25);
    			g.drawLine(620, 35+j*25, 680, 35+j*25);
    			int[][] averageTime = new int[n][2];
    			for (int i = 0; i < waitingTimeArray.get(j).size(); i++) {
    				if (storeArgs.get(j)[3].equals("B")) {
    					// System.err.println("page="+waitingTimeArray.get(j).get(i)[0]+", time="+waitingTimeArray.get(j).get(i)[1]);
    					if ((waitingTimeArray.get(j).get(i)[0]-1)/10 >= n) {
    						averageTime[n-1][0] += waitingTimeArray.get(j).get(i)[1];
    						averageTime[n-1][1] ++;
    					}
    					else {
    						averageTime[(waitingTimeArray.get(j).get(i)[0]-1)/10][0] += waitingTimeArray.get(j).get(i)[1];
    						averageTime[(waitingTimeArray.get(j).get(i)[0]-1)/10][1] ++;
    					}
    				}
    				else if (storeArgs.get(j)[3].equals("C")) {
    					// System.err.println("C");
    					// System.err.println("storeArgs.get(j)[3] = "+storeArgs.get(j)[3]);
    					// System.err.println("waitingTimeArray.get(j).get(i)[0] = "+waitingTimeArray.get(j).get(i)[0]);
    					// System.err.println("100/n = "+(100/n));
    					averageTime[(waitingTimeArray.get(j).get(i)[0]-1)%n][0] += waitingTimeArray.get(j).get(i)[1];
    					averageTime[(waitingTimeArray.get(j).get(i)[0]-1)%n][1] ++;
    				}
    				else {
    					// System.err.println("A");
    					averageTime[(waitingTimeArray.get(j).get(i)[0]-1)/(100/n)][0] += waitingTimeArray.get(j).get(i)[1];
    					averageTime[(waitingTimeArray.get(j).get(i)[0]-1)/(100/n)][1] ++;
    				}
    			}
    			int befox=0, befoy=0;
    			for (int i = 0; i < n; i++) {
    				if (averageTime[i][1] != 0) {
    					averageTime[i][0] /= averageTime[i][1];
    				}
    				else {
    					averageTime[i][0] = 0;
    				}
    				System.out.println(averageTime[i][0]);
    				g.drawRect(130+i*(600/n), (int)(500-seg*Math.log(averageTime[i][0])), 5, 5);
    				g.drawString(String.valueOf(averageTime[i][0]), 120+i*(600/n), (int)(500-seg*Math.log(averageTime[i][0]))-7);
    				if (befox!=0 && befoy!=0) {
    					g.drawLine(befox, befoy, 130+i*(600/n), (int)(500-seg*Math.log(averageTime[i][0])));
    				}
    				befox = 130+i*(600/n);
    				befoy = (int)(500-seg*Math.log(averageTime[i][0]));
    			}
    		}
    
    
    	}
    	public static void main(String[] args) throws IOException {
    		if (args.length != 4) {
    			System.out.println("The args are illegal!");
    		}
    		PrintStream pstream = new PrintStream(new FileOutputStream(args[3]+"result.txt"));
    		System.setOut(pstream);
    
    		Frame frame = new Frame("Result");
    		DrawResult dr = new DrawResult();
    
    		// // change probability:
    		// for (int i = 1 ; i <= 5; i++) {
    		// 	args[0] = String.valueOf(0.1*i);
    		// 	PrintSimulation ps = new PrintSimulation(0.1*i, Integer.parseInt(args[1]), Integer.parseInt(args[2]), args[3]);
    		// 	ps.simulate(1000);
    		// 	for (int j = 0; j < ps.waitingTimeArray.size(); j++) {
    		// 		System.out.println("PageNumber = "+ps.waitingTimeArray.get(j)[0]+", WaitingTime = "+ps.waitingTimeArray.get(j)[1]);
    		// 	}
    		// 	System.out.println("Generated "+ps.waitingTimeArray.size()+" jobs, maxWaitingTime = "+ps.maxWaitingTime+", averageWaitingTime = "+ps.averageWaitingTime);
    
    		// 	dr.storeArgs.add(args);
    		// 	dr.waitingTimeArray.add(ps.waitingTimeArray);
    		// 	dr.maxWaitingTime.add(ps.maxWaitingTime);
    		// 	dr.averageWaitingTime.add(ps.averageWaitingTime);
    		// 	dr.aps.add(ps);
    		// }
    
    		// // change queue number:
    		// for (int i = 1 ; i <= 10; i+=2) {
    		// 	args[1] = String.valueOf(i);
    		// 	System.err.println("n = "+args[1]);
    		// 	PrintSimulation ps = new PrintSimulation(Double.parseDouble(args[0]), Integer.parseInt(args[1]), Integer.parseInt(args[2]), args[3]);
    		// 	ps.simulate(1000);
    		// 	for (int j = 0; j < ps.waitingTimeArray.size(); j++) {
    		// 		System.out.println("PageNumber = "+ps.waitingTimeArray.get(j)[0]+", WaitingTime = "+ps.waitingTimeArray.get(j)[1]);
    		// 	}
    		// 	System.out.println("Generated "+ps.waitingTimeArray.size()+" jobs, maxWaitingTime = "+ps.maxWaitingTime+", averageWaitingTime = "+ps.averageWaitingTime);
    
    		// 	dr.storeArgs.add(args);
    		// 	dr.waitingTimeArray.add(ps.waitingTimeArray);
    		// 	dr.maxWaitingTime.add(ps.maxWaitingTime);
    		// 	dr.averageWaitingTime.add(ps.averageWaitingTime);
    		// 	dr.aps.add(ps);
    		// }
    
    		// // change threshold:
    		// for (int i = 5 ; i <= 25; i+=5) {
    		// 	args[2] = String.valueOf(i);
    		// 	System.err.println("n = "+args[2]);
    		// 	PrintSimulation ps = new PrintSimulation(Double.parseDouble(args[0]), Integer.parseInt(args[1]), Integer.parseInt(args[2]), args[3]);
    		// 	ps.simulate(1000);
    		// 	for (int j = 0; j < ps.waitingTimeArray.size(); j++) {
    		// 		System.out.println("PageNumber = "+ps.waitingTimeArray.get(j)[0]+", WaitingTime = "+ps.waitingTimeArray.get(j)[1]);
    		// 	}
    		// 	System.out.println("Generated "+ps.waitingTimeArray.size()+" jobs, maxWaitingTime = "+ps.maxWaitingTime+", averageWaitingTime = "+ps.averageWaitingTime);
    
    		// 	dr.storeArgs.add(args);
    		// 	dr.waitingTimeArray.add(ps.waitingTimeArray);
    		// 	dr.maxWaitingTime.add(ps.maxWaitingTime);
    		// 	dr.averageWaitingTime.add(ps.averageWaitingTime);
    		// 	dr.aps.add(ps);
    		// }
    
    		// change type:
    		for (int i = 0 ; i <= 2; i++) {
    			args[3] = new String(String.valueOf((char)(i+'A')));
    			System.err.println("type = "+args[3]);
    			PrintSimulation ps = new PrintSimulation(Double.parseDouble(args[0]), Integer.parseInt(args[1]), Integer.parseInt(args[2]), args[3]);
    			ps.simulate(1000);
    			for (int j = 0; j < ps.waitingTimeArray.size(); j++) {
    				System.out.println("PageNumber = "+ps.waitingTimeArray.get(j)[0]+", WaitingTime = "+ps.waitingTimeArray.get(j)[1]);
    			}
    			System.out.println("Generated "+ps.waitingTimeArray.size()+" jobs, maxWaitingTime = "+ps.maxWaitingTime+", averageWaitingTime = "+ps.averageWaitingTime);
    
    			dr.storeArgs.add(new String[]{args[0],args[1],args[2],args[3]});
    			for (int j = 0; j <= i; j++) {
    				System.err.println("storeArgs: "+dr.storeArgs.get(j)[3]);
    			}
    			dr.waitingTimeArray.add(ps.waitingTimeArray);
    			dr.maxWaitingTime.add(ps.maxWaitingTime);
    			dr.averageWaitingTime.add(ps.averageWaitingTime);
    			dr.aps.add(ps);
    		}
    
    
    		frame.add(dr);
    		frame.setLocation(100, 100);
    		frame.addWindowListener(new WindowAdapter() {
    	    public void windowClosing(WindowEvent e) {
    	    	System.exit(0);
    	    }});
    	    frame.pack();
    	    frame.setVisible(true);
    		
    
    	}
    }


    a) 控制任务生成概率:当队列数量为10,访问阈值为5,优先策略采取B时,不同任务产生概率的对比图:
     
    如图所示,随着任务产生概率的升高,平均等待时间成倍增加。
    b) 控制队列数量:当任务产生概率为0.3,访问阈值为3,优先策略采取B时,不同队列数量的对比图:
     
    如图所示,随着队伍数量的升高,平均等待时间逐渐降低。当队伍数为1时,各个队列的平均等待时间基本相同,等价于采取优先策略A。
    c) 控制阈值:当任务产生概率为0.3,队列数量为10,优先策略采取B时,不同阈值的对比图:
     
    如图所示,随着访问阈值的上升,平均等待时间逐渐降低。
    d) 控制优先策略:当任务产生概率为0.3,队列数量为10,访问阈值为5时,不同优先策略的对比图:
     
    如图所示,采取优先策略A和优先策略C时,两者平均等待时间基本一致,这是由于在10个队列情况下,各个可能页数取模都能得到基本一致的数量,故与策略A结果接近,比较奇怪的是当页数很大时C的折线急剧下降,不知道为什么。

    而策略B随着页数的增加,平均等待时间在急剧上升。



    本文为博主原创,转载请注明来源:

    http://blog.csdn.net/cristianojason/article/details/51627993

    展开全文
  • Java语言程序设计课程设计

    千次阅读 2022-02-27 21:11:42
    Java语言程序设计课程设计 Java语言程序设计课程设计 一、 java语言程序设计课程设计要求: (1)java语言课程设计软件设计要求 1.题目不做严格限定,可自行选择题目来完成。 2.模块化程序设计 3.锯齿型书写格式 4....

    Java语言程序设计课程设计

    Java语言程序设计课程设计

    一、 java语言程序设计课程设计要求:

    (1)java语言课程设计软件设计要求
    1.题目不做严格限定,可自行选择题目来完成。
    2.模块化程序设计
    3.锯齿型书写格式
    4.必须上机调试通过

    (2)撰写课程设计报告,内容包括:
    1.课程设计题目;
    2.需求分析;
    2.概要设计(程序设计组成框图、流程图);
    3.详细设计(各模块功能说明(如类功能、接口、抽象类功能、类调用关系描述、等,若使用了第三方类包,请说明该类包在程序中的作用和功能);
    4.系统实现;
    4.调试与测试:调试程序,测试结果的分析与讨论,测试过程中遇到的主要问题及采取的解决措施;
    5.源程序清单和执行结果:清单中应有足够的注释;
    6.总结;

    (3)提交要求:
    1.每个人必须有程序运行结果,需要录制程序运行视频,放入到一个文件夹中命名为“程序运行视频”,而源代码项目也放入到一个文件夹中,命名为“源代码”。
    2.每个人都必须交《课程设计报告》打印稿,同时将Java课程设计报告电子版放入到一个文件夹(命名格式为:学号 姓名,如:20201200XX XXX)中,再将上述的“程序运行视频”和“源代码”文件夹也一并放入后上交。

    (4)打分标准:
    1.根据程序完成质量及运行效果综合判断;
    2.根据所撰写的课程设计报告打分。

    二、提交时间:
    开学后第四天(3月3日)之前提交。

    三、课程设计题目:

    推荐使用这种思路来完成课程设计:
    0.根据网络平台(如B站、Github、51cto、慕课)自行寻找一个项目跟随并独立完成。
    即可自己到网络上寻找一个自己感兴趣的java项目(如坦克大战、飞机大战等),跟着项目提供的文档、代码或者相应的视频解说来完成这个项目。注:完成时,在文档的参考文献里附上源项目的地址。

    以下题目是为没有思路、想法的同学的一个参考:
    1.职工信息管理系统设计
    职工信息包括职工号、姓名、性别、年龄、学历、工资、住址、电话等(职工号不重复)。试设计一职工信息管理系统,使之能提供以下功能:
    1、职工信息录入功能(职工信息用文件保存)--输入
    2、职工信息浏览功能--输出
    3、职工信息查询功能--算法
    查询方式:按学历查询、按职工号查询、条件组合查询
    职工信息删除、修改功能(可选项)

    源码下载

    链接:https://pan.baidu.com/s/1FXQ0nuXgUc2dwlYEX0nAMw?pwd=1111
    提取码:1111

    2.图书信息管理系统设计
    图书信息包括:登录号、书名、作者名、分类号、出版单位、出版时间、价格等。试设计一图书信息管理系统,使之能提供以下功能:
    1、图书信息录入功能(图书信息用文件保存)--输入
    2、图书信息浏览功能--输出
    3、图书信息查询功能--算法
    查询方式:按书名查询、按作者名查询、条件组合查询
    图书信息的删除与修改(可选项)

    源码下载

    链接:https://pan.baidu.com/s/1FXQ0nuXgUc2dwlYEX0nAMw?pwd=1111
    提取码:1111

    3.图书管理系统设计
    图书管理信息包括:图书名称、图书编号、单价、作者、存在状态、借书人
    姓名、性别、学号等
    功能描述:
    1、新进图书基本信息的输入。
    2、图书基本信息的查询。
    3、对撤消图书信息的删除。
    4、为借书人办理注册。
    5、办理借书手续。
    6、办理还书手续
    要求:使用文件方式存储数据。

    源码下载

    链接:https://pan.baidu.com/s/1FXQ0nuXgUc2dwlYEX0nAMw?pwd=1111
    提取码:1111

    4.实验设备管理系统设计
    实验设备信息包括:设备编号,设备种类(如:微机、打印机、扫描仪等等),设备名称,设备价格,设备购入日期,是否报废,报废日期等。
    主要功能:
    1、能够完成对设备的录入和修改
    2、对设备进行分类统计
    3、设备的破损耗费和遗损处理
    4、设备的查询
    要求:使用文件方式存储数据。

    源码下载

    链接:https://pan.baidu.com/s/1FXQ0nuXgUc2dwlYEX0nAMw?pwd=1111
    提取码:1111

    5.学生信息管理系统设计
    学生信息包括:学号,姓名,年龄,性别,出生年月,地址,电话,E-mail等。试设计一学生信息管理系统,使之能提供以下功能:
    1、系统以菜单方式工作
    2、学生信息录入功能(学生信息用文件保存)--输入
    3、学生信息浏览功能--输出
    4、学生信息查询功能--按学号查询、按姓名查询、
    5、学生信息的删除与修改(可选项) 
    要求:使用文件方式存储数据。

    源码下载

    链接:https://pan.baidu.com/s/1FXQ0nuXgUc2dwlYEX0nAMw?pwd=1111
    提取码:1111

    6.学生成绩管理系统设计
    学生成绩信息包括:学期,学号,班别,姓名,四门课程成绩(语文、数学、英语和计算机)等。
    主要功能:
    (1)能按学期、按班级完成对学生成绩的录入、修改
    (2)能按班级统计学生的成绩,求学生的总分及平均分
    (3)能查询学生成绩,不及格科目及学生名单
    (4)能按班级输出学生的成绩单
    要求:使用文件方式存储数据。

    源码下载

    链接:https://pan.baidu.com/s/1FXQ0nuXgUc2dwlYEX0nAMw?pwd=1111
    提取码:1111

    7.学生选修课程系统设计
    假定有n门课程,每门课程有:课程编号,课程名称,课程性质(公共课、必修课、选修课),总学时,授课学时,实验或上机学时,学分,开课学期等信息,
    学生可按要求(如总学分不得少于60)自由选课。
    试设计一选修课程系统,使之能提供以下功能:
    1、系统以菜单方式工作
    2、课程信息录入功能(课程信息用文件保存)--输入
    3、课程信息浏览功能--输出
    4、课程信息查询功能--算法
    查询方式:按学分查询、按课程性质查询、
    5、学生选修课程(可选项)

    源码下载

    链接:https://pan.baidu.com/s/1FXQ0nuXgUc2dwlYEX0nAMw?pwd=1111
    提取码:1111

    8.学生成绩记录簿设计
    编制一个Java语言成绩记录簿,每个学生信息包括:学号、姓名、Java语言成绩。具体功能:
    (1)创建信息链表并以磁盘文件保存;
    (2)读取磁盘文件并显示输出所有学生的成绩;
    (3)按学号或姓名查询成绩;
    (4)添加成绩记录;
    (5)修改指定姓名或学号的学生的成绩并可存盘;
    (6)显示输出60分以下、6079、8089、90分以上各分数段的学生信息(可选项)。

    源码下载

    链接:https://pan.baidu.com/s/1FXQ0nuXgUc2dwlYEX0nAMw?pwd=1111
    提取码:1111

    9.单项选择题标准化考试系统
    编程实现单项选择题标准化考试系统。
    具体要求:
    (1)用文件保存试题库。(每个试题含题干、4个备选1个标准答案)
    (2)试题录入:可随时增加试题到试题库中
    (3)试题抽取:每次从试题库中可以随机抽出N道题(N由键盘输入)
    (4)答题:用户可实现输入自己的答案
    (5)自动判卷:系统可根据用户答案与标准答案的对比实现判卷并给出成绩。
    (6)至少采用文本菜单界面(如果能采用图形菜单界面更好)
    (7)学生可自动增加新功能模块(鼓励新增功能)

    源码下载

    链接:https://pan.baidu.com/s/1FXQ0nuXgUc2dwlYEX0nAMw?pwd=1111
    提取码:1111

    10.用户设置密码验证程序
    做一个密码验证程序,密码验证只有三次机会。
    具体功能:
    (1)要求有登录界面,用户输入密码时应以*代替输出。
    (2)用户登录成功后可以修改密码。
    (3)可以有多个用户登录。初次登录的密码由管理员设置。
    (4)管理员可以添加或删除用户。

    源码下载

    链接:https://pan.baidu.com/s/1FXQ0nuXgUc2dwlYEX0nAMw?pwd=1111
    提取码:1111

    展开全文
  • Java 打印程序设计实例3.1 打印文本3.1.1 应用场景假设我们需要打印一个窗体的某个文本编辑域(可能只有几行,也可能包含多页)的内容,并且每页最多打印 54 行,如何实现呢?3.1.2 解决方法基本思路如下:首先我们...

    Java 打印程序设计实例

    3.1 打印文本

    3.1.1 应用场景

    假设我们需要打印一个窗体的某个文本编辑域(可能只有几行,也可能包含多页)的内容,并且每页最多打印 54 行,如何实现呢?

    3.1.2 解决方法

    基本思路如下:首先我们需要实现 Printable 接口,然后按照每页最多 54 行的格式计算共需要打印多少页,当打印文本的按钮被点击时,执行相应的打印动作。打印文本的具体操作可通过 Graphics2D 的 drawString 方法来实现。

    1、实现 Printable 接口

    /*Graphic 指明打印的图形环境;PageFormat 指明打印页格式(页面大小以点为计量单位,

    1 点为 1 英才的 1/72,1 英寸为 25.4 毫米。A4 纸大致为 595 &TImes; 842 点);page 指明页号 */

    public int print(Graphics g, PageFormat pf, int page) throws PrinterExcepTIon

    {

    Graphics2D g2 = (Graphics2D)g;

    g2.setPaint(Color.black); // 设置打印颜色为黑色

    if (page 》= PAGES) // 当打印页号大于需要打印的总页数时,打印工作结束

    return Printable.NO_SUCH_PAGE;

    g2.translate(pf.geTImageableX(), pf.getImageableY());// 转换坐标,确定打印边界

    drawCurrentPageText(g2, pf, page); // 打印当前页文本

    return Printable.PAGE_EXISTS; // 存在打印页时,继续打印工作

    }

    /* 打印指定页号的具体文本内容 */

    private void drawCurrentPageText(Graphics2D g2, PageFormat pf, int page)

    {

    String s = getDrawText(printStr)[page];// 获取当前页的待打印文本内容

    // 获取默认字体及相应的尺寸

    FontRenderContext c

    Font f = area.getFont();

    String drawText;

    float ascent = 16; // 给定字符点阵

    int k, i = f.getSize(), lines = 0;

    while(s.length() 》 0 && lines 《 54) // 每页限定在 54 行以内

    {

    下面的例子实现了打印字符串,线(包括虚线)和打印图片。而且通过Paper的setImageableArea可以设置打印的区域和边距,让开发者随意的设置打印的位置。

    打印字符串

    package com.cn.gao;

    import java.awt.Graphics;

    import java.awt.print.Book;

    import java.awt.print.PageFormat;

    import java.awt.print.Paper;

    import java.awt.print.Printable;

    import java.awt.print.PrinterException;

    import java.awt.print.PrinterJob;

    import java.awt.*;

    public class PrintTest implements Printable{

    /**

    * @param Graphic指明打印的图形环境

    * @param PageFormat指明打印页格式(页面大小以点为计量单位,1点为1英才的1/72,1英寸为25.4毫米。A4纸大致为595×842点)

    * @param pageIndex指明页号

    **/

    public int print(Graphics gra, PageFormat pf, int pageIndex) throws PrinterException {

    System.out.println(“pageIndex=”+pageIndex);

    Component c = null;

    //print string

    String str = “中华民族是勤劳、勇敢和富有智慧的伟大民族。”;

    //转换成Graphics2D

    Graphics2D g2 = (Graphics2D) gra;

    //设置打印颜色为黑色

    g2.setColor(Color.black);

    //打印起点坐标

    double x = pf.getImageableX();

    double y = pf.getImageableY();

    switch(pageIndex){

    case 0:

    //设置打印字体(字体名称、样式和点大小)(字体名称可以是物理或者逻辑名称)

    //Java平台所定义的五种字体系列:Serif、SansSerif、Monospaced、Dialog 和 DialogInput

    Font font = new Font(“新宋体”, Font.PLAIN, 9);

    g2.setFont(font);//设置字体

    //BasicStroke bs_3=new BasicStroke(0.5f);

    float[] dash1 = {2.0f};

    //设置打印线的属性。

    //1.线宽 2、3、不知道,4、空白的宽度,5、虚线的宽度,6、偏移量

    g2.setStroke(new BasicStroke(0.5f, BasicStroke.CAP_BUTT, BasicStroke.JOIN_MITER, 2.0f, dash1, 0.0f));

    //g2.setStroke(bs_3);//设置线宽

    float heigth = font.getSize2D();//字体高度

    System.out.println(“x=”+x);

    // -1- 用Graphics2D直接输出

    //首字符的基线(右下部)位于用户空间中的 (x, y) 位置处

    //g2.drawLine(10,10,200,300);

    Image src = Toolkit.getDefaultToolkit().getImage(“F:\\workspace\\QQ.png”);

    g2.drawImage(src,(int)x,(int)y,c);

    int img_Height=src.getHeight(c);

    int img_width=src.getWidth(c);

    //System.out.println(“img_Height=”+img_Height+“img_width=”+img_width) ;

    g2.drawString(str, (float)x, (float)y+1*heigth+img_Height);

    g2.drawLine((int)x,(int)(y+1*heigth+img_Height+10),(int)x+200,(int)(y+1*heigth+img_Height+10));

    g2.drawImage(src,(int)x,(int)(y+1*heigth+img_Height+11),c);

    return PAGE_EXISTS;

    default:

    return NO_SUCH_PAGE;

    }

    }

    public static void main(String[] args) {

    // 通俗理解就是书、文档

    Book book = new Book();

    // 设置成竖打

    PageFormat pf = new PageFormat();

    pf.setOrientation(PageFormat.PORTRAIT);

    // 通过Paper设置页面的空白边距和可打印区域。必须与实际打印纸张大小相符。

    Paper p = new Paper();

    p.setSize(590,840);//纸张大小

    p.setImageableArea(10,10, 590,840);//A4(595 X 842)设置打印区域,其实0,0应该是72,72,因为A4纸的默认X,Y边距是72

    pf.setPaper(p);

    // 把 PageFormat 和 Printable 添加到书中,组成一个页面

    book.append(new PrintTest(), pf);

    //获取打印服务对象

    PrinterJob job = PrinterJob.getPrinterJob();

    // 设置打印类

    job.setPageable(book);

    try {

    //可以用printDialog显示打印对话框,在用户确认后打印;也可以直接打印

    boolean a=job.printDialog();

    if(a)

    {

    job.print();

    }else{

    job.cancel();

    }

    } catch (PrinterException e) {

    e.printStackTrace();

    }

    }

    }

    展开全文
  • 使用Java三大特性,编写喷墨打印机和针式打印机类,通过test调用,控制台打印输出
  • java实现调用打印机

    万次阅读 2018-05-14 16:34:07
    前言在我们的实际工作中,经常需要...所以,在以前用 Java/Applet/JSP/Servlet 设计程序中,较复杂的打印都是通过调用 ActiveX/OCX 控件或者 VB/VC 程序来实现的,非常麻烦。实际上,SUN 公司也一直致力于 Java...
  • 设计一个抽象类Printer和它的两个子类BlackPrinter(黑白打印机)和ColorPrinter(彩色打印机) 要求如下: (1) 抽象类Printer有brand(品牌)属性,一个包含一个参数的构造方法,用于给brand属性赋值,一个抽象方法...
  • 当我找到了像这样的项目时,这些项目是为Arduino MCU设计的,而我拥有具有imo的RasPi至少具有相同的功能后,我开始计划建造3d打印机,这是实现此功能所必需的软件。 目前的发展 2018-05-07 清理仓库 初始化的基本...
  • 有台奇怪的打印机有以下两个特殊要求: 打印机每次只能打印同一个字符序列。 每次可以在任意起始和结束位置打印新字符,并且会覆盖掉原来已有的字符。 给定一个只包含小写英文字母的字符串,你的任务是计算这个...
  • 输出设备(例如,显示器和打印机) 通信设备(例如,调制解调器和网卡) 1.3:代表电脑中央处理器。 1.4:速度衡量单位是赫兹,1赫兹相当于每秒一个脉冲。20 世纪 90 年代计算机的时钟速度通常是以兆赫( MHz) 来...
  • java中USB接口程序设计

    千次阅读 2020-10-20 11:42:24
    java中USB接口程序设计 1.定义USB接口 package java; //定义一个 名称为USB的接口 public interface USB { void turnOn(); //启动 void turnOff(); //关闭 } 2.编写鼠标、键盘和麦克风类,作为USB接口的实现类,分别...
  • Java练习:一个简单的USB接口程序设计

    万次阅读 多人点赞 2019-12-12 20:43:33
    USB接口程序设计 1. 任务描述 通常人们使用的计算机上都有USB接口,鼠标、键盘、麦克风等都可以连接到USB接口中使用。在计算机启动时,这些设备也随之启动; 当计算机关闭时,这些设备也会随之关闭。鼠标、键盘、...
  • 在计算机系统中,线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。这些应用都或多或少具有资源管理器的功能。每台计算机可以有若干个打印机,但只能有一个Printer Spooler,以避免两个...
  • Java语言程序设计(基础篇)第十版 第一章习题答案 1.1什么是硬件和软件? 计算机是一种存储和处理数据的电子设备。 计算机包括硬件和软件。 一般来说,硬件是计算机可见的物理方面,而软件是控制硬件并使其工作的...
  • Java语言USB接口程序设计

    千次阅读 2020-12-04 11:44:59
    编写一个USB接口程序,模拟描述中的计算机的开机和关机过程。 实现思路 (1)分析任务描述可知,此任务中涉及到的对象有USB接口、鼠标、键盘、麦克风以及计算机。要实现此程序,就需要对这些对象进行相应的编写...
  • 进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动,它是系统进行资源分配和调度的一个独立单位。 线程是进程的一个实体,是CPU调度和分配的基本单位。线程基本不拥有系统资源,与同一个进程的其他...
  • java链接易联云打印机

    千次阅读 2019-08-11 08:44:35
    文章目录所需jar文件api相关配置调用api接口所有接口的调用易联云接口工具类自定义商品对象,可根据自己的需求进行设计打印模板,这里设计一个小票模板控制器,这里可以自己定义,用于测试 所需jar文件 网盘链接:...
  • 迄今为止,Java 平台已吸引了 650 多万软件开发者。它在各个重要的行业部门得到了广泛的应用,而且出现在各种各样的设备、计算机和网络中。 Java 技术的通用性、高效性、平台移植性和安全性,使之成为网络计算的理想...
  • JAVA设计模式之单例模式

    万次阅读 多人点赞 2014-04-16 06:51:34
     java中单例模式是一种常见的设计模式,单例模式的写法有好几种,这里主要介绍三种:懒汉式单例、饿汉式单例、登记式单例。  单例模式有以下特点:  1、单例类只能有一个实例。  2、单例类必须自己创建自己的...
  • JAVA语言程序设计

    2020-02-05 15:40:29
    学习一种程序设计语言,并不一定要了解计算机硬件知识,但是如果你了解一些硬件知识的话,它的确可以帮助你更好地理解程序中指令对于计算机及其组成部分的功效。 1.1 计算机硬件概述 一台计算机是由以下几个主要的...
  • Java高级程序设计笔记 • 【第6章 设计模式】

    万次阅读 多人点赞 2020-10-14 19:25:41
    6.1 设计模式 6.1.1 设计模式概述和分类 6.1.2 单列模式介绍 6.1.3 单例模式的实现 6.1.4 实践练习 6.2 单例模式的应用 6.2.1 单例模式应用场景 6.2.2 单例模式的优缺点分析 6.2.3 实践练习 6.3 简单工厂...
  • 本文实例讲述了Java面向接口编程之简单工厂模式。分享给大家供大家参考,具体如下:一 代码interface Output{// 接口里定义的成员变量只能是常量int MAX_CACHE_LINE = 50;// 接口里定义的普通方法只能是public的抽象...
  • Java桌面应用程序

    万次阅读 多人点赞 2017-04-13 15:27:47
    java桌面应用印象因为桌面程序运行在宿主机器上, 所以比如你运行java桌面程序,必然要安装java虚拟机, 也就是相当于在操作系统上再加一层抽象, 这与直接调用api的桌面程序效率相比,或多或少低一点。 因为...
  • 在并行程序中,临界区资源是保护的对象,如果出现意外,打印机同时打印两个任务,那么最有可能的结果就是打印出来的文件是坏的。 1.4 阻塞和非阻塞 阻塞和非阻塞通常用来形容多线程间的相互影响。比如一个线程占用...
  • 东大yaoyu_java

    2018-11-13 16:21:30
    东北大学yaoyujava高级程序设计
  • Java打印小票

    千次阅读 2018-12-21 22:09:18
    “无边落木萧萧下,不尽长江滚滚来” 前言 ...首先我用Java代码实现: import com.xxx.students.domain.StudentInfo; import com.sun.image.codec.jpeg.JPEGCodec; import com.sun.image.codec.j...
  • Java打印程序设计全攻略-打印预览,包括:Java的打印API 、如何实现打印 、打印机对话框。。。比较齐全,可以参考
  • Java中的23种设计模式的介绍

    千次阅读 2021-09-16 16:13:34
    设计模式 代表了最佳的实践,通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在...JAVA一共有23种设计模式,我们今天首先来学其中一种:单例设计模式 下面我们将对各种设计模式进行介绍: ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 18,995
精华内容 7,598
关键字:

java设计打印机程序

java 订阅