java期末复习

基础

class HelloWorldApp
{
    public static void main (String
    {
        System.out.println(“Hi, ”+args[0]);
    }
}

编辑存盘：主类名 含有 main 方法 和文件名要 一致性 HelloWorldApp.java
•编译程序 : javac HelloWorldApp.java
•运行程序 : java HelloWorldApp “myjava”
•运行结果 : Hi, myjava

main()方法参数String[] args称为命令行参数。

javac: Java编译器 , 用来将 java 程序编译成Bytecode字节码
java: Java编译器 执行已经转换成 Bytecode 的java应用程序

C1&2语法（关键字）

1.1语句

/** *- - - / 文档注释

1.2标识符

Java标识符是用来表示类名、变量名、方法名、类型名、数组名、文件名等有效字符序列。一般都要在使用前进行声明。

1.3命名规则：

（1）字母（区分大小写）、下划线、美元符号和数字组成

（2）第一个字母不能是数字；不能包含空格。

（3）不能是关键字。
（4）不能是true，false，null（非关键字）

1.4关键词

• 字符常量（不是）
  false
  true
• 也不包括main bool （java中是boolean） args System.out.println

  访问控制	private	私有的
  protected	受保护的
  public	公共的
  default	默认
  类、方法和变量修饰符	abstract	声明抽象
  class	类
  extends	扩充,继承
  final	最终值,不可改变的
  implements	实现（接口）
  interface	接口
  native	本地，原生方法（非 Java 实现）
  new	新,创建
  static	静态
  strictfp	严格,精准
  synchronized	线程,同步
  transient	短暂
  volatile	易失
  程序控制语句	break	跳出循环
  case	定义一个值以供 switch 选择
  continue	继续
  default	默认
  do	运行
  else	否则
  for	循环
  if	如果
  instanceof	实例
  return	返回
  switch	根据值选择执行
  while	循环
  错误处理	assert	断言表达式是否为真
  catch	捕捉异常
  finally	有没有异常都执行
  throw	抛出一个异常对象
  throws	声明一个异常可能被抛出
  try	捕获异常
  包相关	import	引入
  package	包
  基本类型	boolean	布尔型
  byte	字节型
  char	字符型
  double	双精度浮点
  float	单精度浮点
  int	整型
  long	长整型
  short	短整型
  变量引用	super	父类,超类
  this	本类
  void	无返回值
  保留关键字	goto	是关键字，但不能使用
  const	是关键字，但不能使用
  null	空

1.5数据类型

1.5.1 基本类型：

整型 byte(8)-128 ~ 127, short(16)-32768 ~ 32767, int(32), long(64)long数值在超出 int 范围时必须加 l 或 L

浮点类型 float (32)（有后缀"f"或"F"没有默认double）, double(64)

char (16) 注：Unicode码(String非基类)

boolean (8) (true / false)

虽然编译后1和0只需占用1位空间，但计算机处理数据的最小单位是1个字节，1个字节等于8位，实际存储的空间是：用1个字节的最低位存储，其他7位用0填补，如果值是true的话则存储的二进制为：0000 0001，如果是false的话则存储的二进制为：0000 0000。

小技巧：

String.charAt(index)（返回值为char）可以得到String中某一指定位置的char。

使用String.toCharArray()（返回值为char[]）可以得到将包含整个String的char数组

String s = String.valueOf(‘c’); //效率最高的方法

1.5.2 引用类型

• 名称 : 标识符
• 初始值 :为其赋值或者是保留缺省值
• 作用域 : 在不同程序块中的可用性及生命周期

1.6常量：

整型常量

二进制：0b开头

一般常量：32bit 长整型常量：64bit (88L)
十进制数：非0开头的正负整数 105，-23
八进制数： 0开头的正负整数 017(15), -023(-19)
十六进制：0x开头的正负整数 0x2F(47),-0xa8(-168)

long常量：超过int表示范围后，必须+后缀L

1.7变量强转

• int nx = (int)x;

1.8表达式：短路

短路或||：如果第一个变量为真，就不判断第二个
短路与&&：如果第一个变量为假，就不判断第二个

1.9 Instanceof 运算符

if (t instanceof InstanceOfDemo) {
System.out.println (“T是InstanceOfDemo 的实例”);
}

1.10 math类

random() : 返回类型为 double 且介于 0.0 和 1.0
之间的随机数

int i=(int)(Math.random()*100); //生成0-100的随机数，包括0不包括100 – [0,100)
int j=rand.nextInt(100); // 这里是一个方法的重载，参数的内容是指定范围

• random.nextInt(max-min+1)+min;

• pow(x,y): 返回双精度浮点数=x^y

C3 程序控制结构 do while

switch语句：

表达式必须为byte，short，int或或char

循环：loop

label: statement

可以跳出多个循环

First_Loop for( int i =2,k=0;i<1000;i++)
{
for( int j=2;j<= Math.sqrt(i); j++)
{ if(i%j ==0)
continue First_Loop ;
}
System.out.print（i+"t");

程序中的错误：

语法编译错误：由语言的编译系统负责检测和报告由于所编写的程序存在语法问题，未能通过由源代码到目标代码的编译过程而产生的错误。
运行错误：在程序的运行过程中产生的错误。
严重错误：出现死机、死循环，内存溢出，递归无出口(只能在编程阶段解决）
非致命错误（异常）：被 0 除，读文件而文件不存在，网络中断等。

java异常处理：

处理错误的方法等内容。每**当 Java 程序运行过程中发生一个可识别的运行错误时，即该错误有一个异常类与之相对应时，系统都会产生一个相应的该异常类的对象，**即产生一个异常。一旦一个异常对象产生了，系统中就一定有相应的机制来处理

1.捕获异常，就地解决，并使程序继续执行 。

2.将异常向外转移，即将异常抛出方法之外，由调用该方法的环境去处理。

​ 异常抛出方式：

• 自动抛出（系统定义异常）
• 用 throw 语句抛出（用户定义异常）

自定义异常：

throws出现在方法函数头；而throw出现在函数体。

• throws E1,E2,E3告诉程序这个方法可能会抛出这些异常，方法的调用者可能要处理这些异常，而这些异常可能是该函数体产生的。
• throw则是明确了这个地方要抛出这个异常。

定义异常类：class MyExp extends Exception { //或继承其他异常类

用户自定义的异常要转移需要在方法头声明一下

{…………………
throw new MyExp(“年龄超过规定”）；
}

异常语句：

try{
//接受监视的程序块 在此区域内发生
//若 try 块中出现异常，则控制转向下面的异常处理部分，然后执行后续语句。
//若 try 块中没有异常，则 try 块执行完，控制转向后续语句。  
}
catch (要处理的异常种类和标识符 ){
//处理异常1
//按先后顺序捕获 注意 catch 块书写时的 排列顺序 :先具体、后一般 ))，但只捕获一次。
}
catch (要处理的异常种类和标识符 ){
//处理异常2
}
}finally{
………
}

finally: 不论是否有异常抛出，均执行只有当 try 块中执行 System.exit() 时，会立即结束程序，return finally也执行。

处理过程：

try { //抛出例外
    a=1/b;
    System.out.println("a="+ a);
    if(b==0) throw new Exception(“Here‘s my Exception”); //不执行
    if(a==0) throw new Exception("Here's my Exception");//当遇到关键字 throw 时就抛出一个异常
} catch(Exception e) { //将控制转移到相关的 catch 块中处理之//捕获例外
	//处理例外
    System.out.println("Caught Exception");
    System.out.println("e.getMessage(): " + e.getMessage());
    System.out.println("e.toString(): " + e.toString());
    System.out.println("e.printStackTrace():");
    e.printStackTrace();
}
//如果产生异常的方法本身没有相应 catch 语句 块，则应有 throws 语句声明例外
//退出当前方法并转向上一级调用此方法的方法的 catch 语句块

C4 面向对象

类：

Java 类由状态或属性 和 行为 两部分组成 。

用变量来描述类的状态用方法 来实现类的行为 。

类都派生自 Object

定义

[类的修饰符 class 类名 extends 父类名 ]][implement 接口名表

关系：包含 关联 继承

修饰

Ø一般类只能是public和非public，而内部类可以指 定为 private 和 protected。

对象：

对象 实例 instance 以类为模板创建的

方法

在方法体中可以访问所有的类属性，可以调用所有类中定义的方法。

返回值:

要指定方法返回值类型。如没有返回值，类型要写void。

修饰符 (Modifier)

访问控制符：
public、 private 、 protected 、 protected

• static 静态方法，又称 类方法使用类名或对象名作为前缀，建议使用类名在方法体中只能使用 static 变量和 static 方法
• abstract ：只有方法头，而没有具体的方法体和操作实现的方法， 要在子类中通过重新定义（ override ）来实现
• final ：不能被重新定义 override 的方法

类方法 静态方法：

static 方法名 (…){
使用类方法不用创建类的对象。建议使用类名做前缀，而不是使用某一个具体的对象名。

main 方法要调用本类的其它方法：

1.将这些方法设计成静态方法
2.创建对象，使用对象方法（静态对象也适用）

抽象方法和抽象类

抽象类

包含抽象方法的类就是抽象类。通过abstract方法定义规范，然后要求子类必须定义具体实现。通过抽象类，我们就可以做到严格限制子类的设计，使子类之间更加通用。

不能放在一起的修饰符：final和abstract，private和abstract，static和abstract，因为abstract修饰的方法是必须在其子类中；用static声明方法表明这个方法在不生成类的实例时可直接被类调用，而abstract方法不能被调用，两者矛盾。

//抽象类
abstract class Animal {
    abstract public void shout();  //抽象方法
}
class Dog extends Animal { 
    //子类必须实现父类的抽象方法，否则编译错误
    public void shout() {
        System.out.println("汪汪汪！");
    }
    public void seeDoor(){
        System.out.println("看门中....");
    }
}
//测试抽象类
public class TestAbstractClass {
    public static void main(String[] args) {
        Dog a = new Dog();
        a.shout();
        a.seeDoor();
    }
}

要点

\1. 有抽象方法的类只能定义成抽象类或者接口

\2. 抽象类不能实例化，即不能用new来实例化抽象类。

\3. 抽象类可以包含属性、方法、构造方法。但是构造方法不能用来new实例，只能用来被子类调用。

\4. 抽象类只能用来被继承。

\5. 抽象方法必须被子类实现。

变量

[修饰符] 数据类型 变量名；

成员变量（实例变量）

其生命周期与对象存在的时间相同。

静态变量（类变量，对所有的实例一致）

位于类的内存区域中，为该类的各个对象共享

类变量的声明：要用上述修饰符

控制域

修饰符
访问控制符

• public ：可被所有其他类引用

• private ：仅可被该类自身引用和修改，不能被其他
  任何类（包括该类的子类）引用，它提供了最高级
  别的保护。

• protected 该类自身、子类、同一包中的其他类

• 缺省：本包中的类

static: 类成员变量，对所有的实例一致，引用时前缀
可使用类名或对象名

final: 数值不变常量，定义同时应对其进行初始化

局部变量：要初始化没有赋初值

三大特性

面向对象的分析（OOA）

面向对象的设计（OOD）

封装：

\1. 提高代码的安全性。

\2. 提高代码的复用性。

\3. “高内聚”：封装细节，便于修改内部代码，提高可维护性。

\4. “低耦合”：简化外部调用，便于调用者使用，便于扩展和协作。

技巧：

\1. 类中的数据使用private定义。

\2. 使用public方法来操作数据。

\3. 把逻辑上相关联的数据封装成新的类来使用，类似 结构体。

\4. 不要定义太庞大的类，要把无关的功能适当分离。

\5. 培养良好的编程风格

多态：（polymorphism）

用同一个名字调用实现不同操作的方法

方式1：不同的类之间的同名方法。

方式2：同一程序中同名的不同方法共存，参数不同的同名方 法

• 可以通过子类对父类方法的覆盖实现多态
• 可以利用重载(overload)在同一个类中定义多个同名的方法（用不同的参数列表(参数的个数, 类型, 顺序的不同)在一个类中，不可 以存在两个只有返 回值不同的方法）

向上转型

public class Animal {
    public void eat(){
        System.out.println("animal eatting...");
    }
}
public class Cat extends Animal{
    public void eat(){
        System.out.println("我吃鱼");
    }
}
public class Dog extends Animal{
    public void eat(){
 
        System.out.println("我吃骨头");
    }
    public void run(){
        System.out.println("我会跑");
    }
}
public class Main {
 
    public static void main(String[] args) {
 
        Animal animal = new Cat(); //向上转型
        animal.eat();
 
        animal = new Dog();
        animal.eat();
    }
 
}
//结果:
//我吃鱼
//我吃骨头
这就是向上转型，Animal animal = new Cat(); 将子类对象 Cat 转化为父类对象 Animal。这个时候 animal 这个引用调用的方法是子类方法。

转型过程中需要注意的问题

• 向上转型时，子类单独定义的方法会丢失。比如上面Dog类中定义的run方法，当animal引用指向Dog类实例时是访问不到run方法的，animal.run()会报错。
• 子类引用不能指向父类对象。Cat c = (Cat)new Animal()这样是不行的。

向下转型：

//还是上面的animal和cat dog
Animal a = new Cat();
Cat c = ((Cat) a);
c.eat();
//输出  我吃鱼
Dog d = ((Dog) a);
d.eat();
// 报错 ： java.lang.ClassCastException：com.chengfan.animal.Cat cannot be cast to com.chengfan.animal.Dog
Animal a1 = new Animal();
Cat c1 = ((Cat) a1);
c1.eat();
// 报错 ： java.lang.ClassCastException：com.chengfan.animal.Animal cannot be cast to com.chengfan.animal.Cat

• 向下转型的前提是父类对象指向的是子类对象（也就是说，在向下转型之前，它得先向上转型）
• 向下转型只能转型为本类对象（猫是不能变成狗的）。

重载：

一个类中，同名方法

• 方法名相同
• 方法的参数类型，参数个不一样
• 方法的返回类型可以不相同（注意此时参数不同，不然不知道调用哪个）
• 方法的修饰符可以不相同
• main 方法也可以被重载

继承：

继承实际上是存在于面向对象程序中的两个类之间的一 种关系。Java要求每个类都有父类(隐含为java.lang包中的Object类)。

覆盖：extends 超类/父类名

子类继承父类，可以得到父类的全部属性和方法(除了父类的构造方法)，但不见得可以直接访问(比如，父类私有的属性和方法)。

重新定义父类中已有的方法：覆盖(override )

子类中的方法应与父类中的被覆盖的方法有完全相同的：参数列表、返回值,访问权限不能缩小，抛出的例外要相同

Ø三个条件有一个不满足，就不是方法的覆盖，而是子类 自己定义与父类无关的方法，父类的方法未被覆盖，因 而仍然存在。

this引用和super引用

this表示的是当前对象本身，更确切地说，this 代表了当前对象的一个引用。

解决实例变量被局部变量屏蔽的问题

super 表示的是当前对象的直接父类对象，通过super来访问父类中被子类覆盖的方法或属性。

继承树追溯

• 属性/方法查找顺序

​ \1. 查找当前类中有没有属性h

\2. 依次上溯每个父类，查看每个父类中是否有h，直到Object

\3. 如果没找到，则出现编译错误。

\4. 上面步骤，只要找到h变量，则这个过程终止。

• 构造方法调用顺序：

构造方法第一句总是:super(…)来调用父类对应的构造方法。所以，流程就是：**先向上追溯到Object，然后再依次向下执行类的初始化块和构造方法，直到当前子类为止。**注：**静态初始化块调用顺序，**与构造方法调用顺序一样，不再重复。

final:

\1. 修饰变量: 被他修饰的变量不可改变。一旦赋了初值，就不能被重新赋值。

final` `int`  `MAX_SPEED = ``120``;

\2. 修饰方法：该方法不可被子类重写。但是可以被重载!

final` `void` `study(){}

\3. 修饰类: 修饰的类不能被继承。比如：Math、String等。

final`  `class` `A {}

构造函数

在创建每个新的类对象时自动执行，以保证新对象的各成员有合法、确定的数值。没有返回类型，当一个构造函数调用另一个构造函数时,要使用关键字 this,同时这个调用语句应该是整个构造函数的第一条可执行语句。

A(String n,int a,float s)
{  name = n ;
    if(a>=18 && a<=60)
    age = a ;  else {
    System.out.println("illegal age");
    System.exit(1);
}
salary = s ;
}
A( String n , int a ) 
{  this(n , a , 300 ) ;
}

构造函数的继承：

Ø子类没有定义构造函数时，自动继承父类不含参 数的构造函数，并在创建新子类对象时自动执行。

子类有自己的构造函数时，创建新子类对象时也要先执行父类不含参数的构造函数，再执行自己的构造函数。

Ø若子类的构造函数中没有super(…)语句，系统将隐含调用父类无参数构造函数。如要调用父类的含参数的构造函数，需用super关键字，且该调用语句必须是子类构造函数的第一个可执行语句。

原理：

类对象创建时，利用运算符new 在内存中开辟专用空间， 这时会自动执行类的构造函数,构造函数不是用来调用的，而是new算符的参数。

静态初始化器:

静态初始化器则是在它所属的类加载入内存时 由系统调用执行；比构造函数执行得更早

static {

a=10;

b=a+3; c=a+b;

……

}

构造函数初始化：

为对象分配内存并初始化(0、 false、 null)。

如果没有为类中的某些成员赋初始值，Java系统会为类 的成员赋固定的初始值（数值变量的值为0，布尔变量的 值为false ，未初始化的引用为null ）。

执行每一层的类的显式初始化。

执行每一层的类的构造函数（由于显式或隐式调用）。

抽象类和最终类

Øfinal可以与abstract一起使用吗？

不能同时修饰同一个方法，因为abstract和final修饰词是相对矛盾的，abstract必

须有子类来实现，而final则不能被子类所重载。

abstract class PhoneCard {
……
}
class Number_PhoneCard extends PhoneCard {
……
}
final class D200_Card extends  Number_PhoneCard{
…….
}

控制修饰符总结

1.protected方法和友好方法的区别。

如果子类和父类不在同一个包中，那么，子类继承了父类的protected、public成员变量做为子类的成员变量，并且继承了父类的protected、public方法为子类的方法。如果子类和父类不在同一个包里，子类不能继承父类的友好变量和友好方法。

Øfinal可以用于类名前，表示类不可被继承；final用于变量前， 表示它是只能一次赋值的变量，如果初始化了那就是常量。

Østatic可用于类内部的变量或方法前，表示这是整个类共享的变量和方法，与类对象无关。

Øabstract用于类名前表示一个抽象类，abstract用于成员方 法前表示抽象方法，而抽象类内部至少要有一个抽象方法。

• 跟final不能一起用，至于为什么，你一想就清楚了，抽象类本身必须有子类需要实现它的方法，但是final类又不 能有子类，这不矛盾了么，所以不能一起用。

Østatic final 用于修饰类的静态变量时表示一个常数，其实更 多的还是用在接口里，毕竟用在类里面可能会被子类隐藏

三种情况，四个范围

接口：

用关键字interface来定义，而不是用class

接口中定义的变量全是最终的静态变量。

没有自身的构造方法而且定义的其他方法全是抽象方法，即只提供方法的定义，而没有提供方法的实现语句。

采用多重继承机制

接口定义
public interface 接口名 [extends 父接口名列表]
{ // 常量域声明
public static final 域类型 域名 = 常量值；
// 抽象方法声明
public abstract 返回值类型 方法名( 参数列表 ) ；
}

实现接口：

当一个类声明 implements 某一 interface 时，必须具体实现该 interface 中定义的抽象方法**，实现接口的全部方法并把此方法定义为public的**

• 如果实现了某个接口的类是abstract的抽象类，则它可以不实现指定接口的所有抽象方法。

特点：可以实现 多继承

interface Instrument{
    int i =5 ; // static & final
// Cannot have method definitions:  
    void play(); // Automatically public  
    String what();
	 void adjust();
}
class Wind implements Instrument {
// public cannot be omitted  
    public void play() {
System.out.println("Wind.play()");
}
public String what() { return "Wind"; }
//注意"adjust(){} "与"adjust();"的区别  
    public void adjust() {}
}

//系统接口代表了监听并处理动作事件的功能
public interface ActionListener extends EventListener
{
public abstract void actionPerformed(ActionEvent e);
}

内部类（了解）

Ø在某个类的内部定义的类称之内部类。

• 设外层类名为Myclass，则该类的内部类名为： **Myclass$c1.class (c1 为 命 名 内 部 类 名 ）**Myclass$1.class (表示类中定义的第一个匿名内部类）

Ø内部类拥有对在外层类中定义的所有属性和方法的访

问权，内部类可以随意使用外部类的成员变量（包括私有） 而不用生成外部类的对象，这也是内部类的唯一优点

//有名内部类
class Button1Adapter implements ActionListener {
public void actionPerformed(ActionEvent e) {
…
}
//匿名内部类也就是没有名字的内部类
    
//使用一次  必须继承一个父类或实现一个接口。
Out.In in = new Out().new In();
in.print();
//或者采用下种方式访问
/*
Out out = new Out();
Out.In in = out.new In();
in.print();
*/

C5 数组&字符串

数组：

类型相同的元素组成的有顺序的数据集合有自身的方法，不是变量的集合

(step1)数组的声明(1) int intArray [ ];不是指长度可变

​ 二维数组(可以)
​ int [ ] x [ ];

(step2）通过new运算符来动态创建

(step3)创建数组元素并初始化。

创建:

方法一：先声明后创建
int intArray [ ] ;
intArray = new int [5] ;
方法二：在声明的同时创建
int intArray [ ] = new int [5] ;
方法三：直接赋值
int [ ] intArray = { 1, 2, 3, 4, 5 } ;

调用：

1.doubleArray(b); // 调用不加[]
2.void doubleArray(Integer c[ ] )；//方法参数表中要加[]表示数组

Bubble Sort

class BubbleSort {
// sort the elements of an array with bubble sort
public void bubbleSort( int b[] )
{
    for ( int pass = 1; pass < b.length; pass++ ) // passes
    for ( int i = 0; i < b.length - pass; i++ ) // one pass
    if ( b[ i ] > b[ i + 1 ] ) // one comparison
    swap( b, i, i + 1 ); // one swap
}
// swap two elements of an array
public void swap( int c[], int first, int second )
{
    int hold; // temporary holding area for swap
    hold = c[ first ];
    c[ first ] = c[ second ];
    c[ second ] = hold;
}
}

字符串：

转化为其它类型：

toString()方法

Object类中定义有public String toString()方法，

其返回值是 String 类型。

默认会返回“类名+@+16进制的hashcode”。在打印输出或者用字符串连接对象时，会自动调用该对象的toString()方法。

一般都会重写Float.toString()方法就会转化为String

常见方法：

int indexOf(String str) //返回str在当前串中开始位置

int indexOf(String str,int fromIndex)

字符串转换为数组

char[] toCharArray()

byte[] getBytes()

比较内容是否相等：

boolean equals(String str)

boolean equalsIgnoreCase(String str)

不使用“==”号来比较字符串内容是否相等(常量池除外)

可变字符串（StringBuffer）

StringBuffer类（线程安全的）对象是可变的字符串，有改变字符串的若干方法。

构造方法

1.StringBuffer() // 创建一个空的StringBuffer对象

2.StringBuffer(int length) //设置初始容量

3.StringBuffer(String s) //利用已有字符串String对象来初始化

方法

1.String toString() 将可变串变为不可变字符串

System.out.println()不接受可变字符串

2.append(char c)

正则：

String s = "@Shang Hai Hong Qiao Fei Ji Chang";
String regEx = "a|F"; // 表 示 a 或 F  
Pattern pat = Pattern.compile(regEx);  
Matcher mat = pat.matcher(s);  
boolean rs = mat.find();

C6界面（内容少，主要局 ）

事件处理：引入java.awt.event包

考布

borderlayout.NORTH\EAST

Swing 、awt

(空窗口、frame(窗口)、panle、JOptionPane)

第一代组件:Java.AWT(组件和容器)

第二代组件:Javax.Swing

布局：

组件的位置由容器的布局管理器（Layout Manager）决定

组件自身不能构成独立的图形界面，必须放到容器（ JContainer）对象中。

窗口：

框架（Frame）类是Window类的子类，它是一种带标题框并且可以改变大小的窗口。

JFrame =Frame + Container

面板:

面板（Panel）与框架类似，也是一种容器，可以容纳其他GUI组件。

showDialog对话框:

showMessageDialog —— 信息对话框，显示信息，告知用户发生了什么情况

JOptionPane.showMessageDialog(frame, “File not found.”, “An error”, JOptionPane.ERROR_MESSAGE);

1.showMessageDialog()没有返回值
2.showConfirmDialog()和showOptionDialog()方法返回int型数值，代表用户选择按钮的序号
（JOptionPane中定义了YES_OPTION、NO_OPTION、CANCEL_OPTION、OK_OPTION和CLOSED_OPTION等常量，分别代表用户选择了YES、NO、CANCEL、OK按钮以及未选择而直接关闭了对话框）
3.showInputDialog()方法的返回值为String或Object，代表用户的输入或选项JOptionPane.showConfirmDialog(this,"确定要退出吗？ 确认 ",
JOptionPane.OK_CANCEL_OPTION,JOptionPane.WARNING_MESSAGE);

布局管理器：

BorderLayout（边框布局）：Window类、Dialog类和Frame类的默认布局管理器。

FlowLayout(流式布局)：Panel和Applet默认的

事件处理 actionlistener

1. public ButtonAct() {
     ... ... ... //为b1注册事件监听者B1
     b1.addActionListener(new B1());
     add(b1);
     ... ... ...
   }
   //利用inner class结构定义监听者类
   //每种Listener接口均定义了一套abstract方法  
   class B1 implements ActionListener {
     //利用actionPerformed方法进行事件处理
     public void actionPerformed(ActionEvent e){
     //ActionEvent类：属于动作事件，包括：点击按钮； 双击一个列表中的选项;选择菜单项；在文本框中 按回车。
     who.setText("Button 1");
   

C7 IO流

4种主要类型

InputStream、OutputStream（字节流、几个子类BufferednputStream、BufferedInputStream和PrintStream）

Reader、Writer（Character Streams处理Assic更快）

根据流的数据的类型：将流分为字符流（Character Streams）和字节流（Byte Streams），

–过滤缓冲区 有预留空间减少处理

out=new BufferedWriter(new OutputStreamWriter(new FileOutputStream(“copy”)));
out=new BufferedWriter(new FileWriter(“copy”));
out.write(“Hello World”);out.flush();

实现了缓冲流bufin 和文件输入流 in

文件类 FileReader和FileWriter

File类主要用于命名文件、查询文件属性和处理文件目录。

File (String pathname)

		File src=new File("c.txt");
		File dest=new File("1.java");
		InputStream iStream=null;
		OutputStream oStream=null;
		try {
			iStream=new FileInputStream(src);
			oStream=new FileOutputStream(dest);
			//3.操作
			byte[] flush=new byte[1024];
			//缓冲容器
			int len=-1;
			while((len=iStream.read(flush))!=-1) {
				oStream.write(flush,0,len);
				
			}
			oStream.flush();
		} catch (FileNotFoundException e) {
			// TODO: handle exception
			e.printStackTrace();
		}catch (IOException e) {
			// TODO: handle exception
			e.printStackTrace();
		}finally {
			try {
				if(null!=oStream) {
					oStream.close();
				}
			} catch (Exception e) {
				// TODO: handle exception
				e.printStackTrace();
			}
			try {
				if(null!=iStream) {
					iStream.close();
				}
			} catch (Exception e) {
				// TODO: handle exception
				e.printStackTrace();
			}
		}

inputStream = new FileReader(".jpg"); //"original.txt");
outputStream = new FileWriter(".jpg"); //characteroutput.txt");
int c;
while ((c = inputStream.read()) != -1) {
    outputStream.write(c);
}

BufferedReader fin =new BufferedReader(new FileReader("test.txt") );
fin.readLine()//读文件 
//输出    
PrintWriter fout =new PrintWriter(new FileWriter("test.txt") , true) );
//写文件 
fout.println(…) 
flush()
    

//System类的输入和输出
System类包含三个I/O流成员用于系统标准输入/输出
public static InputStream System.in
public static PrintStream System.out
public static PrintStream System.err
BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in) );
stdin.read() 读一个字符
String readLine() 读一行

C8多线程

–五种状态

在它的一个完整的生命周期中通常要经历如下的五种状态：

新建new：

当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态

就绪start()：

处于新建状态的线程被启动后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件

运行：

当就绪的线程被调度并获得处理器资源时,便进入运行状态， run()方法定义了线程的操作和功能

阻塞Blocked：

在某种特殊情况下，被人为挂起或执行输入输出操作时，让出CPU并临时中止自己的执行，进入阻塞状态

死亡：线程完成了它的全部工作或线程被提前强制性地中止 stop()或destroy()

–两种实现方法(Runnable多)

class P extends Thread{
    
}
(new P()),start();
class P1 implements Runnable{
    
}
(new Thread(new P1())).start();

警察抓小偷程序

class CatchTest2 {
	public static void main(String args[]) {
		CatchTest2 x = new CatchTest2();
		x.go();
	}

