JAVA程序设计
据说博客可以用来记笔记
JAVA程序设计
文章目录
- JAVA程序设计
-
- Java概述
-
- Java虚拟机
- JRE与JDK
- Java基本程序
- Java的基本语法
-
- 数据类型与运算
- 数组
- 与c类似的程序控制语句
- 面向对象基础程序设计
-
- 基本概念
- 定义类、声明对象与访问变量、方法
- 构造方法与finalize方法
- 重载方法
- package 与 import 语句
- Object类
- 面向对象高级程序设计
-
- 继承
- 向上造型与方法重写
- 多态
- 抽象类与抽象方法
- 接口与方法
- 接口的实现
- 枚举类型
- Annotation注释
- 内部类
- 匿名类
- Lambda表达式
- Java的线程使用
-
- 线程与进程
- 线程的创建
- 线程的调度
- 调度的优先级
- 线程互斥
- syncronized
- 线程同步
- 线程死锁
- 线程池
- Java的异常处理
-
- 异常产生与处理机制
- 捕获与抛出
- 用户定义的异常和使用
- Java的字符串类
-
- 概述
- String
- StringBuffer
- StringTokenizer
- 字符串类型转换
- Java的输入和输出类
-
- 概述
- FILE类
-
- 概述
- 静态变量
- PATH
- 构造方法
- 常用方法
- 遍历文件夹
- IO流
-
- 概述
- 字节输出流
- 字节输入流
- 字符输入流
- 字符输出流
- IO异常处理
- 缓冲流
-
- 概述
- 字节缓冲输出流
- 字节缓冲输入流
- 字符缓冲输入流
- 字符缓冲输入流
- Java的常用的标准类
-
- Wrapper
- System
- Runtime
- Math
- Date
- Calendar
- SimpleDateFormat
- Container
-
- 类集
- 映射
- Comparator
- Generics
- static methods in Collection
- JAVA网络编程
-
- 概述
- 网络通信的要素
- IP
- PORT
- SocketAddress
- 通信协议
- 基于TCP协议通信
- 基于TCP文件上传
- 基于UDP协议通信
- URL下载
- JAVA图形化用户界面程序设计
-
- GUI程序设计概述
- AWT
-
- 窗口和面板
- 布局管理器
- 事件监听器
- 文本框
- 标签
- 画笔
- 鼠标监听器
- 键盘监听器
- 窗口监听器
- Swing
-
- 弹窗
- Icoin And ImageIcoin
- JScroll Panel
- 高级按钮
- 下拉框和列表框
- 文本框和文本域
- MVC模式
- 图片与音频
Java概述
Java虚拟机
1.只要计算机提供java虚拟机，用java编写的软件就能在上面运行
2.运行在解释器上，每一个操作系统都有一个解释器，这样Java便成为与平台无关的语言
3.java IDE Eclipse
4.运行机制 java.exe
.java --> .class --> Class Loader (将.class加载到虚拟机) --> Bytecode Verifier (检查是否非法操作) -->java.exe (解释器解释为机器码执行)
5.始终存在系统级线程，自动回收内存
6.面向对象，多线程，不支持宏
JRE与JDK
1.java程序运行需要JRE java run environment
http://java.sun.com
2.java开发工具集 java development kits
bin 命令文件
lib 类库文件
添加环境变量
-->JAVA_HOME
d:\java\jdk
-->PATH
d:\java\jdk\bin;%path%
3.JDK 工具包
Javac: javac filename.java
Java: java filename java -jar filename.jar
Java基本程序
1.java每个.java文件中只有一个公共类，且与文件名一致
System.out.println("hello world!");
import java.io.*;
BufferedReader ir = new BufferedReader (new InputStreamReader(System.in));
String s = ir.readLine();
/***/
import Java.util.Scanner;
Scanner in = new Scanner (System.in);
int a = in.nextInt();
4.Applet 小程序
运行依赖于浏览器
5.Servlet 程序
在服务器内部运行
Java的基本语法
数据类型与运算
1.标识符：与c语言相比可以有货币符号$￥(可在开头)甚至汉字
2.关键字：没有c语言的sizeof
3.注释：和c语言相同，其中/** */作为文档注释，可以用javadoc.exe产生API文档
4.变量：与c语言大致相同
private int i = 5, k =6;
//可分为成员变量（静态变量，实例变量），局部变量，方法参数
5.常量：
final int MAX = 10;
final int MAX_VALUE =10;
//与c语言大致相同，注意命名写法
6.总结
基本数据类型：整型，浮点型，字符型，布尔型
引用类型：类，接口，数组，枚举
7.与c不同的用法
其一
\ddd //八进制的ddd
\uxxxx //十六进制的xxxx
其二
java字符型与整型不同，不可看作整数，但可以参与计算，计算时自动类型转换（整型转为字符型需要强制转换）
其三
整数类型除了short int long 还有 byte , 用法与c语言一致
result = sum == 0 ? 100 : 2 ;
其四
不同于c语言，其关系运算符结果时true或false，并非 1或0
& | 与&& || 类似但不会 “ 短路 ” ，^ 两侧相同为false，不同为true
附：
优先级
. [] () ++ -- ! ~ //单目
new
* / %
+ - //算术运算
>> >>> <<
< > <= >=
== != //关系运算
&
^
|
&&
|| //逻辑运算
? : //条件运算
= += -= *= /= %= ^=
&= != <<= >>= >>>= //赋值运算
数组
1.与c不同，会自动初始化，其中布尔类型默认false
int a[] = {
0,1,2,3,4};//不允许填入大小
int a[][] = {
{
0,1,2},
{
3,4,5},
};
/***/
int[] a = new int[5];//分配在堆中
int[][] a = new int[2][3];
a[1] = new int [2];
a[2] = new int [3];//可以不规则,不同于c，它可以节省空间
/***/
int len = a.length;//它是实例变量，是类产生的对象，具有成员变量和方法
int len = a[0].length;//这里a是二维数组
2.字符串
不同于c语言，java有String 和 StringBuffer 类来处理这个字符串
String[] s = {
"hello","world",
};
s = new String[4];
s[0] = new String("hello");
与c类似的程序控制语句
事实上，java程序控制语句与c/c++几乎完全相同，以下是一些差异
switch(num){
//表达式必须byte,short,int,char,enum，字符串常量
case 1: //value要和expression兼容
case 2: //重复的case非法
break;
default:
}
2.for-each
for(int a : a){
//
//do something
}
3.“先进” 的 goto
OutterLoop: //label所表示的代码块必须包含 break or continue
while(true){
InnerLoop:
while(true){
if(i==0){
break OutterLoop;
}else{
continue InnerLoop;
}
}
}
面向对象基础程序设计
基本概念
1.OOP：object oriented programing
2.封装，继承，多态
定义类、声明对象与访问变量、方法
public abstract/final class MyClass extends superClass implements interfaceClass{
//类名大写开头
private/protected/private static final int a = 0;
public/protected/private static final/abstract synchronized void function throws Exception(int i){
return;
}
}
//注意：在Java中final和static不同于c语言的修饰含义
//final类不允许被继承，final方法不允许被子类覆盖
//static变量和方法为所有对象所共有，不会随对象不同而发生改变
//static方法
MyClass.a = 10;
MyClass.function();
MyClass ir = new MyClass();
ir.a = 10;
ir.function(5);
构造方法与finalize方法
构造方法
1.每一个类至少有一个构造方法，它是在new的时候被调用的，不允许有返回值，方法名与类名一致
2.一个类的构造方法可以多个，但函数签名应该不同（构造方法的多态）
3.没有定义构造方法会默认调用父类的构造方法，最高父类到object，其构造方法为空
4.其中this. 表示当前对象的
finalize方法
System.gc() 作为守护线程会自动的垃圾回收，在清除该对象前，会调用以下格式的方法
protected void finalize () throws Throwable{
//do something like close opened file, save information, and so on.
}
重载方法
Method overloading
一个类中可以存在多个同名方法，但它们需要有不同的参数值，或者返回值（方法的多态）
另外
1.类方法不允许有this，super因为它们是对于对象而言的以及不允许有对象变量和调用非static的方法
2.一个类的main方法必须要static修饰，对于java来说，所有的方法调用时才分配空间，完毕后，立即释放内存
package 与 import 语句
1.不同包中的类可以重名，package语句也是 .java文件中的第一句
package register;
package com.view.display;
2.import 语句：引入所需要的类
import语句里的package name word表示包的层次
import java.util.*;
Date date = new Date ();
或直接引入这个类
java.util.Date date = new java.util.Date ();
3.包的层次必须和文件目录相同，运行一个包中的类时，必须指出包含这个类的包
如：.java中package只在chap包下，而该文件放在chap\test下
在cmd中只有：d:\chap> java test.MyClassFile 才能运行
Object类
所有类都继承自object类，所有类有间接具有object类的方法，当然也可以覆盖父类方法
clone() 返回创建与对象相同类的对象
equal (object) 返回比较2个对象是否同一个对象（布尔值）
finalize() 在回收该对象内存前执行的方法 返回void
toString() 返回对象的字符串表示返回string
面向对象高级程序设计
继承
1.创建子类
public class SubClass extends SuperClass{
}
2.子类访问权限
subclass有权访问父类的成员变量和方法（被public、protected、default修饰）
被private修饰的子类无权访问
3.构造方法
java会自动调用父类的构造方法，即使没有super（），随后再调用子类的构造方法
public class SuperClass {
int i;
int j;
public SuperClass (int i,int j){
this.i = i;
this.j = j;
}
}
public class SubClass extends SuperClass{
int k;
public SubClass (int i,int j,int k){
super(i,j);
this.k = k;
}
}
向上造型与方法重写
1.若子类具有同名字的变量和方法，父类将会被隐藏，因此，子类可以重写父类的方法将其覆盖
2.若想调用父类方法，使用super
public class SuperClass () {
public void test () {
//do something in superclass
}
}
public class SubClass () extends SuperClass () {
public void test () {
super.test();
//do something in subclass
}
}
public class Main() {
public static void main (String args[]) {
SubClass subclass = new SubClass();
subclass.test;
}
}
//do someting in SuperClass
//do something in SubClass
3.将子类的对象放入父类的对象变量，即向上造型（cast）
这个对象具有如下特点
不能操作子类新增方法与变量，但可以操作重新的变量与方法
调用时编译器会自动检测出这是哪一个子类的对象，并调用子类的方法
4.方法重写时不允许比父类具有更严格的访问权限和抛出更多的异常
多态
java变量是多态的
1.方法重载实现静态多态性
2.方法覆盖实现动态的多态
抽象类与抽象方法
public abstract class AbstractClass () {
//不允许new，但允许定义变量，与父类一样，其对象变量允许被子类对象变量赋值
public abstract absFun() (int i, int j);//不允许final修饰，它们必须要继承并重写
public void notAbsFun () {
retunn; //可以含有非abstract的方法，与父类一样，被子类继承
}
}
接口与方法
1.定义
public interface classable () extends SuperInterface {
//继承多个接口是被允许的
//some abstract methods
}
2.在接口中所定义的成员变量一定是
public static final
而方法一定是
public abstract
3.与父子类一样，相同的接口变量、方法会隐藏父类的
接口的实现
public class implementClass implements interfaceClassOne,interfaceClassTwo () {
//you must implement all methods in interface class
//接口名可以定义变量，并被实现类的对象变量赋值
}
枚举类型
1.不说明按0、1、2 … 依次赋值
enum EnumName {
RED = 1, //RED是enumName类型，它被规定是public static
BLUE = 5,
BLACK, //black is 6
}
//so, you can use it as follow
EunmName enumname = EnumName.RED;
//you also can use == to compare and use in switch-case
2.本质上enum，类似于class or interface，但不允许继承和被继承，当然for-each 也是可以使用的
Annotation注释
1.也叫元数据，附加在package、class、method、field 之上，是一种注释
2.用于编写文档，代码分析，编译器编译的检查
3.JDK内置的基本常用注释
@Override
@Deprecated
@Suppress Warnings
内部类
1.内部类相对于外部类来说的，形如
public class OutterClass () {
//outterclass methods
public class InnerClass () {
//innerclass methods
}
}
2.类和接口具有同等地位，因此类在接口中，接口在类中，甚至方法里有类，也称内部类
3.使用
//内部类有权使用外部类的成员变量（包括静态变量），也可以使用所在方法的局部变量
//内部类不允许有static的成员，加static对内部类进行修饰后成为顶层类，此时成员可为static，但对外部类也是去了所有成员的访问权限
public class Outter {
private int i;
public class Inner {
private static int i;
private String s;
public void innerFun () {
//do innerFun
int j;
s = null; //直接的访问权限
Inner.i = 10; //用类名访问static的变量
public class innerClassInMethod {
i = 10;
j = 20; //方法内部类，有权访问局部变量和类变量以及实例变量
}
}
}
public void outterFun () {
//do outterFun
Inner innner = new Innner ();
inner.s = "hi"; //用对象变量访问
innner.Fun();
i = 0;//直接的访问权限
}
pubilc static void main (String args[]) {
//在外部创建内部类对象以及访问方式
Outter.Inner inner = new Outter.Inner ();
inner.innnerFun(); //内部类标识为外部类名.内部类名
}
}
4.内部类可以是抽象的，但它需要被其他内部类所继承，当然也可以是接口，但它需要被内部类所实现
匿名类
匿名类是一种非静态内部类，它的权限和非静态内部类一样
addWindowListenner (new WindowsAdapter(){
//new后面是一个父类或接口，花括号内是继承这个父类或实现接口的方法体，可以有多个方法体
//最终它产生继承父类或实现接口类的对象给addWindowListenner
@Override
public void windowClosing (WindowsEvent e){
System.exit(1);
}
});
Lambda表达式
当匿名类所要实现new后接口的方法只有一个时，那么可以采用lambda表达式，即省略new和接口名，省略的接口名称为函数式接口
addWindowListenner ( (e) -> System.exit(1); );
//函数体只有一条语句时可以省略花括号 （函数参数） -> {函数语句}
Java的线程使用
线程与进程
1.进程是处理器调度的单位
2.一个程序可以实现多个线程，这些线程同时运行，意味着一个程序的多行语句同时执行
线程的创建
Thread类：java.lang,Thread
1.构造方法
Thread ()
Thread (String)
Thread (Runnable)
Thread (Runnable,String)
2.实现多线程
//通过继承Thread，重写run方法，因为是Thread子类，所以获取父类全部方法，此时用子类对象即可调用父类函数如start（）
public class TestThread extends Thread {
public TestThread (String ThreadName) {
super(ThreadName);
}
public void run () {
//Todo
}
}
public class Main {
public static void main (String args[]) {
TestThread thread = new TestThread ("MyThread");
thread.run();
}
}
//通过实现runnable接口中的方法，并将实现该接口的类实例传给Thread，那么Thread类也获得了run方法，之后可调用start（）
//这种方法解决了继承只能有一种线程的问题，因为实现Runnable接口的类的数量没有限制
public class TestThread implements Runnable {
public void run () {
//Todo
}
}
public class Main {
public static void main (String args[]) {
Thread thread = new Thread (new TestThread,"My testThread");
thread.run();
Thread t = new Thread (new TestThread,"testThread");
t.run();
}
}
线程的调度
1.线程的生命周期：New、Runnable、Blocked、Dead
2.Thread的方法实现了对线程的管理和调度
sleep (long milliseconds)
suspend () //enter to blocked
resume () //enter to runnable
yield () //线程退出cpu，重新进入runnable
wait () //可以给它毫秒数作为参数进入阻塞，直到毫秒数达到或notify（）被调用
notify () //线程进入runnable
调度的优先级
//Thread 提供了一些方法来设置优先级
setPriority (enum Rank) //MIN_PRIORITY MAX-PRIORITY NORMAL_PRIORITY
getPriority ()
setDaemon () //将线程设为守护线程
线程互斥
1.经典的例子
public class Acount {
private double balance;
public Account () {
this.balance = 200;
}
public void getMoney (double money) {
balance -= money;
}
public double getBalance () {
return balance;
}
}
public class AccountThread extends Thread{
Account = account;
public AccountThread (Account account) {
this.account = account;
}
@Override
public void run () {
if(Account.getBalance >= 200) {
Account.getMoney (200);
System.out.println("now,balance is "+get.Balance());
}else {
System.out.println("your balance : "+get.Balance()+" is not enough");
}
}
}
public class Main {
public static void main (String args[]) {
Account account;
AccountThread t1 = new AccountThread (account);
AccountThread t2 = new AccountThread (account);
AccountThread t3= new AccountThread (account);
t1.start();
t2.start();
t3.start();
}
}
上述代码执行完毕余额可能为负数，这是因为多个线程对象共享了一份资源或数据（临界资源），同时进行操作会产生不安全，这些对象称为互斥对象
syncronized
1.互斥锁：为每一个对象设置一个互斥所，同一时间只有一个对象能执行操作临界资源的代码块，一个对象结束操作后，释放互斥锁，其余对象中的一个获得后便可执行代码块，这样依次排队执行来避免这个问题
synchronized(受互斥锁保护的对象){
//Todo
}
2.使用方法
public class Acount {
private double balance;
public Account () {
this.balance = 200;
}
syncronized (this) {
//同一时刻只有一个对象来进行此代码块的执行
public void getMoney (double money) {
balance -= money;
}
}
public double getBalance () {
return balance;
}
}
public class AccountThread extends Thread{
Account = account;
public AccountThread (Account account) {
this.account = account;
}
@Override
public void run () {
if(Account.getBalance >= 200) {
Account.getMoney (200);
System.out.println("now,balance is "+get.Balance());
}else {
System.out.println("your balance : "+get.Balance()+" is not enough");
}
}
}
public class Main {
public static void main (String args[]) {
Account account;
AccountThread t1 = new AccountThread (account);
AccountThread t2 = new AccountThread (account);
AccountThread t3= new AccountThread (account);
t1.start();
t2.start();
t3.start();
}
}
public class Acount {
private double balance;
public Account () {
this.balance = 200;
}
public synchronized void getMoney (double money) {
//该方法成为同步方法，同一时间只有一个对象操作此代码块
balance -= money;
}
public double getBalance () {
return balance;
}
}
public class AccountThread extends Thread{
Account = account;
public AccountThread (Account account) {
this.account = account;
}
@Override
public void run () {
if(Account.getBalance >= 200) {
Account.getMoney (200);
System.out.println("now,balance is "+get.Balance());
}else {
System.out.println("your balance : "+get.Balance()+" is not enough");
}
}
}
public class Main {
public static void main (String args[]) {
Account account;
AccountThread t1 = new AccountThread (account);
AccountThread t2 = new AccountThread (account);
AccountThread t3= new AccountThread (account);
t1.start();
t2.start();
t3.start();
}
}
线程同步
1.生产-消费模型：一个线程满足某条件是暂停，唤醒令一线程，另一线程满足某条件后，暂停，唤醒之前的线程
wait() //该线程进入blocked，同步锁被让出，进入互斥对象等待队列
notify() //任何对象执行后，队列中首线程被唤醒，并获得互斥锁
2.用上述2个方法便可以进行实现
public class Account {
double balance = 0;
public synchronized void withdraw (double money){
if (balance==0) {
try {
wait ();
} catch (InterruptedException e) {
}
}
balance -= 100;
notify ();
}
public synchronized void deposite (double money){
if (balance==100) {
try {
wait ();
} catch (InterruptedException e) {
}
}
balance += 100;
notify ();
}
}
//此时创建2个线程分别进行不断地同时存钱和取钱，当余额为0时，取钱线程进入等待，并释放互斥锁
//存钱线程此时正常运行完毕后，执行notify(),此时取钱线程被唤醒，继续执行，但互斥所在存钱线程
//当存钱线程发现余额为100，wait（）被调用，存钱线程进入休眠，释放互斥锁，等待已久的取钱线程获得互斥锁
//取出钱后，唤醒存钱线程，此时存钱线程未获取互斥锁，取钱进程将继续运行，当发现余额为0时，变进入休眠，释放互斥锁
//等待已久的存钱进程获得互斥锁，执行存钱进程
//这样，每次余额为100，存钱进程休眠，取钱进程获得互斥锁取出，取出后存钱进程立刻唤醒，不久取钱进程休眠释放互斥锁，存钱进程开始工作
sleep()不会释放互斥锁，休眠时其他对象依然无法访问临界资源
wait() 和 notify() 因该在临界代码中，也就是获得互斥锁地对象才有权使用
线程死锁
许多线程都不能获取想要的互斥锁，均处于等待状态，导致互斥代码块都无法执行，此时发生线程死锁，这种情况发生概率非常小，但要注意避免
线程池
1.对于线程来说，一旦进入死亡状态后，便无法重新启动，除非重新创建
import java.util,concurrent.*;
为了对一些这样地线程，为了避免资源浪费，可将它们放入线程池中，任务结束放回池，在池中取出就执行
2.创建一个池
ExecutorSerive threadPool = ExecutorSerive.newFixedThreadPool (5);
//it means create a pool can contain 5 threads
//if some thread stop in exception, it will be created again
也可以创建可变线程池，大小根据线程的多少来自动变化
ExecutorSerive threadPool = ExecutorSerive.newCashedFixedThreadPool ();
//if a thread stop in pool and cannot run again in 60 seconds, this thread will be removed from this thread pool
3.在池中加入线程
threadPool.Execute (Runnale command)
//池中线程对于设定地池大小，多的线程进入等待，当池中正在执行地线程停止时，等待地线程依次进入
4.告诉java解释器当池中无可运行的线程时关闭池
//java's threadpool will not auto-shutdown when all threads finished
threadPool.shutdown ();
Java的异常处理
异常产生与处理机制
1.异常（Exception）：对Java来说，异常本身作为一个对象，产生异常就是产生一个异常对象
这个对象就包含了异常事件类型以及应用程序状态
它由正在运行的方法产生也可由Java虚拟机产生
2.处理机制：
异常对象对应于类 java.lang.Throwable and its subclass like Error and Exception
对于Exception里的子类RuntimeException可不处理，因为它们非常普遍，我们要处理的是其他子类产生的异 常
3.继承于Throwable异常的类所包含的常用方法
public String getLocalizedMessage ()
//it will tell you local information about this exception
//if subclass is not override this method
//it will return the result of getMessage()
public String getMessage ()
//return message about exception
public void printStackTrace ()
//print stack trace to console
捕获与抛出
1.异常捕获用 try - catch - finally
try{
//do something may throw exception
}catch (ExceptionName1 e){
//do something or use some methods from ExceptionName1 e
}catch (Exception2 e){
//必须是Throwable的子类，异常产生后异常对象将传递给代码块
//Todo
}finally{
//system must do code in finally, even if cannot catch any exception
}
2.如果方法中产生异常而暂时无法处理，那么必须抛出这些异常，在方法体中必须做出声明
public int read () throws IOException,IndexOutOfBoundsException {
//read.read();
return 0;
}
用户定义的异常和使用
1.Java中的异常间接都继承自Throwable，我们一般继承Exception
2.定义
public class UserException extends Exception {
public UserException {
super();
//Todo
System.out.println("出错啦");
}
//methods like
public void printtrace () {
System.out.println("Error:"+getMessage());
}
}
3.使用
public class ExceptionExample throw UserException{
public void function () {
//Todo
throw new UserException;
}
}
4.捕获
public class MainClass {
public static void main (String args[]){
//Todo ...
try{
i.function();
}catch(UserException e){
e.printtrace();
e.getMessage();
}finally{
//Todo
}
}
}
Java的字符串类
概述
3种常使用的类
String
StringBuffer
StringTokenizer
String
1.String无需import语句即可使用，以下都是等价的，它们会生成一个String的实例
String s = new String ("Hi,Java");
String string = "Hi,Java" ;
2.构造方法
String() //空字符串
String(char[] char) //将char[]转化并生成成String
String(char[] char,int offset,int count) //同上，offset：子数组第一个索引 count：长度
String(String s) //字符串s
String(StringBuffer s) //将StringBuffer转化并产生一个的字符串
3.常用方法
//计算长度
int length()
//是否等价
boolean equals(String s) //equalsIgnoreCase同理
//是否以某字符串开头或结尾
boolean startsWith(String s) //endsWith类似
//字串是否等价
boolean regionMatches(int firstStart,String other,int otherStart,int length)
//比较大小（按字典顺序排序）
boolean compareTo(String s) //compareToIgnoreCase类似
//寻找字符或字符串位置
int indexOf(char ch)
int indexOf(char ch,int fromIndex) //ch -> String同理 lastIndexOf同理
//cannot find return -1
//产生字串
String substring (int beginIndex)
String substring (int beginIndex,int endIndex)
//替换字符或字符串
String replace(char oldChar,char newChar)
String replaceAll (String old,String new)
//改变大小写
String toUpperCase() //toLowerCase同理
//转为数组
char[] toArray()
//连接字符串
String concat(String str)
StringBuffer
1.String产生的对象是不可改变的，对要反复操作的字符串为节约资源，因使用StringBuffer
2.构造方法
public StringBuffer() //产生一个字符串缓冲区，16字符
public StringBuffer(int len) //同上，大小为len
pubilc StringBuffer(String s) //同上，大小为String所占字符数+16
3.常用方法
//连接与插入
StringBuffer append (...) //...可以是绝大多数数据类型，用于将...连接字符串缓冲区 之后，会自动扩充缓冲区大小
StringBuffer insert (int offset,...) //在offset处开始插入 ... ，...同上
//转化为String
String toString() //将StringBuffer转化为String类型
//删除与替换
StringBuffer delete (int start, int end)//删除序号从start到end-1
StringBuffer replace (int start,int end,String str)//在start到end-
//找字串返回String
String substring (int beginIndex)
String substring (int beginIndex,int endIndex)
//反转
StringBuffer reverse()
//计算长度
int length()
StringTokenizer
1.用于解析字符串，默认空格，Tab，换行，回车
2.构造方法
StringTokenizer (String str)
StringTokenizer (String sb,String delim)
//str:被分析的字符串
//delim:分析的分隔符号
3.常用方法
int countTokens ()
while(st.hasMoreTokens()){
System.out.println("st.nextToken()");
}
字符串类型转换
1.对于包裹类型Character、Integer、Float、Double、Boolean、Short、Exception、StringBuffer可直接用覆盖了object类的toString方法转化为String类型
2.Integer、Float、Double、long中由静态方法valueOf(String)来将字符串转化为包裹类型，静态方法类似于parseInt、parseDouble等转化为基础类型如int、double
Java的输入和输出类
概述
1.对Java来说，输入输出都是通过数据流来实现的，处理数据流的类主要放在java.io包中
2.数据流是一组有序的，有起点的和终点的字节集合，是对输入和输出的总称和抽象
3.数据流分输入流和输出流，输入流只能读，输出流只能写
FILE类
概述
java.io.File
文件和目录路径名的抽象表示形式
java把电脑中的文件和文件夹封装成一个类，可以使用File类来对文件和文件夹进行操作
静态变量
//路径分割符
File.pathSeparator
//文件分割符
File.separator
PATH
分为绝对路径(以windows为例，以盘符开始的路径)和相对路径(指所在文件夹的目录开始)
构造方法
File (String pathname);//路径以文件或文件夹结尾，可以是绝对或相对路径，可以是存在的或不存在的
File(String parent, String child);//把路径分成了两部分：父路径和子路径，可以单独书写，比较灵活
File(File parent, String child);//父路径以File类型给出，好处是可以利用File类中的方法进行操作后，再传入
常用方法
-
获取类方法
public String getAbsolutePath();//返回绝对路径 public String getPath();//toString方法就是调用的该方法 public String getName();//获取传递路径结尾的文件或文件夹 public long length();//获取文件的大小，文件夹是没有大小的，而不存在的文件返回0 -
判断类方法
public boolean exist(); //以下方法当路径不存在时候，也返回false public boolean isDirectory(); public boolean isFile(); -
功能类方法
//文件不存在，创建返回true，而存在返回flase //该方法不会创建文件夹，如果文件路径不存在，那么抛出Exception public boolean createNewFile(); //删除由File表示的文件或文件夹，当文件夹不为空，路径不存在返回false public boolean delete(); //只能创建单级的文件夹，也就是传入构造方法的最后文件夹，文件夹不存在创建，返回true，存在或路径不存在返回false public boolean mkdir(); //可以创建多级的文件夹，将路径中不存在不会抛出异常，但它不会创建 public boolean mkdirs(); -
遍历文件夹
//表示File目录所有的子文件和目录，而当路径不存在或构造方法中传入的不是目录时，抛出空指针异常 public String[] list(); //它将文件封装成File类数组返回 public File[] listFiles();
遍历文件夹
public void getAllFile(files){
for(File file : files){
if(f.isDirectory){
getAllFiles(file);
} else {
//Todo
}
}
}
IO流
概述
input / output
流：数据(字节或字符) 一个字节等于八个bit
对字节流，字符流操作的顶层的父类：
字节输出流
一切皆字节，一切文件都以字节来存储
OutputStream 是抽象的，它定义了子类都因该具有的方法
以FileOutputStream为例
-
构造方法
//该构造方法参数主要为了得知其要写入的文件，它们会更据传递的参数创建一个空文件 FileOutputStream(String name); FileOutputStream(File file); //append为true时，表示追加写入 FileOutputStream(String name, boolean append); FileOutputStream(File file, boolean append); -
举例
FileOutputStream fos = new FileOutputStream("test\\test.txt"); fos.write(97);//表示写入一个字节，当然也可以以字节数组传入，来实现写入多个字节 fos.close(); //上述均会可能抛出异常
字节输入流
InputStream 是抽象的，它定义了子类都因该具有的方法
以FileInputStream为例
-
构造方法
//传入文件路径或File对象，目的是获得要读取的文件 FileInputStream(String name); FileInputStream(File file); -
举例
FileInputStream fis = new FileInputStream("test\\test.txt"); byte[] buffer = new byte[1024]; int len = 0; while((len = fis.read(buffer)) != -1){ //Todo } fis.close(); //上述均会可能抛出异常
字符输入流
它可以用于读写字符，无论是中文还是英文，这样解决了中文乱码问题
以 InputStreamReader 下的 FileRead 为例
- 构造方法
Filereader(String name);
FileReader(File file);
Filereader(String name, boolean append);
FileReader(File file, boolean append);
- 举例
Filereader fis = new Filereader("test\\test.txt");
char[] buffer = new char[1024];
int len = 0;
while((len = fis.read(buffer)) != -1){
//Todo
}
fis.close();
//上述均会可能抛出异常
字符输出流
-
构造方法
FileWriter(String name); FileWriter(File file); -
举例
FileWriter fw = new FileWriter("test\\test.txt"); fw.write(97);//表示写入一个字符，当然也可以以字节数组传入，来实现写入多个字节 fw.flush();//刷新缓冲区 fw.close(); //上述均会可能抛出异常
IO异常处理
一般的书写方式
当然JDK7增加了新特性
在JDK9增加了新特性
缓冲流
概述
缓冲流相对于上述的流，它们的效率更高
例如字节缓冲输出流，给基本的字节输入流增加一个缓冲区，提高读取的效率
字节缓冲输出流
根据继承关系，它继承了OutputStream
举例
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream);
bos.write("test".getBytes());
bos.flush();
bos.close();
//上述均会可能抛出异常
字节缓冲输入流
根据继承关系，它继承了OutputStream
举例
BufferedInputStream bos = new BufferedInputStream(new FileInputStream);
int len = 0;
byte[] buffer = new byte[1024];
while((len = bos.read(buffer)) != -1){
//Todo
}
bos.close();
//上述均会可能抛出异常
字符缓冲输入流
因此它具有writer中所定义的全部方法
与字节缓冲输出流一样
字符缓冲输入流
它继承自Reader
使用方法是类似的
Java的常用的标准类
Wrapper
1.java.lang中的类被自动导入，无需import
2.对于包裹类型和基本类型之间 JDK5 开始可以自动装箱
Integer i = 9;
Integer i = new Integer (9);
int i = j;
int i = j.intValue();
3.当把基本类型放入类集合时，就会发生自动装箱转换，把基本类型转换为对应的包装器对象
System
1.System类中的方法
//copy a array from source to target, the length is size
static void arraycopy (Object source,int SourceStart, Object target, int targetStart, int size)
//return milliseconds from 1970.1.1.00:00am
static long currentTimeMills ()
//return nanoseconds from any past time randomly
static long nanoTime()
//stop application
static void exit (0)
//try java's best to clearn garbage
static void gc ()
2.应用
//执行某代码块所花费的时间
pubilc class runTime () {
private static start = 0L, end = 0L;
public static void startRecord (){
start = System.nanoTime();
}
public static void endRecord (){
end = System.nanoTime();
}
pubilc static long RunTime () {
return end-start;
}
pubilc static void PrintRunTime () {
System.out.println("it spends "+(end-start)+" nanoseconds.");
}
}
Runtime
1.概述
Runtime类封装了运行时环境，一般调用static方法getRuntime来获取当前Runtime的对象引用
Runtime runtime = Runtime.getRuntime();
2.获得对象引用后，可调用以下方法
//Process：描述新进程的类
//唤醒程序
Process exec (String progName)
Process exec (String comLineArray[], String environment[])
//终止程序，向父程序返回exitcode
void exit(int exitcode)
3.唤醒另一个程序
Runtime runtime = Runtime.getRuntime(); //获取当前进程Runtime的实例
Process process = runtime.exec("accountManage"); //唤醒其他程序，并获取Process的实例
process.destory(); //杀死子进程
process.waitFor(); //暂停程序直到等子进程运行结束
Math
1.Fields：定义了两个常用的类变量
static double E
static double PI
2.methods：都是静态方法，之间用类名调用即可
... abs(...)
double log (double) //log e
double log10 (double)
double max(...,...) //min类似
double pow (...,...)
double random () //产生0~1的随机数
Date
1.以上的类在 java.lang 包下，以下在 java.util 包下
2.构造方法
Date () //it contains current time and date
Date (long) //it need nilliseconds from 1070.1.1 00:00am
3.常用方法
int compareTo (Date date) //before return <0 after return >0 equals return 0
int compareTo (Date date)
String toString()
Calendar
1.GregorianCalendar是抽象类Calendar的子类，是标准日历（公历）的具体工具
2.构造方法
GregorianCalendar (int year, int month, int Date)
GregorianCalendar (int year, int month, int Date, int hours, int minutes, int seconds)
3.常用方法
void add (int filed, int amount)
//filed必须是如：Calendar.HOUR
boolean after (Object when)
//before同理
boolean equals (Object when)
int get (int Field)
//同add，如Calendar.MONTH、Calendar.MINUTE
void set (int filed, int val)
void set (...,...,...,...,......)
void setTime (Date date)
//设置时间，从date中获取
boolean isLeapYear ()
SimpleDateFormat
1.java.text.DateFormat 是日期/时间格式化子类的抽象类，用于格式化并解析时间和日期，DateFormate是它的父类
2.格式化或解析一个当前语言环境下的日期
SimpleDateFormate sdf = new SimpleDateFormate ("yyyy-MM-dd E HH:mm:ss");
Date date = sdf.parse ("2020-07-02 Thu 9:16:17");
String nowTime = sdf.formate (new Date ());
3.常用方法：
String format (Date date)
//translate date to string
Date parse (String datestr)
//translate string to date
//it needs formate first
Container
类集
1.Collection接口：它是集合框架的基础，它声明了所有类集合都将拥有的核心方法
boolean add (Object) //add
boolean addAll (Collection)
void clear () //clear
boolean contains (Object) //search
boolean isEmpty ()
boolean remove (Object) //remove
boolean removeAll (Object)
int size () //size
Object[] toArray () //toString
2.List接口：继承自Collection，对Collection进行补充
void add (int index, Object obj) //add
boolean addAll (int index, Object Collection c)
Object get (int index) //search
int indexOf (Object obj) //cannot find return -1
//lastIndexOf 同理
Object remove (int index) //delete
Object set (int index, Object obj) //set value
3.set接口：继承了Collection，说明了不允许重复的特性，没有更多的方法
4.实现它们的类
/*class:ArrayList it implements List, also implements its super interface collection*/
ArrayList ()
ArrayList (Collection c)
ArrayList (int capacity)
/*class:LinkedList it implements List. it supply a struction of linked-list */
LinkedList ()
LinkedList (Collection c)
void addFirst (Object obj)
void addLast (Object obj)
void getFirst (Object obj)
void getLast (Object obj)
void removeFirst (Object obj)
void removeLast (Object obj)
/*class:HashSet it implements set. it supply a collection witnout two same elements */
HashSet ()
HashSet (Collection c)
HashSet (int capacity)
/*class:TreeSet it implements set. it supply a struction in turn */
映射
1.Map接口
void clearn ()
boolean containsKey (Object key)
boolean containValue (Object value)
boolean equals (Object obj) //if two Maps comtain same elements, return true, or flase
Object get(Object key) //return another element related to key
boolean isEmpty ()
Object put (Object key, Object value) //override the key and value
void putAll (Map map) //put all elements in map
Object remove (Object key)
int size ()
Collection values () //return a collection contains map's value
2.SortedMap:继承了Map，并按关键字升序
SortedMap subMap (Object start, Object end) //return a sortedmap contains elements whose key is between start and end
SortedMap tailMap (Object start) //return a sortedmap contains elements whose key is > start
3.Map.Entry接口
Object getKey ()
Object getValue ()
4.实现它们的类
HashMap implements Map
TreeMap implements sortedMap
Comparator
TreeSet treeSet = new TreeSet (new ComparatorDemo);
...
class ComparatorDemo implements Comparator{
//userComparator needs implements Comparator interface
public int compare (Object a, Object b){
int i;
//To compare two elements //a>b,return >0;a=b,return =0;a
return i;
}
}
Generics
1.集合框架里的类基本都有泛型声明
public class ArraryList<E> ......
2.指明集合中元素的存储类型
ArrayList<Integer> a = new ArrayList<Integer> ();
static methods in Collection
1.这些静态方法能用于类集和映射
2.一些常用的方法
static int binarySearch (List list, Object value, Comparator comparator)
static int binarySearch (List list, Object value)
//elements in list has been sorted
static Object max (Collection c,Comparator comparator)
static Object max (Collection c)
//min同理
static void sort (List list, Comparator comparator)
static void sort (List list)
JAVA网络编程
概述
- 计算机网络：计算机网络是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统
- 目的：传播信息，数据交换，通信
- 达到效果：
- 定位到网络上的某台主机(IP和port)
- 传输数据(TCP/IP)
网络通信的要素
IP : PORT每一个设备就具有唯一的IP，每一个端口提供不同的服务
协议：
IP
- 与IP有关的类：InetAddress
- 127.0.0.1 -> 表示当前主机
- IP地址分类
- IPV4/IPV6
- 公网(互联网)/私网(局域网)
- 域名：解决记忆问题
package learn;
import java.net.InetAddress;
import java.net.UnknownHostException;
public class MainClass {
public static void main(String[] args) {
// TODO Auto-generated method stub
try {
//InetAddress inetAddress = InetAddress.getByName("127.0.0.1");
InetAddress inetAddress = InetAddress.getLocalHost();
System.out.println(inetAddress);
System.out.println(inetAddress.getHostAddress());
System.out.println(inetAddress.getHostName());
} catch (UnknownHostException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
InetAddress inetAddress = InetAddress.getByName("www.baidu.com");
System.out.println(inetAddress);
} catch (UnknownHostException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
PORT
-
每一个进程因该有不同的端口号 0 ~ 65535
-
同一个协议下，端口号不能冲突
-
端口分类
-
公有端口 0 ~ 1023
HTTP：80
HTTPS：443
FTP：21
Telent：23
-
程序注册端口 1024 ~ 49151
-
-
命令行下
netstat -ano netstat -ano | findstr "5900" tasklist | findstr "8689" #查找指定进程
SocketAddress
package learn;
import java.net.InetSocketAddress;
public class MainClass {
public static void main(String[] args) {
InetSocketAddress inetSocketAddress = new InetSocketAddress("127.0.0.1", 8888);
System.out.println(inetSocketAddress.getAddress());
}
}
通信协议
网络通信协议：速率，传输码率，代码结构等
利用 TCP/IP 协议族中的传输层：TCP UDP
-
TCP：连接，稳定，三次握手，四次挥手，分为客户端和服务端
传输完成，释放连接，效率低
-
UDP：不连接，不稳定，没有明确的界限
不考虑是否准备好，都会发送
三次握手：至少需要三次来保证稳定的连接
四次挥手
基于TCP协议通信
package learn;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class Server {
public static void main(String[] args) {
ServerSocket serverSocket = null;
Socket socket = null;
InputStream inputStream = null;
ByteArrayOutputStream byteArrayOutputStream = null;
try {
serverSocket = new ServerSocket(8888);
socket = serverSocket.accept();
inputStream = socket.getInputStream();
byteArrayOutputStream = new ByteArrayOutputStream();
byte[] buffer = new byte[1024];
int len;
while((len = inputStream.read(buffer)) != -1) {
byteArrayOutputStream.write(buffer,0,len);
}
System.out.println(byteArrayOutputStream.toString());
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
if(byteArrayOutputStream != null) {
try {
byteArrayOutputStream.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
if(inputStream != null) {
try {
inputStream.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
if(socket != null) {
try {
socket.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
if(serverSocket != null) {
try {
serverSocket.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}
package learn;
import java.io.IOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
public class client {
public static void main(String[] args) {
Socket socket = null;
OutputStream outputStream = null;
try {
socket = new Socket(InetAddress.getByName("127.0.0.1"),8888);
outputStream = socket.getOutputStream();
outputStream.write("test".getBytes());
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
if(outputStream != null) {
try {
outputStream.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
if(socket != null) {
try {
socket.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}
基于TCP文件上传
serverSocket = new ServerSocket(8888);
socket = serverSocket.accept();
inputStream = socket.getInputStream();
fileOutputStream = new FileOutputStream(new File("get.png"));
byte[] buffer = new byte[1024];
int len;
while((len = inputStream.read(buffer)) != -1) {
fileOutputStream.write(buffer,0,len);
}
System.out.println("finish");
socket = new Socket(InetAddress.getByName("127.0.0.1"),8888);
fileInputStream = new FileInputStream(new File("test.png"));
outputStream = socket.getOutputStream();
byte[] buffer = new byte[1024];
int len;
while((len = fileInputStream.read(buffer)) != -1) {
outputStream.write(buffer, 0, len);
}
System.out.println("finish");
基于UDP协议通信
不需要连接，建立一个socket，发送数据包
发送端
接收端
URL下载
URL：统一资源定位符，定位互联网上的某一个资源
协议 : // IP : 端口 / 项目名 / 资源
JAVA图形化用户界面程序设计
GUI程序设计概述
1.Graphic User Interface
2.核心技术：Swing，AWT
3.界面不够美观，需要JRE环境，所以不常使用来做图形化用户界面
AWT
所用的类位于java.awt包中
窗口和面板
public class InitComponent {
public static frame frameWindow (String title,int width,int height,Color color,int x,int y,boolean isResizable,LayoutManager mgr) {
Frame frame = new Frame (title);
frame.setVisible (true);
frame.setSize (width,height); //frame.pack(); 自动填充实现大小
frame.background (color);
frame.setLocation(x,y);
frame.setResizable (isResizable);
frame.setLayout (mgr);
frame.addWindowListener (new WindowAdapter {
@Override
public void windowClosing (WindowEvent e) {
System.exit(0);
}
});
}
public static Panel initPanel (int x,int y,int width,int height,Color color,LayoutManager mgr,Frame target) {
Panel panel = new Panel ();
panel.setBounds (x,y,width,height);
panel.setBackground (color);
panel.setLayout (mgr);
target.add (panel);
return panel;
}
public static Button setButton (String lable,Panel target) {
button = new Button (lable);
target.add(button);
return button;
}
}
布局管理器
frame.setLayout(new FlowLayout (FlowLayout.RIGHT/LIFT/CENTER));
frame.setLayout(new GridLayout([rows],[clos]));
frame.add([conponent],BorderLayout.EAST/WEST/NORTH/SOUTH);
事件监听器
//按钮监听器
//窗体监听器
//鼠标监听器
//键盘监听器
public class SetActionListener {
public static void setActionListener (Component target) {
target.addActionListener (new ActionListener () {
@Override
public void actionPerformed (ActionEvent e) {
//Todo
//......
}
});
}
}
文本框
//create a TextField or TextArea
public class Text {
TextField textField;
Component component;
String text;
public Text (TextField textField,Component component) {
this.textField = textField;
this.component = component;
textField.setEchoChar ('*');
this.component.add(this.textField);
}
public void setActiomListener () {
textField.addActionListener (new ActionListener () {
@Override
public void actionPerformed (ActionEvent e) {
e.getSource ();
text = textfield.getText();
field.setText("");
}
});
}
public String getText () {
return text;
}
}
标签
Label label = new Lable ("+");
画笔
public class Paint extends Frame{
@Override
public void paint (Graphics g) {
//Todo
g.setColor ();
g.drawOvel(...);
g.fillOvel(...);
}
}
鼠标监听器
public Myframe extends Frame {
public MyFrame (String title) {
super(title);
//......
this.addMouseListener (new MouseAdapter {
@Override
public void mousePress (MouseEvent e) {
e.getSourse();
e.getX();
e.getY();
repaint();
}
});
}
@Override
public void paint (Graphics g) {
//Todo
//...
//paint
}
}
键盘监听器
frame.addKeyListener(new KeyAdapter () {
@Override
public void KeyListener (KeyEvent e) {
//Todo
if(e.getKeyCode()==KeyEvent.VK_UP) {
//Todo
//......
}
//......
}
});
窗口监听器
frame.addWindowListener(new WindowAdapter () {
@Override
public void windowClosing (WindowEvent e) {
//Todo
//......
}
@Override
public void windowActivated (WindowEvent e) {
//Todo
//......
}
} );
Swing
所用的类位于java.swing包中
使用方法与AWT类似
JFrame frame = new JFrame ("JFrame");
frame.setVisible (true);
frame.setDefaultCloseOperation (WindowsConstants.EXIT_ON_CLOSE);
Container container = frame.getContentPane();
Container.setBackGround (Color.BLUE); //对窗口的设置需要在container里
frame.add(new JLabel("label"));
弹窗
本质也是一个窗口，也可以和窗口一样加入按钮等
public Dialog extends JDialog {
public Dialog () {
setVisible (true);
setBounds(100,100,100,100);
//不需要设置窗口监听器，默认点击×自动关闭
Container dialog = getContentPane ();
dialog.setLayout(null);
container.add(new Label("this is a dialog"));
}
}
Icoin And ImageIcoin
container.add(new JLable("lable",new IconDemo (),SwingConstants.CENTER));
//--------------------------
public class IconDemo implements Icoin {
@Override
public void paintIcon (Component c,Graphics g,int x,int y) {
//Todo
//......
}
public int getIconWidth () {
return 10;
}
public int getIconHeight () {
return 10;
}
}
new Lable.setIcoin(new ImageIcon (classname.class.getResource("filename,jpg")));
JScroll Panel
JScrollPane是一个滚动面板，只能添加一个组件，例如在Swing中，像JTextArea、JList、JTable等组件，但是我们可以添加一个面板JPanel，然后再把很多组件添加到JPanel上
public class ScrollPanel {
public static ScrollPanel (Container container,int rows,int cols) {
container.add(new JScrollPanel(new JTextArea(20,50)));
}
}
高级按钮
/*图片按钮*/
button.setIcon(icon);
button.setToolTipsText("图片按钮"); //鼠标放上会给出提示
/*单选框*/
JRadioButton rb1 = new JRadioButton ("rb1");
JRadioButton rb2 = new JRadioButton ("rb2");
JRadioButton rb3 = new JRadioButton ("rb3");
ButtonGrop grop = new ButtonGrop ();
grop.add(rb1);
grop.add(rb2);
grop.add(rb3); //将选择框放入一个组内，告诉编译器它们时一组单选框
/*多选框*/
JCheakBox cb1 = new JCheakBox ("cb1");
JCheakBox cb2 = new JCheakBox ("cb2");
JCheakBox cb3 = new JCheakBox ("cb3");
下拉框和列表框
/*下拉框*/
JComboBox cb = new JcomboBox ();
cb.addItem (null);
cb.addItem ("choice 1");
cb.addItem ("choice 2");
cb.addActionListener(new actionListener () {
//Override methods
} );
/*文本框*/
String[] contents = {
"1","2","3",
};
JList list = new Jlist (contents);
container.add(list); //可以放入JScroll panel
文本框和文本域
//文本框
new TextField ("hello",[columns]);
//密码框
PasswordField passwordField = new JPasswordField ();
passwordField.setEchoChar ('*');
//文本域
container.add(new JScrollPanel(new JTextArea(20,50)));
MVC模式
1.如果时间足够小，就成为动画，每一帧就是一个静态图片
//定时器
public class test {
Timer timer = new Timer ([delay],[listener]);
//[listener] is a class implements ActionListener which has abstract menthod :
//public void actionPerformed (ActionEvent e) {
//Todo
//}
timer.start();
}
2.Model、View、Controller
图片与音频
1.加载和使用图片
public static Image getImage(String path) {
URL url = GameUtil.class.getClassLoader().getResource(path);
BufferedImage image = null;
try {
image = ImageIO.read(url);
} catch (IOException e) {
e.printStackTrace();
}
return image;
}
//-----------
public void paint(Graphics g) {
g.drawImage(image, 200, 200, null);
}
2.加载和使用音频
public class Sound {
byte[] data;
AudioFormat format;
int length;
public Sound(String name) throws Exception{
AudioInputStream in = AudioSystem.getAudioInputStream(getClass().getResource(name));
format = in.getFormat();
length = (int)in.getFrameLength();
data = new byte[length];
in.read(data);
in.close();
}
public void play(){
Runnable runnable = new Runnable() {
@Override
public void run() {
try {
Clip clip = AudioSystem.getClip();
clip.open(format, data, 0, length);
clip.start();
// System.out.println(new String(data,0,length));
// clip.drain();
// clip.stop();
// clip.close();
} catch (LineUnavailableException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
};
new Thread(runnable).start();
}
}