《Java语言及网络编程》复习笔记 | ComyDream Studio

喝杯咖啡冷静一下。

本文为信息安全专业《Java语言及网络编程》课程（专业选修课）的复习笔记。

题型

1. 选择
2. 读程序写结果
3. 程序填空
4. 编程

考点

1. 面向对象（全是重点）
2. 多线程
3. 图形用户界面
4. 异常
5. 类库（String, StringBuffer, IO, lang）选择题

细节易错点

main() 函数不要写错了

说来有趣，平时敲代码时习惯自动补全，手写可能真写错了。

public class Test {
    public static void main(String[] args) {
        // code
    }
}

用 switch 语句注意 break

break 用于跳出 switch 语句。

System.in.read() 函数需要捕获异常

try{
    char ch = (char)System.in.read();
    System.out.println(ch);
} catch(IOException e) { }

异常类型：IOException。

Thread.sleep(long millis) 函数需要捕获异常

try {
    Thread.sleep(1000);
} catch (InterruptedException e) { }

异常类型：InterruptedException。

生成随机数用 Math.random() 函数

该函数返回 [0,1) 区间内的一个随机浮点数。（半开半闭区间，取不到右界）

那么，如何生成一个任意区间内的随机整数呢？

如生成 [5,9) 之间的整数赋给 x ：

x = (int)(5+4*Math.random());

生成任意范围内的随机整数：(int)(左界+区间长度*Math.random())

元件要 add()

JButtom btn = new JButton("btn1");
frame.add(btn);

窗体最后一定要 setVisible(true)

frame.setVisible(true);

写 GUI 要覆盖 paint() 函数

public void paint(Graphics g) {
    g.setColor(Color.BLACK);//设置颜色
    g.drawString(str,x,y);    //字符
    g.drawOval(x,y,w,h);    //空心椭圆
    g.fiilOval(x,y,w,h);    //实心椭圆
    g.drawRect(x,y,w,h);    //空心矩阵
    g.fillRect(x,y,w,h);    //实心矩阵
    g.drawLine(x1,y1,x2,y2);    //画线
    g.drawArc(x,y,w,h,startAngle,arcAngle);    //画弧线
}

第一、二章

基本概念要懂，不做特别要求。

一个源代码文件 .java 有且只能有一个公共类（即在 class 前加上 public），且必需与源代码文件同名。

第三章 语言基础

标识符

定义规则：

1. 由字母、数字、下划线、$（美元符） 组成，不能由数字开头，不能含有其他任何字符（包括空格）
2. 不能是保留字（关键字）
3. 大小写敏感，长度无限制

注释

// 这是单行注释

/*
 * 这是多行注释
 */

/**
 * 这是文档注释，可以自动形成文档
 */

变量

所有变量必须先定义后使用。

变量名用标识符表示。

命名应尽量取有意义的名称，一般采用驼峰型（首字母小写）。

局部变量

在某个方法内的变量，在使用前必须给定初值，否则会编译出错。

类成员变量

常量

修饰符为 final 。一旦赋值不可更改。

类静态成员常量只能在定义时初始化；方法中的常量(局部常量)可以在定义时初始化，也可以先定义，以后再初始化。

整型常量

十进制常量 42

八进制常量 042

十六进制常量 0x42

一个整型常量在机器中默认以int类型存储。整型常量后面加上后缀 L 或 l，在机器中以long类型存储。

浮点型常量

十进制表示法 3.65、3.65f

科学记数表示法 3.2e3 阶码必须为整数，基数是10

一个实型常量在机器中默认以double类型存储。实型常量后加后缀F或f在机器中以float类型存储。

例题：

字符型常量

Unicode 编码，2B（16bit）。用两个单引号括起来。也可以用 Unicode 代码表示，如 ‘\u0041’ 。

基本数据类型

1. 整数类型
2. 实数类型
3. 字符型
4. 布尔型

整型

