Java课程实践

Java Java

发布时间 : 2020-01-10 11:06

阅读 :

1 背景
2 流程控制程序设计
3 面向对象程序设计
4 语言基础与面向对象
5 Java类库
6 图形用户界面程序设计基础
7 图形用户界面应用程序设计
8 I/O编程
1. 8.1 文件内容拷贝
2. 8.2 In类
9 异常处理、线程控制
10 网络通讯编程

1 背景

前一阵一直在忙着各种考试，所以就没怎么写博客，这两天放假了，在学校闲着无事，补补博客吧。

2 流程控制程序设计

2.1 打印乘法表

说明

打印一个三角形的1到9的乘法表。

打印三角形

代码

public class Demo
{
    public static void main(String arg[])
    {
    int s;
    for(int i = 1; i <= 9; i++)
    {
        for(int j = 1; j <= i; j++)
        {
            s = i * j;
            System.out.print(i * j + "\t");
        }
        System.out.println();
    }
    }
}

运行截图

打印三角形乘法表

2.2 月份转换

说明

编写一程序，将从键盘输入的每个月份数(整数)显示出其对应的英文，直至输入0结束，注意对非法数据的处理。 (while,switch语句)

代码

import java.util.Scanner; 
public class Demo 
{ 
    public static void main(String arg[]) 
    { 
        System.out.println("请输入月份数："); 
        Scanner Month = new Scanner(System.in); 
        int month = 1; 
        while(month != 0) 
        { 
            month = Month.nextInt(); 
            switch(month) 
            {
                case 0: System.out.println("程序结束！"); break; 
                case 1: System.out.println("January"); break; 
                case 2: System.out.println("February"); break; 
                case 3: System.out.println("March"); break; 
                case 4: System.out.println("April");break; 
                case 5: System.out.println("May"); break; 
                case 6: System.out.println("June"); break; 
                case 7: System.out.println("July"); break; 
                case 8: System.out.println("August"); break; 
                case 9: System.out.println("September"); break; 
                case 10: System.out.println("October"); break; 
                case 11: System.out.println("November"); break; 
                case 12: System.out.println("December"); break; 
                default: System.out.println("输入数据的格式错误，请输入 1~12 之间的整 数！"); break; 
            } 
        } 
    } 
}

运行截图

打印数字对应的月份

2.3 打印图案

说明

打印图案：一个由n行星花组成的三角形。如n=5时的图案为：

打印图案

代码

import java.util.Scanner; 
public class Demo 
{ 
    public static void main(String arg[]) 
    { 
        System.out.println("请输入*的行数："); 
        Scanner Row = new Scanner(System.in); 
        int row = Row.nextInt(); 
        for(int i = 1; i <= row; i++) 
        { 
            for(int j = 1; j <= row - i; j++) 
            { 
                System.out.print(" "); 
            }
            for(int k = 1; k <= 2 * i - 1; k++) 
            { 
                if(k % 2 != 0) 
                { 
                    System.out.print("*"); 
                }
                else 
                { 
                    System.out.print(" "); 
                } 
            }
            System.out.println("");
        } 
    } 
}

运行截图

打印图案

2.4 打印水仙花数

说明

打印出所有的“水仙花数”。所谓“水仙花数”是指一个三位数，其各位数字的立方和等于该数本身。例如153是一个“水仙花数”，因为153=13+53+33。

代码

public class Demo 
{ 
    public static void main(String arg[]) 
    { 
        int bai, shi, ge, num; 
        for(num = 100; num < 1000; num++) 
        { 
            bai = num / 100; 
            shi = (num - bai * 100) / 10; 
            ge = num - bai * 100 - shi * 10; 
            if(num == bai * bai * bai + shi * shi * shi + ge * ge * ge) 
            { 
                System.out.println(num); 
            } 
        } 
    } 
}

运行截图

打印水仙花数

2.5 判断闰年

说明

编写一个程序，从键盘读一个年份的数字，然后判断该年是否是闰年，如果是就输出“闰年”，如果不是就输出“非闰年”。
闰年的条件是满足以下两个条件之一：
1）能被4整除，但不能被100整除；
2）能被4整除，又能被400整除。

代码

import java.util.Scanner; 
public class Demo 
{ 
    public static void main(String arg[]) 
    { 
        System.out.println("请输入需要判断的年份："); 
        Scanner input = new Scanner(System.in); 
        int year = input.nextInt(); 
        if((year % 400 == 0) || (year % 4 == 0 && year % 100 != 0)) 
        { 
            System.out.println(year + " is leapyear."); 
        } 
    } 
}

运行截图

判断闰年

2.6 五位数

说明

统计个位数是6，并且能被3整除的五位数共有多少个。

代码

public class Demo 
{ 
    public static void main(String arg[]) 
    { 
        int wan, qian, bai, shi, ge, num, sum = 0; 
        for(num = 10000; num < 100000; num ++) 
        {
            wan = num / 10000; 
            qian = (num - wan * 10000) / 1000; 
            bai = (num - wan * 10000 - qian * 1000) / 100; 
            shi = (num - wan * 10000 - qian * 1000 - bai * 100) / 10; 
            ge = num - wan * 10000 - qian * 1000 - bai * 100 - shi * 10; 
            if(num % 3 == 0 && ge == 6) 
            { 
                sum++; 
            } 
        }
        System.out.println("统计个位数是 6，并且能被 3 整除的五位数的个数：" + sum);
    } 
}

运行截图

满足条件的五位数

2.7 输出最小数

说明

编写一个程序，在其中建立一个有10个整数的数组，运行后从键盘输入10个数，然后输出其中的最小数。

代码

import java.util.Scanner; 
public class Demo 
{ 
    public static void main(String arg[]) 
    { 
        System.out.println("请输入 10 个整数："); 
        int arr[] = new int [10]; 
        int small = 0; 
        Scanner input = new Scanner(System.in); 
        for(int i = 0; i < 10; i++) 
        { 
            arr[i] = input.nextInt(); 
        }
        small = arr[0]; 
        for(int j = 0; j < 9; j++) 
        { 
            small = arr[j + 1] > small ? small : arr[j + 1];
        }
        System.out.println(small); 
    } 
}

运行截图

输出最小数

2.8 数组排序

说明

编写一个程序，在其中建立一个有10个整数的数组，运行后从键盘输入10个数，然后排序(升序)后输出。

代码

import java.util.Scanner; 
import java.util.Arrays; 
public class Demo 
{ 
    public static void main(String arg[]) 
    { 
        System.out.println("请输入 10 个整数："); 
        int arr[] = new int [10]; 
        Scanner input = new Scanner(System.in); 
        for(int i = 0; i < 10; i++) 
        { 
            arr[i] = input.nextInt(); 
        }
        Arrays.sort(arr); 
        for(int j = 0; j < 10; j++) 
        { 
            System.out.println(arr[j]); 
        } 
    }
}

运行截图

数组排序

2.9 矩阵最小元素

说明

编写一个程序，找出5行5列整数矩阵中的最小元素，矩阵元素由键盘输入。

代码

import java.util.Scanner; 
import java.util.Arrays; 
public class Demo 
{ 
    public static void main(String arg[]) 
    { 
        System.out.println("请输入 25 个整数："); 
        int arr[][] = new int [5][5]; 
        int small = 100000; 
        Scanner input = new Scanner(System.in); 
        for(int i = 0; i < 5; i++) 
        { 
            for(int j = 0; j < 5; j++) 
            { 
                arr[i][j] = input.nextInt(); 
            }
            Arrays.sort(arr[i]); 
            small = arr[i][0] > small ? small : arr[i][0]; 
        }
        System.out.println(small);
    } 
}

运行截图

矩阵最小元素

2.10 矩阵行之和

说明

编写一个程序，计算出5行5列整数矩阵的每行之和。

代码

import java.util.Scanner; 
import java.util.Arrays; 
public class Demo 
{ 
    public static void main(String arg[]) 
    { 
        System.out.println("请输入 5 * 5 矩阵的 25 个元素："); 
        int arr[][] = new int [5][5]; 
        int sum[] = new int[5]; 
        Scanner input = new Scanner(System.in); 
        for(int i = 0; i < 5; i++) 
        { 
            for(int j = 0; j < 5; j++) 
            { 
                arr[i][j] = input.nextInt(); 
                sum[j] += arr[i][j]; 
            } 
        }
        for(int k = 0; k < 5; k++) 
        { 
            System.out.println("矩阵的第" + k + "行之和是：" + sum[k]); 
        } 
    } 
}

运行截图

矩阵行元素之和

2.11 随机数组对角线元素和

说明

编写一个程序，在其中定义一个6行6列的二维整型数组, 利用随机函数产生36个10到20之间的随机整数放入，然后将数组输出到屏幕上(6行6列格式)。最后计算出数组中对角线元素的平方根和。

代码

import java.util.Scanner; 
import java.util.Random; 
public class Demo 
{ 
    public static void main(String arg[]) 
    { 
        System.out.println("请输入 6 * 6 矩阵的 36 个元素："); 
        int[] sum = { 0, 0 }; 
        int arr[][] = new int [6][6]; 
        Scanner input = new Scanner(System.in); 
        Random random = new Random(); 
        for(int i = 0; i < 6; i++) 
        { 
            for(int j = 0; j < 6; j++) 
            { 
                arr[i][j] = random.nextInt(10) + 10; 
            } 
        }
        for(int k = 0; k < 6; k++) 
        { 
            sum[0] += arr[k][k]; 
            sum[1] += arr[k][5 - k];
        }
        System.out.println("从左上角到右下角的元素之和是：" + sum[0]); System.out.println("从右上角到左下角的元素之和是：" + sum[1]); 
    } 
}

运行截图

随机数组对角线元素和

