张季跃 201771010139《面向对象程序设计（java）》第十六周学习总结

Posted 2021-01-27 alex-morcer

张季跃 201771010139《面向对象程序设计（java）》第十六周学习总结

1、实验目的与要求

(1) 掌握线程概念；

(2) 掌握线程创建的两种技术；

(3) 理解和掌握线程的优先级属性及调度方法；

(4) 掌握线程同步的概念及实现技术；

2、实验内容和步骤

实验1：测试程序并进行代码注释。

测试程序1：

l 在elipse IDE中调试运行ThreadTest，结合程序运行结果理解程序；

l 掌握线程概念；

l 掌握用Thread的扩展类实现线程的方法；

l 利用Runnable接口改造程序，掌握用Runnable接口创建线程的方法。

class Lefthand extends Thread {    public void run()    {        for(int i=0;i<=5;i++)        {  System.out.println("You are Students!");            try{   sleep(500);   }            catch(InterruptedException e)            { System.out.println("Lefthand error.");}            }   } } class Righthand extends Thread {     public void run()     {          for(int i=0;i<=5;i++)          {   System.out.println("I am a Teacher!");              try{  sleep(300);  }              catch(InterruptedException e)              { System.out.println("Righthand error.");}          }     } } public class ThreadTest {      static Lefthand left;      static Righthand right;      public static void main(String[] args)      {     left=new Lefthand();            right=new Righthand();            left.start();            right.start();      } }

 程序代码：

package Test;

class Lefthand implements Runnable {
    public void run() {
        for (int i = 0; i <= 5; i++) {
            System.out.println("You are Students!");
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                System.out.println("Lefthand error.");
            }
        }
    }
}

class Righthand implements Runnable {
    public void run() {
        for (int i = 0; i <= 5; i++) {
            System.out.println("I am a Teacher!");
            try {
                Thread.sleep(300);
            } catch (InterruptedException e) {
                System.out.println("Righthand error.");
            }
        }
    }
}

public class ThreadTest {
    static Lefthand left;
    static Righthand right;

    public static void main(String[] args) {
        Runnable left1 = new Lefthand();
        Runnable right1 = new Righthand() ;
        Thread left = new Thread(left1);
        Thread right = new Thread(right1);
        left.start();
        right.start();
    }
}

 

 实验结果：

 

测试程序2：

l 在Elipse环境下调试教材625页程序14-1、14-2 、14-3，结合程序运行结果理解程序；

l 在Elipse环境下调试教材631页程序14-4，结合程序运行结果理解程序；

l 对比两个程序，理解线程的概念和用途；

l 掌握线程创建的两种技术。

程序代码：

 

package ball;

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

/**
 * Shows an animated bouncing ball.
 * @version 1.34 2015-06-21
 * @author Cay Horstmann
 */
public class Bounce
{
   public static void main(String[] args)
   {
      EventQueue.invokeLater(() -> {
         JFrame frame = new BounceFrame();
         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
         frame.setVisible(true);
      });
   }
}

 

package balll;

import java.awt.*;
import java.util.*;
import javax.swing.*;

/**
 * The component that draws the balls.
 * @version 1.34 2012-01-26
 * @author Cay Horstmann
 */
public class BallComponent extends JPanel
{
   private static final int DEFAULT_WIDTH = 450;
   private static final int DEFAULT_HEIGHT = 350;

   private java.util.List<Ball> balls = new ArrayList<>();

   /**
    * Add a ball to the component.
    * @param b the ball to add
    */
   public void add(Ball b)
   {
      balls.add(b);
   }

   public void paintComponent(Graphics g)
   {
      super.paintComponent(g); // erase background
      Graphics2D g2 = (Graphics2D) g;
      for (Ball b : balls)
      {
         g2.fill(b.getShape());
      }
   }
   
   public Dimension getPreferredSize() { return new Dimension(DEFAULT_WIDTH, DEFAULT_HEIGHT); }
}

package ball;

import java.awt.geom.*;

/**
 * A ball that moves and bounces off the edges of a rectangle
 * @version 1.33 2007-05-17
 * @author Cay Horstmann
 */