数据类型名	占用内存空间
byte	1 字节
short	2 字节
int	4 字节
long	8 字节

实型

数据类型名	占用内存空间
float	4 字节
double	8 字节

字符型

char 2 字节

布尔型

boolean 1 bit

运算符

与 C/C++ 一致。

例题：

特别注意：%是取余，如 5%2结果为1，5.2%2结果为1.2，5.2%2.2结果为0.8，10%-4结果2； -10%-4结果-2。

%的结果：先按两个操作数都是正数处理，结果和第一个操作数的符号一致。

思考：某个培训中心要为新到的学员安排房间，假设共有x个学员，每个房间可以住6人，让你用一个公式来计算他们要住的房间数？

答案： (x+5)/6

关系运算符 instanceof

用来确定一个对象是不是某一指定类的对象。

Test t1 = new Test();
if(t1 instanceof Test) System.out.println("Yes");

逻辑运算符

&& 短路与 || 短路或

移位运算符

在进行移位之前，java系统首先把移的位数与被移位数求余数，然后移动这个位数。也就是说，整型向右移动 32 位结果是其本身。

1<<x 可表示 $2^x$ 。

注意：boolean型的只能赋给boolean型。

public class max 
{
    public static void main(String args[])
    {
        int a=3,b=4,c;
        c=a>b? ++a:b++;
        System.out.println(a+"、"+b+"、"+c);
    }
}
//输出结果：3、5、4

数据类型转换

Java中整型、实型、字符型数据可以混合运算。运算过程中，Java自动把精度较低的类型转换为另一种精度较高的类型。

b=(byte)345;      //b为345%256=89

运算时注意（一般的运算都有类型提升功能）：
（1）在运算过程中，运算的结果至少是int型，即如果参与运算的两个数级别比int型低或是int型，则结果为int型
（2）参与运算的数据如果有一个级别比int型高，则运算结果的类型与类型级别高的数相同
（3）参与运算的两个数据如果类型不一样，会先把低级的数据转换成高级的类型的数据后再作运算，结果是高级的类型

Java允许把 int 型常量直接赋给 byte/short 变量，不需要强制转换。但是不允许将 int 型变量直接赋给 byte/short 变量，必须强制转换。

例题：

public class XiagaoTest {
    public static void main(String[] args) {
        float x = 3.3f;
        double y = 2.9;
        byte a = 5;
        System.out.println(x+(int)y/3*a);
    }
}
//输出 3.3

标准输入输出

System.in是字节流，作用是从标准输入读一个字节。

read() 方法返回值是 int 类型！

• int read() 从流中读取一个字节并将该字节作为整数返回,若没有数据则返回-1

• int read(byte b[]) 从流中读取多个字节放到b中, 返回实际读取到的字节数

• int read(byte b[],int off,int len) 从流中读取最多len字节的数据, 放到数组b的下标off开始的单元中，返回读取到的字节数

注意：调用 read() 函数一定要 try catch ：

try {
    char ch = (char)System.in.read();
    System.out.println(ch);
} catch (IOException e) { }

String 类对象的 trim() 方法用于删除头尾的空白符。

数组的定义

一维数组

int[] arr = new int[20];    //首选方法
int arr[] = new int[20];    //非首选方法，但也可以这样

Java 在对数组元素操作时会对数组下标进行越界检查，以保证安全性。

int[] arr = {1,2,3,4};
System.out.println(arr[4]);

会抛出异常：java.lang.ArrayIndexOutOfBoundsException

数组可调用成员变量 length 查看其长度。

int[] arr = {1,2,3,4};
System.out.println(arr.length);    //输出4

二维数组

Java 中的多维数组实际上是数组的数组。不一定是规则的矩阵数组。

排序

import java.util.Arrays;

Arrays.sort(x);

二分查找

前提：数组已排好序。若找到，返回下标，否则输出小于0的数。

System.out.println(Arrays.binarySearch(arr, 10));

第四章 面向对象程序设计

