JAVA课件总结.doc

JAVA课件总结
第一章 Java入门
1、JAVA特点：简单性、面向对象性、分布式、健壮性、安全性、体系结构中立、可移植性、解释型（Java运行机制：先编译后解释，开发环境：源文件.javaà，编译器：字节码文件.class，解释器：解释运行(由虚拟机完成字节码文件的解释运行)）、高性能、多线程、动态性。
2、Java程序特点：Java源文件可由若干各类组成，类的关键字是class，类名后{}内的部分为类体；每个文件中最多只能有一个public类，public类名与文件名相同；public static void main(String args[]){} 主方法，程序运行的入口，命令行参数 String args[]；可以有多个其他方法。
3、注释：javadoc 用于对.java文件中的文档注释进行提取，从而生成一个帮助文档
命令：javadoc -d docs HelloWorld.java

第二章 java数据类型
1、标识符：对程序中各元素加以命名时使用的符号，遵循以下规则：
由字母、下划线、$、数字组成；不能以数字打头，不能是java中关键字；望文生义。
包名所有单词均小写；类名每个单词的首字母大写；变量、方法名第一个单词首字母小写、其它单词首字母大写；常量都大写
2、 变量：变量三要素：变量类型；变量名；变量作用域（作用域从定义它开始，到定义它的代码块结束为止）。
3、 数组：声明数组仅仅是给出了数组名字和元素的数据类型；要使用数组还必须为它分配内存空间，即创建数组。

第三章 运算符、表达式和语句
1、 实验内容
输出1-10之间的奇数之和，偶数之和，及总和
输出1-100之间，能够被5整除的前5个数
编程输出所有的三位水仙花数 水仙花数:各位数字的立方数相加等于该数本身 例如 153 1*1*1+5*5*5+3*3*3=153 153就是一个三位水仙花数
从键盘输入一个数，求这个数的阶乘。
从键盘输入一个数，求这个数的阶乘之和（1!+2!...7!）。
输入成绩，并按成绩给出相应的等级。

第四章　类、对象和接口
1、面向对象编程三特性：封装（Encapsulation) 、继承 (Inheritance) 、多态 (Polymorphism)
2、成员变量和局部变量关系：局部变量在使用之前，必须进行初始化；对于成员变量即使程序员不进行初始化,虚拟机也会对成员变量进行初始化操作赋默认值。实例变量和局部变量可重名，重名后在方法内采用局部优先策略，这时通过使用this,在该方法内使用成员变量。
3、方法重载：OverLoading 编译时多态：方法的重载指的是在一个类中定义多个名字相同的方法，但是这些方法的参数列表必须不同，编译器会根据实参的型来确定调用哪一个方法，对使用者屏蔽由于方法的形参不同所带来的差异
3、简单变量与对象变量：简单变量，8种原始类型定义的变量；对象变量，引用 对象类型定义出来的变量 ；区别，简单变量--》值；对象变量---》地址。