3 面向对象程序设计

3.1 最大公约数

说明

编一程序，求两个正整数m、n的最大公约数。
要求程序中有两个方法，分别使用循环和递归求最大公约数，最后在主方法中分别调用这两个方法求解56与91的最大公约数。
提示：用辗转相除法。
方法：
(1) 求m除n的余数r；
(2) 如果r为0，则n为最大公约数，结束。否则转(3);
(3) 用n置m，用r置n ，回到(1)。

代码

public class Demo 
{ 
    public static void main(String arg[]) 
    { 
        int m = 96, n = 51, result = 0; xunhuan(m, n); 
        result = digui(m, n); 
        System.out.println("96 与 51 的最大公约数是：" + result); 
    }
    public static void xunhuan(int a, int b) 
    { 
        int gongyueshu = 0, r = a % b;
        while(r != 0)
        { 
            r = a % b; 
            if(r != 0) 
            { 
                a = b; 
                b = r; 
            }
            else 
            { 
                gongyueshu = b; 
                break; 
            } 
        }
        System.out.println("96 与 51 的最大公约数是：" + gongyueshu); 
    }
    public static int digui(int a, int b) 
    { 
        int r = a % b; 
        if(r != 0) 
        { 
            b = digui(b, r); 
        }
        return b; 
    } 
}

运行截图

最大公约数

3.2 复数类

说明

编写一个完整的Java Application程序，其中设计一个复数类Complex，利用它验证两个复数 1+2i 和3+4i 相加产生一个新的复数 4+6i 。复数类Complex的设计必须满足如下要求：
1）Complex 的属性有：
realPart：int型，代表复数的实数部分；
maginPart：int型，代表复数的虚数部分。
2）Complex 的方法有：
Complex()：构造方法，将复数的实部和虚部都置0；
Complex(int r , int i )：构造方法，形参 r 为实部的初值，i为虚部的初值。
3）Complex complexAdd(Complex a)：将当前复数对象与形参复数对象相加，最后的结果仍是一个复数对象，返回给此方法的调用者。
4）String toString(): 把当前复数对象的实部、虚部组合成 a+bi 的字符串形式，其中a 和 b分别为实部和虚部的数据。

代码

class Complex 
{ 
    int RealPart; 
    int ImaginPart; 
    Complex() 
    { 
        RealPart = 0; 
        ImaginPart = 0; 
    }
    Complex(int r, int i) 
    { 
        RealPart = r; 
        ImaginPart = i; 
    }
    Complex complexAdd(Complex a) 
    { 
        Complex temp = new Complex();
        temp.RealPart = RealPart + a.RealPart; 
        temp.ImaginPart = ImaginPart + a.ImaginPart; 
        return temp; 
    }
    public String toString() 
    { 
        return (RealPart + " + " + ImaginPart + " i "); 
    } 
}
public class Demo 
{ 
    public static void main(String[] args) 
    { 
        Complex fushu1 = new Complex(1, 2); 
        Complex fushu2 = new Complex(3, 4); 
        Complex tmp = new Complex(); 
        tmp = fushu1.complexAdd(fushu2); 
        System.out.println("1+2i 与 3+4i 的结果为："); 
        System.out.println(tmp.toString()); 
    } 
}

运行截图

复数类

3.3 圆类

说明

编写一个包含圆类的程序，并为圆类设计几个构造方法和一般方法，在主方法中创建一个圆类对象并输出它的周长和面积。
要求：
属性有3个：x,y,r，分别放置圆心坐标和半径；
构造方法有2个。一个是无参的，用于设置3个属性的值都为0；另一个有参的，用于设置3个属性的值，以确定一个具体的圆。
计算周长的方法：double zc()；
计算面积的方法：double mj()。

代码

import java.util.Scanner; 
class Round 
{ 
    double x; 
    double y; 
    double r;
    Round() 
    { 
        x = 0; 
        y = 0; 
        r = 0; 
    }
    Round(double x, double y, double r) 
    { 
        this.x = x; 
        this.y = y; 
        this.r = r; 
    }
    double zc() 
    { 
        return 2 * 3.1415926 * this.r; 
    }
    double mj() 
    { 
        return 3.1415926 * this.r * this.r; 
    } 
}
public class Demo 
{ 
    public static void main(String[] args) 
    { 
        double x = 0, y = 0, r = 0;
        Scanner input = new Scanner(System.in); 
        System.out.println("请输入圆的 x 坐标、y 坐标和半径 r："); 
        x = input.nextDouble(); 
        y = input.nextDouble(); 
        r = input.nextDouble(); 
        Round round = new Round(x, y, r); 
        System.out.println("圆的周长为：" + round.zc()); System.out.println("圆的面积为：" + round.mj()); 
    } 
}

运行截图

3.4 圆柱类

说明

编写一个程序，它含有一个圆类、圆柱类和主类。
要求：
1）圆类参考上一题中的圆类；
2）圆柱类：继承圆类，并加入一个属性h(高)；
构造方法(给4个属性赋值)；
计算面积的方法(double mj())；
计算体积的方法(double tj())。
注意，要充分利用父类的方法。
3）主类：在主方法中创建圆和圆柱类的对象，然后计算并输出它们的面积及圆柱的体积。

代码

import java.util.Scanner; 
class Round 
{ 
    double x; 
    double y; 
    double r; 
    Round() 
    { 
        x = 0; 
        y = 0; 
        r = 0; 
    }
    Round(double x, double y, double r) 
    { 
        this.x = x; 
        this.y = y; 
        this.r = r; 
    }
    double zc() 
    { 
        return 2 * 3.1415926 * this.r; 
    }
    double mj() 
    {
        return 3.1415926 * this.r * this.r;
    } 
}
class Cylinder extends Round 
{ 
    double h; 
    Cylinder() 
    { 
        x = 0; 
        y = 0; 
        r = 0;
        h = 0; 
    }
    Cylinder(double x, double y, double r, double h) 
    { 
        this.x = x; 
        this.y = y; 
        this.r = r; 
        this.h = h; 
    }
    double mj() 
    { 
        return 2 * 3.1415926 * this.r * this.r + 2 * 3.1415926 * this.r * this.h; 
    }
    double tj() 
    { 
        return 3.1415926 * this.r * this.r * this.h; 
    } 
}
public class Demo 
{ 
    public static void main(String[] args) 
    { 
        double x = 0, y = 0, r = 0, h = 0; 
        Scanner input = new Scanner(System.in); 
        System.out.println("请输入圆柱的 x 坐标、y 坐标、半径 r 和高度 h："); 
        x = input.nextDouble(); 
        y = input.nextDouble(); 
        r = input.nextDouble(); 
        h = input.nextDouble(); 
        Cylinder cylinder = new Cylinder(x, y, r, h); 
        System.out.println("圆柱的面积为：" + cylinder.mj()); 
        System.out.println("圆柱的体积为：" + cylinder.tj()); 
    }
}

运行截图

圆柱类

3.5 人类

说明

编写一个含有5个类的程序：
类Person:
属性：编号、姓名、性别；
构造方法：确定编号和姓名；
一般方法：修改编号、姓名，获取编号、姓名。
类Teacher：继承类Person并增加：
属性：系别；
构造方法：调用父类的构造方法；
一般方法：修改、获取系别。
类Student：继承类Person并增加：
属性：班级；
构造方法：调用父类的构造方法；
一般方法：修改、获取班级属性值。
类Classes：
属性：班级名称，学生名单(Student类对象的数组)；
构造方法：确定班级名称；
一般方法：建立学生名单，输出学生名单。
类Main：
主类。主方法中创建一个班级，然后建立该班级的学生名单，最后
输出学生名单。

代码

import java.util.Scanner; 
class Person 
{ 
    String num; 
    String name; 
    String sex; 
    Person() 
    { 
        this.num = ""; 
        this.name = ""; 
    }
    Person(String num, String name) 
    { 
        this.num = num; 
        this.name = name; 
    }
    String getNum() 
    { 
        return this.num; 
    }
    String getName() 
    { 
        return this.name; 
    }
    void change(String num, String name) 
    { 
        this.num = num; 
        this.name = name; 
    } 
}
class Teacher extends Person 
{ 
    String department; 
    Teacher() 
    { 
        this.num = ""; 
        this.name = ""; 
        this.department = ""; 
    }
    Teacher(String num, String name, String department) 
    { 
        this.num = num; 
        this.name = name; 
        this.department = department; 
    }
    String getDepartment() 
    { 
        return this.department; 
    }
    void change(String department) 
    { 
        this.department = department; 
    } 
}
class Student extends Person
{ 
    String banji; 
    Student() 
    { 
        this.num = ""; 
        this.name = ""; 
        this.banji = ""; 
    }
    Student(String num, String name, String banji) 
    { 
        this.num = num; 
        this.name = name; 
        this.banji = banji; 
    }
    String getClass() 
    { 
        return this.banji; 
    }
    void change(String banji) 
    { 
        this.banji = banji; 
    } 
}
class Classes 
{ 
    String class_name; 
    Student[] student_list; 
    Classes() 
    { 
        this.class_name = ""; 
        this.student_list = new Student[4]; 
    }
    Classes(String class_name) 
    {
    this.class_name = class_name; 
    this.student_list = new Student[4]; 
    }void create() 
    { 
        Scanner sc = new Scanner(System.in); 
        for(int j = 0; j < 4; j++) 
        { 
            student_list[j] = new Student(); 
        }
        System.out.println("请输入学生的编号和姓名："); 
        for(int i = 0; i < 4; i++) 
        { 
            student_list[i].num = sc.nextLine(); 
            student_list[i].name = sc.nextLine(); 
        } 
    }
    void output() 
    { 
        for(int i = 0; i < 4; i++) 
        { 
            System.out.println(student_list[i].num + " " + student_list[i].name + " " + student_list[i].banji); 
        }
    } 
}
public class Demo 
{ 
    public static void main(String[] args) 
    { 
        Classes classes = new Classes("信息安全 2017-04 班"); 
        classes.create(); 
        classes.output(); 
    } 
}