老师：这一章全是重点。

终于可以面向对象编程了QAQ。

main() 的写法

写了那么久代码，别把 main() 函数怎么写都忘了（2333），因为使用 Eclipse 一打上 main 回车就可以自动写好。

铭记：（推荐）

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

或者：

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

多态

重载：单个类中，可以具有多个相同名字的方法，具体调用哪个，由传入参数的数量和类型决定。

重写（覆盖）：继承时子类对父类方法的覆盖。

类首

访问权限修饰符：public 或缺省。（一个 .java 文件有且只有一个公共类）

abstract 抽象类（不能创建对象） final 最终类（不能有子类）

类名通常要求首字母大写。

extends 继承（父类） implements 实现（接口）

定义在成员函数中的变量只是局部变量，不是成员变量。类的成员变量和类中的局部变量可以重名。

访问修饰符

总结：缺省则在其他包都无法访问。public 怎么样都能访问，protected 在不同包的非子类中访问不到，private 只有本类能访问。

大小：public > protected > 缺省 > private

静态 static

静态变量也叫类变量，可以用类访问，也可以用该类的对象访问。

形式：类名.静态成员变量 or 对象名.静态成员变量。

类常量一定要在定义时就给定初始值：（对象常量可以先定义后赋值）

static final x = 5;
//static final x; x = 5;    //Wrong!

方法

方法体也可以是一个分号“;”，表示无具体方法（方法还没有实现，即只是一个方法框架。当且仅当方法的修饰符中有 abstract 或 native 时，方法才可无方法体。

例如：

abstract void play();

构造方法

1. 构造方法的方法名与类名相同。
2. 构造方法没有返回类型，也不能写 void。
3. 构造方法的主要作用是完成对类对象的初始化工作。
4. 每个类都至少有一个构造方法，如果没有显示地定义构造方法，Java会自动提供一个缺省的构造方法。但是只要类中显式定义了一个或多个构造方法，而且所有显式定义的构造方法都带参数，那么将失去缺省构造方法。

继承

Object 类是 Java 中所有类的直接或间接父类。

子类可以继承父类所有非 private 属性及非构造非 private 方法。

属性的隐藏（覆盖）：子类重新定义一个与父类成员变量完全相同的变量。

方法的重写（覆盖）：首部必须与父类中被覆盖的方法的首部完全匹配（返回值类型、方法名、参数、抛出的异常）。

如果子类中新定义的静态成员变量与父类中的某个静态成员变量同名，则这两个静态成员变量相互独立。

class Parent {
    static int a;
}

public class Test extends Parent {
    static int a = 3;
    public static void main(String[] args) {
        a = 2;
        System.out.println(Parent.a);
    }
}

注意：在继承机制中，不允许在子类中降低成员(包括变量和方法)的访问权限。

在子类中若想调用父类的构造方法，则必须放在构造方法的第一行：

class ColorPoint extends Point {
    String color;
    ColorPoint(int x,int y,String color) {
        super(x,y);
        this.color = color;
    }
}

建议：在子类的构造方法中最好能明确使用super调用父类的构造方法给从父类继承来的变量初始化，否则系统会自动加上 `super()`。

构造方法调用顺序：

• 构造方法是不能继承的，因为继承意味着与父类的构造方法同名，但显然子类的构造方法不可能与父类的构造方法同名。
• 但是创建一个子类对象时，子类的构造方法一定会调用父类（直接和间接）的构造方法，以此类推，将继承阶层串联起来，使每个父类的构造方法皆被调用。

例题：

铭记：构造方法的调用顺序（考试可能会考这种变态的题目）：

1. 首先调用父类的构造方法（递归，也就是说，最顶级的父类会最先调用）。
2. 根据各成员的声明顺序，执行初始化语句。
3. 自己的构造方法。

最终类：类被 final 修饰，说明它是最终类，不能被继承。

最终方法：方法被 final 修饰，说明它是最终方法，不能被覆盖（重写）。