4、对象的引用和实体：类中的成员变量被分配内存空间，这些内存空间称做该对象的实体。
对象中存放着是对实体的引用，以确保实体由该对象操作使用。 一个类创建的两个对象，如果两对象具有相同的引用，那么就具有完全相同的实体。 没有实体的对象称作空对象，空对象不能使用，即不能让一个空对象去调用方法产生行为。
5、访问权限修饰符： private(私有的） 类的内部访问，不能被子类继承；( default)(友好的) 本包内部可用，本包子类可以继承； protected(受保护的) 本包以及其他包的子类访问，可被子类继承，注：继承后，在子类里覆盖后使用 ； public（公开的）所有地方都可用 ，可以被子类继承。只有public和default可以修饰类。
6、接口回调：可以把实现某一接口的类创建的对象的引用赋给该接口声明的接口变量中,之后接口变量可以调用被类实现的接口中的方法。
7、运行时多态：原则：1. 对象类型不变；2. 对于一个引用只能调用其引用类型里定义的方法；3. 运行时会根据对象的真实类型，运行覆盖过的方法
8、实验内容
定义表示用户的类User。用户的属性包括用户ID、用户姓名，年龄，性别，用户名，密码等；方法包括所有属性的设置和获取方法，以及打印用户名，用户性别，和用户年龄的打印方法，覆盖toString()方法为返回用户的ID，覆盖equals()方法为用户ID相等时两个对象想同。编写主程序，创建User类的对象userA，userB，设置他们的相关属性，并按要求覆盖相应方法，在本题中体现static关键字的使用及权限修饰符的使用。
建立User类的子类Student，在子类中对父类方法进行覆盖，然后编写主程序实现上转型对象，体现运行时多态的编程理念。
定义接口Shape，其中包括Area方法。类Circle、Square和Triangle均实现了接口Shape定义主函数，创建元素个数为3的Shape类型的一维数组，分别为数组元素创建Circle、Square和Triangle类型的对象，最后分别调用各数组元素的Area方法，输出相关信息。
编辑程序利用包装类实现各类型数据的转换。
编辑程序实现Class类的应用工

第五章 字符串时间日期和数字
1、 字符串：字符串常量与字符串变量；“equals（）”与“= =”。
2、 StringTokenizer类：构造函数 StringTokenizer（String s） 为字符串s构造一个分析器。使用默认的分隔符集合，即空格符 、换行符、回车符、Tab符、进纸符。StringTokenizer(String s, String delim) 为字符串s构造一个分析器。参数dilim中的字符被作为分隔符。StringTokenizer字符串分析器使用nextToken()方法逐个获取字符串中的语言符号（单词）
3、 StringBuffer类 ：StringBuffer类能创建可修改的字符串序列，也就是说，该类的对象的实体的内存空间可以自动的改变大小，便于存放一个可变的字符序列。String类创建的字符串对象是不可修改的，也就是说，String字符串不能修改、删除或替换字符串中的某个字符，即String对象一旦创建，那么实体是不可以再发生变化的。
append()将其他Java类型数据转化为字符串再追加到StringBuffer对象中
4、 Date类：使用Date类的无参数构造方法创建的对象可以获取本地当前时间: new Date()，Date对象表示时间的默认顺序是：星期、月、日、小时、分、秒、年。
实现时期的格式化:使用DataFormat的子类SimpleDateFormat来。构造方法：public SimpleDateFormat(String pattern) ，pattern中应当含有一些特殊意义字符，这些特殊的字符被称做元字符，y或yy：表示用2位数字输出年份，yyyy表示用4为数字输出年份；M 或MM表示用2为数字或文本输出月份，如果想用汉字输出月份，应连续包含至少3个M。
d 或dd表示用2为数字输出日；H或HH表示用两位数字输出小时；m或mm表示用两位数字输出分；s或ss表示用两位数字输出秒；E 表示用字符串输出星期。
5、 Calendar类：使用Calendar类的static方法getInstance()可以初始化一个日历对象。月份返回0表示当前是一月

第六章 异常处理
1、 异常(Exception)概述：异常:一种“例外”情况,也就是正常情况之外的一种“情况”｡
2、 异常机制：异常机制能够简化错误控制代码｡程序再也不用对特定错误进行检查,然后在发生错误的多处地方对其进行控制处理｡也不需要在方法调用的时候检查错误｡程序中只在异常处理模块进行问题处理，这样可有效减少代码量,并将那些用于描述具体操作的代码与专门纠正错误的代码分隔开｡
3、 异常条件：异常条件是表示在出现什么问题的时候应中止方法或作用域的继续，在异常条件情况下：程序不能再进行下去，因为当地没有提供解决问题所需的足够多的信 息｡此时,我们能做的唯一事情就是跳出当地环境,将那个问题委托给一个更高级的负责人｡这便是出现异常时出现的情况｡
4、 异常处理方法：抛出异常： throws 异常类类名 消极处理；throw 异常类名
捕获异常： try-catch-finally
语法：将可能出现的异常操作放在try~catch语句的try部分，当try部分中的某个语句发生异常后，try部分将立刻结束执行，而转向执行相应的catch部分；程序将发生异常后的处理放在 catch部分。一个try可以跟多个catch 积极处理，分别处理发生的相应异常。 Finally代表无论如何都要执行的代码，除非try-catch里出现System.exit(0);
注：被抛出的异常沿着方法调用顺序的反向传递方法覆盖时，子类覆盖的方法不能比父类被覆盖的方法抛出更多的异常。
5、 例子
public class NopositiveException extends Exception {//处理在除法计算中出现的0值异常
String message;
public NopositiveException(int i){
message=i+"不是一个正整数";
}
@Override
public String toString(){
return message;
}
}
public class Computer {
public int divide(int i,int j)throws NopositiveException{
if(j<=0){
NopositiveException n=new NopositiveException(j);
throw n;
}
int x=i/j;
return x;
}
}
public class Text {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc=new Scanner(System.in);
int i=sc.nextInt();
int j=sc.nextInt();
Computer c=new Computer();
int k=0;
try {
k=c.divide(i, j);
} catch (NopositiveException e) {
// TODO Auto-generated catch block
System.out.println(e.toString());
}
System.out.println(k);
}
}

