java程序设计基础知识

一、Java语言概述

1.1 Java基本概念:

类是java程序的基本构成单位，重要的入口main方法,基本结构主类主方法

public class test{
       public static void main(String[] args){
              System.println(“hello java”);
        }
}    

1.2 Java特性：

跨平台、安全稳定、支持多线程、支持网络编程、具有丰富的库函数、面向对象(继承、封装、多态)

1.3 Java程序的执行环境和源文件处理过程：

javac xxx.java        //编译
java xxx                //运行

举个栗子：假设有一个test.java文件

javac test.java
javac test

编译如果通过就会生成一个.class后缀结尾的字节码(bytecode)文件

字节码由Java虚拟机执行

1.4 JDK文件的结构：

bin: 该目录存放运行程序；

db:  该目录存放有关数据库方面的文件；

demo: 该目录存放一些实例文件；

include: 该目录存放与C相关的头文件；

jre：该目录存放java运行环境相关的文件；

lib: 该目录存放程序库；

更多的可以了解JDK官方文档查就ok

1.5 面向对象的软件开发过程：

面向对象的分析(Object Oriented Analysis OOA)

面向对象的设计(Object Oriented Design OOD)

面向对象的实现(Object Oriented Programming OOP)

二、Java编程基础

2.1 基础数据类型：

注意和包装类的区别（包装类首字母大写，而基本类型都是小写），注意和C语言的区别，注意类型之间的转换，低精度可以直接存储到高精度变量中，这是自动转换；高精度数据放入低精度变量必须强制转换。还要注意有些数据类型不能转换。比如boolean不能将其转换为其他类型，尤其是整型，这一点是和C的明显区别。

float a=8.1;    //报错，8.1默认是double类型

2.2 命名规则：

类、接口首字母大写，变量首字母小写，常量全大写（行业惯例）

标识符的命名规则（掌握，这是强行规定）

• 首字符必须是字母（大小写均可）、下划线(_)或美元符号（$）
• 标识符可以由数字（0-9）、A-Z、a-z和下划线(_)、美元符号（$）
• 长度不限

2.3 Java的注释符号

a)       单行注释 //开始 行尾结束
b)       多行注释 /*开始 */结束
c)       doc注释 /**开始 */结束

注意：第3种注释主要是为支持JDK工具javadoc而采用的。Javadoc能识别注释中用标记@标识的一些特殊变量，并把doc注释加入它所生成的HTML文件。常用的@标记如下。

@see: 应用其他类；

@version: 版本信息

@author: 作者信息

@paran: 参数名说明

@return: 说明

@exception: 完整类名说明

对于有@标记的注释，javadoc在生成有关程序文档时，会自动识别它们，并生成相应的文档。

2.4 运算符

按照运算符功能来分，基本的运算符有下几类：

a)       算数运算符（+  -  *  /  %  ++  --）

b)       关系运算符（>  <  >=  <=  ==  !=）

c)        布尔逻辑运算符（!  &&  ||  &   |）

d)       位运算符（>>  <<   >>>   &   |   ^    ~）

e)       赋值运算符（=  +=  -=  %=   *=  /=）

f)         条件运算符（? :）

g)       其他（包括分量运算符.    下标运算符[]   实例运算符 instanceof    内存分配运算符new   强制类型转换符（类型） 方法调用运算符（）等）

注意：短路与或短路或，对于&&，只要左边表达式为false，就不用计算右边的表达式，则整个表达式为false。对于||，只要左边表达式为true，就不计算右边的表达式，则整个表达式为true。

2.5 基本流程控制语句

三种基本控制语句：选择、顺序、循环

2.5.1顺序语句

Java中一句一句的读写。而最简单的语句是方法调用语句及赋值语句，是在方法调用或赋值表达式后加一个分号（；），分别表示完成相关的任务及赋值。如：

System.out.println(“hello world”);
a=3;
b=2;

2.5.2分支语句

Java中的分支语句有两个，一个是负责实现双分支的if语句，另一个是负责实现多分支的switch语句

1)       if语句

if 语句的一般形式：

if(条件表达式)
              语句块;  //if分支
else
              语句块;  //else分支

注：如果条件表达式为true，则执行if分支，否则执行else分支

下面是一个if语句的简单例子，实现求某个数的绝对值

If(a>0)
b=a;
else
b=-a;

2)       switch语句

switch语句是多分支语句，一般形式是：

switch(表达式)

{
       case 判断值1:语句1; break;
       case 判断值2:语句2; break;
        ………
        case 判断值n:语句n; break;
        default:语句n+1;
} 

注：表达式必须是整数型或字符类型；判断值必须是常数，而不能是变量或表达式。从java6开始，表达式可以是字符串（String）类型或者枚举类型。Switch语句每一个case判断，一般情况下都有break语句，以指明这个分支执行后，就跳出switch语句。在某些特定的场合下可能不需要break语句，比如在若干判断共享同一分支时，就可以实现由不同的判断语句流入相同的分支。