注意：所有包含在 final 类中的方法，都被默认为是 final 的。因为这些方法不可能被子类所继承，所以不可能被重载，自然都是最终的方法。

接口

实现程序设计和实现分离。

接口的权限修饰符有两种：

1. 缺省，则只能同包访问
2. public ，则任意访问

包

相当于文件夹。

基本数据变量和引用变量

基本类型变量：在栈中直接存值。

引用型变量：实体值存在堆中，栈中存储堆首地址。

区别：

成员变量如果没有赋初值，则会自动以该类型的默认值（0,false,null等）赋值；而局部变量则不会自动赋值，必须显示地赋值后才能使用。

参数传递总结：

1. Java 按值传递所有参数,制作所有参数的副本,而不管它们的类型
2. 对于基本类型的变量形参修改了并不能反映到函数外面的实参
3. 对于引用类型的变量，在形参中修改了对象实体值可以反映到实参，在形参中修改了对象引用值，不能反映到实参

比较两个变量是否是同个变量（引用值相等）：== 和 !=。

比较两个变量的内容是否相等，用 equals() 方法。

自己定义的类要实现比较内容，则必须重写 equals() 方法：

public boolean equals(Object obj) {
    if(obj == null) return false;
    if(this == obj) return true;
    if(getClass() != obj.getClass()) return false;
    Person p = (Person)obj;
    if(name.equals(p.name) && age == p.age) return true;
    return false;
}

内部类

类中的类。

作用：逻辑分组，隐藏细节。

可用 private、protected 修饰（外部类不能）。

创建时要确保已经有一个外部类对象。

final 表明内部类不能被继承。abstract 表明内部类不能被实例化。static 表明是一个静态内部类。

内部类的好处：

1. 可以直接访问外部类的包括 private 的属性和方法。
2. 若内部类中有和外部类同名的属性或方法，可以使用 outerClass.this 表示外部类的引用。

匿名类

没有类名的特殊内部类。

作用：当需要创建一个类的对象而且用不上它的名字时，使用内部类可以使代码看上去简洁清楚。

类中不能定义构造方法，因为它没有名字。

第五章 异常处理

程序错误分类

编译错误和运行错误。

异常分类

运行时异常（Runtime Exception）和非运行时异常。

运行时异常是程序员编写程序不正确所导致的异常，理论上，程序员经过检查和测试可以查出这类错误。如除数为零等，错误的强制类型转换、数组越界访问、空引用。运行时异常不建议捕获，改正错误就好了。

语法

try {
    ...
} catch(Exception e) {
    ...
} finally {
    ...
}

finally 总是执行，可以为异常处理事件提供一个清理机制。

访问文件未找到 FileNotFoundException

将可能抛出一个或者若干个异常的代码放入try 语句块中。
注意：应当尽量减小 try 代码块的大小，不要将整个程序代码全部放入 try 语句块中，而是应当仔细分析代码，在可能出现异常情况的地方用 try 进行监控。

例：

public class J_Test {
    public static void main(String args[]) {
        try {
            System.out.print('h');
            mb_method1(args);
            System.out.print('x');
        }catch(Exception e){
                  System.out.print('m');
        }
         System.out.print('n');
    }
    static void mb_method1(String a[]){
        try {
            mb_method2(a);
            System.out.print('a');
        } catch(Exception e){
            System.out.print('b');
        } finally {
            System.out.print('c');
        }
        System.out.print('d');
    }//方法mb_method1结束

    static void mb_method2(String a[]) {
        System.out.println(a[a.length]);
    }//方法mb_method2结束

}//类J_Test结束
//输出结果：hbcdxn

将 catch 去掉：

public class J_Test {
    public static void main(String args[]) {
        try {
            System.out.print('h');
            mb_method1(args);
            System.out.print('x');
        }catch(Exception e){
                  System.out.print('m');
        }
         System.out.print('n');
    }
    static void mb_method1(String a[]){
        try {
            mb_method2(a);
            System.out.print('a');
        } finally {
            System.out.print('c');
        }
        System.out.print('d');
    }//方法mb_method1结束