运行截图

4 语言基础与面向对象

4.1 验证程序1

说明

请先阅读下面的程序，确定它的输出结果。再将程序上机运行，验证自己分析的输出结果是否正确。

代码

class Yuan
{ 
    int r; 
    String name; 
    static int z= 5;
    Yuan(int r)
    { 
        this.r=r; 
    }
    int a()
    {
        return z * r * r;
    }
    int p()
    { 
        return 5 * z * r;
    }  
    void value ()
    { 
        name = "china"; 
    }
} 
class testOverride extends Yuan
{ 
    int h; 
    String name;
    testOverride(int r, int h1) 
    { 
        super(r); 
        h = h1; 
    } 
    int a()
    { 
        value();  
        return 2 * super.a() + p() * h; 
    }
    void value()
    { 
        super.value();
        name = "America";
        System.out.println("\""+this.name+"\"");
        System.out.println(super.name); 
    }
    public static void main(String args[]) 
    { 
        Yuan y = new Yuan(4);
        Yuan yz= new testOverride(5, 2);
        System.out.println(y.a());
        System.out.println(yz.p());
        System.out.println(yz.a());        
    } 
}

运行截图

验证程序1

4.2 验证程序2

说明

请先阅读下面的程序，确定它的输出结果。再将程序上机运行，验证自己分析的输出结果是否正确。

代码

public class TestTransOfValue 
{
    public static void main(String args[])
    { 
        double val;
        StringBuffer sb1, sb2;
        String sb3;
        char s[] = {'a', 'p', 'p', 'l', 'e'};
        val = 5.8;
        sb1 = new StringBuffer("apples");
        sb2 = new StringBuffer("pears");
        sb3 = new String("pear");
        modify(val, sb1, sb2,sb3,s);
        System.out.println(val);
        System.out.println(sb1);
        System.out.println(sb2);
        System.out.println(sb3);
        System.out.println(s);
    }
    public static void modify(double a, StringBuffer r1, StringBuffer r2,String r3,char s[] )
    { 
        a = 6.8;  
        r1.append(" taste good");
        r2 = null;
        r3 = "banana";
        s[2] = 'R';
    }
}

运行截图

验证程序2

4.3 矩阵运算

说明

编写一个程序，其中设计一个矩阵类Matrix，最后计算：

示例矩阵

要求Matrix类满足：
1）Matrix的属性有：
m,n：int型，矩阵的行、列数；
ma：int型两维数组，放置矩阵的数据。
2）Matrix的方法有：
Matrix (int m , int n )：构造方法，设置矩阵的行数和列数；
cheng(Matrix a)：将当前矩阵与形参矩阵相乘，最后返回乘的结果(Matrix对象)； void print()：输出矩阵。

代码

import java.util.Scanner; 
class Matrix 
{ 
    int m; 
    int n; 
    int[][] ma; 
    Matrix(int m, int n) 
    { 
        this.m = m; 
        this.n = n; 
        this.ma = new int[m][n]; 
    }
    void create() 
    { 
        Scanner shuru = new Scanner(System.in); 
        for(int i = 0; i < m; i++) 
        { 
            for(int j = 0; j < n; j++) 
            {
                ma[i][j] = shuru.nextInt(); 
            } 
        } 
    }
    void multi(Matrix param) 
    { 
        Matrix result = new Matrix(this.m, param.n); 
        for(int i = 0; i < this.m; i++) 
        { 
            for(int j = 0; j < param.n; j++) 
            { 
                for(int k = 0; k < param.m; k++) 
                { 
                    result.ma[i][j] += this.ma[i][k] * param.ma[k][j]; 
                }
            } 
        }
        for(int a = 0; a < this.m; a++) 
        { 
            for(int b = 0; b < result.n; b++) 
            {
                System.out.println(result.ma[a][b]); 
            } 
        } 
    } 
}
public class Demo 
{ 
    public static void main(String[] args) 
    { 
        Scanner input = new Scanner(System.in); 
        int row1, col1, row2, col2;
        System.out.println("请输入第一个矩阵的行数："); 
        row1 = input.nextInt();
        System.out.println("请输入第一个矩阵的列数："); 
        col1 = input.nextInt(); 
        Matrix juzhen1 = new Matrix(row1, col1); 
        System.out.println("请输入第一个矩阵的数据："); 
        juzhen1.create(); 
        System.out.println("请输入第二个矩阵的行数："); 
        row2 = input.nextInt(); 
        System.out.println("请输入第一个矩阵的列数："); 
        col2 = input.nextInt(); 
        Matrix juzhen2 = new Matrix(row2, col2);
        System.out.println("请输入第二个矩阵的数据："); 
        juzhen2.create(); 
        juzhen1.multi(juzhen2); 
    } 
}

运行截图

矩阵相乘

4.4 多态

说明

请仔细阅读下面的程序，分析程序的结构和输出结果。由此理解接口、抽象类、继承、实现接口，进一步理解多态。

代码

interface Food
{ 
    public void doEat();
}     // doEat()是吃食物的方法
abstract class Fruit{}      //水果抽象类
abstract class Meat{ }      //肉抽象类
class Apple extends Fruit implements Food//苹果类
{
    public void doEat()
    { 
        System.out.println("我是苹果，属于水果类，你不必烹饪我就可吃！"); 
    }
}
class Beef extends Meat implements Food        //牛肉类
{ 
    public void doEat()
    {
        System.out.println("我是牛肉，属于肉类，必须烹饪后才可吃！"); 
    }
}
public class Use
{ 
    public static void main(String args[])
    { 
        Food f=new Apple();
        f.doEat();
        f=new Beef();
        f.doEat();        // 两个“f.doEat()”体现了多态
    }
}

运行截图

4.5 形状

说明

设计一个程序，其中含有一个接口Shape(形状)，其中有求形状的面积的方法area()。再定义三个实现接口的类：三角型类、矩形类和圆类。在主方法中创建Shape类型的一维数组，它有三个元素，放置三个对象，分别表示三角形、矩形和圆，然后利用循环输出三个图形的面积。
( 注：三角形面积s=Math.sqrt(p*(p-a)(p-b)(p-c))，a,b,c为三条边，p=(a+b+c)/2 )

代码

import java.lang.Math; 
interface Shape 
{ 
    public double area(); 
}
class Round implements Shape 
{ 
    double radius; 
    Round(double radius) 
    { 
        this.radius = radius; 
    }
    public double area() 
    { 
        return Math.PI * radius * radius; 
    } 
}
class Rectangle implements Shape
{ 
    double length; 
    double width; 
    Rectangle(double length, double width) 
    { 
        this.length = length; 
        this.width = width; 
    }
    public double area()
    { 
        return length * width; 
    } 
}
class Triangle implements Shape 
{ 
    double a; 
    double b; 
    double c; 
    Triangle(double a, double b, double c) 
    { 
        this.a = a; 
        this.b = b; 
        this.c = c; 
    }
    public double area() 
    { 
        double p = (a + b + c) / 2; 
        return Math.sqrt(p*(p-a)*(p-b)*(p-c)); 
    } 
}
public class Demo 
{ 
    public static void main(String[] args) 
    { 
        Shape round = new Round(2.0); 
        Shape triangle = new Triangle(3.0, 4.0, 5.0); 
        Shape rectangle = new Rectangle(2.0, 3.0); System.out.println("圆形、矩形和三角形的面积分别为："); 
        System.out.println(round.area()); 
        System.out.println(triangle.area()); 
        System.out.println(rectangle.area()); 
    } 
}

运行截图

求图形面积

5 Java类库

5.1 字符串转化

说明

编写一个程序，该程序运行后读入字符串并转换成基本类型数据后输出。要求依次读入十进制整数、二进制整数、实数、布尔型的字符串。

代码

public class Demo 
{ 
    public static void main(String[] args) 
    { 
        int x = 998; 
        Integer int1 = new Integer(x); 
        Long long1 = new Long(11100111L); 
        Double double1 = new Double(12.8); 
        Boolean boolean1 = new Boolean("True"); 
        System.out.println("程序运行结果为:"); 
        System.out.println("int1 = " + int1 + ", long1 = " + long1 + ", double1 = " + double1 + ", boolean1 = " + boolean1); 
        String str1 = int1.toBinaryString(int1); 
        String str2 = long1.toString(long1, 10); 
        String str3 = double1.toString(); 
        String str4 = boolean1.toString(); 
        System.out.println("str1 = " + str1 + ", str2 = " + str2 + ", str3 = " + str3 + ", str4 = " + str4); 
        int int2 = Integer.parseInt(str1, 2); 
        System.out.println("将字符串 str1 按照二进制转化为 int 型：" + int1); 
        long long2 = Long.parseLong(str2, 10); 
        System.out.println("将字符串 str2 按照十六进制转化为 long 型：" + long2); 
        double double2 = Double.parseDouble(str3); 
        System.out.println("将字符串 str3 转化为 double 类型的值：" + double2); 
        boolean boolean2 = Boolean.parseBoolean(str4); 
        System.out.println("将字符串 str4 转化为 boolean 类型的值：" + boolean2); 
    } 
}

运行截图

字符串转化

5.2 字符串匹配

说明

编写一个程序，在其中定义一个String类型变量s和一个StringBuffer类对象sb；从键盘输入100个字母放入sb中，再将sb中的字串赋给s，最后输出“abc”在s中第一次和最后一次出现的位置。观察字串分别含有零个、一个和多个“abc”时的输出结果。

