201771010101 白玛次仁 《2018面向对象程序设计（Java）》第十六周学习总结

实验十六  线程技术

实验时间 2017-12-8

1.学习总结：

1.程序 是一段静态的代码，它应用程序执行蓝 是一段静态的代码，它应用程序执行蓝 本。
2.进程 是程序的一次动态执行，它对应了从代码加 是程序的一次动态执行，，它对应了从代码加 载、执行至完毕的一个整过程。

3.操作系统为每个进程分配一段独立的内存空间和 系统资源，包括：代码数据以及堆栈等。每 系统资源，包括：代码数据以及堆栈等。每 一个进程的内部数据和状态都是完全独立。
4.多任务操作系统 中，进程切换对 CPU 资源消耗较 大。多线程 是进程执行过中产生的多条线索。 线程是比进执行更小的单位。线程不能独立存在，必须于进 中同一程的各线间共享进空数据。 程的各线共享进空数据。每个线程有它自身的产生、存在和消亡过，  是一个动态的概念。
5.Java 实现多线程有两种途径：
1.创建 Thread 类的子

2.在程序中定义实现 Runnable 接口的类

6.首先需从 Thread 类派生出一个子， 在该子类中 重写 run()方法。

首先设计一个实现 Runnable  接口的类； 接口的类； 接口的类； 接口的类； 接口的类；
7.? 用Runnable() 接口实现线程

1.首先设计一个实现 Runnable  接口的类

2.然后在类中根据需要重写 run 方法；

3再创建该类对象，以此为参数立 再创建该类对象，以此为参数立 Thread类的对象；

4.调用 Thread 类对象的 start 方法启动线程，将 CPU 执行权转交到 run 方法。
8.当线程的  run 方法执行体中最后 一条语句方法执行体中最后 一条语句， 或者出现了在 run 方法中没有捕获的异常时 ，线 程将终止 ，让出 CPU 使用权 。

9.利用各线程的状态变换，可以控制个轮流 利用各线程的状态变换， 使用 CPU ，体现多线程的 并行性特征。

10.线程的终止：当线程的run方法执行方法体中最后一条语句后， 或者出现了在run方法中没有捕获的异常时，线 程将终止，让出CPU使用权。调用interrupt()方法也可终止线程。

11.线程的状态：利用各线程的状态变换，可以控制各个线程轮流 使用CPU，体现多线程的并行性特征。线程有如下7种状态： New (新建) 、Runnable (可运行) 、Running(运行) 、Blocked (被阻塞) 、Waiting (等待) 、Timed waiting (计时等待) 、Terminated (被终止)

12.调用setPriority(int a)重置当前线程的优先级， a 取值可以是前述的三个静态量。

2、实验目的与要求

(1) 掌握线程概念；

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

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

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

3、实验内容和步骤

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

测试程序1：

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

l 掌握线程概念；

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

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

class Lefthand extends Thread {
 2    public void run()
 3    {
 4        for(int i=0;i<=5;i++)
 5        {  System.out.println("You are Students!");
 6            try{   sleep(500);   }
 7            catch(InterruptedException e)
 8            { System.out.println("Lefthand error.");}
 9        }
10   }
11 }
12 class Righthand extends Thread {
13     public void run()
14     {
15          for(int i=0;i<=5;i++)
16          {   System.out.println("I am a Teacher!");
17              try{  sleep(300);  }
18              catch(InterruptedException e)
19              { System.out.println("Righthand error.");}
20          }
21     }
22 }
23 public class ThreadTest
24 {
25      static Lefthand left;
26      static Righthand right;
27      public static void main(String[] args)
28      {     left=new Lefthand();
29            right=new Righthand();
30            left.start();
31            right.start();
32      }
33 }
package gfhc;
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.");}
             }
             Lefthand left=new Lefthand ();
             Righthand right=new Righthand ();
        }

        }

    public class fgyukg
    {
         static Lefthand left;
         static Righthand right;
         public static void main(String[] args)
         {    // left=new Lefthand();
               //right=new Righthand();
              // left.start ();
              // right.start();
             Runnable Lefthand =new Lefthand ();
             Thread t=new Thread(Lefthand );
             t.start();
             Runnable Righthand =new Righthand ();
             Thread t1=new Thread(Righthand );
             t1.start();
         }
    }

测试程序2：

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

package bounce;

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);
   }
}
package bounce;

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 bounce;

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);
      });
   }
}