    static void mb_method2(String a[]) {
        System.out.println(a[a.length]);
    }//方法mb_method2结束

}//类J_Test结束
//输出结果：hcmn

抛出异常

除了捕获异常，还可以不捕获——抛出异常，交给上一层处理。

throws 在方法体头部声明，这样也可以使它的调用者必须考虑处理这些异常。

第六章 Java基本类库

本章主要介绍两个包：

java.lang    //Java语言包
java.util    //Java工具包

java.lang.Object

整个类层次结构的根节点。

java.lang.Math

提供数学常数及各种函数。

java.lang.Thread

提供对多线程的支持。

java.lang.Throwable

是所有异常的基类。

字符串类

java.lang.String        //不可改变的静态字符串
java.lang.StringBuffer    //动态可变字符串

String 类

所有字符串常量都是 String 对象，存储在 String Pool（字符串池）中，字符串池是常量池的一部分。

String 类对象一旦创建，其内容不可更改。若要更改，则必须创建一个新的 String 对象。

在比较字符串内容时，不能用 ==，而应该用 equals() 方法。（==比较地址值，equals() 方法比较实体值）

//常量池优化，输出 true
public class Test {
    public static void main(String[] args) {
        String a = "hello";
        String b = "hello";
        System.out.println(a == b);
    }
}

//两个对象，两个常量，输出 false
public class Test {
    public static void main(String[] args) {
        String a = new String("hello");
        String b = new String("hello");
        System.out.println(a == b);
    }
}

//equals()方法，比较实体值，输出 true
public class Test {
    public static void main(String[] args) {
        String a = new String("hello");
        String b = new String("hello");
        System.out.println(a.equals(b));
    }
}

还有种情况：

常用方法

String str = "hello";
System.out.println(substring(2));    //子串，llo
System.out.println(substring(2,4));    //子串，ll，左闭右开
System.out.println(str.length());    //长度，5
System.out.println(str.charAt(1));    //某个字符，e

//字符数组转换为String
char[] s = {'a','b','c'};
String str = new String(s);
System.out.println(str);    //abc

//String转换为字符数组    toCharArray
String str = "abc";
char[] s = str.toCharArray();

//大小写转换
String s1 = "Hello";
System.out.println(s1.toUpperCase());    //HELLO
System.out.println(s1.toLowerCase());    //hello

StringBuffer 类

动态可变。

三种构造方法：

StringBuffer sb = new StringBuffer();
StringBuffer sb = new StringBuffer(int length);
StringBuffer sb = new StringBuffer(String str);

更新方法：

s.append("java");   //hellojava
s.insert(5, "sun"); //hellosunjava
s.setCharAt(0,'H'); //Hellosunjava
s.delete(5, 8);     //Hellojava

String 对象和 StringBuffer 对象相互转换：

//String 2 StringBuffer: 直接用构造函数
StringBuffer sb = new StringBuffer("hello");
//StringBuffer 2 String: 用 toString()方法
String s = sb.toString();

数据类型类

//将字符串转成 int：parseInt()方法
String string = "123";
int a = Integer.parseInt(string);

//将 int 转成字符串：toString()方法
String aString = Integer.toString(a);

Math 类

//PI
double x = Math.PI;

//三角函数
double y = Math.sin(3.14);

//得到一个[0,1)之间的随机数
double c = Math.random();
//得到一个[20,80)之间的随机整数
int c = (int)(Math.random()*60+20);
//得到一个[500,600)之间的随机整数
int c = (int)(Math.random()*100+500);

//舍入函数
double x = Math,ceil(double a);        //向上取整
double x = Math.floor(double a);    //向下取整
double x = Math.rint(double a);        //四舍五入
int x = Math.round(float a);        //四舍五入
long x = Math.round(double a);        //四舍五入

