Java程序设计教程（第3版）雍俊海 全书例程-3

已于 2022-08-27 09:06:14 修改
阅读量454 收藏 1
点赞数 1
分类专栏： Java程序设计教程 文章标签： java 开发语言
于 2022-08-27 03:20:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45750767/article/details/126553099
版权

在这里插入图片描述

p502声音加载与播放小应用程序例程


import java.applet.AudioClip;
import java.awt.Container;
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import javax.swing.JApplet;
import javax.swing.JButton;
import javax.swing.JComboBox;
public class J_Audio extends JApplet implements ActionListener, ItemListener
{
    private AudioClip m_soundFirst,  m_soundSecond, m_soundCurrent;
    private JButton   m_buttonPlay,  m_buttonLoop,  m_buttonStop;
    private JComboBox m_comboChoose;
    public void init( ) // 在本方法中将建立起图形用户界面，并获取声音资源
    {
        Container container = getContentPane( );
        container.setLayout( new FlowLayout( ) );
        String choices[ ] = { "hi", "bark" };
        m_comboChoose = new JComboBox( choices );
        m_comboChoose.addItemListener( this );
        container.add( m_comboChoose );
        m_buttonPlay = new JButton( "播放" );
        m_buttonPlay.addActionListener( this );
        container.add( m_buttonPlay );
        
        m_buttonLoop = new JButton( "循环播放" );
        m_buttonLoop.addActionListener( this );
        container.add( m_buttonLoop );
        
        m_buttonStop = new JButton( "暂停播放" );
        m_buttonStop.addActionListener( this );
        container.add( m_buttonStop );
        
        m_soundFirst = getAudioClip( getDocumentBase( ), "hi.au" );
        m_soundSecond = getAudioClip( getDocumentBase( ), "bark.au" );
        m_soundCurrent = m_soundFirst;
    } // 方法init结束
    public void stop( )
    {
        m_soundCurrent.stop( ); // 中止声音的播放
    } // 方法stop结束
    public void itemStateChanged(ItemEvent e)
    {
        m_soundCurrent.stop( );
        m_soundCurrent=(m_comboChoose.getSelectedIndex( ) == 0 ? 
            m_soundFirst : m_soundSecond);
    } // 方法itemStateChanged结束
    public void actionPerformed(ActionEvent e)
    {
        if ( e.getSource( ) == m_buttonPlay ) 
            m_soundCurrent.play( );
        else if ( e.getSource( ) == m_buttonLoop ) 
            m_soundCurrent.loop( );
        else if ( e.getSource( ) == m_buttonStop ) 
            m_soundCurrent.stop( );
    } // 方法actionPerformed结束
} // 类J_Audio结束

p508图像输入、输出与像素处理例程


import java.awt.Graphics;
import java.awt.image.BufferedImage;
import javax.imageio.ImageIO;
import java.io.File;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Container;
import javax.swing.JFrame;
import javax.swing.JPanel;
class J_Panel extends JPanel
{
    BufferedImage m_image;
    public J_Panel( )
    {
        System.out.print("当前支持的可读取的图像类型有: ");
        mb_printString(ImageIO.getReaderFormatNames( ));
        try
        {
            File f = new File("ts.jpg");
            m_image = ImageIO.read(f); // 读取图像
            mb_getPixel(0, 0); // 输出图像的一个像素颜色值
            mb_setPixel(new Color(255, 0, 0)); // 修改图像的部分内容(加条红边)
            f = new File("ts.png");
            ImageIO.write(m_image, "png", f); // 保存图像
        }
        catch (Exception e)
        {
            System.err.println("发生异常:" + e);
            e.printStackTrace( );
        } // try-catch结构结束
        System.out.print("当前支持的可写入的图像类型有: ");
        mb_printString(ImageIO.getWriterFormatNames( ));
    } // J_Panel构造方法结束
    public void mb_printString(String [ ] s)
    {
        for (int i=0; i< s.length; i++)
            System.out.print(s[i]+ " ");
        System.out.println( );
    } // 方法mb_printString结束
    public void mb_getPixel(int x, int y)
    {
        Color c = new Color(m_image.getRGB(x, y));
        System.out.print("图像位置(" + x + ", " + y + ")的颜色值为: (");
        System.out.println(c.getRed( ) + ", "
            + c.getGreen( ) + ", " + c.getBlue( ) + ")");
    } // 方法mb_getPixel结束
    public void mb_setPixel(Color c)
    {
        for (int i=0; i< m_image.getWidth( ); i++)
            for (int j=0; j< 20; j++)
                m_image.setRGB(i, j, c.getRGB( ));
    } // 方法mb_setPixel结束
    protected void paintComponent(Graphics g)
    {
        g.drawImage(m_image, 0, 0, 150, 150, this); // 显示图像
    } // 方法paintComponent结束
} // 类J_Panel结束
public class J_Image extends JFrame
{
    public J_Image( )
    {
        super("图像处理例程");
        Container c = getContentPane( );
        c.add(new J_Panel( ), BorderLayout.CENTER);
    } // J_Image构造方法结束
    public static void main(String args[ ])
    {
        J_Image app = new J_Image( );
        app.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        app.setSize(200, 200);
        app.setVisible(true);
    } // 方法main结束
} // 类J_Image结束

