Java语言基础经典总结

第一章 java概述
java程序是由类(class)构建而成的，类包含成员（member），主要的是属性（field）和方法(method)。从类的定义开始，可以创建无数个对象，对象通常称为那个类的实例（instance），属性是属于类本身或类对象的数据变量，它们构成对象或类的状态（state），而方法是在属性上进行运算从而操纵状态的语句集合，语句定义类或对象的行为。可以将类想象成一个工厂，而对象是工厂生产的零件，属性和方法相当于工厂的员工。
egg：

注：上述程序是一个最简单的类。它只有一个成员：main方法。main方法是一个特殊的方法，一个java程序可以有多个方法，但只能有一个main方法，main方法被声明为public，这样java虚拟机中的任何对象都可以调用它,同时也被声明为static，这说明该方法属于类本身。而不与类的实例相关联。方法名前面的是方法的返回类型，main方法声明为void，因为他它不返回任何值，因此

无返回类型。
第二章 语言符号，运算符与表达式
1.注释：注释在代码产生阶段不起任何作用，但它为程序员阅读代码提供了便利，java有三种形式的注释,分别是：
(1)//comment 单行注释，从//开始到行尾的字符被忽略。
(2)/comment/多行注释，从/开始到/结束中间的字符被忽略。
(3) /comment*/块注释，从/到*/之间的字符被忽略。
注：java的注释不允许发生嵌套。
2.标识符：标识符用作被声明实体（变量，常量）的名字，java标识符由字母，数字，下划线（_）和美元符号（$）组成,但不能以数字开头。
3.关键字：java语言的关键字不能用作标识符，Java的关键字有：abstract，boolean， break，byte，continue，case，catch，char，class，const，default，do，double，else，extends，false，final，finally，float，for，if，implements，import，instanceof，int，interface，native，long，new，null，package，private，protected，public，return，short，static，super，switch，synchronized，throw，throws，this，transient，try，void，while等；
4.表达式

表达式将会产生什么养的结果是由表达式的类型决定的，而表达式的类型是由表达式中的值和变量决定的，类型被分为引用型和基本类型。
(1)java的基本类型包括:
byte 8位 -27——-27-1 带符号整数
short 16位 -215——-215-1 带符号整数
int 32位 -231——-231-1 带符号整数
long 64位 -263——263-1 带符号整数
char 16位 0—–216-1 无符号整数
float 32位 单精度符点
double 64位 双精度符点
boolean 1位 值：true 或 false
(2)引用型包括类类型，接口类型和数组类型，这些类型的变量指的就是相应类型的对象。
5.变量：变量时一个存储位置，可以保存一个值，变量声明指定标识符，类型和其他属性，声明的类型确定了值的类型。
(1)变量分为全局变量和局部变量，它们以同样的方式进行声明，声明分为三个部分：修饰符 类型 标识符列表。全局变量是类或接口的成员，都在类或接口的程序体内进行声明，局部变量可以在程序的任何位置声明，既可以是基本类型也可以是引用类型，可用于局部变量的唯一修饰符是final，final修饰符声明的值一旦被设定，就将一直保持这个值，即不可改变，且声明为final时必

须进行初始化。
6.运算符：
(1) 运算符的优先级
java语言中各运算符优先级如下所示（优先级从上到下依次递减）
类型 运算符
单操作数运算符 ++ 、– 、+ 、- 、！、~、（）
算术运算符 * 、 / 、% 、+ 、 -
移位运算符 << 、 >> 、 >>>
比较运算符 < <= > >= == != instanceof
按位运算符 & ^ |
逻辑运算符 && ||
条件运算符 ?:
赋值运算符 =
(2)单操作运算符：分别是:自动递增运算符(++) 自动递增运算符(++) 取正运算符(+) 取负运算符(-) 按位取反运算符(~) 逻辑取反运算符(!) 造型运算符()，其中按位取反运算~对易个整数型操作数进行按位操作，生成与输入位的相反值。若输入0，则输出为1；若输入1，则输出0。逻辑取反运算！ 对一个布尔型操作数进行操作，生成与输入位的相反值。若输入为