第七章 图形用户界面（GUI）
1、 图形用户界面（Graphics User Interface，缩写GUI）：以图形的显示方式与用户实现交互操作的应用程序界面。Java语言中有两个包（java.awt和javax.swing）包括了实现图形用户界面的所有基本元素。“awt”是抽象窗口工具包（Abstract Windowing Toolkit）的缩写，其中的组件常被称为AWT组件。 javax.swing是Java2提出的AWT的改进包，它主要改善了组件的显示外观，增强了组件的控制能力。
2、 在Java中，设计用户界面需要经历4个基本步骤：（1）创建和设置组件（2）将组件加入到容器中 （3）布局组件 （4）处理由组件产生的事件
3、 GUI的三要素：组件：与用户实现交互操作的部件,集成了一定的功能模块，提供了公用接口以便外部调用，具有良好的可重用性。容器：也称窗体，是一种特殊的组件，容器中可以放置其他组件，并且通过布局管理器（LayoutManager）管理容器中各组件的位置。事件：每个组件都会触发动作事件，Java中不同的事件由不同的监听器（Listener）处理，组件是事件源，而某种监听器主要用来监听来自指定事件源产生的动作事件。
4、 FlowLayout是Panel容器的默认布局管理器。BorderLayout是Frame和Dialog两种容器的默认布局管理器。
5、 Swing容器：尽管所有的Swing都属于容器，但还是有几种专门用于作为容器的组件。它们被分成顶层容器、通用容器和专用容器三个类别，其中顶层容器和通用容器是常用的两类容器形式。
6、 事件处理机制：事件处理主要涉及三种对象：事件源An event source)，可供用户进行交互的GUI组件；事件对象(An event object)，封装了包含所发生的各种事件的有效信息，信息包括: 事件源的引用、以及事件监听器在处理事件时所需要的其它各种信息，事件信息被包含在类AWTEvent或其子类的实例对象中；事件监听器(event listener(s))，接受事件对象，并处理事件对象
7、 例子
public class AwtTest extends Frame implements ActionListener{
public Button b;
public Label l1;
public Label l2;
public Panel p;
public CardLayout a;
public AwtTest(){
super("实例");
b=new Button("确定");
b.addActionListener(this);
l1=new Label("北京");
l2=new Label();
p=new Panel();
a=new CardLayout();
p.setLayout(a);
p.add(l1,"l1");
p.add(l2,"l2");
p.add(b,"b");
a.show(p, "b");
this.add(p);
this.setBounds(100, 100, 200, 400);
this.setVisible(true);
}
@Override
public void actionPerformed(ActionEvent e) {
// TODO Auto-generated method stub
l2.setText(l1.getText());
a.show(p, "l2");
}
public static void main(String[] args) {
// TODO Auto-generated method stub
AwtTest at=new AwtTest();
}
}
8、 实验
编写一个登陆界面，在该界面中包括一个用户名输入的文本框，在其中输入用户名为“admin”，一个密码框，在其中输入密码为“123456”时登陆系统，跳转到登陆成功窗口。在登陆成功窗口建立菜单栏，包括“文件”，“操作”两个菜单，文件菜单中包括“退出”菜单项，操作菜单中包括录入和查询页面。在点击录入功能时，将打开一个个人信息录入窗口，在其中录入个人信息，包括文本框的用户名，密码框的密码和确认密码，单选按钮的性别，下拉列表的省份，以及下拉列表的城市，（随着省份列表框的选项不同，城市列表框的内容产生变化），复选框的个人爱好。可输入多组用户信息，然后通过操作菜单的查询字菜单项，在查询窗口中显示前面输入的所有用户信息。