代码

import java.util.Scanner; 
public class Demo 
{ 
    public static void main(String[] args) 
    { 
        Scanner input = new Scanner(System.in); 
        String s = new String(); 
        StringBuffer sb = new StringBuffer(); 
        System.out.println("请输入 100 个字符:"); 
        sb.append(input.nextLine()); 
        s = sb.toString(); 
        System.out.println("abc 在 s 中第一次出现的位置是: " + s.indexOf("abc")); System.out.println("abc 在 s 中 最 后 一 次 出 现 的 位 置 是 : " + s.lastIndexOf("abc")); 
    } 
}

运行截图

字符串匹配

5.3 加法

说明

编写一个让小朋友做十次加法的程序，要求程序中生成两个不大于50的随机正整数a和b，其中a由Math类的随机函数生成，b则利用机器当前时间的秒数和分数生成，在小朋友回答后要给出对错的判断。(另：了解java.util.Randoma类)

代码

import java.util.Scanner; 
import java.util.Random; 
public class Demo 
{ 
    public static void main(String[] args) 
    { 
        Random random = new Random(); 
        Scanner input = new Scanner(System.in); 
        int a = 0; 
        int b = 0; 
        int result = 0; 
        for(int i = 0; i < 10; i++) 
        { 
            a = (int)(Math.random() * 50); 
            b = random.nextInt(50); 
            result = a + b; 
            System.out.println("请计算" + a + " + " + b + " = " ); 
            if(input.nextInt() == result) 
            { 
                System.out.println("恭喜你，回答正确(#^.^#)(#^.^#)(#^.^#)"); 
            }
            else 
            { 
                System.out.println("抱歉，回答错误 o(╥﹏╥)oo(╥﹏╥)oo(╥﹏ ╥)o"); 
            } 
        } 
    } 
}

运行截图

5.4 数组排序

说明

java.util包中有个类“Arrays”，它有个方法“sort(<数组名>)”，功能是将数组按升序排序。请编一程序，在其中创建一个数组，然后利用sort方法进行排序。

代码

import java.util.Scanner; 
import java.util.Arrays; 
public class Demo 
{ 
    public static void main(String[] args) 
    { 
        Scanner input = new Scanner(System.in); 
        int[] arr = new int[10]; 
        System.out.println("请输入 10 个数字:"); 
        for(int i = 0; i < arr.length; i++) 
        { 
            arr[i] = input.nextInt(); 
        }
        System.out.println("排序前数组中元素的顺序:"); 
        for(int j = 0; j < arr.length; j++) 
        { 
            System.out.println(arr[j]); 
        }
        Arrays.sort(arr); 
        System.out.println("排序前数组中元素的顺序:"); 
        for(int k = 0; k < arr.length; k++) 
        { 
            System.out.println(arr[k]); 
        } 
    } 
}

运行截图

数组排序

5.5 篮球队类

说明

编一程序，在其中定义一个代表篮球队的类，它有放置队员姓名的向量并放入队员的姓名，再写两个方法：
1）在向量中查找某人。若找到则输出“找到此人！”，否则输出“查无此人！”。
2）删除队员。先查找该人，若找到则删除，否则输出“无此队员！”。

代码

import java.util.Scanner; 
class BasketballTeam 
{ 
    public String[] name; 
    BasketballTeam() 
    { 
        name = new String[100]; 
    }
    public int insert(int num) 
    { 
        Scanner input = new Scanner(System.in); 
        System.out.println("请分别输入" + num + "个篮球队员的姓名:"); 
        for(int i = 0; i < num; i ++) 
        { 
            name[i] = input.nextLine().toString(); 
        }
        return 0; 
    }
    public int find(String arg) 
    { 
        for(int i = 0; i < name.length; i++) 
        { 
            if(name[i].equals(arg)) 
            { 
                System.out.println("找到此人!"); 
                return 0; 
            } 
        }
        System.out.println("查无此人!"); 
        return 0; 
    }
    public int delete(String arg) 
    { 
        for(int i = 0; i < name.length; i++) 
        { 
            if(name[i].equals(arg)) 
            { 
                for(int j = i; j < name.length - 1; j++) 
                { 
                    name[j] = name[j + 1]; 
                }
                System.out.println("查无此人!"); 
                return 0; 
            } 
        }
        return 0; 
    } 
}
public class Demo 
{ 
    public static void main(String[] args) 
    { 
        Scanner sc = new Scanner(System.in); 
        int personNum = 0; 
        BasketballTeam BT = new BasketballTeam(); 
        System.out.println("请输入篮球队员的数量:"); 
        personNum = sc.nextInt(); 
        BT.insert(personNum); 
        BT.find("ikun"); 
        BT.delete("ikun"); 
    } 
}

运行截图

篮球队类

5.6 队列

说明

设计一个继承Vector类的队列类Queue，实现队列的先进先出功能, 类中含有两个方法：入队inqueue和出队outqueue(要充分利用Vector类的方法)。在主方法中创建一个队列类对象，然后依次完成 “111” 入队、“222”入队、出队一元素(输出到屏幕)、“333”入队，最后出队所有元素并且输出到屏幕。

代码

import java.util.Scanner; 
import java.util.Vector; 
class Queue extends Vector 
{ 
    public void inqueue(Object obj) 
    { 
        addElement(obj); 
    }
    public Object outqueue() 
    { 
        Object bb = firstElement(); 
        removeElementAt(0); 
        return bb; 
    } 
}
public class Demo 
{ 
    public static void main(String[] args) 
    { 
        Scanner input = new Scanner(System.in); 
        Queue queue = new Queue(); 
        System.out.println("请输入入队前两个元素:"); 
        queue.inqueue(input.nextLine()); 
        queue.inqueue(input.nextLine()); 
        Object tmp = queue.outqueue(); 
        System.out.println("出队的第一个元素:"); 
        System.out.println(tmp); 
        System.out.println("请输入入队的第三个元素:"); 
        queue.inqueue(input.nextLine());
        tmp = queue.outqueue(); 
        System.out.println("出队的第二个元素:"); 
        System.out.println(tmp); 
        tmp = queue.outqueue(); 
        System.out.println("出队的第三个元素:"); 
        System.out.println(tmp); 
    } 
}

运行截图

6 图形用户界面程序设计基础

6.1 窗口布局

说明

使用编写代码的方式写三个用户界面程序，窗口中都是只放一个按钮，但布局方式分别为FlowLayout、BorderLayout和GridLayout(3行3列)，运行后界面如下面所示：

窗口布局

代码

import java.awt.*;
import javax.swing.JFrame;
public class Demo
{
    public static void main(String[] args)
    {
        JFrame frameOne = new JFrame("了解FlowLayout布局");
        FlowLayout flow = new FlowLayout();
        frameOne.setLayout(flow);
        frameOne.add(new Button("FlowLayout布局"));
        frameOne.setBounds(200, 300, 400, 300);
        frameOne.setVisible(true);
        frameOne.getContentPane().setBackground(Color.WHITE);
        
        JFrame frameTwo = new JFrame("了解BorderLayout布局");
        BorderLayout border = new BorderLayout();
        frameTwo.setLayout(border);
        frameTwo.add("Center", new Button("BorderLayout布局"));
        frameTwo.setBounds(600, 300, 400, 300);
        frameTwo.setVisible(true);
        frameTwo.getContentPane().setBackground(Color.WHITE);
        
        JFrame frameThree = new JFrame("了解GridLayout布局");
        GridLayout grid = new GridLayout(3, 1);
        frameThree.setLayout(grid);
        frameThree.add(new Button("GridLayout布局"));
        frameThree.setBounds(1000, 300, 400, 300);
        frameThree.setVisible(true);
        frameThree.getContentPane().setBackground(Color.WHITE);
    }
}

运行截图

窗口布局

6.2 单标签窗口

说明

一个图形用户界面程序如下图，窗口中只有一个标签
请编写该程序代码，布局方式为FlowLayout。要求用二种方式写该程序：
1）在主方法中用Frame创建窗口并布置窗口；
2）将自己的类构造成框架类，在构造方法中布置窗口，在主方法创建窗口。

单标签窗口

代码

import java.awt.FlowLayout;
import javax.swing.*;
public class Demo extends JFrame
{
    private JLabel l = new JLabel();
    public Demo()
    {
        this.setLayout(new FlowLayout());
        l.setText("有标签的窗口");
        this.add(l);
        this.setBounds(200, 300, 400, 300);
        this.setVisible(true);
    }
    public static void main(String[] args)
    {
        new Demo();
        JFrame frame = new JFrame();
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        FlowLayout flow = new FlowLayout();
        frame.setLayout(flow);
        frame.add(new JLabel("有标签的窗口！"));
        frame.setVisible(true);
        frame.setBounds(600, 300, 400, 300);
    }
}

运行截图

单标签窗口

6.3 计算器

说明

使用编写代码的方式，设计一个用户界面如下图所示：

计算器演示

代码

import java.awt.*;
import javax.swing.*;
public class Demo extends JFrame
{
    String[] str = {"+", "-", "*", "/"};
    JButton[] button;
    JTextField num1, num2, result;
    public Demo()
    {
        super("计算器");
        button = new JButton[4];
        this.setLayout(new GridLayout(4, 1));
        num1 = new JTextField(20);
        num2 = new JTextField(20);
        result = new JTextField(20);
        Panel panel = new Panel();
        panel.setLayout(new GridLayout(1, 4));
        for(int i = 0; i < 4; i++)
        {
            button[i] = new JButton(str[i]);
            panel.add(button[i]);
        }
        this.getContentPane().add(num1);
        this.getContentPane().add(num2);
        this.getContentPane().add(panel);
        this.getContentPane().add(result);
        this.setSize(300, 300);
        this.setVisible(true);
        this.getContentPane().setBackground(Color.WHITE);
    }
    public static void main(String[] args)
    {
        new Demo();
    }
}