p512图像显示例程


import javax.swing.JApplet;
import java.awt.Graphics;
import java.awt.Image;
public class J_ImageApplet extends JApplet
{
    Image m_image[ ] = new Image[2];
    public void init( )
    { 
        m_image[0]= getImage(getCodeBase( ), "ts1.gif");
        m_image[1]= getImage(getCodeBase( ), "ts2.gif");
    } // 方法init结束
    public void paint(Graphics g)
    { 
        g.drawImage(m_image[0],   0,   0, 150, 150, this);
        g.drawImage(m_image[1], 150,   0, 150, 150, this);
        g.drawImage(m_image[0],   0, 150, 300, 150, this);
    } // 方法paint结束
} // 类J_ImageApplet结束

p513图像显示例程


import javax.swing.JApplet;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.MediaTracker;
import java.awt.image.BufferedImage;
import java.awt.Color;
public class J_ImageApplet extends JApplet
{
    Image m_image[ ] = new Image[2];
    BufferedImage m_bufferedImage;
    MediaTracker m_media;
    public void init( )
    { 
        m_image[0]= getImage(getCodeBase( ), "ts1.gif");
        m_image[1]= getImage(getCodeBase( ), "ts2.gif");
        // 实际上这时并没有真正加载图像
        System.out.println("图像[0]的宽度为: " 
            + m_image[0].getWidth(this)); 
        System.out.println("图像[0]的高度为: "
            + m_image[0].getHeight(this));
        m_media = new MediaTracker(this);
        m_media.addImage(m_image[0], 0);
        try
        {
            m_media.waitForID(0);
        }
        catch (Exception e)
        {
            System.err.println("发生异常:" + e);
            e.printStackTrace( );
        } // try-catch结构结束
        if (m_media.checkID(0, true))
        {
            if (m_media.isErrorID(0))
                System.out.println("在加载图像[0]时出错。");
            else
                System.out.println("成功加载图像[0]。");
        }
        else
        {
            System.out.println("无法完成图像[0]的加载。");
        } // if-else结构结束
        System.out.println("图像[0]的宽度为: "
            + m_image[0].getWidth(this));
        System.out.println("图像[0]的高度为: "
            + m_image[0].getHeight(this));
        m_bufferedImage = new BufferedImage(m_image[0].getWidth(this),
            m_image[0].getHeight(this), BufferedImage.TYPE_INT_RGB);
        Graphics g = m_bufferedImage.createGraphics( );
        g.drawImage(m_image[0], 0, 0,
            m_image[0].getHeight(this), m_image[0].getHeight(this), this);
        Color c = new Color(255, 0, 0);
        for (int i=0; i< m_bufferedImage.getWidth( ); i++)
            for (int j=0; j< 20; j++)
                m_bufferedImage.setRGB(i, j, c.getRGB( ));
    } // 方法init结束
    public void paint(Graphics g)
    { 
        g.drawImage(m_image[0],   0,   0, 150, 150, this);
        g.drawImage(m_image[1], 150,   0, 150, 150, this);
        g.drawImage(m_bufferedImage,   0, 150, 300, 150, this);
    } // 方法paint结束
} // 类J_ImageApplet结束

p520字体及图形显示例程


import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.Font;
import java.awt.geom.Arc2D;
import java.awt.geom.Ellipse2D;
import java.awt.geom.QuadCurve2D;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Polygon;
import java.awt.Rectangle;
import javax.swing.JFrame;
import javax.swing.JPanel;
class J_Panel extends JPanel
{
    protected void paintComponent(Graphics g)
    {
        int[ ]x = {55, 67,109, 73, 83, 55, 27, 37,  1, 43};
        int[ ]y = { 0, 36, 36, 54, 96, 72, 96, 54, 36, 36};
        Graphics2D g2d = (Graphics2D)g;
        g.clearRect(0, 0, getWidth( ), getHeight( ));
        g.drawLine(20, 30, 60, 90);
        g2d.translate( 80, 20 );
        g2d.draw(new Rectangle(0, 10, 40, 80));
        g2d.translate( 70, 20 );
        g2d.rotate(Math.PI/2);
        Font bakF = g2d.getFont( ); // 保存原来的字体设置
        g2d.setFont(new Font("Serif", Font.ITALIC|Font.BOLD, 14 ) );
        g2d.drawString("设置字体", 0, 0);
        g2d.setFont(bakF);  // 恢复来的字体设置
        g2d.rotate(-Math.PI/2);
        g2d.translate( 40, -20 );
        g2d.draw(new Arc2D.Double(0, 30, 40, 40, 0, 360, Arc2D.OPEN));
        g2d.translate( 70, 0 );
        g2d.draw(new QuadCurve2D.Double(0, 30, 20, 130, 40, 30));
        g2d.translate( 70, 0 );
        g2d.draw(new Ellipse2D.Double(0, 10, 40, 80));
        g2d.translate( 70, 0 );
        g2d.draw(new Polygon(x, y, x.length));
    } // 方法paintComponent结束
} // 类J_Panel结束
public class J_Graphics extends JFrame
{
    public J_Graphics( )
    {
        super("字体及图形显示例程");
        Container c = getContentPane( );
        c.add(new J_Panel( ), BorderLayout.CENTER);
    } // J_Graphics构造方法结束
    public static void main(String args[ ])
    {
        J_Graphics app = new J_Graphics( );
        app.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        app.setSize(540, 160);
        app.setVisible(true);
    } // 方法main结束
} // 类J_Graphics结束