/**
 * The frame with ball component and buttons.
 */
class BounceFrame extends JFrame
{
   private BallComponent comp;
   public static final int STEPS = 1000;
   public static final int DELAY = 3;

   /**
    * Constructs the frame with the component for showing the bouncing ball and
    * Start and Close buttons
    */
   public BounceFrame()
   //BounceFrame类的addBall方法中有调用comp.paint(comp.getGraphics())
   {
      setTitle("Bounce");
      comp = new BallComponent();
      add(comp, BorderLayout.CENTER);
      JPanel buttonPanel = new JPanel();
      addButton(buttonPanel, "Start", event -> addBall());
      addButton(buttonPanel, "Close", event -> System.exit(0));
      add(buttonPanel, BorderLayout.SOUTH);//将buttonPanel组件整体放在南端
      pack();
   }

   /**
    * Adds a button to a container.
    * @param c the container
    * @param title the button title
    * @param listener the action listener for the button
    */
   public void addButton(Container c, String title, ActionListener listener)
   {
      JButton button = new JButton(title);
      c.add(button);
      button.addActionListener(listener);
   }

   /**
    * Adds a bouncing ball to the panel and makes it bounce 1,000 times.
    */
   public void addBall()//Start按钮的处理程序将调用addBall
   {
      try
      {
         Ball ball = new Ball();
         comp.add(ball);

         for (int i = 1; i <= STEPS; i++)
         {
            ball.move(comp.getBounds());/调用move方法
            comp.paint(comp.getGraphics());
            Thread.sleep(DELAY);//Sleep是  Thread累静态方法，用于暂停当前线程的活动。
         }
      }
      catch (InterruptedException e)
      //InterruptedException 只是在发生异常时简单地终止弹跳。
      {
      }
   }
}

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

 
package bounceThread;

import java.awt.*;
import java.awt.event.*;

import javax.swing.*;

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

/**
 * The frame with panel and buttons.
 */
class BounceFrame extends JFrame
{
   private BallComponent comp;
   public static final int STEPS = 1000;
   public static final int DELAY = 5;

   /**
    * Constructs the frame with the component for showing the bouncing ball and
    * Start and Close buttons
    */
   public BounceFrame()
   {
      comp = new BallComponent();
      add(comp, BorderLayout.CENTER);
      JPanel buttonPanel = new JPanel();
      addButton(buttonPanel, "Start", event -> addBall());
      addButton(buttonPanel, "Close", event -> System.exit(0));
      add(buttonPanel, BorderLayout.SOUTH);
      pack();
   }

   /**
    * Adds a button to a container.
    * @param c the container
    * @param title the button title
    * @param listener the action listener for the button
    */
   public void addButton(Container c, String title, ActionListener listener)
   {
      JButton button = new JButton(title);
      c.add(button);
      button.addActionListener(listener);
   }

   /**
    * Adds a bouncing ball to the canvas and starts a thread to make it bounce
    */
   public void addBall()
   {
      Ball ball = new Ball();
      comp.add(ball);//引用实现了Runnable的方法
      Runnable r = () -> {
         try
         {
            for (int i = 1; i <= STEPS; i++)
            {
               ball.move(comp.getBounds());
               comp.repaint();
               Thread.sleep(DELAY);
            }
         }
         catch (InterruptedException e)
         {
         }
      };
      Thread t = new Thread(r);//用Runnable创建一个Thread对象     t.start();//启动线程
   }
}

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

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