例子：根据考试成绩的等级打印出百分制分数段

Switch(grade){
       case ‘A’:
              system.out.println(grade+”is 85 ~100”);
              break;
       case ‘B’:
              system.out.println(grade+”is 70 ~84”);
              break;
       case ‘C’:
              system.out.println(grade+”is 60 ~69”);
              break;
       case ‘D’:
              system.out.println(grade+”is <60”);
              break;
       default:
              system.out.println(”error”);
}

2.5.3 循环语句

Java循环语句共有三种：for、while和do-while语句。三种语句在使用时，都要表达以下几个要素。

• 循环的初始化
• 循环的条件
• 循环体
• 循环的改变

1)       for语句

for语句的一般语法格式如下：

for(初始化;循环条件;循环改变){
             循环体
}

注：for循环的第一个表达式中，可以定义变量，这里定义的变量直在该循环体内有效。如for(int n=0; n<100; n++){System.out.println(n);}

2)       while语句

while语句的一般语法格式如下：

　　　　　　初始化
       while(条件表达式){
              循环体
              循环改变语句
}

先初始化，然后进入循环，表达式为true进入循环体，循环内也应该有循环控制语句，防止死循环。如果表达式为false则跳过while循环执行语句后面的语句。

3)       do-while语句

do-while语句的一般语法结构如下：

       do {
       循环体
}（条件表达式）；

注：与while语句类型，不同的是它会无条件进入循环体一次，再来判断条件表达式。若为true则执行循环体，为false则跳出循环，执行后面的语句，do-while语句特点是它的循环体至少被执行一次。

5.5.4 跳转语句

• continue语句

终止当前这一轮的循环，跳过本轮剩下的语句，直接进入当前循环的下一轮。

• break语句

从一个语句块内部跳转出来。如从switch语句的分支中跳出，或从循环体内部跳出。

• return语句

return一般格式：return 表达式;

用来使程序流程从方法调用中返回，表达式的值就是调用方法的返回值，如果方法没有返回值，则return语句不用表达式。

2.6 数组

一维数组的定义

 type [] arrayName 或者 type arrayName[];
 arrayName = new type[大小]

注：以为数组元素的引用（数组不初始化有初始值）根据定义的类型决定（整数默认0、实数默认0.0、字符默认‘‘、boolean默认false、引用默认null）。这是因为，数组实际是一种引用型的变量，而其每个元素是引用型变量的成员变量。

二维数组的定义

       Java中的二维数组看作是由多个一维数组构成。

例如：int [][] x;表示定义了一个二维数组引用变量x，如果将二维数组x看作一个一维数组，那么它的第一个元素为x[0]，最后一个元素为x[n-1]，分别都是整型数组引用，并且长度不定。

三、类、包和接口

面向对象的特征：封装、继承、多态（重载和覆盖）。

3.1 类、字段、方法

定义类：

[类型修饰符] class 类名称{
       类体
}

程序中，类的定义包括类头和类体两个步骤，其中类体用一堆大括号{}括起，类体又由字段和方法组成。字段是对象的属性、状态的表示，又称为域、域变量、成员变量、字段变量等。

例子：表示人的类的定义person。

Class person{
       String name;                //name字段
       Int age;                        //age字段
       Void sayHello(){           //sayHello方法
       System.out.println(“hello,my name is”+ name);
　　　　}
}

注意：如果字段变量，不赋初始值，系统会自动赋一个默认值（数值型为0，boolean型为false，引用型为null。String类型是引用类型）

方法是对对象的行为和功能的表示，标志了类所具有的功能和操作，用来把类和对象的数据封装在一起。

声明成员变量：

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

定义方法：

[修饰符] 返回值类型  方法名（参数表）{
       方法体
　　return [表达式];
}
[修饰符] class A extends B{
       类体
}

修饰符分为访问控制符和非访问控制符

访问控制符：

• private，类中限定为private的成员（字段或方法）只能被这个类本身访问，即私有访问控制。由于private域或方法只能被这个类本身所访问，所以private域或方法不可能被子类所继承。当我们说“子类自动继承所有域或方法”时，是指非private域或方法。
• 默认访问控制，类中成员默认访问控制时，成为默认访问控制，默认访问控制的成员可以被这个类和同一个包中的类所访问，即包访问控制。Java中没有friend这个关键字，所以要与c++的friend区分开
• Protected，类中限定为protected的成员可以被这个类本身、它的子类（包括同一个包中及不同包中的子类）及同一个包中所有其他的类访问。Java中还有一种访问控制符为private protected，它限定能被本类及其子类可以访问，而包中的其他非子类的类不能访问。
• l  Public,类中限定为public的成员可以被所有的类访问。

注：java中不允许多重继承，也就是说一个类只能有一个父类，java中使用接口实现类似多重继承的功能。方法中不可以定义方法，但是可以调用方法。类中可以定义类，例如匿名类。