记忆方法：ceil、floor、rint 均返回 double 类型。

参数是 float 则 round 返回 int（都是4字节） ；参数是 double ，则 round 返回 long 类型（都是8字节）。

向量类 java.util.Vector

向量和数组的异同

相似点：都是类，均可保存列表。

不同点：

1. 数组一旦定义，空间长度不可变，而向量空间是动态的。
2. 数组中既能存放基本数据类型，又能存放对象。而向量中只能存储对象，若要存储基本数据类型，可通过封装类如 Integer 。

构造函数：

Vector()                //默认大小10
Vector(int sz)            //指定大小
Vector(int sz,int inc)    //指定大小，指定增量

创建向量：

Vector<Integer> v = new Vector<Integer>(10);

<> 中的类型不能是基本数据类型。

重要方法：

v.add(x);            //添加元素
v.elementAt(idx);    //获取下标为idx的元素
System.out.println(v.size());    //实际元素个数
System.out.println(v.capacity());    //存储容量
v.insertElementAt(obj,idx);    //在下标为idx位置插入元素obj
v.setElement(onj,idx);        //修改元素
v.removeElementAt(idx);        //删除元素
v.clear();                    //清空向量
v.contains(obj);            //判断有无元素obj
v.indexOf(obg);                //返回向量中obj的下标，若无，返回-1

重写 equals() 方法

class Person {
    String name;
    int age;
    Person(String name,int age) {
        this.name = name;
        this.age = age;
    }
    public boolean equals(Object obj) {
        if(obj == null) return false;
        if(this == obj) return true;
        if(this.getClass() != obj.getClass()) return false;
        Person person = (Person)obj;
        return name.equals(person.name) && age == person.age;
    }
}
public class Test {
    public static void main(String[] args) {
        Person aPerson = new Person("Wang", 20);
        Person bPerson = new Person("Wang", 20);
        System.out.println(aPerson == bPerson);
        System.out.println(aPerson.equals(bPerson));
    }
}

输出：

false
true

对 euals() 方法的设计要求：

1. 对称性：如果x.equals(y)返回是"true"，那么y.equals(x)也应该返回是"true"。
2. 反射性：x.equals(x)必须返回是"true"。
3. 类推性：如果x.equals(y)返回是"true"，而且y.equals(z)返回是"true"，那么z.equals(x)也应该返回是"true"。
4. 一致性：如果x.equals(y)返回是"true"，只要x和y内容一直不变，不管你重复x.equals(y)多少次，返回都是"true"。
5. 非空性，x.equals(null)，永远返回是"false"；x.equals(和x不同类型的对象)永远返回是"false"。

第七章 图形用户界面

两个包：

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

最后一定要：

frame.setVisible(true);

为关闭窗体添加事件，使用匿名类，重载 public void windowClosing(WindowEvent e) 方法：

this.addWindowListener(new WindowAdapter(){
    public void windowClosing(WindowEvent e){
        System.exit(0);
    } 
});

三个考试中重要的组件：

JButton, JTextField, JLabel

各种 setXxx() 函数：

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

public class Test extends JFrame {
    //paint()方法
    public void paint(Graphics g) {
        g.setColor(Color.RED);
        g.drawOval(x,y,w,h);
    }
    public static void main(String[] args) {
        //设置窗体标题
        frame.setTitle("Title");
        //设置布局管理器为流布局
        frame.setLayout(new FlowLayout());
        //设置窗体在屏幕中的位置
        frame.setLocation(x,y);
        //设置窗体的大小
        frame.setSize(w,h);
        //设置窗体在屏幕中的位置、大小
        frame.setBounds(x,y,w,h)；
    }
}

若要调整组件的大小、坐标，则将布局管理器改为 null ：

frame.setLayout(null);

在布局为 null 下，组件一定要设置大小（否则默认为宽0高0）：