测试程序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);//将指定的 double 值分配给指定 double 型数组的每个元素
   }

   /**
    * 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);
         t.start();
      }
   }
}

综合编程练习

编程练习1

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

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

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

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

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

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);
    }
}
import java.awt.Color;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.GridLayout;
import java.awt.LayoutManager;
import java.awt.Panel;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Timer;
import java.util.TimerTask;

import javax.swing.BorderFactory;
import javax.swing.ButtonGroup;
import javax.swing.ButtonModel;
import javax.swing.JButton;
import javax.swing.JCheckBox;
import javax.swing.JComboBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JRadioButton;
import javax.swing.JTextField;

public class DemoJFrame extends JFrame {
    private JPanel jPanel1;
    private JPanel jPanel2;
    private JPanel jPanel3;
    private JPanel jPanel4;
    private JTextField fieldname;
    private JComboBox comboBox;
    private JTextField fieldadress;
    private ButtonGroup bg;
    private JRadioButton male;
    private JRadioButton female;
    private JCheckBox read;
    private JCheckBox movie;
    private JCheckBox learn;

    public DemoJFrame() {
        // 设置窗口大小
        this.setSize(800, 400);
        // 设置可见性
        this.setVisible(true);
        // 设置标题
        this.setTitle("编程练习一");
        // 设置关闭操作
        this.setDefaultCloseOperation(EXIT_ON_CLOSE);
        // 设置窗口居中
        WinCenter.center(this);
        // 创建四个面板对象
        jPanel1 = new JPanel();
        setJPanel1(jPanel1);
        jPanel2 = new JPanel();
        setJPanel2(jPanel2);
        jPanel3 = new JPanel();
        setJPanel3(jPanel3);
        jPanel4 = new JPanel();
        setJPanel4(jPanel4);
        // 设置容器的为流布局
        FlowLayout flowLayout = new FlowLayout();//构造一个新的 FlowLayout，它是居中对齐的
        this.setLayout(flowLayout);
        // 将四个面板添加到容器中
        this.add(jPanel1);
        this.add(jPanel2);
        this.add(jPanel3);
        this.add(jPanel4);

    }

    /*
     * 设置面一
     */
    private void setJPanel1(JPanel jPanel) {
        // TODO 自动生成的方法存根
        jPanel.setPreferredSize(new Dimension(700, 45));
        // 给面板的布局设置为网格布局 一行4列
        jPanel.setLayout(new GridLayout(1, 4));
        JLabel name = new JLabel("姓名:");
        name.setSize(100, 50);
        fieldname = new JTextField("");
        fieldname.setSize(80, 20);
        JLabel study = new JLabel("学历:");
        comboBox = new JComboBox();
        comboBox.addItem("初中");
        comboBox.addItem("高中");
        comboBox.addItem("本科");
        jPanel.add(name);
        jPanel.add(fieldname);
        jPanel.add(study);
        jPanel.add(comboBox);

    }

    /*
     * 设置面板二
     */
    private void setJPanel2(JPanel jPanel) {
        // TODO 自动生成的方法存根
        jPanel.setPreferredSize(new Dimension(700, 50));
        // 给面板的布局设置为网格布局 一行4列
        jPanel.setLayout(new GridLayout(1, 4));
        JLabel name = new JLabel("地址:");
        fieldadress = new JTextField();
        fieldadress.setPreferredSize(new Dimension(150, 50));
        JLabel study = new JLabel("爱好:");
        JPanel selectBox = new JPanel();
        selectBox.setBorder(BorderFactory.createTitledBorder(""));//创建一个新标题边框
        selectBox.setLayout(new GridLayout(3, 1));//创建具有指定行数和列数的网格布局。给布局中的所有组件分配相等的大小。
        read = new JCheckBox("读书");
        movie = new JCheckBox("看电影");
        learn = new JCheckBox("学习");
        selectBox.add(read);
        selectBox.add(movie);
        selectBox.add(learn);
        jPanel.add(name);
        jPanel.add(fieldadress);
        jPanel.add(study);
        jPanel.add(selectBox);
    }

    /*
     * 设置面板三
     */
    private void setJPanel3(JPanel jPanel) {
        // TODO 自动生成的方法存根
        jPanel.setPreferredSize(new Dimension(700, 150));
        FlowLayout flowLayout = new FlowLayout(FlowLayout.LEFT);
        jPanel.setLayout(flowLayout);
        JLabel sex = new JLabel("性别:");
        JPanel selectBox = new JPanel();
        selectBox.setBorder(BorderFactory.createTitledBorder(""));
        selectBox.setLayout(new GridLayout(2, 1));
        bg = new ButtonGroup();
        male = new JRadioButton("男");
        female = new JRadioButton("女");
        bg.add(male);
        bg.add(female);
        selectBox.add(male);
        selectBox.add(female);
        jPanel.add(sex);
        jPanel.add(selectBox);

    }

    /*
     * 设置面板四
     */
    private void setJPanel4(JPanel jPanel) {
        // TODO 自动生成的方法存根
        jPanel.setPreferredSize(new Dimension(700, 150));
        FlowLayout flowLayout = new FlowLayout(FlowLayout.CENTER, 50, 10);
        jPanel.setLayout(flowLayout);
        jPanel.setLayout(flowLayout);
        JButton sublite = new JButton("提交");
        JButton reset = new JButton("重置");
        sublite.addActionListener((e) -> valiData());
        reset.addActionListener((e) -> Reset());//给提交和重置按钮创建监听器
        jPanel.add(sublite);
        jPanel.add(reset);
    }

    /*
     * 提交数据
     */
    private void valiData() {
        // TODO 自动生成的方法存根
        // 拿到数据
        String name = fieldname.getText().toString().trim();
        String xueli = comboBox.getSelectedItem().toString().trim();
        String address = fieldadress.getText().toString().trim();
        System.out.println(name);
        System.out.println(xueli);
        String hobbystring="";
        if (read.isSelected()) {
            hobbystring+="读书   ";
        }
        if (movie.isSelected()) {
            hobbystring+="看电影   ";
        }
        if (learn.isSelected()) {
            hobbystring+="学习  ";
        }
        System.out.println(address);
        if (male.isSelected()) {
            System.out.println("男");
        }
        if (female.isSelected()) {
            System.out.println("女");
        }
        System.out.println(hobbystring);
    }

    /*
     * 重置
     */
    private void Reset() {
        // TODO 自动生成的方法存根
        fieldadress.setText(null);
        fieldname.setText(null);
        comboBox.setSelectedIndex(0);
        read.setSelected(false);
        movie.setSelected(false);
        learn.setSelected(false);
        bg.clearSelection();
    }
}
import java.awt.EventQueue;