p524颜色及纹理设置例程


import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Container;
import java.awt.geom.Ellipse2D;
import java.awt.geom.Rectangle2D;
import java.awt.GradientPaint;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import java.awt.Paint;
import java.awt.Rectangle;
import java.awt.TexturePaint;
import javax.imageio.ImageIO;
import java.io.File;
import javax.swing.JFrame;
import javax.swing.JPanel;
class J_Panel extends JPanel
{
    public void mb_drawCircleGreen(Graphics2D g, int x, int y)
    {
        Color c = g.getColor( ); // 获取原来的颜色
        g.setColor( Color.green );
        g.fill( new Ellipse2D.Double( x, y, 100, 100 ) );
        g.setColor( c );   // 恢复原来的颜色设置
    } // 方法mb_drawCircleGreen结束
    public void mb_drawCircleGradientPaint(Graphics2D g, int x, int y)
    {
        Paint p = g.getPaint( ); // 获取原来的图形属性设置
        g.setPaint( new GradientPaint(x, y, Color.green,
                                x+50, y+50, Color.yellow, true) );
        g.fill( new Ellipse2D.Double( x, y, 100, 100 ) );
        g.setPaint( p );  // 恢复原来的图形属性设置
    } // 方法mb_drawCircleGradientPaint结束
    public void mb_drawRectangleTextureGraphics(Graphics2D g, int x, int y)
    {
        Paint p = g.getPaint( ); // 获取原来的图形属性设置
        BufferedImage buffImage
            = new BufferedImage(10, 10, BufferedImage.TYPE_INT_RGB );
        Graphics2D gg = buffImage.createGraphics( );   
        gg.setColor( Color.yellow );
        gg.fillRect( 0, 0, 10, 10 ); // 将图像背景设置为黄色
        gg.setColor( Color.blue );
        gg.drawRect( 1, 1, 6, 6 );   // 画一个蓝色的方框
        gg.setColor( Color.green );
        gg.fillRect( 1, 1, 3, 3 );   // 画一个绿色的正方形
        gg.setColor( Color.red );
        gg.fillRect( 4, 4, 3, 3 );   // 画一个红色的正方形
 
        g.setPaint( new TexturePaint(buffImage, new Rectangle( 10, 10 ) ) );
        g.fill( new Rectangle2D.Double( x, y, 100, 100 ) );
        g.setPaint( p );  // 恢复原来的图形属性设置
    } // 方法mb_drawRectangleTextureGraphics结束
    public void mb_drawRectangleTextureImage(Graphics2D g, int x, int y)
    {
        Paint p = g.getPaint( ); // 获取原来的图形属性设置
        BufferedImage buffImage;
        try
        {
            File f = new File("ts.jpg");
            buffImage = ImageIO.read(f); // 读取图像
            g.setPaint( 
                new TexturePaint(buffImage, new Rectangle( 50, 50 ) ) );
            g.fill( new Rectangle2D.Double( x, y, 100, 100 ) );
            g.setPaint( p );  // 恢复原来的图形属性设置
        }
        catch (Exception e)
        {
            System.err.println("发生异常:" + e);
            e.printStackTrace( );
        } // try-catch结构结束
    } // 方法mb_drawRectangleTextureImage结束
    protected void paintComponent(Graphics g)
    {
        mb_drawCircleGreen((Graphics2D)g, 20, 20);
        mb_drawCircleGradientPaint((Graphics2D)g, 140, 20);
        mb_drawRectangleTextureGraphics((Graphics2D)g, 260, 20);
        mb_drawRectangleTextureImage((Graphics2D)g, 380, 20);
    } // 方法paintComponent结束
} // 类J_Panel结束
public class J_Texture extends JFrame
{
    public J_Texture( )
    {
        super("颜色及纹理设置例程");
        Container c = getContentPane( );
        c.add(new J_Panel( ), BorderLayout.CENTER);
    } // J_Texture构造方法结束
    public static void main(String args[ ])
    {
        J_Texture app = new J_Texture( );
        app.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        app.setSize(510, 180);
        app.setVisible(true);
    } // 方法main结束
} // 类J_Texture结束

p530计算机动画例程