true,则输出为false;若输入为false，则输出为true; 造型运算（）的作用是明确将一种数据类型转换为另一种数据类型，可能造成数据信息的丢失。在java中，合法的类型转换编译器会自动进行，只有强制类型转换时，程序员才有必要进行造型运算。造型运算的操作对象不仅仅是基本数据类型，也可以是引用型。
(3)按位运算符
java语言中共提供了4种按位运算符,分别为按位与&, 按位|,按位异或^和按位非~,这四个运算符适合所有整型数据.进行按位运算时,总是先将字符型、字节型、短整型值转换为整型再进行位运算。对于布尔型运算只有按位非（~）不能用于布尔型数值。其他3种位运算都可以把布尔型数值当作一个具有一位值进行按位运算。布尔型值为true对应为1，false对应为0，尽管位运算可以应用于布尔型，但不能将布尔型值和其他整数型值混合使用，如混合使用，将发生类型转换错误，因为布尔型值和其他基本类型之间不能进行相互转换。
第三章 控制流
1.语句和块：语句是由表达式和分号组成的，用花括号将多条语句组合成为块。
2.if语句：它是条件控制流的最基本形式，它选择是否执行后续的语句。语法为：

if（boolean-expression）
statement1
else
statement2
首先求布尔表达式的值，如果只为true，则执行statement1,否则，执行statement2;
(3)switch语句：
Switch语句可以根据一个整型表达式的值，将控制转移到语句块中标号后的入口点。语法为：
Switch（expression）
{
Case 1：statements
Case 2：statements
}
如果找到匹配的case标号，控制转移到他后面的第一个语句，否则转移到default标号后的第一个语句，否则跳出switch语句。
(4)While和do…..while语句
While循环的形式如下：
While（boolean-expression）
Statement

先求布尔表达式的值，如果是true，则执行语句，执行完毕后重新求表达式的值，如果是true，则继续执行语句，否则退出循环。
由于表达式可能第一次求值就是false,所以while循环可能执行一次或多次，有时候需要执行循环至少一次，这时就用do-while语句
Do
Statement
While （boolean-expression）
表达式在语句执行完毕后求值，当表达式为true是，语句被重复执行，否则退出循环。
(5)for循环：for语句在一定范围的值伤从头到尾执行，形式为
For(init-expr;boolean-expr;incr-expr)
Statement
Init-expr允许定义和初始化变量，它只执行一次，然后求布尔表达式的值，如果结果为truro，则执行循环体内的语句，执行完毕之后，执行incr-expr更新循环变量的值，然后重新计算布尔表达式的值，如果为true，则继续执行，否则退出循环。
(6)break语句
Break语句用于从任何语句块中退出，有两种形式，有标号的和无标号的，无标号的终止最内层的switch.for,while或者do语句。有

标号的终止任何被标注的语句。
(7)continue语句只能在循环中使用，它把控制体转移到循环的结尾。
(8)return语句
Return终止方法的执行并返回调用者，如果不返回任何值，则写return并以分号结尾则可，若有返回类型，return语句必须包含其类型同返回类型一致的表达式。
第四章 类和对象
1.类成员
类可以有三种类型的成员：
 变量：与类及其对象相关的数据变量，其中保存着类和对象的状态
 方法：包含类的可执行代码并定义了对象的行为
 嵌套类和嵌套接口：嵌套在其他类或接口中的类和接口
2.类修饰符
类声明前面可以有类修饰符以指定类的特定属性：
 Public 一个Public类是公共访问的，任何人都可以访问对该类的对象的引用或者访问它的公共成员。如果没有修饰符，则该类只能在自己的包内访问
 abstract：一个抽象类被认为是不完整的，不能创建实例，如

果该类中有abstract方法，该方法必须在子类中实现
 final：final类不能有子类
 strict floating point ：定义为strictdfp的类要求其中所定义的浮点运算都都进行精确运算
注：一个类不能即是final又是abstract的
3.访问控制和继承
类的成员对于类本身来说，始终是可以访问的，为了控制其他类的访问，类成员具有四种访问控制修饰符：
 private： private成员只能在类自身中访问
 package：声明时不带任何访问修饰符的成员，只有相同包内的代码可以访问
 protected：子类，同一包中的类及类内部可以访问声明为protected的成员
 public：在类是可以访问的地方，声明为public的成员都是可以访问的