运行截图

计算器

6.4 选课系统

说明

使用编写代码的方式，设计一个含有菜单的图形用户界面程序，运行后的界面如下图所示：

选课系统演示

代码

import java.awt.Color;
import javax.swing.*;
public class Demo extends JFrame
{
    private JMenuBar mb = new JMenuBar();
    private JMenu menuOne = new JMenu("文体类");
    private JMenu menuTwo = new JMenu("计算机类");
    private JMenu menuThree = new JMenu("帮助");
    private JMenuItem menu11 = new JMenuItem("艺术欣赏");
    private JMenuItem menu12 = new JMenuItem("健美操");
    private JMenuItem menu13 = new JMenuItem("篮球");
    private JMenuItem menu21 = new JMenuItem("java语言");
    private JMenuItem menu22 = new JMenuItem("网络编程");
    private JMenuItem menu31 = new JMenuItem("选课方法");
    public Demo()
    {
        super("选课系统");
        this.setLayout(null);
        menuOne.add(menu11);
        menuOne.add(menu12);
        menuOne.add(menu13);
        menuTwo.add(menu21);
        menuTwo.add(menu22);
        menuThree.add(menu31);
        mb.add(menuOne);
        mb.add(menuTwo);
        mb.add(menuThree);
        this.setJMenuBar(mb);
        this.getContentPane().setBackground(Color.WHITE);
        this.setBounds(500, 500, 400, 300);
        this.setVisible(true);
    }
    public static void main(String[] args)
    {
        new Demo();
    }
}

运行截图

选课系统-文体类

选课系统-计算机类

选课系统-帮助

6.5 绘制矩形

说明

编写一个图形界面程序，运行后界面如下图，其中绘制矩形的方法是drawRect(40,50,120,80)。

内切圆演示

代码

import java.awt.Graphics;
import javax.swing.*;
public class Demo extends JFrame
{
    public static void main(String[] args)
    {
        Demo m = new Demo();
        m.setBounds(500, 500, 400, 300);
        m.setVisible(true);
    }
    public void paint(Graphics m)
    {
        m.drawRect(40, 50, 120, 80);
        m.drawOval(40, 50, 120, 80);
        m.drawOval(40, 70, 60, 40);
        m.drawOval(40, 80, 30, 20);
    }
}

运行截图

内切圆

6.6 苦笑脸

说明

编写二个图形界面程序，在其中分别画出笑和哭的脸。

哭笑脸演示

代码

import java.awt.Graphics;
import javax.swing.*;
class Laugh extends JFrame
{
    public Laugh()
    {
        this.setTitle("笑脸");
        this.setBounds(200, 300, 400, 300);
        this.setVisible(true);
    }
    public void paint(Graphics m)
    {
        super.paint(m);
        m.drawOval(150, 50, 150, 200);
        m.drawArc(180, 160, 100, 50, 180, 180);
        m.drawArc(160, 120, 50, 35, -180, -180);
        m.drawArc(250, 120, 50, 35, -180, -180);
        m.drawString("笑！", 50, 100);
    }
}
class Cry extends JFrame
{
    public Cry()
    {
        this.setTitle("哭脸");
        this.setBounds(600, 300, 400, 300);
        this.setVisible(true);
    }
    public void paint(Graphics m)
    {
        super.paint(m);
        m.drawOval(150, 50, 150, 200);
        m.drawArc(180, 160, 100, 50, -180, -180);
        m.drawArc(160, 120, 50, 35, 180, 180);
        m.drawArc(250, 120, 50, 35, 180, 180);
        m.drawString("哭！", 50, 100);
    }
}
public class Demo
{
    public static void main(String[] args)
    {
        new Laugh();
        new Cry();
    }
}

运行截图

哭笑脸

7 图形用户界面应用程序设计

7.1 程序验证1

说明

下面的程序运行后界面如下图所示：

程序没有实现事件处理，请添加适当的代码，使窗口能够累计点击按钮的次数，如下图是点击3次后的结果。
要求分别用三种方式实现事件处理：
1）让PressMe类实现事件接口；
2）另外加一个实现事件接口的类；
只加入一个语句。

按钮演示

代码

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
class PressMe extends JFrame implements ActionListener
{
    static TextField textField = new TextField("您还没按我呢！", 12);
    static int num;
    public void actionPerformed(ActionEvent e)
    {
        num++;
        textField.setText("您按了我" + num + "次！");
    }
}
public class Demo
{
    public static void main(String[] args)
    {
        PressMe click = new PressMe();
        click.setLayout(new FlowLayout());
        click.setTitle("PressMe!");
        Button button = new Button("PressMe");
        button.addActionListener(click);
        click.add(click.textField);
        click.add(button);
        click.setLocation(300, 300);
        click.resize(170, 100);
        click.show();
    }
}

运行截图

7.2 变脸程序

说明

编写一个“变脸”程序：将实验六第5题中的两个脸合到一个程序中，利用事件处理程序mouseUp()实现程序运行后出现一张笑脸，鼠标点击一次则变成哭脸，再点击一次又变成笑脸，依次轮换。

变脸演示

代码

import javax.swing.*;
import java.awt.Graphics;
import java.awt.Canvas;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.InputEvent;
class Click extends Canvas implements MouseListener
{
    int p = 0;
    public Click()
    {
        addMouseListener(this);
    }
    //paint方法，当p=1时，画笑脸，其它时，画哭脸
    public void paint(Graphics g)
    {
        if(p == 1)
        {
            g.drawString("笑!", 20, 50);
            g.drawOval(40, 40, 60, 120);
            g.drawArc(60, 130, 20, 10, 180, 180);
            g.drawArc(50, 80, 15, 8, 0, 180);
            g.drawArc(80, 80, 15, 8, 0, 180);
        }
        else
        {
            g.drawString("哭", 20, 50);
            g.drawOval(40, 40, 60, 120);
            g.drawArc(60, 130, 20, 10, 0, 180);
            g.drawArc(50, 80, 15, 8, 0, 180);
            g.drawArc(80, 80, 15, 8, 0, 180);
        }
    }
    public void mousePressed(MouseEvent e)
    {
        if(e.getModifiers() == InputEvent.BUTTON1_MASK)
        {
            p = (1 + p) % 2;
            repaint();
        }
    }
    @Override
    public void mouseClicked(MouseEvent e) {
        // TODO 自动生成的方法存根
        
    }
    @Override
    public void mouseReleased(MouseEvent e) {
        // TODO 自动生成的方法存根
        
    }
    @Override
    public void mouseEntered(MouseEvent e) {
        // TODO 自动生成的方法存根
        
    }
    @Override
    public void mouseExited(MouseEvent e) {
        // TODO 自动生成的方法存根
        
    }
}
public class Demo
{
    public static void main(String args[])
    {
        JFrame f = new JFrame("变脸");
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.setBounds(300, 300, 300, 300);
        f.setVisible(true);
        f.add(new Click());
        f.validate();
    }
}

运行截图

7.3 自助早餐

说明

设计一个“自助早餐”的图形界面事件处理程序，运行后界面如下图左；选择早点后界面如下图右；点击“退出”则结束程序运行。
(提示：需要编写列表的itemStateChanged()事件处理方法)

自助早餐演示

代码