import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import javax.swing.JApplet;
import javax.swing.JLabel;
import javax.swing.Timer;
public class J_AnimatorTimer extends JApplet implements ActionListener
{
    int  m_frame = 0; // 当前帧的帧号
    Timer  m_timer; // 定时器
    boolean  m_frozen = false; // 定时器状态: 当为false时，暂停；否则，启动
    JLabel  m_label = new JLabel("第1帧", JLabel.CENTER);
    public void init( )
    {
        int delay = 50;
        m_timer = new Timer(delay, this);
        m_timer.setInitialDelay(0);
        m_timer.setCoalesce(true);
        getContentPane( ).add(m_label, BorderLayout.CENTER);
        m_label.addMouseListener(new MouseAdapter( )
        {
            public void mousePressed(MouseEvent e)
            {
                m_frozen = !m_frozen;
                if (m_frozen)
                     mb_stopAnimation( );
                else mb_startAnimation( );
            } // 方法mousePressed结束
        }); // 父类型为类MouseAdapter的匿名内部类结束，并且方法调用结束
    } // 方法init结束
    public void start( )
    { 
        mb_startAnimation( );
    } // 方法start结束
    public void stop( )
    { 
        mb_stopAnimation( );
    } // 方法stop结束
    public void actionPerformed(ActionEvent e)
    {
        m_frame++; // 当前帧号自增1
        m_label.setText("第" + m_frame + "帧"); // 更新当前帧号
    } // 方法actionPerformed结束
    public void mb_startAnimation( )
    {
        if (!m_frozen && !m_timer.isRunning( ))
            m_timer.start( );
    } // 方法mb_startAnimation结束
    public void mb_stopAnimation( )
    {
        if (m_timer.isRunning( ))
            m_timer.stop( );
    } // 方法mb_stopAnimation结束
} // 类J_AnimatorTimer结束

p533计算机动画例程——花的缩放


import java.awt.Color;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.geom.Ellipse2D;
import java.awt.geom.Rectangle2D;
import java.awt.GradientPaint;
import java.awt.Graphics;
import java.awt.Graphics2D;
import javax.swing.JApplet;
import javax.swing.Timer;
public class J_Flower extends JApplet implements ActionListener
{
    int  m_frame = 0; // 当前帧的帧号
    Timer  m_timer; // 定时器
    boolean  m_frozen = false; // 定时器状态: 当为false时，暂停；否则，启动
    public void init( )
    {
        int delay = 50;
        m_timer = new Timer(delay, this);
        m_timer.setInitialDelay(0);
        m_timer.setCoalesce(true);
        getContentPane( ).addMouseListener(new MouseAdapter( )
        {
            public void mousePressed(MouseEvent e)
            {
                m_frozen = !m_frozen;
                if (m_frozen)
                     mb_stopAnimation( );
                else mb_startAnimation( );
            } // 方法mousePressed结束
        }); // 父类型为类MouseAdapter的匿名内部类结束，并且方法调用结束
    } // 方法init结束
    public void start( )
    { 
        mb_startAnimation( );
    } // 方法start结束
    public void stop( )
    { 
        mb_stopAnimation( );
    } // 方法stop结束
    public void actionPerformed(ActionEvent e)
    {
        m_frame++; // 当前帧号自增1
        repaint( ); // 更新当前帧
    } // 方法actionPerformed结束
    public void mb_startAnimation( )
    {
        if (!m_frozen && !m_timer.isRunning( ))
            m_timer.start( );
    } // 方法mb_startAnimation结束
    public void mb_stopAnimation( )
    {
        if (m_timer.isRunning( ))
            m_timer.stop( );
    } // 方法mb_stopAnimation结束
    public void paint(Graphics g)
    { 
        Graphics2D g2d= (Graphics2D)g;
        int i= (m_frame>0 ? m_frame%600 : (-m_frame)%600);
        double a= (i>300 ? 600-i : i);
        double b= a*6/16;
        double a_2= a/2;
        double b_2= b/2;
        
        g2d.setPaint(new GradientPaint(0, 0, new Color(187,255,204),
                                       0, 300, Color.green, true));
        g2d.fill( new Rectangle2D.Double( 0, 0, 320,  300)); // 绘制背景
        g2d.setColor( Color.magenta ); // 绘制小花
        g2d.fill( new Ellipse2D.Double( 160-b_2, 150-a_2, b, a));
        g2d.fill( new Ellipse2D.Double( 160-a_2, 150-b_2, a, b ));
        g2d.setColor( Color.orange );
        g2d.fill( new Ellipse2D.Double( 160-b_2, 150-b_2, b, b ));
        g2d.setPaint(Color.white); // 显示当前帧号
        g2d.fill( new Rectangle2D.Double( 0, 300, 320, 20 ) );
        g2d.setColor(Color.black);
        g2d.drawString(""+m_frame, 150, 315);
    } // 方法paint结束
} // 类J_Flower结束

p537采用帧缓存的计算机动画例程——花的缩放