JLabel label = new JLabel("这是一个标签");
label.setBounds(x,y,w,h);
label.setSize(w,h);            //若不设置坐标，则默认为(0,0)

AWT 和 Swing 的区别与联系

AWT 提供重量级控件，Swing 提供轻量级的组件（而且是纯 Java 实现的）。事件处理机制 Swing 是延用 AWT 的：

import java.awt.event.*;

容器组件考点

顶级容器：Frame, Dialog（一般不考）默认使用 BorderLayout

中间容器：Panel 默认使用 FlowLayout

Frame/JFrame

默认布局：BorderLayout

JFrame();        //不带标题
JFrame(title);    //带标题

常用方法：

//默认不可见，使其可见
f.show();
//或者
f.setVisible(true);

//设置标题
f.setTitle(title);

//设置大小
f.setSize(w,h);

//设置(左上角)坐标
f.setLocation(x,y);

//设置坐标和大小
f.setBounds(x,y,w,h);

//添加组件
f.add(component);
//position是东西南北中：
//"South","East","North","West","Center"
f.add(position,component);

Dialog/JDialog

两种模式：响应模式（所依附窗口不接收任何操作）和非响应模式。

Panel/JPanel

默认布局：Flowlayout 从左到右，从上到下

设置背景颜色和前景颜色：

JPanel panel = new JPanel();
panel.setBackground(Color.RED);
panel.setForeground(Color.BLUE);

按钮 Button/JButton

构造方法：

JButton()        //无文本
JButton(text)    //有文本

常用成员方法：

JButton btn = new JButton();

//btn.setLable("2333");    //过时，不建议使用
btn.setText("2333");    //改变文本

标签 Label/JLabel

构造方法：

JLabel()
JLabel(text)
JLabel(text,alignment)

对齐方式有三种：

JLabel.LEFT、JLabel.CENTER、JLabel.RIGHT

这些都是静态 int 常量，对应0，1，2 。

常用方法：

JLabel label = new JLabel("2333");

int align = label.getAlignment();    //获取对齐方式
String str = label.getText();        //获取文本

set...

单行文本框 TextField/JTextField

构造方法：

JTextField()        //空
JTextField(text)    //有初始文本
JTextField(col)        //指定列数
JtextField(text,col)//有初始文本并指定列数

常用方法：

getText()

常用事件监视器的添加方法

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

public class Test extends JFrame {
    public void paint(Graphics g) {
        g.setColor(Color.RED);
        g.drawOval(x,y,w,h);
        g.drawRect(x,y,w,h)；    //矩形
    }
    public static void main(String[] args) {
        Test frame = new Test();
        Test.setTitle("Test");
        Test.setSize(500,500);
        JButton btn = new JButton("btn1");
        btn.addActionListener(new ActionListener(){
            public void actionPerformed(ActionEvent e) {
                repaint();
            }
        });
        Test.addWindowListener(new WindowAdapter(){
            public void windowClosing(WinodwEvent e) {
                System.exit(0);
            } 
        });

        Test.setVisible(true);
    }
}

四个加法器别忘了看 2333.

第九章 多线程

两种方式：

1. 继承 Thread ，覆盖 run()
2. 实现 Runnable ，实现 run()

class myThread extends Thread {
    public void run() {
        //code
    }
}

class myThread2 implements Runnable {
    public void run() {
        //code
    }
}

开始线程用 start() 方法：

MThread thread = new MyThread();
thread.start();

实现互斥使用修饰符 synchronized ：

public synchronized void methodName(..){}

闲聊

说来有趣，《Java语言及网络编程》这门课主要讲了 Java 语言基础，讲到网络编程就结课了。

考试挺简单，基本把平时作业认真做好，复习个两三天就 OK 了，考试的时候仔细点。

毕竟选修课！

本文采用 CC BY-NC-SA 4.0 许可协议，转载请注明来自 ComyDream 。
本文链接：http://comydream.github.io/2019/01/04/java-review/