import java.awt.Button;
import java.awt.Frame;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Label;
import java.awt.List;
import java.awt.TextArea;
import java.awt.event.*;
public class Demo
{
    public static void main(String args[])
    {
        new frame2();
    }
}
class frame2 extends Frame
{
    GridBagLayout layout = new GridBagLayout();     //使用网格包布局
    List List1 = null;
    Button bu = null;
    private static final long serialVersionUID = 1L;
    TextArea text = null;       //输出选择信息
    Double[] Money={0.20, 0.30, 0.50, 0.80, 0.50, 1.00};        //设定每一个选项的价钱
    Double Countadd(int Demo[])
    {
        Double Count = 0.00;        //每次点击都重新计算价钱
        for(int i = 0; i < Demo.length; i++)
        {
            Count = Count + Money[Demo[i]];     //通过传过来的选择的索引号，计算价钱
        }
        return Count;
    }
    frame2()
    {
        String[] data = {"馒头 0.20元", "花卷 0.30元", "面包 0.50元", "蛋糕 0.80元", "豆浆 0.50元", "牛奶 1.00元"};//菜单选项
        String[] notice = {"名称 单价", "***************"};     //提示信息
        List1 = new List();
        for(int i = 0; i < 2; i++)
            List1.add(notice[i]);
        for(int i = 0 ; i < 6; i++)
            List1.add(data[i]);
        bu = new Button("退出");
        text = new TextArea(8, 15);
        Label label1 = new Label("请选择早点:");
        Label label2 = new Label("您选择了: ");
        this.add(label1);
        this.add(label2);
        this.add(List1);
        this.add(bu);
        this.add(text);
        //注意添加顺序，在布局中很重要
        List1.addItemListener(new ItemListener()
        {
            @Override
            public void itemStateChanged(ItemEvent e)
            {
                // TODO 自动生成的方法存根
                int i[] = List1.getSelectedIndexes();
                //用i这个数组来接收索引号（此时索引号已经按照升序排好)
                if(List1.getSelectedIndexes().length != 0)
                {
                    //如果中了的话
                    for(int ii = 0; ii < List1.getSelectedIndexes().length; ii++)
                        i[ii] = i[ii]-2;        //前两个选项是没有用的故传过来的索引号-2
                    if(i[0] >= 0)       //如果第一个索引号是大于等于0的时候
                    {
                        String Out =data[i[0]];     //Out字符串用于输出已经选择的数据以及总价
                        //Out字符串首先接收第一个选择的数据（索引号最小的)
                        for(int j = 1; j < List1.getSelectedIndexes().length; j++)
                        {
                            Out = Out + "\n" + data[i[j]];      //Out字符串接收其他选择的数据（索引号升序）并且换行
                        }
                        if(Out != null)
                        {
                            text.setText(Out + "\n\n" + "总计 " + Countadd(i) + "元");     //在文本框输出已经选择的数据以及总价前（通过调用Countadd函数）
                        }
                    }
                }
                else
                {
                    text.setText(null);
                }
            }
        });
        List1.setMultipleMode(true);
        this.setLayout(layout);     //设定布局
        GridBagConstraints s = new GridBagConstraints();        //定义一个GridBagConstraints
        //是用来控制添加进的组件的显示位置
        s.fill = GridBagConstraints.BOTH;
        s.anchor = GridBagConstraints.NORTHWEST;        //单元格对齐方式
        s.gridx = 0;        //gridx,gridy设置组件所在位置
        s.gridy = 0;
        s.gridwidth = 2;
        s.weightx = 0;      //该方法设置组件水平的拉伸幅度，如果为0就说明不拉伸，不为0就随着窗口增大进行拉伸，0到1之间
        s.weighty = 0;      //竖直方向的拉伸幅度同上 weightx,weighty
        layout.setConstraints(label1, s);
        s.gridx = 2;
        layout.setConstraints(label2, s);
        s.weightx = 0;
        s.gridy =1;
        s.gridwidth = 2;
        s.gridheight =1 ;
        s.gridx = 0;
        s.gridheight = 4;
        s.gridy = 1;
        layout.setConstraints(List1, s);
        s.gridwidth = 2;
        s.gridy = 1;
        s.gridx = 2;
        s.gridheight = 3;
        layout.setConstraints(text, s);
        s.gridheight = 1;
        s.gridy = 5;
        layout.setConstraints(bu, s);
        this.setVisible(true);
        this.setBounds(200, 200, 265, 280);
        this.setLocation(200, 200);
        this.setTitle("自助早餐");
        bu.addActionListener(new ActionListener()
        {
            @Override
            public void actionPerformed(ActionEvent arg0)
            {
                // TODO 自动生成的方法存根
                System.exit(0);
            }
        });
        this.addWindowListener(new WindowListener()
        {
            @Override
            public void windowActivated(WindowEvent arg0)
            {
                // TODO 自动生成的方法存根
            }
            @Override
            public void windowClosed(WindowEvent e)
            {
                // TODO 自动生成的方法存根
            }
            @Override
            public void windowClosing(WindowEvent e)
            {
                // TODO 自动生成的方法存根
                System.exit(0);
            }
            @Override
            public void windowDeactivated(WindowEvent e)
            {
                // TODO 自动生成的方法存根
            }
            @Override
            public void windowDeiconified(WindowEvent e)
            {
                // TODO 自动生成的方法存根
            }
            @Override
            public void windowIconified(WindowEvent e)
            {
                // TODO 自动生成的方法存根
            }
            @Override
            public void windowOpened(WindowEvent e)
            {
                // TODO 自动生成的方法存根
            }
        });
    }
}

运行截图

自助早餐

7.4 计算器

说明

开发一个加、减、乘、除四则运算器。用户界面如下图

计算器演示

代码

import java.awt.*;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import javax.swing.*;       //导入图形化需要的包
class Calculator extends JFrame
{
    private static final long serialVersionUID = 1L;
    private double a = 0;
    private double b = 0;
    private JTextField Input_1 = null;
    private JTextField Input_2 = null;
    private JButton jButton1 = null;
    private JButton jButton2 = null;
    private JButton jButton3 = null;
    private JButton jButton4 = null;
    private JTextField Output = null;
    public void Convert()
    {
        double a = Double.parseDouble(Input_1.getText());
        geta(a);
        double b = Double.parseDouble(Input_2.getText());
        getb(b);
    }
    /** * Create the frame. */
    public void geta(double i)
    {
        
        a = i;
    }
    public void getb(double i)
    {
        b = i;
    }
    public Calculator()
    {
        GridBagLayout layout = new GridBagLayout();
        //用来布局
        this.setLayout(layout);
        //设置布局方式为GridBagLayout
        Input_1 = new JTextField();
        Input_2 = new JTextField();
        jButton1 = new JButton("+");
        jButton2 = new JButton("-");
        jButton3 = new JButton("*");
        jButton4 = new JButton("/");
        jButton1.setForeground(Color.RED);      //设置颜色
        jButton2.setForeground(Color.GREEN);
        jButton3.setForeground(new Color(255,0,255));
        jButton4.setForeground(Color.BLUE);
        Output = new JTextField();
        this.setLayout(layout);
        GridBagConstraints s = new GridBagConstraints();        //定义一个GridBagConstraints
        //是用来控制添加进的组件的显示位置
        s.fill = GridBagConstraints.BOTH;       //该方法是为了设置如果组件所在的区域比组件本身要大时的显示情况
        //NONE：不调整组件大小。
        //HORIZONTAL：加宽组件，使它在水平方向上填满其显示区域，但是不改变高度。
        //VERTICAL：加高组件，使它在垂直方向上填满其显示区域，但是不改变宽度
        //BOTH：使组件完全填满其显示区域。
        s.anchor = GridBagConstraints.NORTHWEST;        //单元格对齐方式
        s.gridx = 0;        //gridx,gridy设置组件所在位置
        s.gridy = 0;
        s.gridwidth = 4;
        s.weightx = 1;      //该方法设置组件水平的拉伸幅度，如果为0就说明不拉伸，不为0就随着窗口增大进行拉伸，0到1之间
        s.weighty = 1;      //竖直方向的拉伸幅度同上 weightx,weighty
        add(Input_1);
        layout.setConstraints(Input_1, s);      //设置组件 
        add(Input_2);
        s.weightx = 1;
        s.weighty = 1;
        s.gridy = 1;
        layout.setConstraints(Input_2, s);
        add(jButton1);
        s.gridy = GridBagConstraints.RELATIVE;
        s.gridwidth = 1;
        layout.setConstraints(jButton1, s);
        s.gridy = 2;
        s.gridx = GridBagConstraints.RELATIVE;      //设置下一个组件添加在上一个组件的右方
        layout.setConstraints(jButton2, s);
        add(jButton2);
        add(jButton3);
        layout.setConstraints(jButton3, s);
        add(jButton4);
        layout.setConstraints(jButton4, s);
        s.gridy = 3;
        s.gridwidth = 4;
        add(Output);
        layout.setConstraints(Output, s);
        this.setVisible(true);
        this.setSize(300, 200);
        this.setLocation(300, 300);
        this.setTitle("计算器");
        this.setDefaultCloseOperation(EXIT_ON_CLOSE);
        jButton1.addMouseListener(new MouseListener()
        {
            public void mouseClicked(MouseEvent e) {}
            public void mouseEntered(MouseEvent e) {}
            public void mouseExited(MouseEvent e) {}
            @Override
            public void mousePressed(MouseEvent e)
            {
                Convert();
                Double c = a + b;
                Output.setText(new Double(c).toString());
            }
            public void mouseReleased(MouseEvent e) {}
        });
        jButton2.addMouseListener(new MouseListener()
        {
            public void mouseClicked(MouseEvent e) {}
            public void mouseEntered(MouseEvent e) {}
            public void mouseExited(MouseEvent e) {}
            @Override
            public void mousePressed(MouseEvent e)
            {
                Convert();
                Double c = a - b;
                Output.setText(new Double(c).toString());
            }
            public void mouseReleased(MouseEvent e) {}
        });
        jButton3.addMouseListener(new MouseListener()
        {
            public void mouseClicked(MouseEvent e) {}
            public void mouseEntered(MouseEvent e) {}
            public void mouseExited(MouseEvent e) {}
            @Override
            public void mousePressed(MouseEvent e)
            {
                Convert();
                Double c = a * b;
                Output.setText(new Double(c).toString());
            }
            public void mouseReleased(MouseEvent e) {}
        });
        jButton4.addMouseListener(new MouseListener(){
            public void mouseClicked(MouseEvent e) {}
            public void mouseEntered(MouseEvent e) {}
            public void mouseExited(MouseEvent e) {}
            @Override
            public void mousePressed(MouseEvent e)
            {
                Convert();
                Double c = a / b;
                Output.setText(new Double(c).toString());
            }
            public void mouseReleased(MouseEvent e) {}
        });
    }
}
public class Demo
{
    public static void main(String args[])
    {
        new Calculator();
    }
}

运行截图

计算器

8 I/O编程

8.1 文件内容拷贝

说明

编写一个程序，实现文件内容拷贝，具体过程如下：
(1) 建一文件myfile1.txt，写入内容“I am a student.”；
(2) 打开文件myfile1.txt，读出内容放入字符数组中；
(3) 再建一文件myfile2.txt，将字符数组中内容写入；
(4) 打开文件myfile2.txt，读出内容输出到屏幕。

代码