非访问控制符：

• static,静态变量是属于某一个类，而不属于类的对象。静态变量的引用直接通过类名引用。静态变量在某种程序上与其他语言的全局变量相类似，如果不是私有的就可以在类的外部进行访问。用static修饰的方法是属于类的静态方法（类方法），非static得方法是属于某个对象的方法，在该对象创建时，对象的方法在内存中拥有属于自己专有的代码段；而static的方法是属于整个类的，它在内存中的代码段将被所有对象所共用。static方法只能访问static成员变量或static方法。在静态方法中不能使用this或super,静态方法访问格式：类名.静态方法名（）；也可以用对象名.静态名();
• final，不能被继承，一般是用来完成某种标准功能的类，final方法不能被覆盖，final域必须且只能赋值一次，一旦赋值，不能修改。Final局部变量，必须且只能赋值一次。String和StingBuffer都是final类，不能做父类使用。
• abstract,抽象类，没有具体对象的概念类，所有子类公共属性的集合，不能使用new实例化，为所有子类定义一个统一的接口，只需声明，不需实现，子类必须去实现父类中的abstract方法，否则仍为abstract类，abstract方法必须位于abstract类中。Abstract不能与private,static,final或native并列修饰同一方法。

注：包含abstract方法的类一定是abstract类，不用去构造对象，必须实现其所有抽象方法后，才能用这个类去生成对象abstract。

抽象类和接口的区别

一个类不能既是abstract又是final，因为abstract修饰的类是未完工的，必须被继承，形成子类，在子类中补充完整才能被实现，而final类表示是最终状态，不饿能被继承去生成子类，二者是矛盾的。

同理abstract和private也是矛盾的，因为private表示一个方法不能在子类中覆盖，而abstract修饰一个方法表示此方法未完工，应该在子类中去实现。

Java使用接口实现类似多重继承的功能，从本质上讲，当类实现一个接口的时候，就必须实现所有定义在接口以及它的SuperInterfaces中的方法，实现时，类中方法的形参和返值个数和形式必须和接口声明中保持一致。

接口的声明 （注意接口与类的区别）

[修饰符] interface 接口名 extends 父接口{

…  //常量和abstract方法声明

}

接口的实现

一个类要实现接口时，要注意以下问题

• 在类的声明部分，用implements关键字声明该类将要实现哪些接口
• 非抽象类中不能存在抽象方法
• 一个类在实现某接口的抽象方法时，必须使用完全相同的方法头，否则，只是在重载一个新的方法，而不是实现已有的抽象方法。
• 接口的抽象方法的访问限制符都已指定为public,所以类在实现方法时，必须显示地使用public修饰符，否则将被系统警告为缩小了接口中定义的方法的访问控制范围
• 一个类只能有一个父类，但是它可以同时实现若干个接口。一个类实现多个接口时，在implements子句中用逗号分隔。

定义接口格式如下：

class 类名 implements 接口名列表；

例：

class MyClass implements Range{
       …  
}

实现接口就意味着这个类要实现接口里面全部的abstract方法，有一个没实现，这个实现接口的类仍是abstract类型的

接口与抽象类的区别

接口封装了方法定义与常量值，类封装了成员变量和成员方法；

接口中的方法必须是抽象的，类中的方法没有这个要求，可以是抽象也可以是具体的；

接口允许多重继承，而类不允许多重继承。

父类对象和子类对象相互转换的条件：

1)       子类对象可以被视为父类的一个对象

2)       父类对象不能被当作子类对象

3)       如果形参为父类对象，可以使用子类对象做实参

4)       父类引用指向子类对象时，此对象可以被强制转换为子类对象

成员变量与局部变量的区别

1)       语法形式上看，成员变量属于类，而局部变量是方法中定义的变量或方法的参数，成员变量可以被public、private和static等修饰，而局部变量则不能，二者可以被final修饰。

2)       变量在内存中的存储方式看，成员变量是对象的一部分，对象存储在堆内存中，局部变量存储在栈中。

3)       变量的生命周期看，成员变量随着对象的创建而创建；随对象的消失而消失。局部变量随着方法的调用而产生，随着方法调用的消失而消失。

4)       成员变量若没有被赋初始值，则自动初始化默认为0（用final修饰的但没有被static修饰的成员变量必须显示赋值）;局部变量不会自动赋值，必须显示赋值。

构造方法的特征：

1)       构造方法的方法名与类名相同

2)       构造方法没有返回值，也没有void

3)       构造方法的主要作用是完成对类对象的初始化工作。

4)       构造方法一般不能像普通函数那样调用，而是用new来调用。

5)       在创建一个类的新对象的同时，系统会自动调用该类的构造方法为新对象初始化。

6)       构造方法中，如果既不使用this，也不使用super，系统会自动加上super();

7)       不定义构造方法，则默认创建一个空构造方法