import java.awt.Color;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.geom.Ellipse2D;
import java.awt.geom.Rectangle2D;
import java.awt.GradientPaint;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import javax.swing.JApplet;
import javax.swing.Timer;
public class J_Flower extends JApplet implements ActionListener
{
    int  m_frame = 0; // 当前帧的帧号
    Timer  m_timer; // 定时器
    boolean  m_frozen = false; // 定时器状态: 当为false时，暂停；否则，启动
    boolean m_ready = true; // 缓存帧准备状态: 当为true时，准备好；否则，没有
    BufferedImage m_image = 
        new BufferedImage(320, 320, BufferedImage.TYPE_INT_RGB ); // 帧缓存
    public void init( )
    {
        int delay = 50;
        m_timer = new Timer(delay, this);
        m_timer.setInitialDelay(0);
        m_timer.setCoalesce(true);
        getContentPane( ).addMouseListener(new MouseAdapter( )
        {
            public void mousePressed(MouseEvent e)
            {
                m_frozen = !m_frozen;
                if (m_frozen)
                     mb_stopAnimation( );
                else mb_startAnimation( );
            } // 方法mousePressed结束
        }); // 父类型为类MouseAdapter的匿名内部类结束，并且方法调用结束
    } // 方法init结束
    public void start( )
    { 
        mb_startAnimation( );
    } // 方法start结束
    public void stop( )
    { 
        mb_stopAnimation( );
    } // 方法stop结束
    public void actionPerformed(ActionEvent e)
    {
        m_frame++; // 当前帧号自增1
        repaint( ); // 更新当前帧
    } // 方法actionPerformed结束
    public void mb_startAnimation( )
    {
        if (!m_frozen && !m_timer.isRunning( ))
            m_timer.start( );
    } // 方法mb_startAnimation结束
    public void mb_stopAnimation( )
    {
        if (m_timer.isRunning( ))
            m_timer.stop( );
    } // 方法mb_stopAnimation结束
    public void mb_draw( )
    {
        if (!m_ready)
            return;
        m_ready=false; // 开始准备帧缓存
        Graphics2D g2d = m_image.createGraphics( );
        int i= (m_frame>0 ? m_frame%600 : (-m_frame)%600);
        double a= (i>300 ? 600-i : i);
        double b= a*6/16;
        double a_2= a/2;
        double b_2= b/2;
        
        g2d.setPaint(new GradientPaint(0, 0, new Color(187,255,204),
                                       0, 300, Color.green, true));
        g2d.fill( new Rectangle2D.Double( 0, 0, 320,  300)); // 绘制背景
        g2d.setColor( Color.magenta ); // 绘制小花
        g2d.fill( new Ellipse2D.Double( 160-b_2, 150-a_2, b, a));
        g2d.fill( new Ellipse2D.Double( 160-a_2, 150-b_2, a, b ));
        g2d.setColor( Color.orange );
        g2d.fill( new Ellipse2D.Double( 160-b_2, 150-b_2, b, b ));
        g2d.setPaint(Color.white); // 显示当前帧号
        g2d.fill( new Rectangle2D.Double( 0, 300, 320, 20 ) );
        g2d.setColor(Color.black);
        g2d.drawString(""+m_frame, 150, 315);
        m_ready=true; // 帧缓存已经准备好
    } // 方法mb_draw结束
    public void paint(Graphics g)
    { 
        if (m_ready)
            g.drawImage(m_image, 0, 0, 320, 320, this);
        mb_draw( );
    } // 方法paint结束
} // 类J_Flower结束

p554创建数据库表: “学生成绩”例程


import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
public class J_AccessCreateTable
{
    public static void main(String args[ ])
    {
        try
        {
            // 加载JDBC-ODBC桥驱动程序
            Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
            // 通过数据源与数据库建立起连接
            Connection c
            =DriverManager.getConnection("jdbc:odbc:studentDatabase");
            Statement s=c.createStatement( ); // 创建SQL语句对象
            // 创建数据库表: 学生成绩
            s.executeUpdate(
                "create table 学生成绩( " +
                "学号 integer CONSTRAINT authIndex PRIMARY KEY, " +
                "姓名 char(20), " +
                "成绩 integer)");  // 创建数据库表: 学生成绩
            s.close( );
            c.close( );
            System.out.println("创建数据库表: 学生成绩");
        }
        catch (Exception e)
        {
            System.err.println("异常: " + e.getMessage( ));
        } // try-catch结构结束
    } // 方法main结束
} // 类J_AccessCreateTable结束

p558删除数据库表: “学生成绩”的例程


import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
public class J_AccessDropTable
{
    public static void main(String args[ ])
    {
        try
        {
            // 加载JDBC-ODBC桥驱动程序
            Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
            // 通过数据源与数据库建立起连接
            Connection c
            =DriverManager.getConnection("jdbc:odbc:studentDatabase");
            Statement  s=c.createStatement( ); // 创建SQL语句对象
            s.executeUpdate("drop table 学生成绩"); // 删除数据库表: 学生成绩
            s.close( );
            c.close( );
            System.out.println("删除数据库表: 学生成绩");
        }
        catch (Exception e)
        {
            System.err.println("异常: " + e.getMessage( ));
        } // try-catch结构结束
    } // 方法main结束
} // 类J_AccessDropTable结束

p560显示数据库表“学生成绩”的列信息的例程