注：private和protected访问控制修饰符只能用于成员，而不能用于类或接口本身（除非嵌套），如果要从某个类的一段代码中访问一个成员，首先要在这段代码中访问该成员的类。
4.构造和初始化
 构造函数

为了完成简单初始化之外的目的，类可以通过构造函数实现。构造函数是一段初始化对象的代码，这种初始化动作在new返回新创建对象的引用之前完成。构造函数与它要初始化的类同名。构造函数与方法一样，它拥有一个或多个自变量，但是构造函数不是方法，所以没有返回类型。利用new创建对象时，自变量放在类型名后面的括号里。
注：构造函数的声明包括类的名字，后面是括在圆括号内的参数列表，在加上花括号之间的语句。构造函数可以与类成员同样的访问控制修饰符，但构造函数不能使类的成员——这一点很容易被忽略，除非在遇到继承时。
构造函数可以把this()作为本身的第一个可执行语句，来调用同一个类中的其他构造函数。这叫做显式构造函数调用。
5.方法
 方法的声明：方法头和方法体：方法头包括修饰符集，方法的返回类型，签名（方法名和用圆括号括起来的参数列表）和该方法所抛出的异常，所有的方法都必须有返回类型和签名，但修饰符和抛出的异常时可选的。
 方法修饰符的组成
1. 访问控制修饰符
2. Abstract：abstract方法的方法体未在类中定义，只是用参数

列表之后的一个分号来表示，子类负责实现该方法的方法体。
3. Static：静态方法可以以整个类的名义调用，而不是从该类实例化得到的特定对象调用，他叫做类方法，静态方法只能访问类的静态变量和静态方法。
4. 方法的调用：利用“.”运算符把方法作为对象上的操作加以调用，方法调用时，调用者必须提供与方法声明中所要求的类型相对应的参数
注：方法还具有返回类型，它可以是基本类型，也可以是引用型，如果方法不返回任何值，返回类型的位置上应写上void，意为无返回类型
5. 方法的控制和返回：方法调用时，控制流就从调用方法转移到被调用方法，被调用的方法就按照语义开始执行。被调用的方法在三种情况下停止执行，并返回调用者：执行return语句；已经到达方法的结尾；抛出未捕获的异常。
6.重载：如果两个方法的名字相同，但方法参数的个数和类型不同，这种现象叫做重载。
第五章 继承类
1.继承类叫做它所继承的类的子类或继承类，被继承的叫做超类

类继承分为两种形式：
类继承：子类将获得超类的类型，因而可以在任何允许使用超类的地方多态使用，类继承实现了子类可以重新定义新的行为，解决了代码的复用。
接口继承：依照超类所访问的变量和方法，子类对超类进行了实例化。
2.继承的格式：
Class 子类名 extends(implements) 父类名
3.子类与超类的关系
1 方法之间：方法覆盖是面向对象语言的特性，即父类中的一个方法在子类中获得重新定义，但是方法名、参数列表和返回值均不变。
2 属性之间：如果我们在子类定义了与父类相同的属性，那么我们称之为属性（数据成员）的隐藏。
3 构造函数之间：如果子类没有定义自己的构造方法，则它将自动调用父类的无参数的构造器。如果子类自己定义了构造器，则在创建对象时，它将先执行自父类的无参数的构造器，然后再执行自己的构造器。
4.super的使用：类的所有非静态方法中都可以使用关键字super，在变量和方法的调用中，super实际上作为超类实例当前对象的引用。
注：super必须放在调用其构造器中的第一行，而且子类中覆盖

方法可以通过 super(…) 来访问超类中被覆盖的方法，但只能访问其直接超类，而不能跨级访问。
5.方法的覆盖：方法覆盖是面向对象语言的特性，即父类中的一个方法在子类中获得重新定义，但是方法名、参数列表和返回值均不变。覆盖的规则如下：
（1）覆盖的方法之间必须拥有相同的方法名和参数列表，即要求参数列表中参数的个数、排列顺序以及参数的类型要相同。注意，参数的名称是否相同，不是覆盖的决定因素；
（2）覆盖的方法之间，其返回类型必须相同；
（3）一个静态方法只能被覆盖方法为一个静态方法，但是不能被覆盖为一个非静态方法；
（4）父类中被子类覆盖的方法，在每一个子类中，最多只能被覆盖一次；
（5）覆盖方法的访问控制修饰符所定义的访问控制不能小于父类中被覆盖方法的访问控制修饰符定义的范围，即覆盖方法不能比原有方法访问范围窄；
（6）覆盖方法声明的抛出异常，只能是被覆盖方法抛出异常的子类，或者一样，或者不抛出任何异常。
第六章 接口