第八章 多线程机制
1、 程序是描述应用软件执行的蓝本的一段静态代码。 进程是程序的一次动态执行过程，它对应了从代码加载、执行至执行完毕的一个完整过程，这个过程也是进程本身从产生、发展至消亡的过程。线程是比进程更小的执行单位,一个进程在其执行过程中，可以产生多个线程，形成多条执行线索。每条线索，即每个线程也有它自身的产生、存在和消亡的过程，也是一个动态的概念。 Java的多线程就是在操作系统每次分时给Java程序一个时间片的CPU时间内，在若干个独立的可控制的线程之间切换。
2、 用Thread类或子类创建线程对象。编写Thread类的子类时，需要重写父类的run方法，其目的是规定线程的具体操作 。
public class Clerk extends Thread {
public Clerk(String name) {
super(name);
}
@Override
public void run() {
super.run();
// 添加具体的工作代码
}
}
3、 实现Runnable接口。
构造方法：Thread（Runnable target）形式参数为Runnable类型的接口，在创建线程对象时实际参数为Runnable接口类的实例对象，作为所创线程的目标对象。当线程享用CPU资源，目标对象就会自动调用接口中的run方法（接口回调）。
public class Clerk implements Runnable{
@Override
public void run() {
// 添加具体的工作代码
}
}
Thread clerk=new Thread(new Clerk());
4、 线程的常用方法：
start() 作用：线程调用该方法将启动线程，使之从新建状态进入就绪队列排队，一旦轮到它来享用CPU资源时，就可以脱离创建它的线程独立开始自己的生命周期了。
格式：创建线程对象.start();
run() 作用：用来定义线程对象被调度之后所执行的操作，都是系统自动调用而用户程序不得引用的方法。注：系统的Thread类中，run()方法没有具体内容，所以用户程序需要创建自己的Thread类的子类，并重写run()方法来覆盖原来的run()方法。当run方法执行完毕，线程就变成死亡状态。
currentThread（）特点：Thread类中的类方法，可以用类名调用。作用：返回当前正在使用CPU资源的线程。 格式：Thread.currentThread()
sleep(int millsecond)作用：线程运行期间执行sleep方法来使自己放弃CPU资源，休眠一段时间。休眠时间的长短由参数millsecond决定，以毫秒为单位计算休眠时间。如果线程在休眠时被打断JVM就抛出Interrupted Exception异常。所以必在try~catch语句块中调用sleep方法。 格式：Thread.sleep(int millsecond);
interrupt() intertupt方法用来“吵醒”休眠的线程。作用:当一些线程调用sleep方法处于休眠状态时，一个正占有CPU资源的线程可让休眠的线程调用interrupt 方法“吵醒”自己 。 格式：休眠线程.interrupt();
5、 线程同步:当几个线程都需要调用一个同步方法(使用关键字synchronized修饰的方法) ,称为线程同步.
同步机制：当一个线程A使用一个synchronized修饰的方法时，其他线程再想使用这个方法时就必须等待，直到线程A 使用完该方法（除非线程A使用wait主动让出CPU资源）。
6、 挂起：所谓挂起一个线程就是让线程暂时让出CPU的使用权限，暂时停止执行，但停止执行的持续时间不确定，因此不能使用sleep方法暂停线程。挂起一个线程需使用wait方法，即让准备挂起的线程调用 wait 方法，主动让出CPU的使用权限.
7、 恢复线程
8、 在其它线程占有CUP资源期间，让挂起的线程的目标对象执行notifyAll()方法，使得挂起的线程继续执行；如果线程没有目标对象，为了恢复该线程，其它线程在占有CUP资源期间，让挂起的线程调用notifyAll()方法，使挂起的线程继续执行。
9、 计时器线程Timer：作用：需要周期性执行的操作,可以通过计时器来进行处理
构造方法：Timer(int a, Object b)创建一个计时器 参数a的单位是豪秒，确定计时器每隔a 毫秒"震铃"一次，参数b是计时器的监视器。
震铃事件为ActinEvent 类型，当该事件发生时，监视器就会监视到这个事件，然后执行方法:actionPerformed(Actionevent e) 使用Timer类的start()方法启动计时器即启动线程。使用stop()方法停止计时器，即挂起线程，使用restart()方法重新启动计时器，即恢复线程。
10、 线程联合：一个线程A在占有CUP资源期间，可以让其它线程调用join()和本线程联合。如果线程A在占有CUP资源期间一旦联合B线程，那么A线程将立刻中断执行，一直等到它联合的线程B执行完毕，A线程再重新排队等待CUP资源，以便恢复执行。
11、 例子
public class ThreadTest {
public static void main(String args[]){
//调用所建立的线程类，并创建线程对象
LHand l;
RHand r;
l=new LHand();
r=new RHand();
//调用start方法运行线程对象
r.start();
l.start();
//编写主线程代码
for(int i=0;i<10;i++){
System.out.println("i am main!");
}
}
}
class LHand extends Thread{

public void run(){
for(int i=0;i<10;i++){
System.out.println("i am left hand!");
}
}
}
class RHand extends Thread{
public void run(){
for(int i=0;i<10;i++){
System.out.println("i am right hand!");
}
}
}