8)       构造方法执行顺序，在创建对象时，对象所在类的所有属性会首先进行初始化，在类的所有成员初始化完成后，才调用对象所在类的构造方法创建对象，构造方法的功能就是初始化。如果时继承了父类的子类，会自动调用父类的构造函数进行初始化。

创建对象的步骤

1)       声明指向“由类所创建的对象”的引用变量

2)       利用new创建新的对象，并指派给前面所声明的变量

Person p1;                     //声明指向对象的引用变量
P1= new Person();        //利用new创建新的对象，并让引用p1指向它
Person p1 = new Person(); //声明并创建新的对象，并让p1指向该对象

方法的覆盖：与父类同名同参

方法的重载：参数个数不同、不同参数类型、不同参数类型顺序

this使用最普遍的3中情况：

1)       在方法的某个局部变量，比如形参名与当前对象的某个成员有相同的名字，为了不至于混淆，需要明确使用this关键字来指明要使用哪个成员，使用方法时“this.成员名”，而不带this的那个便是形式参数。

2)       “this.方法名”来引用当前对象的某个方法，但这时this就不是必不可少的了，可以直接用方法名来访问那个方法，编译器会知道你要调用的时哪一个。

3)       this(参数表)，这个构造函数就会调用同一个类的另一个相同的构造函数。

super小结:

1)       子类自动调用父类的属性和方法，一般情况下，直接使用父类的属性和方法。

2)       super不能访问在子类中添加的域和方法

3)       子类的构造方法中，可以用super来调用父类的构造方法

4)       super必须放在第一句

5)       super可以间接访问父类中定义的域和方法

6)       super指的时对象，所有super不能再static中使用，包括类变量、类方法、static语句块。

包

Package语句

package语句作为java源文件的第一条语句，指明该文件中定义的类所在的包。用点（.）来指明目录的层次。它的格式为：

package pkg1[.pkg2[pkg3…]];

java源文件没有package语句，这时称为无名包，无名包不能有自包。

注：包及子包的定义，实际上是为了解决名字空间、名字冲突，它与类的继承没有关系，实际上，一个子类与其父类可以位于不同的包中。

JDK提供的包包括：java.applet,java.awt,java.awt.image,java.awt.peer,java.io等

在实际应用中，一种常见的做法是将包命名在组织机构之下，如：com.sun.xxxx.org.w3c.xxx等。

导入包的格式：

Import 包命1[.包命2[.包名3…]](.类名|.*);

只能在结尾出现一个*；

最后必须是类名或*，不能落在函数上；

四、深入了解java

Object类是java程序中所有类的直接或间接父类。也是类库中所有类的父类。

4.1 Object类包含了所有java类的公共属性，其中主要的有如下方法。

• clone(): 生成当前对象的一个备份，并返回这个复制对象
• equals():比较两个对象是否相同，是则返回true
• getClass():获取当前对象所属的类信息，返回Class对象
• finalize():定义回收当前对象时所需完成的清理工作
• toSting():返回当前对象本身的有关信息，按字符串对象返回
• notify():唤醒线程
• notifyAll():唤醒所有等待此对象的线程
• wait():等待线程

4.1.1 equals()方法与==运算符

equals()方法用来比较两个对象是否相同，如果相同，则放回true；否则放回false

如果一个类没有覆盖equals()方法，那么它的“相等”意味着两个引用相等，即它们引用的是同一个对象，这是equals()方法的结果与相等运算符（==）的结果相同；

注：==运算符可用于基本数据类型（判断数据是否相等），也可用于引用类型，当用于引用类型时，表示是否引用同一个对象（判断它的地址是否相同），区分equals()方法与==运算符是十分重要的。如果我们想要比较两个字符串是否相等，就应该用equals()方法，而不是==。

4.1.2 toString()方法

toString()方法用来返回对象的字符串表示，可以用于显示一个对象。如果我们打印一个对象，则会自动的去调用对象的toSting()方法。

4.2 函数调用及参数传递

Java中调用对象的方法时，需要进行参数传递。在传递参数时，java遵循的是值传递。当调用一个方法时，是将表达式的值赋值给形式参数。但是对于引用型变量，传递的值是引用值，所以方法中对数据的操作可以改变对象的属性。这样java通过引用型变量这一概念，代替了其他语言中的指针，并且更安全。

4.3调用本类或父类的构造方法

构造方法不能被继承，，但是可以调用别的构造方法，在构造方法中一定要调用本类或父类的构造方法直到Object类，因为Object类没有父类。具体做法可以选择一下三种之一：

• 使用this来调用本类的其他构造方法；
• 使用super来调用父类的构造方法，与普通方法中的super含义不同，super指其直接父类的构造方法，不能指间接父类的构造方法。
• 既不用this，也不用super，则编译器会自动加上super()。即调用父类的无参构造函数。

注意：调用this或super的构造方法的语句必须放在第一条语句，并且最多只有一条这样的语句，不能既调用this,又调用super

五、异常处理

5.1 异常分类