import javax.swing.JFrame;

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

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

package project2;

class Lefthand extends Thread { 

       public void run()

       {

           for(int i=0;i<=4;i++)

           {  System.out.println("1.你好");

               try{   sleep(500);   }

               catch(InterruptedException e)

               { System.out.println("Lefthand error.");}    

           } 

      } 

    }

    class Righthand extends Thread {

        public void run()

        {

             for(int i=0;i<=4;i++)

             {   System.out.println("2.你好");

                 try{  sleep(300);  }

                 catch(InterruptedException e)

                 { System.out.println("Righthand error.");}

             }

        }

    }

    public class ThreadText 

    {

         static Lefthand left;

         static Righthand right;

         public static void main(String[] args)

         {     left=new Lefthand();

               right=new Righthand();

               left.start();

               right.start();

         }

    }

实验总结：这次实验运行多个程序的能力。例：操作系统将CPU的时间片分配给每一个进程，给人并行处理的感觉。

重要比较了多线程和多进程有哪些区别等，好多知识的收获。

原文地址：https://www.cnblogs.com/baimaciren/p/10115371.html

时间： 2024-11-08 23:57:47

201771010101 白玛次仁 《2018面向对象程序设计（Java）》第十六周学习总结的相关文章

20177101010101 白玛次仁《面向对象程序设计》第十八周学习总结

实验十八  总复习 实验时间 2018-12-30 1.实验目的与要求 (1) 综合掌握java基本程序结构: (2) 综合掌握java面向对象程序设计特点: (3) 综合掌握java GUI 程序设计结构: (4) 综合掌握java多线程编程模型: (5) 综合编程练习. 2.实验内容和步骤 任务1:填写课程课后调查问卷,网址:https://www.wjx.cn/jq/33108969.aspx. 任务2:综合编程练习 练习1:设计一个用户信息采集程序,要求如下: (1) 用户信息输入界面如

201771010101白玛次仁《面向对象程序设计（java）》第十二周实验总结

实验十二  图形程序设计 实验时间 2018-11-14 学习总结: 1.Java的抽象口工具箱( Abstract WindowToolkit, AWT)包含在java.awt包中,它提供了许多用来设计GUI的组件类和容器类. 2.AWT库处理用户界面元素的方法:把图形元素的创建和行为委托给本地GUI工具箱进行处理. 3.Swing用户界面库是非基于对等体的GUI工具箱.Swing具有更丰富并且更方便的用户界面元素集合.Swing对底层平台的依赖很少,因此与平台相关的bug很少.Swing会带

201771010109焦旭超《面向对象程序设计》第十八周学习总结

1.实验目的与要求 (1) 综合掌握java基本程序结构: (2) 综合掌握java面向对象程序设计特点: (3) 综合掌握java GUI 程序设计结构: (4) 综合掌握java多线程编程模型: (5) 综合编程练习. 2.实验内容和步骤 任务1:填写课程课后调查问卷,网址:https://www.wjx.cn/jq/33108969.aspx. 任务2:综合编程练习 练习1:设计一个用户信息采集程序,要求如下: (1) 用户信息输入界面如下图所示: (1)用户点击提交按钮时,用户输入信息显