public class Ball
{
   private static final int XSIZE = 15;
   private static final int YSIZE = 15;
   private double x = 0;
   private double y = 0;
   private double dx = 1;
   private double dy = 1;

   /**
    * Moves the ball to the next position, reversing direction if it hits one of the edges
    */
   public void move(Rectangle2D bounds)
   {
      x += dx;
      y += dy;
      if (x < bounds.getMinX())
      {
         x = bounds.getMinX();
         dx = -dx;
      }
      if (x + XSIZE >= bounds.getMaxX())
      {
         x = bounds.getMaxX() - XSIZE;
         dx = -dx;
      }
      if (y < bounds.getMinY())
      {
         y = bounds.getMinY();
         dy = -dy;
      }
      if (y + YSIZE >= bounds.getMaxY())
      {
         y = bounds.getMaxY() - YSIZE;
         dy = -dy;
      }
   }

   /**
    * Gets the shape of the ball at its current position.
    */
   public Ellipse2D getShape()
   {
      return new Ellipse2D.Double(x, y, XSIZE, YSIZE);
   }
}

 

 

实验结果：

 

测试程序3：分析以下程序运行结果并理解程序。

class Race extends Thread {   public static void main(String args[]) {     Race[] runner=new Race[4];     for(int i=0;i<4;i++) runner[i]=new Race( );    for(int i=0;i<4;i++) runner[i].start( );    runner[1].setPriority(MIN_PRIORITY);    runner[3].setPriority(MAX_PRIORITY);}   public void run( ) {       for(int i=0; i<1000000; i++);       System.out.println(getName()+"线程的优先级是"+getPriority()+"已计算完毕!");     } }

程序代码：

 

class Race extends Thread {
    public static void main(String args[]) {
        Race[] runner = new Race[4];
        for (int i = 0; i < 4; i++)
            runner[i] = new Race();
        for (int i = 0; i < 4; i++)
            runner[i].start();//使该线程开始执行
        runner[1].setPriority(MIN_PRIORITY);// 更改线程优先级，线程可以具有的最低优先级
        runner[3].setPriority(MAX_PRIORITY);// 更改线程的优先级，线程可以具有的最高优先级
    }

    public void run() {
        for (int i = 0; i < 1000000; i++);// 延时作用
        System.out.println(getName() + "线程的优先级是" + getPriority() + "已计算完毕!");
    }
}

 

 

 

测试结果：

 

测试程序4

l 教材642页程序模拟一个有若干账户的银行，随机地生成在这些账户之间转移钱款的交易。每一个账户有一个线程。在每一笔交易中，会从线程所服务的账户中随机转移一定数目的钱款到另一个随机账户。

l 在Elipse环境下调试教材642页程序14-5、14-6，结合程序运行结果理解程序；

程序代码：

 

package unsynch;

import java.util.*;

/**
 * A bank with a number of bank accounts.
 * 
 * @version 1.30 2004-08-01
 * @author Cay Horstmann
 */
public class Bank {
    private final double[] accounts;

    /**
     * Constructs the bank.
     * 
     * @param n              the number of accounts
     * @param initialBalance the initial balance for each account
     */
    public Bank(int n, double initialBalance) {
        accounts = new double[n];
        Arrays.fill(accounts, initialBalance);
    }

    /**
     * Transfers money from one account to another.
     * 
     * @param from   the account to transfer from
     * @param to     the account to transfer to
     * @param amount the amount to transfer
     */
    public void transfer(int from, int to, double amount) {
        if (accounts[from] < amount)
            return;
        System.out.print(Thread.currentThread());//返回对当前正在执行的线程对象的引用
        accounts[from] -= amount;
        System.out.printf(" %10.2f from %d to %d", amount, from, to);
        accounts[to] += amount;
        System.out.printf(" Total Balance: %10.2f%n", getTotalBalance());
    }

    /**
     * Gets the sum of all account balances.
     * 
     * @return the total balance
     */
    public double getTotalBalance() {
        double sum = 0;

        for (double a : accounts)
            sum += a;

        return sum;
    }