1.java程序设计的基本单元式类，但是面相对象程序设计的基本单元是类型。类可以定义类型，而接口以一种抽象的形式作为方法或者其他类型的集合，类可以实现一个或多个接口来实现类型的扩展，当然，接口本身没有任何实现，也就不能创建实例。
2.接口的声明：
Public interface T
{
Int comper();
}
除了使用的关键字是interface而不是class之外，接口的声明和类的声明很像。定义的接口是类的超接口，类必须实现定义在其超接口中的所有方法，否则，类就必须声明为abstract的。
3.接口修饰符
 Public——被public修饰的接口可以被公共访问，如果没有这个修饰符，则只能被其所在包内的成员访问。
 Abstract——所有的接口都被隐式的定义为abstract的，因为他们的方法没有任何实现。
4. 抽象类
用 abstract 修饰符修饰的类，我们称为抽象类，在抽象类可以有

抽象方法也可以没有抽象方法，如果一个子类继承了抽象类，择、则其必须实现抽象类的所有抽象方法，否则必须声明为抽象类，继承接口也如此。
5. 接口和抽象类的异同
接口和抽象类都有抽象方法，都代表定义层次上的抽象；
 接口和抽象类都不能创建对象。
不同：
 接口中没有构造器，抽象类中可以有构造器；
 接口中只能有接口常量和抽象方法，抽象类中可以有抽象方法，也可以有非抽象方法；
 接口中的抽象方法的修饰符不写，默认还是abstract public。而抽象类中的抽象方法必须写abstract关键字。
第七章 嵌套类和接口
1. 类和接口可以在其他类和接口内部声明，或者作为成员，或者在代码块内部，这种类型称为嵌套。
2，作为成员时，分为静态嵌套类和非嵌套类，在代码块内部分为有实例名称的嵌套类和无实例名称的嵌套类（匿名嵌套类）
3.静态嵌套类：静态嵌套类是嵌套类的最简单形式，其声明格s式与普通类的格式类似。但创建对象时有所不同，格式为：外部类.内部类 内部类对象=new 外部类.内部类（）；

4.非静态嵌套类：非静态嵌套类可以继承任何其他类，实现任何接口和被任何类继承，可以定义为final或者abstract的，但其内部不能有静态成员。创建对象的格式为：外部类.内部类 内部类对象=new 外部类（）.内部类（）；样的类在定义它们的块外是完全不能访问的，简单的说就是没有途径引用它们，但是这些类的实例是普通对象，可以作为自变量传递，从方法返回，并且它们一直存在，直到不再被引用，唯一可以用的修饰符是final——它通常阻止类被继承，它在定义该类的作用域可以访问所有变量：局部变量，方法参数，实例变量和静态变量。唯一的限制是只有局部变量或方法被声明为final才可以访问。
5.有实例名称的内部类：这
6.无实例名称的内部类：这些类在被定义的同时，通过new实例化，并通过方法返回，达到代码简练的目的。
第八章 异常
1.异常是指阻止当前方法或作用域继续执行的问题，通常在两种情况下发生，一是编译阶段，二是运行阶段。发现错误的理想阶段是编译阶段，可以及时修改。运行期发生异常后，程序不能继续下去，所能做的就是把问题提交上一环境，这一动作叫做抛出异常。Java中的异常是对象。所有异常类型，即所有为可抛出对象设计的类，必须继承Throwable类或它的子类。