import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.Statement;
public class J_AccessShowColumn
{
    public static void mb_ShowColumn(ResultSet r)
    {
        try
        {
            ResultSetMetaData m=r.getMetaData( ); // 获取列信息
            int n=m.getColumnCount( );
            System.out.println("数据库表共有 " + n + " 列。");
            for (int i=1; i<= n; i++)
            {
                System.out.println("第" + i + "列:");
                System.out.println("t名称为: " + m.getColumnName(i));
                System.out.println("t类型名称为: "
                    + m.getColumnTypeName(i));
                System.out.println("t精度为: " + m.getPrecision(i));
            } // for循环结束
        }
        catch (Exception e)
        {
            System.err.println("异常: " + e.getMessage( ));
        } // try-catch结构结束
    } // 方法mb_ShowColumn结束
    public static void main(String args[ ])
    {
        try
        {
            // 加载JDBC-ODBC桥驱动程序
            Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
            // 通过数据源与数据库建立起连接
            Connection c
            =DriverManager.getConnection("jdbc:odbc:studentDatabase");
            Statement s=c.createStatement( ); // 创建SQL语句对象
            // 获取数据库表数据
            ResultSet r=s.executeQuery("select * from 学生成绩");
            mb_ShowColumn(r);
            s.close( );
            c.close( );
        }
        catch (Exception e)
        {
            System.err.println("异常: " + e.getMessage( ));
        } // try-catch结构结束
    } // 方法main结束
} // 类J_AccessShowColumn结束

p563给数据库表“学生成绩”增加一列“性别”的例程


import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
public class J_AccessAddColumn
{
    public static void main(String args[ ])
    {
        try
        {
            // 加载JDBC-ODBC桥驱动程序
            Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
            // 通过数据源与数据库建立起连接
            Connection c
            =DriverManager.getConnection("jdbc:odbc:studentDatabase");
            Statement s=c.createStatement( ); // 创建SQL语句对象
            s.executeUpdate(
                "alter table 学生成绩 " +
                "add 性别 char(10)");
            s.close( );
            c.close( );
            System.out.println("给数据库表"学生成绩"增加一列: 性别");
        }
        catch (Exception e)
        {
            System.err.println("异常: " + e.getMessage( ));
        } // try-catch结构结束
    } // 方法main结束
} // 类J_AccessAddColumn结束

p565删除在数据库表“学生成绩”中的“性别”这一列的例程


import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
public class J_AccessDeleteColumn
{
    public static void main(String args[ ])
    {
        try
        {
            // 加载JDBC-ODBC桥驱动程序
            Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
            // 通过数据源与数据库建立起连接
            Connection c
            =DriverManager.getConnection("jdbc:odbc:studentDatabase");
            Statement s=c.createStatement( ); // 创建SQL语句对象
            s.executeUpdate(
                "alter table 学生成绩 " +
                "drop column 性别");
            s.close( );
            c.close( );
            System.out.println("删除在数据库表"学生成绩"中的列"性别"");
        }
        catch (Exception e)
        {
            System.err.println("异常: " + e.getMessage( ));
        } // try-catch结构结束
    } // 方法main结束
} // 类J_AccessDeleteColumn结束

p566修改在数据库表“学生成绩”中列“姓名”的属性的例程


import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
public class J_AccessModifyColumn
{
    public static void main(String args[ ])
    {
        try
        {
            // 加载JDBC-ODBC桥驱动程序
            Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
            // 通过数据源与数据库建立起连接
            Connection c
            =DriverManager.getConnection("jdbc:odbc:studentDatabase");
            Statement s=c.createStatement( ); // 创建SQL语句对象
            s.executeUpdate(
                "alter table 学生成绩 " +
                "alter column 姓名 char(30)");
            s.close( );
            c.close( );
            System.out.println(
                "修改在数据库表"学生成绩"中的列"姓名"的属性");
        }
        catch (Exception e)
        {
            System.err.println("异常: " + e.getMessage( ));
        } // try-catch结构结束
    } // 方法main结束
} // 类J_AccessModifyColumn结束

p568给数据库表“学生成绩”添加数据(记录)的例程


import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
public class J_AccessInsertRecord
{
    public static void main(String args[ ])
    {
        try
        {
            // 加载JDBC-ODBC桥驱动程序
            Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
            // 通过数据源与数据库建立起连接
            Connection c
            =DriverManager.getConnection("jdbc:odbc:studentDatabase");
            Statement s=c.createStatement( ); // 创建SQL语句对象
            // 添加记录
            s.executeUpdate(
                "insert into 学生成绩 values(2008010441, 'Mary', 70)");
            s.executeUpdate(
                "insert into 学生成绩 values(2008010442, 'Tom',  90)");
            s.executeUpdate(
                "insert into 学生成绩 values(2008010443, 'John',  80)");
            s.close( );
            c.close( );
            System.out.println("给数据库表"学生成绩"增加三行记录");
        }
        catch (Exception e)
        {
            System.err.println("异常: " + e.getMessage( ));
        } // try-catch结构结束
    } // 方法main结束
} // 类J_AccessInsertRecord结束

p570显示数据库表“学生成绩”的记录信息的例程