    /**
     * Gets the number of accounts in the bank.
     * 
     * @return the number of accounts
     */
    public int size() {
        return accounts.length;
    }
}

 

package unsynch;

/**
 * This program shows data corruption when multiple threads access a data
 * structure.
 * 
 * @version 1.31 2015-06-21
 * @author Cay Horstmann
 */
public class UnsynchBankTest {
    public static final int NACCOUNTS = 100;
    public static final double INITIAL_BALANCE = 1000;
    public static final double MAX_AMOUNT = 1000;
    public static final int DELAY = 10;

    public static void main(String[] args) {
        Bank bank = new Bank(NACCOUNTS, INITIAL_BALANCE);
        for (int i = 0; i < NACCOUNTS; i++) {
            int fromAccount = i;
            Runnable r = () -> {
                try {
                    while (true) {
                        int toAccount = (int) (bank.size() * Math.random());
                        double amount = MAX_AMOUNT * Math.random();
                        bank.transfer(fromAccount, toAccount, amount);
                        Thread.sleep((int) (DELAY * Math.random()));//在指定的毫秒数内让当前正在执行的线程休眠
                    }
                } catch (InterruptedException e) {
                }
            };
            Thread t = new Thread(r);//分配新的 Thread 对象
            t.start();//使该线程开始执行
        }
    }
}

 

 

测试结果：

 

综合编程练习

编程练习1

1. 设计一个用户信息采集程序，要求如下：

（1） 用户信息输入界面如下图所示:

（2） 用户点击提交按钮时，用户输入信息显示控制台界面；

（3） 用户点击重置按钮后，清空用户已输入信息；

（4） 点击窗口关闭，程序退出。

实验代码：

 

package 测试程序5;

import java.awt.EventQueue;

import javax.swing.JFrame;

public class Mian {
    public static void main(String[] args) {
        EventQueue.invokeLater(() -> {
            demo page = new demo();
        });
    }
}

 

package 测试程序5;

import java.awt.Dimension;
import java.awt.Toolkit;
import java.awt.Window;

public class WinCenter {
    public static void center(Window win){
        Toolkit tkit = Toolkit.getDefaultToolkit();
        Dimension sSize = tkit.getScreenSize();
        Dimension wSize = win.getSize();
        if(wSize.height > sSize.height){
            wSize.height = sSize.height;
        }
        if(wSize.width > sSize.width) {
            wSize.width = sSize.width;
        }
        win.setLocation((sSize.width - wSize.width)/ 2, (sSize.height - wSize.height)/ 2);
    }
}

