JavaSE编码试题强化练习1

1. 编写应用程序，创建类的对象，分别设置圆的半径、圆柱体的高，计算并分别显示圆半径、圆面积、圆周长，圆柱体的体积。

/**
 * 定义父类--圆类
 */
public class Circle {
  /**
   * 私有属性：成员变量--圆半径
   */
  private double radius;
  /**
   * 构造方法
   */
  public Circle() {
    radius = 0.0;
  }

  public Circle(double radius) {
    this.radius = radius;
  }

  /**
   *成员方法--求圆周长
   */
  double getPerimeter(){
    return 2*Math.PI*radius;
  }

  /**
   * 成员方法--求圆面积
   */
  double getArea(){
    return Math.PI*radius*radius;
  }
  /**
   * 成员方法--显示圆半径、周长、面积
   */
  void show(){
    System.out.println("圆半径："+radius);
    System.out.println("圆周长："+getPerimeter());
    System.out.println("圆面积："+getArea());
  }
}

/**
 * 定义子类--圆柱类
 */
public class Cylinder extends Circle {
  /**
   * 私有属性:成员变量--圆柱体的高
   */
  private double hight;
  /**
   * 构造方法、调用父类方法
   */
  public Cylinder() {
  }

  public Cylinder(double r, double h) {
    super(r);
    this.hight = h;
  }

  /**
   * 成员方法--求圆柱体的体积
   */
  public double getVolume(){
    return getArea()*hight;
  }
  /**
   * 成员方法--显示圆柱体体积
   */
  void showVolume(){
    System.out.println("圆柱体的体积 = "+getVolume());
  }
}

/**
 * 测试类
 */
public class Test {
  public static void main(String[] args) {
    /**
     * 创建圆类对象、调用方法
     */
    Circle c = new Circle();
    /**
     * 调用圆类方法
     */
    c.show();
    /**
     * 创建圆柱体对象(实例)、调用方法
     */
    Cylinder cy = new Cylinder();
    /**
     *调用父类方法
     */
    cy.show();
    /**
     * 调用子类方法
     */
    cy.showVolume();
  }
}

2.设计4个线程，其中两个线程每次对j增加1，另外两个线程对j每次减少1。

编写实现，要求：使用内部类实现线程，对j增减的时候不考虑顺序问题。

/**
 * 测试类
 */
public class ThreadTest {
  /**
   * 声明成员变量
   */
  private int j;
  /**
   * 程序主入口：main方法
   */
  public static void main(String[] args) {
    /**
     * 创建对象
     */
    ThreadTest tt = new ThreadTest();
    /**
     * 创建线程内部类对象
     */
    Inc inc = tt.new Inc();
    Dec dec = tt.new Dec();
    for (int i = 0;i < 2;i++){
      /**
       * 创建线程对象并启动线程
       */
      Thread t = new Thread(inc);
      t.start();
      t = new Thread(dec);
      t.start();
    }
  }
  /**
   * 实现同步对j的值+1操作
   */
  private synchronized void inc(){
    j++;
    System.out.println(Thread.currentThread().getName()+"-inc :"+j);
  }
  /**
   * 实现同步对j的值-1操作
   */
  private synchronized void dec(){
    j--;
    System.out.println(Thread.currentThread().getName()+"-dec :"+j);
  }
  /**
   * 内部类
   */
  private class Inc implements Runnable {
    @Override
    public void run() {
      for (int i = 0;i < 100;i++){
        /**
         * 调用加的方法
         */
        inc();
      }
    }
  }
  private class Dec implements Runnable{
    @Override
    public void run() {
      for (int i = 0; i < 100; i++) {
        /**
         * 调用减的方法
         */
        dec();
      }
    }
  }
}

3.Java的通信编程，用Java Socket编程，要求从客户端录入几个字符，发送到服务器端，由服务器端将接收到的字符进行输出。

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * 线程通信--服务器端
 */
public class Server {
  /**
   * 声明ServerSocket对象
   */
  private ServerSocket ss;
  /**
   * 声明Socket对象
   */
  private Socket socket;
  /**
   * 声明输入流对象BufferedReader
   */
  private BufferedReader br;
  /**
   * 声明输出流对象
   */
  private PrintWriter pw;
  public Server(){
    try {
      /**
       * 创建一个ServerSocket对象，指定等待端口
       */
      ss = new ServerSocket(8848);
      while (true){
        /**
         * 使用ServerSocket接收用户请求(服务器端处于监听状态)
         */
        /**
         * 获得客户端的socket对象
         */
        socket = ss.accept();
        /**
         * 创建输入流并读取信息
         */
        br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        String line = br.readLine();
        System.out.println("客户端请求："+line);
        /**
         * 创建输出流并输出信息
         */
        pw = new PrintWriter(socket.getOutputStream(),true);
        pw.print("请求已接收！");
        /**
         * 关闭流
         */
        pw.close();
        br.close();
        socket.close();
      }
    } catch (IOException e) {
      pw.println("出现异常！");
    }
  }
  /**
   * 程序主入口
   */
  public static void main(String[] args) {
    /**
     * 创建服务器端对象
     */
    new Server();
  }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;

/**
 * 线程通信--客户端
 */
public class Client {
  /**
   * 声明Socket对象
   */
  Socket socket;
  /**
   * 声明输入流对象
   */
  BufferedReader br;
  /**
   * 声明输出流对象
   */
  PrintWriter pw;
  /**
   * 构造方法
   */
  public Client(){
    try {
      /**
       * 创建Socket对象用来发送请求
       */
      socket = new Socket("127.0.0.1",8848);
      /**
       * 创建字符缓冲区对象并输出
       */
      BufferedReader line =
        new BufferedReader(new InputStreamReader(System.in));
      /**
       * 创建输出流对象并输出
       */
      pw = new PrintWriter(socket.getOutputStream(),true);
      pw.println(line.readLine());
      /**
       * 创建输入流对象
       */
      br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
      System.out.println(br.readLine());
      /**
       * 关闭流
       */
      pw.close();
      br.close();
      socket.close();
    } catch (IOException e) {
      System.out.println("请求出错！");
    }
  }
  /**
   * 程序主入口
   */
  public static void main(String[] args) {
    /**
     * 创建客户端对象
     */
    new Client();
  }
}

线程通信在自己的电脑上测试过程：

1、先运行服务器端程序，运行结果如下图

*红色方框中的红色方块按钮亮起代表程序已运行，正在等待（监听）客户端请求

2、再运行客户端程序，并输入请求，运行如下图

2.1　　客户端处于等待输入指令状态

2.2　　客户端完成指令输入并得到服务器端回应，红色方块按钮灭掉

2.3　　服务器端，收到客户端请求给出回馈信息，并未关闭监听状态，需手动停止（现实中服务器一般是时刻处于监听状态的，维护期间会关闭）