public class runnableTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
Hand h=new Hand();
//调用start方法运行线程对象
h.l.setPriority(10);
h.l.start();
h.r.start();
//编写主线程代码
}
}
class Hand implements Runnable{
Thread l,r;
public Hand(){
l=new Thread(this);
r=new Thread(this);

l.setName("student");
r.setName("teacher");
}
public void run(){
if(Thread.currentThread()==l){
System.out.println(l.getName()+"is sleeping!");
System.out.println(l.isAlive());
try {
Thread.sleep(1000*60);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
System.out.println(l.getName()+"被叫醒了！");
}
System.out.println(l.getName()+"开始听课！");
}else if(Thread.currentThread()==r){
for(int i=0;i<3;i++){
System.out.println("上课");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
}
}
l.interrupt();
}
}
}

//线程同步
public class threadSY {
public static void main(String[] args) {
// TODO Auto-generated method stub
FM f=new FM();
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.setSize(500, 500);
f.setVisible(true);

}
}

class FM extends JFrame implements Runnable,ActionListener{
int money=100;
int weekDay;
JButton bStart;
JTextArea tj1,tj2;
Thread kj,cn;
public FM(){
super("线程同步示例");
bStart=new JButton("开始演示");
bStart.addActionListener(this);
kj=new Thread(this);
cn=new Thread(this);
tj1=new JTextArea();
tj2=new JTextArea();
ScrollPane s1=new ScrollPane();
s1.setSize(100,150);
s1.add(tj1);
ScrollPane s2=new ScrollPane();
s2.setSize(100,150);
s2.add(tj2);
Container c=this.getContentPane();
FlowLayout f=new FlowLayout();
f.setHgap(30);
c.setLayout(f);
c.add(bStart);
c.add(s1);
c.add(s2);
}
@Override
public void actionPerformed(ActionEvent arg0) {
// TODO Auto-generated method stub
if(!cn.isAlive()){
cn=new Thread(this);
kj=new Thread(this);
cn.start();
kj.start();
}
}
@Override
public void run() {
// TODO Auto-generated method stub
if(Thread.currentThread()==kj||Thread.currentThread()==cn){
for(int i=1;i<=3;i++){
weekDay=i;
cq(30);
}
}
}
public synchronized void cq(int number){
if(Thread.currentThread()==kj){
tj1.append("今天是星期"+weekDay+"\n");
for(int i=0;i<3;i++){
money=money+number;
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
tj1.append("帐上有"+money+"\n");
}
}
}else if(Thread.currentThread()==cn){

}
}
12、 实验
（1）编写一个应用程序，除主线程外还有两个线程，一个负责模拟红色按钮从(10,60)运动到(100,60)，另一个负责模拟一个绿色按钮从(100,60)运动到(100,300)。
（2）三人排队买票，甲、乙、丙，售票员只有三张5元，电影票5元一张。甲拿20元一张的人民币排在乙的前面买票，乙排在丙前面拿一张10元人民币买票，丙拿一张5元人民币买票。(售票方法为同步对象,在售票方法中分别对接受到五元,十元和二十元的几种货币作区分,对于无法找零的情况,让当时运行的县城被挂起,知道有合适找零金额再将其唤醒。)
（3）编写一个应用程序，在主线程中创建三个线程：“运货司机”“装运工”“仓库管理员”。要求线程“运货司机”占有CPU资源后立刻联合线程“装运工而“装运工”占有资源后立刻联合线程“仓库管理员”，打开仓库搬运货物，然后装成，运走。(采用线程联合的概念)