import java.io.*;
public class Demo
{
    public static void main(String[] args)
    {
        String filePath = "D:/tmp";
        
        // 新建myfile1.txt
        try
        {
            File file = new File(filePath + "/myfile1.txt");
            if(!file.getParentFile().exists())
            {
                file.getParentFile().mkdirs();
            }
            FileWriter fw = new FileWriter(file);
            if(!file.exists())
            {
                file.createNewFile();
                fw.write("I am a student.");
                }
            else
            {
                fw.write("I am a student.");
            }
            fw.flush();
            fw.close();
        }
        catch(IOException e)
        {
            e.printStackTrace(); 
        }

        // 读出myfile1.txt的内容
        String charArray = "";
        try
        {
            BufferedReader in = new BufferedReader(new FileReader(filePath + "/myfile1.txt"));
            StringBuffer sb;
            while (in.ready())
            {
                sb = (new StringBuffer(in.readLine()));
                charArray += sb;
            }
            in.close();
        }
        catch(IOException e){}

        // 新建myfile2.txt
        try
        {
            File file = new File(filePath + "/myfile2.txt");
            if(!file.getParentFile().exists())
            {
                file.getParentFile().mkdirs();
            }
            FileWriter fw = new FileWriter(file);
            if(!file.exists())
            {
                file.createNewFile();
                fw.write(charArray);
            }
            else
            {
                fw.write(charArray);
            }
            fw.flush();
            fw.close();
        }
        catch(IOException e)
        {
            e.printStackTrace(); 
        }
        
        // 读出myfile1.txt的内容
        try
        {
            BufferedReader in = new BufferedReader(new FileReader(filePath + "/myfile2.txt"));
            StringBuffer sb;
            String myfile2Info = "";
            while (in.ready())
            {
                sb = (new StringBuffer(in.readLine()));
                myfile2Info += sb;
            }
            in.close();
            System.out.println(myfile2Info);
        }
        catch(IOException e){}
    }
}

运行截图

文件内容拷贝

8.2 In类

说明

设计一个类In，它含有5个无参类方法，调用它们即可直接从键盘输入字符、字符串、整数、单精度数以及双精度数。5个方法如下：
(1) cha()——执行后等待输入一个字符(ASCII码字符)；
(2) str()——执行后等待输入一个字符串(ASCII码字符串)；
(3) itn()——执行后等待输入一个整数；
(4) flo()——执行后等待输入一个单精度数；
(5) dou()——执行后等待输入一个双精度数。
例如下面的语句行后等待输入一个单精度数，然后输出到屏幕： System.out.println(In.flo());
提示：利用DataInputStream类。

代码

import java.util.Scanner;
class In
{
    public char cha()
    {
        Scanner input = new Scanner(System.in);
        return input.next().charAt(0);
    }
    public String str()
    {
        Scanner input = new Scanner(System.in);
        return input.next();
    }
    public int itn()
    {
        Scanner input = new Scanner(System.in);
        return input.nextInt();
    }
    public float flo()
    {
        Scanner input = new Scanner(System.in);
        return input.nextFloat();
    }
    public double dou()
    {
        Scanner input = new Scanner(System.in);
        return input.nextDouble();
    }
}
public class Demo
{
    public static void main(String arge[])
    {
        In in = new In();
        System.out.println("请输入一个字符");
        char CHAR = in.cha();
        System.out.println("请输入一个字符串");
        String STRING = in.str();
        System.out.println("请输入一个整数");
        int INT = in.itn();
        System.out.println("请输入一个单精度数");
        float FLOAT = in.flo();
        System.out.println("请输入一个双精度数");
        double DOUBLE = in.dou();
        System.out.println("上面输入的数据分别是");
        System.out.println(CHAR);
        System.out.println(STRING);
        System.out.println(INT);
        System.out.println(FLOAT);
        System.out.println(DOUBLE);
    }
}

运行截图

输入不同类型的数据

9 异常处理、线程控制

9.1 随机数发生类

说明

编写一个程序，在其中写一个随机数发生类，它能生成0-100之间的随机整数，在主方法中使用随机数发生类对象生成一些随机数，要求当生成的随机数大于60时定义一个用户定义异常类对象并抛出该对象。

代码

class aExcep extends Exception
{
    private static final long serialVersionUID = 1L;
    public aExcep(){}
    public aExcep(String s)
    {
        super(s);
    }
}
class Random
{
    double a;
    int b;
    Random()
    {
        a = Math.random();
        b =(int)(a * 100);
    }
    public int getrandom()
    {
        return b;
    }
}
public class Demo
{
    public static void main(String args[]) throws aExcep
    {
        Random a[] = new Random[100];
        for(int i = 0; i < 100; i++)
        {
            a[i] = new Random();
            System.out.println(a[i].getrandom());
            if(a[i].getrandom() > 60)
                throw new aExcep("生成的随机数大于60");
        }
    }
}

运行截图

随机数发生类

9.2 定时线程

说明

编写一个多线程程序，在其中实现两个定时线程，一个线程每隔1秒显示一次秒数，另一个每隔3秒显示一次字母(a,b,…)。

代码

class EvenOddNum extends Thread
{
    private int first;
    private int order;
    public EvenOddNum(int first, int order)
    {
        this.first = first;
        this.order= order;
    }
    public void run()
    {
        for(int i = 0; i < 1000; i++)
            try
            {
                sleep(1000 * order);
                System.out.println("线程" + first + "的秒数是" + i);
            }
            catch(Exception e){}
    }
}
class EvenOddAlpha extends Thread
{
    private int first;
    private int order;
    char alpha = 'a';
    public EvenOddAlpha(int first, int order)
    {
        this.first = first;
        this.order = order;
    }
    public void run()
    {
        for(int i = 0; i < 1000; i++)
            try
            {
                sleep(1000 * order);
                System.out.println("线程" + first + "的字母是" + alpha);
                alpha++;
            }
            catch(Exception e){}
    }
}
public class Demo
{
    public static void main(String args[])
    {
        new EvenOddNum(1, 1).start();
        new EvenOddAlpha(2, 3).start();
    }
}

运行截图

定时线程

9.3 线程类ABC

说明

编写一程序，在其中定义一个线程类ABC，它能够实现下面三种功能之一：
（1）每隔1秒显示一次秒数；
（2）每隔2秒显示一个字母(A,B,…)；
（3）每隔3秒显示一个字母(H,I,…)。
构造方法有二个整型参数：m,n，m确定时间间隔(也是由它确定要实现的功能)，n确定输出的字符的个数。
在主方法中建立三个线程对象：A1、A2、A3，分别设置它们的优先级为：4,6,8，最后启动这三个线程，输出1~~10、A~~E、H~K，请观察运行结果。

代码

class ABC extends Thread
{
    int m, n;
    char alpha1 = 'A';
    char alpha2 = 'H';
    ABC(int m, int n)
    {
        this.m = m;
        this.n = n;
    }
    public void run()
    {
        for(int i = 1; i <= n; i++)
        {
            try
            {
                sleep(1000 * m);
                switch(m)
                {
                    case 1:
                        System.out.println("线程" + m + "显示:" + i + "秒");
                        break;
                    case 2:
                        System.out.println("线程" + m + "显示:" + alpha1);
                        alpha1++;
                        break;
                    case 3:
                        System.out.println("线程" + m + "显示:" + alpha2);
                        alpha2++;
                        break;
                    }
            }
            catch(Exception e){}
        }
    }
}
public class Demo
{
    public static void main(String args[])
    {
        ABC A1 = new ABC(1, 10);
        ABC A2 = new ABC(2, 5);
        ABC A3 = new ABC(3, 4);
        A1.setPriority(4);
        A2.setPriority(6);
        A3.setPriority(8);
        A1.start();
        A2.start();
        A3.start();
    }
}

运行截图

线程类ABC

9.4 左右移动

说明

编写一个图形用户界面程序，窗体的宽度300，高度150，布局管理器为null，窗体上有二个标签和二个按钮，标签的位置为（10,30）和（200,60），按钮的位置为（50,100）和（150,100），它们的宽度和高度都是80和20。编写一个线程，该线程可以让标签向右或向左移动10次，每次移动10个单位，间隔1秒，通过按钮的动作事件启动上述线程，“向右走”按钮启动“向右移标签”，“向左走”按钮启动“向左移标签”，界面如下图所示。

左右移动

代码

import java.awt.*;
import java.awt.event.*;
public class Demo extends Frame implements ActionListener, Runnable
{
    static Label l1;
    static Label l2;
    static Button btn1;
    static Button btn2;
    static boolean bool;
    public static int a = 10;
    public static int b = 200;
    public Demo(String name)
    {
        super(name);
    }
    public Demo()
    {
        super();
    }
    public void sz()
    {
        this.setLayout(null);
        this.setBounds(200, 200, 300, 150);
        l1 = new Label("向右移标签");
        l1.setBounds(10, 30, 80, 20);
        l2 = new Label("向左移标签");
        l2.setBounds(200, 60, 80, 20);
        btn1 = new Button("向右走");
        btn1.setBounds(50, 100, 80, 20);
        btn2 = new Button("向左走");
        btn2.setBounds(150, 100, 80, 20);
        add(l1);
        add(l2);
        add(btn1);
        add(btn2);
        btn1.addActionListener(this);
        btn2.addActionListener(this);
    }
    public static void main(String args[])
    {
        Demo yd = new Demo("移动标签");
        yd.sz();
        yd.setVisible(true);
    }
    public void actionPerformed(ActionEvent e)
    {
        if(e.getSource() == btn1)
        {
            Thread t1 = new Thread(new Demo());
            bool = true;
            t1.start();
        }
        if(e.getSource() == btn2)
        {
            Thread t2 = new Thread(new Demo());
            bool = false;
            t2.start();
        }
    }
    public void run()
    {
        if(bool)
        {
            for(int i = 0; i <= 10; i++)
            {
                try
                {
                    l1.setBounds(a, 30, 80, 20);
                    a += 10; 
                    Thread.sleep(1000);
                }
                catch(Exception e)
                {
                    System.out.println(e.toString());
                }
            }
            
        }
        else
        {
            for(int i = 0; i <= 10; i++)
            {
                try
                {
                    l2.setBounds(b, 60, 80, 20);
                    b -= 10;
                    Thread.sleep(1000);
                }
                catch(Exception e)
                {
                    System.out.println(e.toString());
                }
            }
        }
    }
}

运行截图