import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
public class J_AccessShowRecord
{
    public static void mb_ShowRecord(ResultSet r)
    {
        try
        {
            r.last( );
            System.out.println("数据库表共有" + r.getRow( ) + "行记录");
            r.beforeFirst( );
            while (r.next( ))
            {
                System.out.println("第" + r.getRow( ) + "行记录为:");
                System.out.print  ("t学号为: " + r.getInt("学号"));
                System.out.print  ("t姓名为: " + r.getString("姓名"));
                System.out.println("t成绩为: " + r.getInt("成绩"));
            } // while循环结束
        }
        catch (Exception e)
        {
            System.err.println("异常: " + e.getMessage( ));
        } // try-catch结构结束
    } // 方法mb_ShowRecord结束
    public static void main(String args[ ])
    {
        try
        {
            // 加载JDBC-ODBC桥驱动程序
            Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
            // 通过数据源与数据库建立起连接
            Connection c
            =DriverManager.getConnection("jdbc:odbc:studentDatabase");
            // 创建SQL语句对象
            Statement s=c.createStatement(
                ResultSet.TYPE_SCROLL_SENSITIVE,
                ResultSet.CONCUR_UPDATABLE);
            // 获取数据库表数据
            ResultSet r=s.executeQuery("select * from 学生成绩");
            mb_ShowRecord(r);
            s.close( );
            c.close( );
        }
        catch (Exception e)
        {
            System.err.println("异常: " + e.getMessage( ));
        } // try-catch结构结束
    } // 方法main结束
} // 类J_AccessShowRecord结束

p574删除在数据库表“学生成绩”中学号为2008010442的记录的例程

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
public class J_AccessDeleteRecord
{
    public static void main(String args[ ])
    {
        try
        {
            // 加载JDBC-ODBC桥驱动程序
            Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
            // 通过数据源与数据库建立起连接
            Connection c
            =DriverManager.getConnection("jdbc:odbc:studentDatabase");
            Statement s=c.createStatement( ); // 创建SQL语句对象
            // 删除记录
            s.executeUpdate("delete from 学生成绩 where 学号=2008010442");
            s.close( );
            c.close( );
            System.out.println(
                "删除在数据库表"学生成绩"中学号为2008010442的记录。");
        }
        catch (Exception e)
        {
            System.err.println("异常: " + e.getMessage( ));
        } // try-catch结构结束
    } // 方法main结束
} // 类J_AccessDeleteRecord结束

p575将在数据库表“学生成绩”中学号为2008010441的学生姓名改为"Jenny"的例程


import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
public class J_AccessModifyRecord
{
    public static void main(String args[ ])
    {
        try
        {
            // 加载JDBC-ODBC桥驱动程序
            Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
            // 通过数据源与数据库建立起连接
            Connection c
            =DriverManager.getConnection("jdbc:odbc:studentDatabase");
            Statement s=c.createStatement( ); // 创建SQL语句对象
            // 更新记录
            s.executeUpdate(
                "update 学生成绩 set 姓名='Jenny' where 学号=2008010441");
            s.close( );
            c.close( );
            System.out.println("将在数据库表"学生成绩""+
                "中学号为2008010441的学生姓名改为"Jenny"");
        }
        catch (Exception e)
        {
            System.err.println("异常: " + e.getMessage( ));
        } // try-catch结构结束
    } // 方法main结束
} // 类J_AccessModifyRecord结束

p592创建“学校代码”数据库表，并给数据库表添加一条记录的例程


import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
public class J_Sql
{
    public static void main(String args[ ])
    {
        try
        {
            // 加载JDBC-ODBC桥驱动程序
            Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
            // 通过数据源与数据库建立起连接
            Connection c
                =DriverManager.getConnection(
                    "jdbc:odbc:studentSqlDatabase",
                    "sa", "password");
            Statement s=c.createStatement( ); // 创建SQL语句对象
            // 创建数据库表: 学校代码
            s.executeUpdate(
                "create table 学校代码(代码 integer, 学校 char(40))");
            // 增加一条记录
            s.executeUpdate(
                "insert into 学校代码 values(10008405, '清华大学')");
            s.close( );
            c.close( );
            System.out.println("创建数据库表: 学校代码，并添加记录");
        }
        catch (Exception e)
        {
            System.err.println("异常: " + e.getMessage( ));
        } // try-catch结构结束
    } // 方法main结束
} // 类J_Sql结束

p597创建数据库表: “学科代码”，并给数据库表添加一条记录


import com.inet.tds.PDataSource;
import java.sql.Connection;
import java.sql.Statement;
public class J_Jdbc4
{
    public static void main(String args[ ])
    {
        try
        {
            // 创建数据源
            PDataSource dataSource = new PDataSource( );
            // 指定数据库服务器所在的IP地址
            dataSource.setServerName("127.0.0.1");
            // 指定数据库服务器实例名
            dataSource.setInstanceName("student");
            // 指定要使用的数据库名称
            dataSource.setDatabaseName("tempdb");
            // 指定数据库服务器帐号
            dataSource.setUser("sa");
            // 指定数据库服务器帐号密码
            dataSource.setPassword("password");
            // 通过数据源与数据库建立起连接
            Connection c = dataSource.getConnection( );
            Statement s=c.createStatement( ); // 创建SQL语句对象
            // 创建数据库表: 学科代码
            s.executeUpdate(
                "create table 学科代码(代码 integer, 学科 char(40))");
            // 添加记录
            s.executeUpdate(
                "insert into 学科代码 values(0812, '计算机科学与技术')");
            s.close( );
            c.close( );
            System.out.println("创建数据库表: 学科代码，并添加记录");
        }
        catch (Exception e)
        {
            System.err.println("异常: " + e.getMessage( ));
        }  // try-catch结构结束
    } // 方法main结束
} // 类J_Jdbc4结束

p600通过预编译SQL语句给数据库表“学生成绩”添加数据(记录)的例程