Throwable类含有一个可以用于描述异常的字符串。
2：异常利用throw抛出：throw expression；其中的表达式必须估算出一个值或变量，它们必须与throwable类型兼容——简单的说，它们是一个throwable对象的引用。异常时对象，所以在抛出之前需要创建。
3.异常处理程序：异常由包含在try块中的语句捕获，
完整的代码如下:
try
{
}catch(type xx)
{
}finally
{
}
Try的语句如果抛出异常，就要找到其异常类或其超类的catch语句，try中可以包含任意多个catch字句，只要这些字句捕获的异常类型不同。如果try中有finally字句，则不管是否抛出异常，都总被执行。
第九章 字符串
1.字符串是具有内置语言支持的标准对象。

2.基本字符串操作：通过new方法来显式的创建string对象，从而调用它的方法：
 charAt(int index)返回会在index的位置处的字符。返回类型为char
 concat(String str)连接两个字符串，参数str在后面，返回类型为String
 endsWith(String str) 判断字符串是否以str字符串结束，返回类型boolean
 equals(Object obj)判断一个字符串是否等于一个obj对象，返回类型为boolean
 equalsIgnoreCase(String anotherString) 判断一个字符串是否等于另一个字符串，返回boolean
 getBytes()将一个字符串转化为字节数组，使用系统默认编码，返回类型为byte[];
 getBytes(String enc)将一个字符串转化为字节数组，用名字enc的编码，返回类型为byte[];
 indexOf(int ch)返回字符ch在字符串里第一次出现的位置，如果字符串里不存在字符ch,则返回-1，返回类型为int
 indexOf(String str)返回字符串str在字符串里第一次出现的位置，如果不存在字符串str，则返回-1。
 length()返回字串的长度，注意：同数组的区别：数组是属
性，因此用length表示。

 toCharArray()将这个字符串转化成字符叔祖，返回类型为char[]
 trim()：去掉字符串的首尾空格。
 toUpperCase（）:将字符串传唤成大写
3.StringBuffer类：StringBuffer类是可变字符串类，创建了它的对象后，可以随意修改，改变字符串的内容。如果字符串的长度超过了StringBuffer类对象的容器，则该对象的容量自动扩大。StringBuffer并不是String的子类，它们都是Object的扩展。除了拥有字符串所有的方法外，它还有一些特有的方法：
 int capacity()获取它的容量
 void setLength(int a)设置容量
 int length();长度，字符串的真实长度
 StringBuffer append(Object obj)
 StringBuffer append(String str)
 StringBuffer append(StringBuffer sb)
 StringBuffer insert(int offset,Object obj)
 StringBuffer append(int offset,String str)
 StringBuffer append(int offset,StringBuffer sb)
4.StringTokenizer类
Java中提供了专门用于分析字符串的类StringTokenizer（位于java.util包中），可以将字符串分解为独立使用的单词（语言符号）。语言符号之间由定界符（delim）或空格、制表符、换行符等来分隔。其他字符也同样可以设定为定界符。
StringTokenizer的构造方法
StringTokenizer（String str）使用默认的定界符，即空格，制表符，换行回车，TAB
StringTokenizer(String str,String delim)为字符串str构造一个字符串分析器，并使用delim作
为定界符。
方法：
 String nextToken()//返回一个字符
 boolean hasMoreTokens()//判断要分析的字符串还有语言符号吗？有返回true,否则返回false
 int countTokens()//共有多少个语言符号
第十章 I/O包
Java.io包使用术语流（stream）定义I/O（输入/输出）。包含两个主要部分：字符流和字节流。
1.字节流：java.io包为基本的字节输入和输出定义了抽象类。这些抽象类接着被继承，以提供几个有用的流类型。而流类型是成对的，包含输入流和输出流。抽象类InputStream声明的方法在特定的源中读取字节，它是大多数字节输入流的超类。抽象类Output提供将字节写到目的地的抽象方法。具体方法有：

（1）FileInputStream：
int read()
int read(byte b[])
int read(byte b[],int start ,int length)
int available()：返回后面还有个没有被读取的字节数。
void close()
（2）FileOutputStream:
public void write(int b)
public void write(byte b[]);
public void flush();
public void close();
read方法读一个字节，并返回内容。int read(byte b[])读取速度要快于read（）方法。
2.字符流：读写字符流的抽象类是Reader和Writer，它们提供一
些与字节流方法相似的方法。
FileReader 文件字符输入流
public int read();
public int read(char c[]);
public int read(char c[] ,int start,int length)
public void close();