第九章 　输入输出流
1、 File类：代表了磁盘上的一个文件或一个目录，该类对象主要用来获取文件本身的一些信息，例如文件所在的目录、长度、读写权限等。注：File不涉及对文件的读写操作。
2、 I/O流：流就是一个传送有序的字节序列，是传输在数据节点和程序间的连接通道上的字节序列。换句话说，流就是对输入数据源和输出目的地的抽象表示。
按照传输单位分类：字节流：数据的处理以字节为基本单位InputStream（字节输入流）OutputStream(字节输出流)；字符流，用于字符数据的处理 Reader（字符输入流）Writer(字符输出流)
3、 流编程的步骤：创建节点流对象；创建节点流；利用过滤流对节点流进行封装；传递数据；关闭流 (关闭外层流)
4、 例子
//字节型输入输出流的使用
public class StreamTest {
public static void main(String args[])
{
int b;
byte tom[]=new byte[25];
try{
File f=new File("src//io/ListFile.java");
File of=new File("olf");
of.createNewFile();
FileInputStream in=new FileInputStream(f);
FileOutputStream out=new FileOutputStream(of);
while((b=in.read(tom,0,25))!=-1)
{ String s=new String (tom,0,b);
System.out.print(s);
out.write(s.getBytes());
}
in.close();
}
catch(IOException e)
{ System.out.println("File read Error"+e);}
}
}

//字符型输入输出流的使用
public class ReaderTest {
public static void main(String args[ ])
{
File file=new File("Student.txt");
String content[]={"你好:","近来工作忙吗?","常联系","祝好"};
try{
FileWriter outOne=new FileWriter(file);
BufferedWriter outTwo= new BufferedWriter(outOne);
for(int k=0;k outTwo.write(content[k]);
outTwo.newLine();
}
outTwo.close();
outOne.close();

FileReader inOne=new FileReader(file);
BufferedReader inTwo= new BufferedReader(inOne);
String s=null;

int i=0;
while((s=inTwo.readLine())!=null)
{
i++;
System.out.println("第"+i+"行:"+s);
}
inOne.close();
inTwo.close();
}
catch(IOException e)
{ System.out.println(e);
}
}
}

//使用RandomAccessFile字节节点流
public class RandomAccesssTest {
public static void main(String args[])
{ new CommFrame();
}
}

class InputArea extends Panel
implements ActionListener
{ File f=null;
RandomAccessFile out;
Box baseBox ,boxV1,boxV2;