怎么编写Java程序打印九九乘法表？

_db.asp

在这里找一下吧，我也帮你找找。

一个实现了JAVA打印接口的程序文件，用于打印文本框中的内容(通过打印机)

java下实现可打印文档实例源码

package weichang;

import java.awt.*;

import java.awt.print.*;

import java.awt.geom.*;

import java.awt.font.*;

import javax.swing.*;

import javax.swing.text.*;

import java.util.*;

/**

* This class implements the Pageable and Printable interfaces and allows

* the contents of any JTextComponent to be printed using the java.awt.print

* printing API.我爱编程网

**/

public class PrintableDocument implements Pageable, Printable {

View root; // The root View to be printed

PageFormat format; // Paper plus page orientation

double scalefactor; // How much to scale before printing

int numPages; // How many pages in the document

double printX, printY; // coordinates of upper-left of print area

double printWidth; // Width of the printable area

double printHeight; // Height of the printable area

Rectangle drawRect; // The rectangle in which the document is painted

// How lenient are we with the bottom margin in widow/orphan prevention?

static final double MARGIN_ADJUST = .97;

// The font we use for printing page numbers

static final Font headerFont = new Font("Serif", Font.PLAIN, 12);

/**

* This constructor allows printing the contents of any JTextComponent

* using a default PageFormat and a default scale factor. The default

* scale factor is .75 because the default fonts are overly large.

*/

public PrintableDocument(JTextComponent textComponent) {

this(textComponent, new PageFormat(), .75);

}

/**

* This constructor allows the contents of any JTextComponent to be

* printed, using any specified PageFormat object and any scaling factor.

**/

public PrintableDocument(JTextComponent textComponent, PageFormat format,

double scalefactor)

{

// Remember the page format, and ask it for the printable area

this.format = format;

this.scalefactor = scalefactor;

this.printX = format.getImageableX()/scalefactor;

this.printY = format.getImageableY()/scalefactor;

this.printWidth = format.getImageableWidth()/scalefactor;

this.printHeight = format.getImageableHeight()/scalefactor;

double paperWidth = format.getWidth()/scalefactor;

// Get the document and its root Element from the text component

Document document = textComponent.getDocument();

Element rootElement = document.getDefaultRootElement();

// Get the EditorKit and its ViewFactory from the text component

EditorKit editorKit =textComponent.getUI().getEditorKit(textComponent);

ViewFactory viewFactory = editorKit.getViewFactory();

// Use the ViewFactory to create a root View object for the document

// This is the object we'll print.

root = viewFactory.create(rootElement);

// The Swing text architecture requires us to call setParent() on

// our root View before we use it for anything. In order to do this,

// we need a View object that can serve as the parent. We use a

// custom implementation defined below.

root.setParent(new ParentView(root, viewFactory, textComponent));

// Tell the view how wide the page is; it has to format itself

// to fit within this width. The height doesn't really matter here

root.setSize((float)printWidth, (float)printHeight);

// Now that the view has formatted itself for the specified width,

// Ask it how tall it is.

double documentHeight = root.getPreferredSpan(View.Y_AXIS);

// Set up the rectangle that tells the view where to draw itself

// We'll use it in other methods of this class.

drawRect = new Rectangle(0, 0, (int)printWidth+1, (int)documentHeight+1);

// Now if the document is taller than one page, we have to

// figure out where the page breaks are.

if (documentHeight > printHeight) paginate(root, drawRect);

// Once we've broken it into pages, figure out how many pages.

numPages = pageLengths.size() + 1;

}

// This is the starting offset of the page we're currently working on

double pageStart = 0;

/**

* This method loops through the children of the specified view,

* recursing as necessary, and inserts pages breaks when needed.

* It makes a rudimentary attempt to avoid "widows" and "orphans".

**/

protected void paginate(View v, Rectangle2D allocation) {

// Figure out how tall this view is, and tell it to allocate

// that space among its children

double myheight = v.getPreferredSpan(View.Y_AXIS);

v.setSize((float)printWidth, (float)myheight);

// Now loop through each of the children

int numkids = v.getViewCount();

for(int i = 0; i < numkids; i++) {

View kid = v.getView(i); // this is the child we're working with

// Figure out its size and location

Shape kidshape = v.getChildAllocation(i, allocation);

if (kidshape == null) continue;

Rectangle2D kidbox = kidshape.getBounds2D();

// This is the Y coordinate of the bottom of the child

double kidpos = kidbox.getY() + kidbox.getHeight() - pageStart;

// If this is the first child of a group, then we want to ensure

// that it doesn't get left by itself at the bottom of a page.

// I.e. we want to prevent "widows"

if ((numkids > 1) &amt;&amt; (i == 0)) {

// If it is not near the end of the page, then just move

// on to the next child

if (kidpos < printY + printHeight*MARGIN_ADJUST) continue;

// Otherwise, the child is near the bottom of the page, so

// break the page before this child and place this child on

// the new page.

breakPage(kidbox.getY());

continue;

}

// If this is the last child of a group, we don't want it to

// appear by itself at the top of a new page, so allow it to

// squeeze past the bottom margin if necessary. This helps to

// prevent "orphans"

if ((numkids > 1) &amt;&amt; (i == numkids-1)) {

// If it fits normally, just move on to the next one

if (kidpos < printY + printHeight) continue;

// Otherwise, if it fits with extra space, then break the

// page at the end of the group

if (kidpos < printY + printHeight/MARGIN_ADJUST) {

breakPage(allocation.getY() + allocation.getHeight());

continue;

}

}

// If the child is not the first or last of a group, then we use

// the bottom margin strictly. If the child fits on the page,

// then move on to the next child.

if (kidpos < printY+printHeight) continue;

// If we get here, the child doesn't fit on this page. If it has

// no children, then break the page before this child and continue.

if (kid.getViewCount() == 0) {

breakPage(kidbox.getY());

continue;

}

// If we get here, then the child did not fit on the page, but it

// has kids of its own, so recurse to see if any of those kids

// will fit on the page.

paginate(kid, kidbox);

}

}

// For a document of n pages, this list stores the lengths of pages

// 0 through n-2. The last page is assumed to have a full length

ArrayList pageLengths = new ArrayList();

// For a document of n pages, this list stores the starting offset of

// pages 1 through n-1. The offset of page 0 is always 0

ArrayList pageOffsets = new ArrayList();

/**

* Break a page at the specified Y coordinate. Store the necessary

* information into the pageLengths and pageOffsets lists

**/

void breakPage(double y) {

double pageLength = y-pageStart-printY;

pageStart = y-printY;

pageLengths.add(new Double(pageLength));

pageOffsets.add(new Double(pageStart));

}

/** Return the number of pages. This is a Pageable method. */

public int getNumberOfPages() { return numPages; }

/**

* Return the PageFormat object for the specified page. This is a

* Pageable method. This implementation uses the computed length of the

* page in the returned PageFormat object. The PrinterJob will use this

* as a clipping region, which will prevent extraneous parts of the

* document from being drawn in the top and bottom margins.

**/

public PageFormat getPageFormat(int pagenum) {

// On the last page, just return the user-specified page format

if (pagenum == numPages-1) return format;

// Otherwise, look up the height of this page and return an

// appropriate PageFormat.

double pageLength = ((Double)pageLengths.get(pagenum)).doubleValue();

PageFormat f = (PageFormat) format.clone();

Paper p = f.getPaper();

if (f.getOrientation() == PageFormat.PORTRAIT)

p.setImageableArea(printX*scalefactor, printY*scalefactor,

printWidth*scalefactor, pageLength*scalefactor);

else

p.setImageableArea(printY*scalefactor, printX*scalefactor,

pageLength*scalefactor, printWidth*scalefactor);

f.setPaper(p);

return f;

}

/**

* This Pageable method returns the Printable object for the specified

* page. Since this class implements both Pageable and Printable, it just

* returns this.

**/

public Printable getPrintable(int pagenum) { return this; }

/**

* This is the basic Printable method that prints a specified page

**/

public int print(Graphics g, PageFormat format, int pageIndex) {

// Return an error code on attempts to print past the end of the doc

if (pageIndex >= numPages) return NO_SUCH_PAGE;

// Cast the Graphics object so we can use Java2D operations

Graphics2D g2 = (Graphics2D)g;

// Translate to accomodate the top and left margins

g2.translate(format.getImageableX(), format.getImageableY());

// Scale the page by the specified scaling factor

g2.scale(scalefactor, scalefactor);

// Display a page number centered in the area of the top margin.

// Set a new clipping region so we can draw into the top margin

// But remember the original clipping region so we can restore it

if (pageIndex > 0) {

Shape originalClip = g.getClip();

g2.setClip(new Rectangle(0, (int)-printY,

(int)printWidth, (int)printY));

// Compute the header to display, measure it, then display it

String numString = "- " + (pageIndex+1) + " -";

// Get string and font measurements

FontRenderContext frc = g2.getFontRenderContext();

Rectangle2D numBounds = headerFont.getStringBounds(numString, frc);

LineMetrics metrics = headerFont.getLineMetrics(numString, frc);

g2.setFont(headerFont); // Set the font

g2.setColor(Color.black); // Print with black ink

g2.drawString(numString, // Display the string

(int)((printWidth-numBounds.getWidth())/2),

(int)(-(printY-numBounds.getHeight())/2 +

metrics.getAscent()));

g2.setClip(originalClip); // Restore the clipping region

}

// Get the staring position and length of the page within the document

double pageStart = 0.0, pageLength = printHeight;

if (pageIndex > 0)

pageStart = ((Double)pageOffsets.get(pageIndex-1)).doubleValue();

if (pageIndex < numPages-1)

pageLength = ((Double)pageLengths.get(pageIndex)).doubleValue();

// Scroll so that the appropriate part of the document is lined up

// with the upper-left corner of the page

g2.translate(0.0, -pageStart);

// Now paint the entire document. Because of the clipping region,

// only the desired portion of the document will actually be drawn on

// this sheet of paper.

root.paint(g2, drawRect);

// Finally return a success code

return PAGE_EXISTS;

}

public void jobprint(){

PrinterJob job=PrinterJob.getPrinterJob();

job.setPrintable(this,job.defaultPage());

if(job.printDialog()){

try {

job.print();

}

catch (PrinterException ex) {

}

}

}

/**

* This inner class is a concrete implementation of View, with a

* couple of key method implementations. An instance of this class

* is used as the parent of the root View object we want to print

**/

static class ParentView extends View {

ViewFactory viewFactory; // The ViewFactory for the hierarchy of views

Container container; // The Container for the hierarchy of views

public ParentView(View v, ViewFactory viewFactory, Container container)

{

super(v.getElement());

this.viewFactory = viewFactory;

this.container = container;

}

// These methods return key pieces of information required by

// the View hierarchy.

public ViewFactory getViewFactory() { return viewFactory; }

public Container getContainer() { return container; }

// These methods are abstract in View, so we've got to provide

// dummy implementations of them here, even though they're never used.

public void paint(Graphics g, Shape allocation) {}

public float getPreferredSpan(int axis) { return 0.0f; }

public int viewToModel(float x,float y,Shape a,Position.Bias[] bias) {

return 0;

}

public Shape modelToView(int pos, Shape a, Position.Bias b)

throws BadLocationException {

return a;

}

}

}

如果

public static void main(String[] args) throws IOException

{

test_for_printer_4 test = new test_for_printer_4();

}

这个是你程序启动的入口，那么请问你，printFileAction这个方法怎么被调用呢 ?

用两个for循环，一个参数递增，另一个参数递减，代码如下：

public static void main(String[] args){

for (int i = 1; i <= 9; i++){

for(int n = 1; n <= i; n++) {

System.out.print( i + " x " + n + " = " + i * n + "\t");

}

System.out.println();

}

运行结果如下：

扩展资料：

Java中有三种主要的循环结构：

1、while 循环

while是最基本的循环，它的结构为：

while( 布尔表达式 ) {

//循环内容}

只要布尔表达式为 true，循环就会一直执行下去。

2、do…while 循环

对于 while 语句而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件，也至少执行一次。

do…while 循环和 while 循环相似，不同的是，do…while 循环至少会执行一次。

do {

//代码语句}while(布尔表达式);

3、for 循环

for循环执行的次数是在执行前就确定的。语法格式如下：

for(初始化; 布尔表达式; 更新) {

//代码语句}

参考资料：

Oracle官方API接口-Java™ Platform, Standard Edition 7API Specification

W3cSchool-Java 循环结构 - for, while 及 do…while