FileWriter 文件字符输出流
public void write(int s)
public void write(char c[])
public void flush();
public void close();
3.转换流：转换流实现了Unicode同指定编码的字节流或者本机系统的默认编码的字节流之间的转换,包括有：
1、BufferedInputStream
2、BufferedOuputStream
3、BufferedReader
4、BufferedWriter。
4.Buffered流；常用于和File流的连接——存取一个磁盘文件，比用内存缓冲要慢许多，缓冲能够减少文件访问次数。
5.File流：允许将文件看成输入和输出流:
3、方法：如何学习方法？方法名，参数类型，返回类型也必须记
（1）boolean mkdir()创建文件夹（目录），如果成功返回true。也可以创建子目录，但父目录必须存在。
（2）boolean delete() 删除文件夹（目录）或删除文件，如果返回true，删除成功1

(3)boolean mkdirs()父子目录一起创建！
（4）boolean exists()判断一个文件或文件夹是否存在，如果存在返回true。
（5）boolean canRead() 判断一个文件是否可读。如果true。
（6）long length();返回文件的字节数，文件的大小。
（7）String getAbsolutePath()//返回一个文件或文件夹的绝对路径。
（8）String getName();//得到一个文件名（包括扩展名）
（9）boolean isAbsolute() 判断是否是绝对路径。如果是返回true。
（10）boolean isDirectory()判断一个东东是否是目录，如果返回true。
（11）boolean isFile() 判断一个东东是否是文件，如果返回true。
（12）boolean isHidden();判断一个文件或文件夹是否是隐藏文件。如果是返回true。
（13）long lastModified()返回文件的最后修改时间。
（14）boolean renameTo(File newName)改名,成功返回true。
（15）File[] listFile() 得到某一个目录下的File数组。
（16）File []listRoots（） 返回所有的盘符。

（17）boolean setReadOnly（）设置为只读文件。
第十一章 集合
1.集合，有时也称为容器，是一个对象持有者，使你能够通过有用的方法对对象进行组织和存储，以便进行更有效的访问。
2.集合的接口有：
 Collection——集合的根接口。提供诸如add,remove,size,toArray和重要的iterator等方法。
 Set——一个没有重复元素的集合，元素的存储没有任何特定的顺序。（继承Collection）
 List——集合的元素以特定顺序存储。
 Map——从关键字到至多一个对应值的映射。
3.接口的具体实现有：
 HashSet——使用散列表实现的Set。通常适用于那些对内容的规模比较敏感的搜索，插入，删除等操作。
 TreeSet——使用平衡二叉树实现的SortedSet，搜索或修改比HashSet慢，但是他保持元素有序。
 ArrayList——使用可变数组实现的List，如果列表比较大，那么插入和删除一个接近于开始处对的元素比较慢，但随机访问快。
 LinkedList——一个双链接List的实现，修改比较快，但访问慢。


 HashMap——一个map的散列表实现，查询和插入所花的时间比较少。
 TreeMap——通过关键字保持元素有序排列。
4.Collection接口的方法有：
int size( );
boolean isEmpty();
boolean contains(Object o);
Iterator iterator(); 非常重要。
Object[] toArray();
Object[] toArray(Object a[]);
boolean add(Object o);
boolean remove(Object o);
boolean containsAll(Collection c);
boolean addAll(Collection c);
boolean removeAll(Collection c);
List的特有方法：
Object get(int index);
Object set(int index, Object element);
void add(int index, Object element);
Object remove(int index);
int indexOf(Object o);
int lastIndexOf(Object o);
ListIterator listIterator();
List subList(int fromIndex, int toIndex);
Map的方法：
int size();
boolean isEmpty();
boolean containsKey(Object key);
boolean containsValue(Object value);
Object get(Object key);
Object put(Object key, Object value);
Object remove(Object key);
void putAll(Map t);
Set keySet();
void clear();
Collection values();
Set entrySet();
Collection接口定义了一个iterator方法，他返回一个实现迭代器接口的对象，从底层集合中删除迭代最后返回的元素。Remove方法在每次调用next方法后只能被调用一次。