package 测试程序5;

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.border.*;
public class demo extends JFrame {
    public demo() {
        JPanel panel1 = new JPanel();
        panel1.setPreferredSize(new Dimension(700, 45));
        panel1.setLayout(new GridLayout(1, 4));
        JLabel label1 = new JLabel("Name:");
        JTextField j1 = new JTextField("");
        JLabel label2 = new JLabel("Qualification:");
        JComboBox<Object> j2 = new JComboBox<>();
        j2.addItem("Graduate");
        j2.addItem("Not Graduate");
        panel1.add(label1);
        panel1.add(j1);
        panel1.add(label2);
        panel1.add(j2);

        JPanel panel2 = new JPanel();
        panel2.setPreferredSize(new Dimension(700, 50));
        panel2.setLayout(new GridLayout(1, 4));
        JLabel label3 = new JLabel("Address:");
        JTextArea j3 = new JTextArea();
        JLabel label4 = new JLabel("Hobby:");
        JPanel p = new JPanel();
        p.setLayout(new GridLayout(3, 1));
        p.setBorder(BorderFactory.createLineBorder(null));
        JCheckBox c1 = new JCheckBox("Reading");
        JCheckBox c2 = new JCheckBox("Singing");
        JCheckBox c3 = new JCheckBox("Dancing");
        p.add(c1);
        p.add(c2);
        p.add(c3);
        panel2.add(label3);
        panel2.add(j3);
        panel2.add(label4);
        panel2.add(p);

        JPanel panel3 = new JPanel();
        panel3.setPreferredSize(new Dimension(700, 150));
        FlowLayout flowLayout1 = new FlowLayout(FlowLayout.LEFT, 20, 40);
        panel3.setLayout(flowLayout1);
        JLabel label5 = new JLabel("Sex:");
        JPanel p1 = new JPanel();
        p1.setLayout(new GridLayout(2,1));
        p1.setBorder(BorderFactory.createLineBorder(null));
        ButtonGroup bu = new ButtonGroup();
        JRadioButton jr1 = new JRadioButton("Male");
        JRadioButton jr2 = new JRadioButton("Female");
        bu.add(jr1);
        bu.add(jr2);
        p1.add(jr1);
        p1.add(jr2);
        panel3.add(label5);
        panel3.add(p1);
        add(panel1);
        add(panel2);
        add(panel3);

        JPanel panel4 = new JPanel();
        panel4.setPreferredSize(new Dimension(700, 150));
        JButton b1 = new JButton("Validate");
        panel4.add(b1);
        JButton b2 = new JButton("Reset");
        panel4.add(b2);
        add(panel4);

        FlowLayout flowLayout = new FlowLayout();
        this.setLayout(flowLayout);
        this.setTitle("Students Detail");
        this.setBounds(200, 200, 800, 400);
        this.setVisible(true);
        this.setDefaultCloseOperation(DISPOSE_ON_CLOSE);

        b1.addActionListener(new ActionListener() {

        
            public void actionPerformed(ActionEvent e) {
                // TODO 自动生成的方法存根
                String xueli = j2.getSelectedItem().toString();
                System.out.println("Name:" + j1.getText());
                System.out.println("Qualification:" + xueli);
                String hobbystring = "Hobby:";
                if (c1.isSelected()) {
                    hobbystring += "Reading";
                }
                if (c2.isSelected()) {
                    hobbystring += "Singing";
                }
                if (c3.isSelected()) {
                    hobbystring += "Dancing";
                }
                System.out.println("Address:" + j3.getText());
                if (jr1.isSelected()) {
                    System.out.println("Sex:Male");
                }
                if (jr2.isSelected()) {
                    System.out.println("Sex:Female");
                }
                System.out.println(hobbystring);
            }
        });
        b2.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {
                // TODO 自动生成的方法存根
                j1.setText(null);
                j3.setText(null);
                j2.setSelectedIndex(0);
                c1.setSelected(false);
                c2.setSelected(false);
                c3.setSelected(false);
                bu.clearSelection();
            }
        });
    }

    public static void main(String args[]) {
        new demo();
    }

}

 

 

实验结果：

 

2．创建两个线程，每个线程按顺序输出5次“你好”，每个“你好”要标明来自哪个线程及其顺序号。

实验代码：

 

package demo;

class Lefthand extends Thread {
    public void run() 
    {
        for (int i = 1; i <= 5; i++) 
        {
            System.out.println("L:"+i+" 你好!");
            try 
            {
                sleep(300);
            } catch (InterruptedException e) 
            {
                System.out.println("Lefthand error.");
            }
        }
    }
}

class Righthand extends Thread{
    public void run()
    {
        for (int i = 1; i <= 5; i++)
        {
            System.out.println("R:"+i+" 你好!");
            try
            {
                sleep(300);
            } catch (InterruptedException e) 
            {
                System.out.println("Righthand error.");
            }
        }
    }
}

public class ThreadTest {
    static Lefthand left;
    static Righthand right;

    public static void main(String[] args) 
    {
        left = new Lefthand();
        right = new Righthand();
        left.start();
        right.start();
    }
}

 

 

 

实验结果：

 

3. 完善实验十五 GUI综合编程练习程序。

 实验总结：

     在这一周的学习过程中，我初步了解学习了关于线程的知识，并初步掌握了线程创建的两种方法，但在实验过程中，我发现我对线程掌握的并不是很熟练，实验二还好说，但实验一有很多不懂的地方，还是参考了许多同学的代码才做出来，即使如此，与要求的结果还是有许多的不同。