Java的异常类都是java.lang.Trowable的子类它派生出两个子类：Error和Exception,前者称为运行时错误；Exception是可检测的异常类，又分为checked和unchecked;

Error:JVM系统内部错误、资源耗尽等严重情况，由系统保留。

Exception:其他因编程错误或偶然的外在因素导致的一般性问题，比如负数开平方根，空指针访问，试图读取不存在的文件，网络链接中断等。

一般所说的异常，都是指Exception及其子类，因为，应用程序不处理Error类。

Exception类重父类Throwable那里还继承了若干方法。其中常用有如下两种：

1)       toString()：toString()方法返回描述当前Exception类信息的字符串。

2)       printStackTrace() : printStackTrace()方法没有返回值，它的功能是完成一个打印操作，在当前的标准输出（一般就是屏幕显示）上打印输出当前例外对象的堆栈使用轨迹。也就是先后调用并执行了哪些对象或类的哪些方法。

5.2 常处理的语句结构

try{…}  //这里写被监视的代码段，一旦发生异常，则由catch代码须处理
catch(异常类型 e){…}  //待处理的第一种异常
catch(异常类型 e){…}  //待处理的第二种异常
…
finallly{…}  //最终处理的代码段

catch多个异常时，需要遵循子类在前，父类在后的原则，从特殊到一般

finally语句是任选的，try后至少要有一个catch或一个finally

finally语句经常用于对一些资源做清理工作，如关闭打开的文件。

throws语句

throw ThrowableObject; //抛出这个异常，比如Exception

Exception是ThrowableObject的子类

throws语句必须位于左花括号{之前，格式是：

返回值类型  方法名（参数） throws{…}

throws的作用是将此方法内部的所有异常抛出给调用者处理。

自定义异常，肯定是Exception的子类。

六、工具类及常用算法

6.1 java语言基础

6.1.1 Java API

1)       java.lang包

2)       java.io包

3)       java.util包

4)       java.awt及javax.swing包

5)       java.applet包

6)       java.net包

7)       其他包

这里简单列举包名，要想了解，请参考官方文档

6.2 Sting类

字符串常用String类的对象表示。

例如： String s = “ABC”;

这种方法直接利用双引号括起的字符串为新建的String对象赋值。

字符串的一些函数如下：

1.字符串长度

length():求字符串的长度。如字符串为“hello”则长度为5

2.判断字符串的前后缀

startsWith(String prefix):判断字符串的前缀

endsWith(String suffix): 判断字符串的后缀

3.字符串中单个字符的查找

indexOf(int ch)和indexOf(int ch, int fromIndex):这两个方法查找当前字符串中某特定字符出现的位置。第一个方法查找字符串ch在当前字符串中第一次出现的位置，即从头向后查找。并返回字符ch出现的位置。如果找不到则返回-1

4. 字符串中子串的查找

indexOf(String str);

indexOf(String str, int fromIndex);

lastIndexOf(String str);

lastIndexOf(String str,init fromIndex);

在字符串中查找字符串与在字符串中查找单个字符串非常相似，也有以上四种可供选用的方法，它就是把查找单个字符的四个方法中的指定字符串ch换成了指定字符字串str。

5. 比较两个字符串

compareTo(String ,anotherString):字符串相同返回0，前串大于后串返回大于0的整数，反之返回小于0的整数

equals(Object , anotherObject)：覆盖Object类的方法，相同返回true反之返回false

equalsIgnoreCase(String ,anotherString):与equals()方法相似，只不过是不区分大小写

6. 求字符及字串

charAt(int index):index表示下标，例如”hello”.charAt(2)   返回l

substring(int startIndex ,int endIndex): startIndex代表起始位置，endIndex代表结束位置，但是不包括endIndex的字符。 例如：“hello”.substring(1,3)  返回el

substring(int startIndex):从开始位置，一直到最后结束

7. 格式化

format():format函数可以像C语言那样对字符串进行格式化（从JDK1.5以后可用），如String.format(“”%d %f %s”,15,3.15, ”string”) 详细参考文档

8.其他操作如下

concat(String):连接字符串

trim():去掉字符前后的空格

toUpperCase():转换成大写

toLowerCase():转换成小写

replace(char oldChar , char newChar):替换字符串中的字符

注意：在使用String类时，String对象是不可改变对象。String字符串一经创建，无论其长度还是内容，都不能更改了。String类的各种操作，包括连接、替换、转换大小写，都是返回一个新的字符串对象，而原字符串的内容并没有发生改变。这一点特别重要

6.3 StringBuffer类

Java中用来实现字符串的另一个类是StringBuffer类，与实现不可变字符串的String类不同，StringBuffer对象的内容是可以修改的字符串。

6.3.1创建StringBuffer对象

1)       由于StringBuffer表示的是可扩充、修改的字符串，所以在创建StringBuffer类的对象时，并不一定要给出字符串初值。StringBuffer类的构造函数有以下几个：