import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
public class J_AccessInsertRecordPrepareStatement
{
    public static void main(String args[ ])
    {
        try
        {
            // 加载JDBC-ODBC桥驱动程序
            Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
            // 通过数据源与数据库建立起连接
            Connection c
            =DriverManager.getConnection("jdbc:odbc:studentDatabase");
            // 创建预编译SQL语句
            PreparedStatement ps=c.prepareStatement(
                "insert into 学生成绩 values(?, ?, ?)"); 
            // 添加记录
            ps.setInt(1, 2008010444);
            ps.setString(2, "Jim");
            ps.setInt(3, 60);
            ps.executeUpdate( );
            
            // 添加记录
            ps.setInt(1, 2008010445);
            ps.setString(2, "Jack");
            ps.setInt(3, 100);
            ps.executeUpdate( );
            ps.close( );
            c.close( );
            System.out.println("给数据库表"学生成绩"增加两行记录");
        }
        catch (Exception e)
        {
            System.err.println("异常: " + e.getMessage( ));
        } // try-catch结构结束
    } // 方法main结束
} // 类J_AccessInsertRecordPrepareStatement结束

p602通过批处理SQL语句给数据库表“学生成绩”添加数据(记录)的例程

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
public class J_AccessInsertRecordBatch
{
    public static void main(String args[ ])
    {
        try
        {
            // 加载JDBC-ODBC桥驱动程序
            Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
            // 通过数据源与数据库建立起连接
            Connection c
            =DriverManager.getConnection("jdbc:odbc:studentDatabase");
            Statement s=c.createStatement( ); // 创建SQL语句对象
            // 添加批处理SQL语句
            s.addBatch(
                "insert into 学生成绩 values(2008010451, 'Rose', 75)");
            s.addBatch(
                "insert into 学生成绩 values(2008010452, 'Jame',  95)");
            s.addBatch(
                "insert into 学生成绩 values(2008010453, 'Paul', 85)");
            // 执行批处理
            s.executeBatch( );
            s.close( );
            c.close( );
            System.out.println("给数据库表"学生成绩"增加三行记录");
        }
        catch (Exception e)
        {
            System.err.println("异常: " + e.getMessage( ));
        } // try-catch结构结束
    } // 方法main结束
} // 类J_AccessInsertRecordBatch结束

p606将数据源与名称"NameOfDataSource"绑定的例程


import com.inet.tds.PDataSource;
import javax.naming.Context;
import javax.naming.InitialContext;
public class J_JNDI
{
    public static void main(String args[ ])
    {
        try
        {
            // 创建数据源
            PDataSource dataSource = new PDataSource( );
            //指定数据库服务器所在的IP地址
            dataSource.setServerName("127.0.0.1");
            //指定数据库服务器实例名
            dataSource.setInstanceName("student");
            //指定要使用的数据库名称
            dataSource.setDatabaseName("tempdb");
            //指定数据库服务器帐号
            dataSource.setUser("sa");
            //指定数据库服务器帐号密码
            dataSource.setPassword("password");
            //建立命名服务上下文
            Context ctx = new InitialContext( );
            //指定JNDI服务提供者
            ctx.addToEnvironment(Context.INITIAL_CONTEXT_FACTORY,
                "com.sun.jndi.fscontext.RefFSContextFactory");
            //通过上下文绑定数据源
            String nameOfDataSource = "NameOfDataSource";
            ctx.rebind(nameOfDataSource, dataSource);
    
            //检查是否绑定成功
            System.out.println(ctx.lookup(nameOfDataSource) +
                " is bound with " + nameOfDataSource);
    
            //关闭设备上下文
            ctx.close( );
        }
        catch (Exception e)
        {
            System.err.println("异常: " + e.getMessage( ));
        } // try-catch结构结束
    } // 方法main结束
} // 类J_JNDI结束

p608利用名称绑定连接数据库，给学科代码数据库表增加两行记录的例程


import java.sql.Connection;
import java.sql.Statement;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.sql.DataSource;
public class J_JDBC
{
    public static void main(String args[ ])
    {
        try
        {
            // 建立命名服务上下文
            Context ctx = new InitialContext( );
            // 指定JNDI服务提供者
            ctx.addToEnvironment(Context.INITIAL_CONTEXT_FACTORY,
                "com.sun.jndi.fscontext.RefFSContextFactory");
            // 通过命名服务获取数据源
            DataSource dataSource
                = (DataSource)ctx.lookup("NameOfDataSource");
            // 通过数据源与数据库建立起连接
            Connection c = dataSource.getConnection( );
            Statement s=c.createStatement( ); // 创建SQL语句对象
            // 添加记录
            s.executeUpdate(
                "insert into 学科代码 values(0601, '历史学')");
            s.executeUpdate(
                "insert into 学科代码 values(0504, '艺术学')");
            s.close( );
            c.close( );
            System.out.println(
                "利用名称绑定连接数据库，给学科代码数据库表增加两行记录");
        }
        catch (Exception e)
        {
            System.err.println("异常: " + e.getMessage( ));
        } // try-catch结构结束
    } // 方法main结束
} // 类J_JDBC结束

于2022/08/27/03/20完结

俊夫小瞳
关注
专栏目录
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

俊夫小瞳

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值