王艳 《面向对象程序设计》第十五周学习总结

实验十五  GUI编程练习与应用程序部署 一:理论部分. 1.Java 程序的打包:编译完成后,程序员将.class 文件压缩打包为 .jar 文件后,GUI 界面序就可以直接双击图标运行.JAR 文件是压缩的,它使用 ZIP 压缩格式. 创建一个包含清单的 JAR 文件,应该运行:jar cf mMyArchive.jar manifest.mf com/ *.class2.资源:Java 中,应用程序使的类通常需要一些相关数中,应用程序使的类通常需要一些相关数 据文件,这些称为资源 (Res

2016-2017-2 《Java程序设计》第十六周学习总结

在上周通过做实验作业对线程进行了了解,线程有多线程和单线程.多线程可以一次执行多个任务,可以同时运行一个以上线程的程序为多线程程序.线程的建立有两个方法,第一可以通过继承Thread类,并且通过在run()方法中添加方法体来决定自己的线程所要执行的动作:第二可以通过设定类来实现Runnable接口,并重写run()方法.并且用实现了Runnable接口的类设定一个对象,并用此Runnable对象创建一个Thread对象,并用Thread对象来启动线程.如果需要执行一个比较耗时的任务,应当并发地运

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

张季跃 201771010139<面向对象程序设计(java)>第十六周学习总结 1.实验目的与要求 (1) 掌握线程概念: (2) 掌握线程创建的两种技术: (3) 理解和掌握线程的优先级属性及调度方法: (4) 掌握线程同步的概念及实现技术: 2.实验内容和步骤 实验1:测试程序并进行代码注释. 测试程序1: l 在elipse IDE中调试运行ThreadTest,结合程序运行结果理解程序: l 掌握线程概念: l 掌握用Thread的扩展类实现线程的方法: l 利用Runnable接口

20182327 2019-2020-1 《数据结构与面向对象程序设计》第二第三周学习总结

20182327 2019-2020-1 <数据结构与面向对象程序设计>第二第三周学习总结 教材学习内容总结 在第二章的学习中,首先学习了Java编程的基本格式,然后学会了定义.赋值.使用各种数据类型的变量,可以独立打印数据到屏幕上,最后掌握了如何使用Scanner类的一般使用方法. 从第三章中,我学到了由String.Math.Random等类创建对象(即实例化对象),如果要使用Java.long包以外的类,要使用import声明,最后枚举类型,包装类没有看懂. 教材学习中的问题和解决过程

《数据结构与面向对象程序设计》第二、三周学习总结

目录 20182319 2019-2020-1 <数据结构与面向对象程序设计>第二.三周学习总结 教材学习内容总结 教材学习中的问题和解决过程 代码调试中的问题和解决过程 代码托管 上周考试错题总结 结对及互评 评分: 点评过的同学博客和代码 其他(感悟.思考等,可选) 学习进度条 20182319 2019-2020-1 <数据结构与面向对象程序设计>第二.三周学习总结 @ 教材学习内容总结 ??这两周主要学习的是对于数据的类型以及输入输出的学习和对于几个常用的类的学习. ??首

20182304 《数据结构与面向对象程序设计》第七八周学习总结

20182304 <数据结构与面向对象程序设计>第七八周学习总结 教材学习内容总结 时间复杂度分析:时间复杂度越低,程序运行效率越高.时间复杂度又称为算法的阶,符号计为O(),它由增长函数的主项决定.可以通过数学方法求出增长函数从而确定程序的时间复杂度 线性集合:集合中的元素按直线方式组织.如:队列集合.栈集合 栈是一种线性数据结构,采用后进先出(Last in,first out)的方法处理元素,我们学习使用了数组和链表来实现栈 链表:链表是链式结构的一种.在链表中,对象引用变量也可称为指针

201777010217-金云馨《面向对象程序设计Java》第四周总结学习

2019面向对象程序设计(Java)第4周学习指导及要求 项目 内容 这个作业属于哪个课程 <任课教师博客主页链接>https://www.cnblogs.com/nwnu-daizh/ 这个作业的要求在哪里 <作业链接地址>https://www.cnblogs.com/nwnu-daizh/p/11552848.html 作业学习目标 <填写具体目标> 掌握类与对象的基础概念,理解类与对象的关系: 掌握对象与对象变量的关系: 掌握预定义类Date.LocalDate