StringBuffer()：创建一个空的StringBuffer对象

StringBuffer(int length)：新建的StringBuffer对象的长度

StringBuffer(String str)：利用一个已经存在的字符串String对象来初始化StringBuffer对象。

2)       字符串变量的扩充、修改与操作

StringBuffer类有两组来扩充其中所包含的字符串方法，分别是：

append(参数对象类型  参数对象名)：将指定的参数对象转换成字符串，附加在原StringBuffer字符串对象之后。

Insert(int 插入的位置，参数对象类型 参数对象名)：在指定位置插入给出的参数对象所转化而得的字符串。

注意：附加或插入的参数对象可以是各种数据类型的数据。如 int,double,char,String等

3)       StringBuffer与String的相互转化

由String对象转成StringBuffer对象，是创建一个新的StringBuffer对象，如：

String s = “hello”;

StringBuffer sb = new StringBuffer(s);

由StingBuffer转为String对象，则可以用StringBuffer的toString()方法，如：

StringBuffer sb = new StringBuffer();

String s = sb.toString();

4)       有关字符串的连接运算符（字符串加法+）

字符串是经常使用的数据类型，为了编程方方便，java编译系统中引入了字符串的加法（+）和赋值（+=）。字符串的连接运算符（+），在Java中是一种十分特殊的运算符，因为它可以两个字符串连接字符串；如果一个字符与一个对象连接，java还会自动调用对象的toString()方法，如果字符串与基本数据类型相连，则基本数据类型也转化为字符串。

Java中的字符串（+）可以认为是为了方便程序的书写而设立的。事实上，java编译器将这种运算符都转化成StringBuffer的append()方法。如：

String s = “abc”+foo+”def”+3.14+Integer.toString(47);

6.4 算法

冒泡排序、选择排序、水仙花数、Fibonacci（斐波那契数列）、素数、完数

至于写法，后期会补上

七、流与文件

7.1 流式输入与输出

为进行数据的输入、输出操作，java中把不同的输入、输出源（键盘、文件、网络连接等）抽象表述为“流”（stream）。有两种基本的 流：输入流和输出流。输入流只能从中读取数据，而不能向其写入数据；输出流只能向其写入数据，而不能从中读取数据。

Java.io包中定义了多个类（抽象的或者具体的）来处理不同性质的输入、输出流。

注意：java.io中讲的Stream与java.util.stream中的Stream是不同的

9.1.1 字节流与字符流

流类型 处理类型	字节流	字符流
输入	InputStream	Reader
输出	OutputStream	Writer

1. InputStream类

InputStream类最重要的方法是读数据的read()方法。read()方法功能是逐字节地以二进制的原始方法读取数据，它有三种形式：

• read():从输入流的当前位置处读取一个字节的二进制数据，然后以此数据为低位字节，配上3个全零字节合成为一个32位的整形量（0-255）后返回给调用此方法的语句。如果输入流的当前位置没有数据，则返回-1。
• read(byte b[]):从输入流的当前位置处连续读取多个字节保存在参数指定的字节数组b中，同时返回所读到的字节的数目。
• read(byte[] b, int off,int len):len指定要读取的字节个数，off指定在数组中的存放位置。

以下是其他的方法：

• skip(long n):返回值也是long型，使位置指针从当前位置向后跳过n个字节。
• mark():在当前位置指针处做一个标记
• reset():将位置指针返回到标记的位置。
• l  markSupported():是否支持标记操作。
• available():流中有多少字节刻度。
• close():关闭流，并断开外设数据源的连接，释放占用的系统资源。

1. OutputStream类的重要方法是write(),它的功能是将字节写入流中，write()方法有三种形式：

• write(int b):将参数b的低位字节写入流中。
• write(byte b[]):将字节数组b[]中的全部字节顺序写入到输出流。
• write(byte[] b, int off, int len):将字节数组b[]中从off开始的len个字节写入到流中

以下是其他的方法：

• flush():刷新缓冲区的内容。
• close():关闭输出流。关闭输出流与外设的来连接并释放所占用的系统资源。

1. Reader类

Readerl类与InputStream类相似，都是输入流，但差别在于Reader类读取的是字符，而不是字节。

Reader的重要方法是read(),它有三种形式：

• read():将读入的字符转为整数返回。若不能读到字符，返回-1.
• read(char b[]):将字符放入数组中。
• read(char[] b, int off, int len):将字符放入数组中

1. Writer类

Writer类与OutputStream类相似，都是输出流，但差别在于Writer类写入的是字符，而不是字节，Writer类的方法有以下几种：

• write(int b):将参数b的低两字节写入到输出流
• write(char b[]):将字符数组b[]中的全部字节顺序写入到输出流。
• write(char[] b, int off, int len);将字节数组b[]中从off开始的len个字节写入到流中
• write(String s):将字符串写入流中
• write(String s,int off, int len):将字符串写入流中，off为位置，len为长度
• flush():刷新流
• close():关闭流