左右移动

9.5 小球移动

说明

代码

import java.awt.*;
import javax.swing.JFrame;
import java.awt.event.*;
import javax.swing.*;
public class Demo extends JFrame implements Runnable
{
    int i = 0;
    Thread t;
    Timer T = new Timer(1000, new ActionListener()
            {
                public void actionPerformed(ActionEvent event)
                {
                    i++;
                    repaint();
                }
            });
    public Demo()
    {
        this.setBounds(200, 200, 300, 300);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.addMouseListener(new MouseAdapter()
                {
                    public void mouseClicked(MouseEvent e)
                    {
                        startT();
                    }
                });
    }
    private void startT()
    {
        t = new Thread(this);
        t.start();
    }
    public void paint(Graphics g)
    {
        super.paint(g);
        if((i != 0) && (300 > 150 + i * 10) && (300 > 150 + i * 10))
            g.fillOval(50 + i * 10, 50 + i * 10, 100, 100);
        else if(i != 0)
            i = 0;
    }
    public static void main(String args[])
    {
        Demo my = new Demo();
        my.setVisible(true);
        my.T.start();
    }
}

运行截图

小球移动

10 网络通讯编程

10.1 读取中国教育网主页

说明

编程读取中国教育网主页html文档( URL：http://www.edu.cn )，显示该文档内容，并判断其中是否有字符串“中国教育和科研计算机网网络中心”。

代码

import java.io.*;
import java.net.*;
import java.nio.channels.*;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Demo
{
    public static void main(String arge[]) throws Exception
    {
        FileOutputStream fos = null;
        FileChannel fc = null;
        URL url = null;
        try
        {
            fos = new FileOutputStream("D:/tmp/demo.txt");
            fc = fos.getChannel();
            url = new URL("http://www.edu.cn");
            InputStream is = url.openStream();
            ReadableByteChannel rbc = Channels.newChannel(is);
            fc.transferFrom(rbc, 0, Integer.MAX_VALUE);
            fc.force(true);
            is.close();
            rbc.close();
        }
        finally
        {
            fos.close();
            fc.close();
        }
        String fileUrl = "D:/tmp/demo.txt";
        InputStreamReader isr;
        isr = new InputStreamReader(new FileInputStream(fileUrl), "utf-8");
        BufferedReader read = new BufferedReader(isr);
        String s = null;
        List<String> list = new ArrayList<String>();
        while((s = read.readLine()) != null)
        {
            Pattern p = Pattern.compile("中国教育和科研计算机网网络中心");
            Matcher m = p.matcher(s);
            while(m.find())
            {
                System.out.println(m.group());
            }
            if(s.trim().length() > 1)
            {
                list.add(s.trim());   
            }
        }
    }
}

运行截图

读取中国教育网主页

字符匹配

10.2 TCP的Socket程序1

说明

编写一个基于TCP的Socket程序，服务器向客户端发送一个字符串：”Socket你好!”，客户端将接收到的字符串输出到屏幕。在一台PC上测试该程序。

代码

服务器

import java.io.*;
import java.net.*;
import java.util.*;
public class TalkServer
{
    public static void main(String args[])
    {
        ServerSocket server = null;
        Socket socket = null;
        PrintWriter os = null;
        BufferedReader is = null;
        Scanner sin = null;
        try
        {
            String line = null;
            server = new ServerSocket(12345);
            socket = server.accept();
            is = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            os = new PrintWriter(socket.getOutputStream());
            sin = new Scanner(System.in);
            System.out.println("Client: " + is.readLine());
            line = sin.nextLine();
            while(!line.trim().equals("bye"))
            {
                os.println("Server " + line);
                os.flush();
                System.out.println("Client: " + is.readLine());
                line = sin.nextLine();
            }
        }
        catch(Exception e)
        {
            System.out.println("Error: " + e);
        }
        finally
        {
            try
            {
                if(os != null)
                    os.close();
                if(is != null)
                    is.close();
                if(sin != null)
                    sin.close();
                if(socket != null)
                    socket.close();
                if(server != null)
                    server.close();
            }
            catch(Exception e2)
            {
                System.out.println(e2);
            }
        }
    }
}

客户端

import java.io.*;
import java.net.*;
import java.util.*;
public class TalkClient
{
    public static void main(String args[])
    {
        Socket socket = null;
        Scanner sin = null;
        PrintWriter os = null;
        BufferedReader is = null;
        try
        {
            socket = new Socket("127.0.0.1", 12345);
            sin = new Scanner(System.in);
            os = new PrintWriter(socket.getOutputStream());
            is = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            String readline = sin.nextLine();
            while(!readline.trim().equals("bye"))
            {
                os.println(readline);
                os.flush();
                System.out.println("Server: " + is.readLine());
                readline = sin.nextLine();
            }
        }
        catch(Exception e)
        {
            System.out.println(e);
        }
        finally
        {
            try
            {
                if(os != null)
                    os.close();
                if(is != null)
                    is.close();
                if(sin != null)
                    sin.close();
                if(socket != null)
                    socket.close();
            }
            catch(Exception e)
            {
                e.printStackTrace();
            }
        }
    }
}

运行截图

基于TCP的Socket程序

10.3 TCP的Socket程序2

说明

编写一个基于TCP的Socket程序，服务器向客户端发送一个字符串：”Socket你好!”，客户端将接收到的字符串输出到屏幕。在两台PC之间测试该程序。（本题上机时两人一组，一个作为服务方，另一个作为客户方，然后两人之间进行对话）

代码

服务器

import java.io.*;
import java.net.*;
import java.util.*;
public class MultiTalkServer
{
    static int clientNum = 0;
    static ArrayList<Socket> socketList = new ArrayList<Socket>();
    public static void main(String args[]) throws IOException
    {
        ServerSocket serverSocket = null;
        boolean listening = true;
        try
        {
            serverSocket = new ServerSocket(12345);
        }
        catch(IOException e)
        {
            System.out.println("Could not listen on port: 12345.");
            System.exit(-1);
        }
        while(listening)
        {
            Socket ss = serverSocket.accept();
            socketList.add(ss);
            new ServerThread(ss, clientNum).start();
            clientNum++;
        }
        serverSocket.close();
    }
}
class ServerThread extends Thread
{
    Socket socket = null;
    int clientNum;
    public ServerThread(Socket socket, int num)
    {
        this.socket = socket;
        clientNum = num + 1;
    }
    public void run()
    {
        BufferedReader is = null;
        PrintWriter os = null;
        Scanner sin = null;
        try
        {
            String line = null;
            is = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            os = new PrintWriter(socket.getOutputStream());
            sin = new Scanner(System.in);
            String outStr = is.readLine();
            System.out.println("Client" + clientNum + " : " + outStr);
            line = sin.nextLine();
            while(!(outStr == null))
            {
                os.println(line);
                os.flush();
                outStr = is.readLine();
                System.out.println("Client" + clientNum + " : " + outStr);
                line = sin.nextLine();
            }
        }
        catch(Exception e)
        {
            System.out.println("Error: " + e);
        }
        finally
        {
            try
            {
                if(os != null)
                    os.close();
                if(is != null)
                    is.close();
                if(sin != null)
                    sin.close();
                if(socket != null)
                    socket.close();
            }
            catch(Exception e)
            {
                e.printStackTrace();
            }
        }
    }
}

客户端

import java.io.*;
import java.net.*;
import java.util.*;
public class MultiTalkClient
{
    public static void main(String args[])
    {
        Socket socket = null;
        Scanner sin = null;
        PrintWriter os = null;
        BufferedReader is = null;
        try
        {
            socket = new Socket("127.0.0.1", 12345);
            sin = new Scanner(System.in);
            os = new PrintWriter(socket.getOutputStream());
            is = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            String readline = sin.nextLine();
            while(!readline.trim().equals("bye"))
            {
                os.println(readline);
                os.flush();
                System.out.println("Server: " + is.readLine());
                readline = sin.nextLine();
            }
        }
        catch(Exception e)
        {
            System.out.println("Error" + e);
        }
        finally
        {
            try
            {
                if(os != null)
                    os.close();
                if(is != null)
                    is.close();
                if(sin != null)
                    sin.close();
                if(socket != null)
                    socket.close();
            }
            catch(Exception e)
            {
                e.printStackTrace();
            }
        }
    }
}

运行截图

10.4 Socket网络通讯应用程序

说明

编写一个Socket网络通讯应用程序，实现如下功能：
（1）客户端能够发任意的信息给服务器端；
（2）服务器端将收到的客户端信息返还给客户端。

代码

服务器

import java.net.*;
public class UDPServer
{
    public static void main(String args[])
    {
        try
        {
            DatagramSocket dgs = new DatagramSocket(12345);
            byte[] buf = new byte[1024];
            DatagramPacket p = new DatagramPacket(buf, buf.length);
            for(int i = 0; i < 3; i++)
            {
                dgs.receive(p);
                System.out.println("服务器接收到数据报");
                dgs.send(p);
            }
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
    }
}

客户端

import java.net.*;
public class UDPClient
{
    public static void main(String args[])
    {
        try
        {
            DatagramSocket dgs = new DatagramSocket();
            byte[] buf = new byte[1024];
            DatagramPacket p = new DatagramPacket(buf, buf.length, InetAddress.getLocalHost(), 12345);
            for(int i = 0; i < 3; i++)
            {
                dgs.send(p);
                System.out.println("客户机发送数据报完毕");
                dgs.receive(p);
                System.out.println("客户机接受到返回的数据报");
            }
            dgs.close();
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
    }
}

运行截图

网络通讯应用程序

转载请注明来源，欢迎对文章中的引用来源进行考证，欢迎指出任何有错误或不够清晰的表达，可以邮件至 xingshuaikun@163.com。