	public synchronized void go() {
		Position startP = new Position(-20, -30);
		Policeman Pth = new Policeman("TomP", startP);
		Thief Tth = new Thief("hijackT", startP);
		Tth.start();
		Pth.start();
	}
}

class Position {
	int p_x;
	int th_y;

	Position(int px, int ty) {
		this.p_x = px;
		this.th_y = ty;
	}

	public void show() {
		System.out.println("Police at " + p_x);
		System.out.println("Thief at " + th_y);
	}

	boolean isCatched() {
		if (p_x >= -20 && p_x <= 20 && th_y >= -20 && th_y <= 20) {
			return true;
		}
		else
			return false;
	}
}

class Thief extends Thread {
	Position pos;

	Thief(String s, Position pos) {
		super(s);
		this.pos = pos;
	}

	public void run() {
		try {
			this.sleep(900);
		} catch (Exception e) {
		}
		while (true) {
			for (pos.th_y = -100; pos.th_y <= 100; pos.th_y++) {
				pos.show();
				try {
					Thread.sleep(100);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				
			}
		}
	}
}
class Policeman extends Thread {
	Position pos;

	Policeman(String s, Position pos) {
		super(s);
		this.pos = pos;
	}

	public void run() {
		try {
			this.sleep(10);
		} catch (Exception e) {
			e.printStackTrace();
		}
		while (true) {
			for (pos.p_x = -100; pos.p_x <= 100; pos.p_x++) {
				pos.show();
				try {
					Thread.sleep(100);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				if (pos.isCatched()) {
					System.out.println("police at  " + pos.p_x + "have catched" + "the thief who is at" + pos.th_y);
					System.exit(0);
				}

			}
		}
	}

}

加锁线程同步

加锁1 (临界区-方法）

synchronized 方法名{ … } 进入该方法时加锁

加锁2（临界区-代码块）

方法名{

synchronized(this){… } //进入该代码段时加锁

}

notify()唤醒正在排队等待资源管程的线程中优先级最高者，使之执行并拥有资源的管程

死锁：

不同的线程分别占用对方需要的同步资源不放弃， 都在等待对方放弃自己需要的同步资源，就形成了线程的死锁

•当两个线程相互调用Thread.join()

•当两个线程使用嵌套的同步块，一个线程占用了另外 一个线程必需的锁，互相等待时被阻塞就有可能出现死 锁。

C9集合(灵活性)

set

Set接口的特点

(1)无序不重复

(3)集合重元素是无序存储，不能按索引位置访问元素。

HashMap HashSet （Hash Table底层hash表）

TreeSet（BalancedTree底层二叉树，已排序;

TreeSet中含有一个"NavigableMap类型的成员变量"m，而m实际上是 “TreeMap的实例”。）

List:

1LinkedList 底层数据结构是链表，查询慢， 增删快，线程不安全，效率高，可以存储重复元 素

2ArrayList：底层数据结构是数组，查询快， 增删慢，线程不安全，效率高，可以存储重复元 素

3Vector:底层数据结构是数组，查询快，增 删慢，线程安全，效率低，可以存储重复元素

Interator

Iterator iter=c. iterator()
while(iter. hasNext()){
Object obj=iter.next();}

C10网络

java.net.InetAddress类

（1）

getLocalHost

作用：返回本机地址（机器名+IP）

（2）

getByName(String )

作用：给定计算机名，返回IP地址

（3）

String getHostAdress()

作用：返回本机IP地址

传输协议

TCP(Transport Control Protocol)

• 两主机之间有连接的、可靠的、端到端(end-to-end) 的数据流的传输 如http, ftp, telnet 的传输层均使用此协议

UDP(User Datagram Protocol)

• 从一台机器向另一台机器以无连接的、数据报的方 式进行通讯的协议 如：Email可以使用UDP

socket：IP+Port

• 两台机器之间通讯的端点。分辨internet上运行各种服务程序

• Port端口号：计算机根据端口号提供服务，0～65535之间的整数。Socket的连接需要一对套接字，一个运行于客户端称为Client Socket,一个运行于服务端称为ServerSocket。

• Java的Socket通信模式

  Ø创建socket

  Ø打开连接到socket的输入/输出流。

  Ø按照一定的协议对socket进行读写操作，实现

  所要完成的主要工作。

  Ø关闭socket

• //服务器端
  //创建一个ServerSocket对象(指定端口号).  
  ServerSocket mSer = new ServerSocket(8010);
  //在该端口监听，当收到Client发出的请求时，创建一个Socket对象与此Client通讯:
  Socket socket = ss.accept();
  //接收到Client请求之前，该语句处于阻塞状态。
  //通过Socket类的I/O流对象与Client端通信。
  OutputStream InputStream
  //结束通信，关闭输入输出流、关闭Socket对象。
  //撤消服务时，关闭 ServerSocket对象: 
  mServer.close()。
  
  //客户端
  new Socket (host,port);//试图建立与服务器的连接，如果连接成功返回一个Socket对象
  OutputStream//获得输出流
  InputStream//获得输入流
  close();
  
  //实例
  PrintStream out = new PrintStream(s.getOutputStream());
  BufferedReader in = new BufferedReader(
  new InputStreamReader(s.getInputStream()));  String info=in.readLine();
  System.out.println("now got "+info);
  out.println("HTTP/1.0 200 OK"); out.println("MIME_version:1.0");  out.println("Content_Type:text/html");
  i++;
  String c="<html> <head></head><body> <h1> hi This is "+i+"</h1></Body></html>";  out.println("Content_Length:"+c.length( ));
  out.println("");	out.println(c);
  out.close();	s.close();	in.close( );
  
  

C11JDBC连接五步

//1加载驱动程序
Class.forName(driverClass);
//2获取jdbc连接
Connection con=DriverManager.getConnection(url);
//3创建Statement对象
Statement stmt=con.createStatement();
//4得到查询结果集或者执行update等操作
ResultSet rs=stmt.executeQuery("select *from student");
//5关闭数据库连接
try{con.close();
}catch(Exception e){
}

• ResultSet对象表示数据库结果集的数据表，通常通过执行查询数据库的语句生成。保持一个光标指向其当前的数据行。 最初，光标位于第一行之前。next方法将光标移动到下一行，并且由于在ResultSet对象中没有更多行时返回false ，因此可以在while循环中使用循环来遍历结果集。

• Statement stmt = con.createStatement(
                                        ResultSet.TYPE_SCROLL_INSENSITIVE,
                                        ResultSet.CONCUR_UPDATABLE);
         ResultSet rs = stmt.executeQuery("SELECT a, b FROM TABLE2");
         // rs will be scrollable, will not show changes made by others,
         // and will be updatable