7.1.2 节点流和处理流

常用的节点流和处理流

基本输入/输出流是定义基本的输入/输出操作的抽象类，在java程序中真正使用的是它们的子类。能将字节流转为字符流的类是：InputStreamReader及OutputStreamWriter。更多的可参考官方文档

7.1.3 文本文件及二进制文件流应用实例

将FileCopyBychar.java复制文件并显示文件，将每个字符读入，并写入另一个文件，同时显示出来

import java.io.*;
public class FileCopyByChar{
    public static void main(String args[]){
　　　　try{
　　　　　　FileReader input = new FileReader("FileCopyByChar.java");　　
　　　　　　FileWriter ooput = new FileWriter("temp.txt");
　　　　　　int c = input.read();
　　　　　　while(c!=-1){　　　　　　　　　　//循环遍历内容
　　　　　　　　output.write(c);
　　　　　　　　System.out.print((cahr) c);
　　　　　　　　c = input.read();
　　　　　　}
　　　　　　input.close();
　　　　　　output.close();
　　　　}catch(IOException e){
　　　　　　System.out.println(e);
　　　　}
　　}    
}

FileCopyByLine.java复制文件并显示文件，将每个字符读入，并写入另一个文件，同时显示出来。这里用了BufferReader及BufferedWriter,前面一个类的重要方法是readLine(),它读入一行字符。

import java.io.*;
public class FileCopyByLine{
    public static void main(String[] a){
        try{
            FileReader input = new FileReader("FileCopyByLine.java");
            BufferReader br = new BufferReader(input);
            FileWriter output = new FileWriter("temp.txt");
            BufferedWriter bw = new BufferedWriter(output);
            String s = br.readLine();
            while(s!=null){
                bw.writer(s);
                bw.newLine();
                System.out.println(s);
                s = br.readLine();
            }
            br.close();
            bw.close();
        }catch(IOException e){
            e.printStackTrace();
        }
    }
}

分别统计C: est.txt文件（仅包含英文字符和数字）中，大写字母、小写字母和数字别出现的次数，将统计结果保存在D: esult.txt中，并显示在屏幕上。

import java.io.*;
public class Main{
    public static void main(String[] args){
        try{
            FileReader input=new FileReader("C:\test.txt");
            FileWriter output=new FileWriter("D:\result.txt");
            int c=input.read();
            int lowerletter=0;
            int upperletter=0;
            int num=0;
            while(c!=-1){
                if((char)c>='a'&&(char)c<='z') lowerletter++;
                if((char)c>='A'&&(char)c<='Z') upperletter++;
                if((char)c>='0'&&(char)c<='9') num++;
                c=input.read();
            }
            output.write("小写字母："+lowerletter+"个 大写字母："+upperletter+"个 数字："+num+"个");
            System.out.print("小写字母："+lowerletter+"个 大写字母："+upperletter+"个 数字："+num+"个");
            input.close();
            output.close();
        }catch(IOException e){
            System.out.println(e);
        }
    }
}

统计英文文本文件中的行数和单词个数，识别的依据是，单词以空格分隔，文本中无数字和特殊字符。

import java.io.*;
import java.util.regex.*;
import java.util.Arrays;
public class ccnt{
    public static void main(String[] args){
        try{
            FileReader input=new FileReader("D:\text.txt");
            BufferedReader br=new BufferedReader(input);
            StringBuffer str=new StringBuffer("");
            int cnt=0;
            String s1=br.readLine();
            String s2;
            while(s1!=null){
                cnt++;
                str.append("
"+s1);
                s1=br.readLine();
            }
            s2=str.toString();
            String[] s3 = s2.split("\s");
            br.close();
            int count=s3.length-1;
            System.out.print("单词个数为"+count+"个 行数为"+cnt+"个");
        }catch(IOException e){
            e.printStackTrace();
        }
    }
}

7.2 文件及目录

7.2.1文件与目录管理

1. 创建File类的对象

• File(String path):这里的字符串参数path指明了新创建的File对象对应的磁盘文件或目录及其路径名。path参数也可以对应磁盘上的某个目录，如“c:myProgramjava”
• File(String path, String name):第一个参数path表示所对应的文件或目录的绝对路径或相对路径，第二个参数name表示文件或目录名。将路径与名称分开的好处时相同路径的文件或目录可共享同一个路径字符串，管理和修改都较方便。
• File(String dir, String name):第一个参数是一个已经存在的代表某磁盘目录。第二个参数表述文件或目录名

2. 获取文件或目录属性

• exists():若对象代表有效文件，则返回true
• isDirectory():若对象代表有效目录，则返回true
• getName():返回文件名或目录名
• getPath():返回文件或目录的路径
• length():获取文件的长度，返回文件的字节数
• canRead():若文件为可读文件，则返回true
• canWrite():若文件为可写文件，则返回true
• list():返回值为一个数组，将目录中所有文件名保存在字符串数组中返回
• equals(File f): 比较两个文件或目录若两个File对象相同，则返回true

3. 文件或目录操作

• renameTo(Filenew File):将文件重命名成newFile对应的文件名
• delete():将当前文件删除
• mkdir():创建当前目录的子目录

ListAllFiles.java递归地理出某目录下的所有文件

import java.io.*;
public class FileCopyByLine{
    public static void main(String[] a){
        ListFiles(new File("d:\tang"));
    }
    public static void ListFiles(File dir){
        if(!dir.exists()||!dir.isDirectory())return;
        String []files = dir.list();
        for(for int i=0;i<files.length;i++){
            File file=new FIle(dir,files[i]);
            if(file.isFile()){
                System.out.println(dir+"\"+file.getName()+"	"+file.length());
            }else{
                System.out.println(dir+"\"+file.getName()+"	<dir>");
                ListFiles(file);        //对于子目录，进行递归调用
            }
        }
    }
}

八、图形用户界面设计

容器类：Frame,Panel

非容器类：Button、Lable

容器又分为：顶层容器(Frame、Applet、Dialog)和非顶层容器(Panel)

1. Franme框架类

new Frame(String s)

setSize()方法来设置窗口的大小

setVisible(true)方法来显示窗口

setLayout(new BorderLayout());

Panel面板类（包含于Frame内部的容器，可以包含其他组件）

Panel()

容器类使用add方法将组件添加到容器中

2. 布局管理

java.awt包中定义了五种布局管理器，每个布局管理器对应一种布局策略，分别是FlowLayout、BorderLayout、CardLayout、GridLayout和GridBagLayout

FlowLayout:一行排满之后就下转到下一行继续从左至右排列，每一行中的组件都居中排列；
GridLayout:基本布局策略是把容器的空间划分成若干行乘若干列的网格区域，组件就位于这些划分出来的小格里；
BorderLayout:把容器内的空间划分为东南西北中五个区域，每加入一个组件都应该指明把这个组件加到哪个区域；
CardLayout:在同一个时间容器只能从这些组件中选出一个来显示；

GridBagLayout:可以为每个组件指定其包含地网格个数，可以保留组件原来地大小，可以以任意顺序随意加入容器地位置。从而可以真正自由地安排容器中每个组件的大小和位置。

3. 简述事件源、事件、监听器三个对象之间的关系。并举例说明事件源和监听器之间一对一，一对多，多对一的关系。

事件源：产生事件的组件就是一个事件源。例如，当在一个Button上单击鼠标是，将产生一个ActionEvent类型的事件，而这个Button就是事件源
事件：当用户在界面上执行一个操作，例如zhi按下键盘、拖动或者单击鼠标时，都将产生一个事件。Java中事件是用来描述不同类型用户操作的对象，Java中有很多不同类型的事件。例如：单击，双击，右击，拖动，键盘的按下、释放，文本域内容改变等。
事件监听器：就是调用事件处理方法的对象。当界面操作事件产生并被发送到产生事件的组件时，该组件将把事件发送给能接受和处理该事件的监听器

4.简述事件接口与事件适配器的联系与区别。

事件监听器接口定义了对特定的事件，事件处理器必须要实现的方法。事件适配器给事件监听器接口提供了默认的实现。

十、网络、多媒体和数据库编程

java数据库的基本步骤：

第一步：加载驱动

第二步：与数据库建立连接

第三步：创建JDBC Statement对象

第四步：执行SQL语句，并获得结果

第五步：关闭数据库

举个例子：遍历test数据库下的ti表中的数据

package jdbc;
import java.sql.*;
public class jdbc {

    public static void main(String[] args) {
        try {
//            加载JDBC-ODBC驱动
            Class.forName("com.mysql.jdbc.Driver");
            System.out.println("驱动加载成功");
//            定义JDBC-URL
            String url = "jdbc:mysql://localhost:3306/test";
            Connection connection=DriverManager.getConnection(url,"root","root");
            System.out.println("数据库成功");
            System.out.println(connection);
//            得到一个statement对象
            Statement stmt=connection.createStatement();
//            定义一个查询语句
            String sql = "select * from t1";
//            执行sql语句
            ResultSet rs = stmt.executeQuery(sql);
            System.out.println("--------------------");
            System.out.println("执行结果如下所示：");
            System.out.println("--------------------");
            System.out.println("姓名"+"	"+"密码");
            System.out.println("--------------------");
            String user;
            String pass;
//            遍历数据库表
            while(rs.next()) {
                user = rs.getString("name");
                pass = rs.getString("pwd");
                System.out.println(user+"	"+pass);
            }
//            关闭表
            rs.close();
//            释放连接
            connection.close();
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

好了，简单总结了下java程序设计的知识点，有一些没有具体写出来，我能力也有限，希望可以帮助到你们，我也会努力学习，奔着复习的想法，居然让我打出了1万+的字。哎