JAVA 常用类，函数、java 代码练习,Ecliipse使用说明
IDE:集成开发环境，如Eclipse
extend：延生，扩展
implement ： 实现，执行，工具
一、总结一
页数参照《Java 核心技术》卷一：基础知识，机械工业出版社（原书第八版）（2011年4月第一版第七次印刷）
1. 在面向对象特性上，Java与C++的主要不同点在于多继承。（cjP3）
2. 在网页中运行Java的程序称为applet。（P6）
3. Java 5.0（即Java1.5），添加了以下特性：泛型类型(generic type)、for each循环、自动打包和元数据。Java 6于2006年末发布，没有对语言方面再进行改进，但是改进了性能，并增强了类库。（p9）
4. 目前的编译器技术使得Java代码的运行速度有了很大的提高，其“热点”代码运行速度与C++相差无几。（P10）
5. Java中共有8种基本类型：整型（int, short, long, byte）、浮点类型(float, double)、char、boolean（p33）
6. 浮点数值不适用于禁止出现舍入误差的进入计算中。应该用BigDecimal。（p33）
7. 变量的声明尽可能地靠近变量第一次使用的地方。(p36)
8. 运算符>>和<<：讲二进制位进行右移或左移操作。>>>用0填充高位，>>用符号位填充高位。（p39）
9. 使用java库中的数学函数，从JDK5.0开始，可以通过静态导入来简化调用：(p40)
import static java.lang.Math.*;
...
double y = sqrt(x)
10. 对浮点数进行舍入运算获取整数时，应调用Math.round方法，而不是强制转换成整数。(p41)
11. 枚举类型(enum)是在JDK5.0开始引入的。(p43)
12. 检测两个字符串是否相等必须使用equals方法，而不能直接比较。（p45）
13. 应该使用StringBuilder进行字符串拼接操作，而不是将String直接拼接。（p50）
14. Java SE 5.0引入了与C语言中printf类似的方法，以进行格式化输出。(p54)
15. Java语言中读写文件时，文件名中包含反斜杠符号时的写法：”c:\\mydirectory\\myfile.txt”。 （p57）
16. Java SE 5.0引入了for each循环：（p75）
for (variable : collection) statement
其中collection必须是一个数组或者是一个实现了Iterable接口的类对象。
（完）
二、总结二
页数参照《Java 核心技术》卷一：基础知识，机械工业出版社（原书第八版）（2011年4月第一版第七次印刷）
1. 封装(encapsulation，数据隐藏)：实现封装的关键在于绝对不能让类中的方法直接地访问其他类的实例域。(p88)
2. 类之间的关系常见的有：依赖(uses-a， dependence)、聚合(has-a, aggregation)、继承(is-a, inheritance)（p90）
3. Java类库中与时间有关的两个类：Date(表示时间点)、GregorianCalendar(日历表示法)。(p94)
4. 不要编写返回引用可变对象的访问器方法。（p108）
5. NumberFormat类使用了Factory Method来取得实例。(p112)
6. Java程序设计语言总是采用值调用。（p115, P117的例子）
7. Java语言中，方法签名（signature）由方法名和参数类型组成。返回类型不是方法签名的一部分。（p121）
8. 构造器调用同一个类的另一个构造器的语言：第一个语句形如“this(…)”。（p123）
9. Java中初始化数据域的方式有三种：（1）在构造器重设置值（2）在声明中赋值（3）使用初始化块 （p124）
10. 不要依赖使用finalize方法回收任何短缺的资源。(p128)
11. Java SE 5.0提供了导入静态方法和静态域的功能：(p130)
import static java.lang.System.*;
import static java.lang.System.out;
12. 从Java SE 6开始，设置类路径时，可以在JAR文件目录中指定通配符：（p134）
如：c:\archives\*
13. javac编译器总是在当前的目录中查找文件，但Java虚拟机仅在类路径中有”.”目录时才查看当前目录。
如果没有设置类路径，默认的类路径包括当前目录。(p135)
（完）
char 为2个字节 ，char 可以保存一个汉子（保存为UNICODE码），同时char只能保存一个字母；
两个char相加 = 两个ASC11码相加 ASC11码有128个，1--128。
类型转换： 自动从低精度 --> 高精度 （byte < short <int <long<float<double）
例：JAVA中小数默认为DOUBLE，float a = 3.4 会有编译错误（改为 float a =3.4f）；
注意：JAVA中小数 默认为double类型
强制转换 （int）a；
switch (表达式)
case 常量1： 注意：条件表达式与常量 需要为同一种类型（可用的数据类型有：Byte,short,int,char,enum）
case 常量2：
类 与 对象
把某类数据的共同属性提取出来--->创建一个类（包含各种属性/成员变量，类是抽象的，代表一类事物）--->对象（实例，对象是类的实际存在，代表一个具体事物，是类的一个个体）；
创建一个对象 = 创建一个实例 = 实例化一个类；
注意 ：1、类的首字母大写；
2、公共类的类名与文件名一致；
类的定义
class 类名
{
int age;
成员变量；//成员变量可以是基本数据类型 或 引用类型（在一个类中引用另一个类）；
public void speak()//成员函数
{
函数主体；
}
}
注意：成员函数的首字母小写
成员函数定义：
public（访问修饰符） 返回数据类型 方法名（参数列表）//不一定用public
{
主体；
}
注意： 方法的定义有函数体，方法的声明没有函数体
例：
class Cat
{
int age;
String color; //此处为引用
Master myMaster; //此处为引用
public void speak()//成员函数
{
函数主体；
}
}
class Master
{
int age;
String name;
}
Cat cat1 = new Cat();
cat1.speak;//调用成员函数，内存分配新栈与main函数完全独立
类的构造方法
1、方法名与类名完全相同（如果一个源文件中有多个类，那么构造器必须与公共类同名）
2、没有返回值
3、创建新对象时，自动调用构造方法。
4、构造方法可以有多个，根据调用时的参数 来选择 调用哪个构造函数
5、当一个类中没有定义构造函数时，那么系统会默认给该类加入一个无参数的构造函数。
当在类中自定义了构造函数后，默认的构造函数就没有了。
6、用于初始化类的成员变量，创建对象是自动执行
例
class Person ()
{
int age;
String name;
static int total = 0;// static 表明 total 是静态变量可为多个对象共享，可以在成员函数中使用
public Person(int age,String name)
{
age = age; ==>this.age = age;
name = name; ==>this.name = name;
// this 指将来生成的对象，this 是属于一个具体的对象的，不属于类，每个对象都有自己的this，this只能在类定义时使用
}
}
Java程序设计语言总是采用值调用（call by value）。（core java p115, P117的例子）
方法得到的是所有参数值的一个拷贝，特别是，方法不能修改传递给他的任何参数
变量的内容，改变的是参数的拷贝，该拷贝是对某一个对象的引用时，则在方法中
便可对该对象操作，拷贝的存活域仅在该方法中。
对象的创建
法1
先声明--->在创建 Cat cat1; cat1 = new Cat();
法2
类名 对象名 = new 类名（）；
注意：
new之后，在内存（堆）中就分配空间
例
Person a = new Person();
a.age = 10;
Person b ;
b = a; //将a的地址给b，既b与a指向内存的同一个空间；
System.out.println(b.age);
C++中指针与引用的区别：http://blog.csdn.net/listening_music/article/details/6921608?reload
类变量
类变量是该类的所有对象共享的变量；
定义类变量
访问修饰符 static 数据类型 变量名；
private static int a;
访问类变量
类名.类变量名 或 对象名.类变量名
static代码块
也叫静态代码块，是在类中独立于类成员的static语句块，可以有多个，位置可以随便放，它不在任何的方法体内（包括主函数），JVM加载类时会执行这些静态的代码块，如果static代码块有多个，JVM将按照它们在类中出现的先后顺序依次执行它们（只要类中有static代码块，其都会被执行，与有无对象无关），每个代码块只会被执行一次。
例
public class Test5 {
private static int a;
private int b;
static
{
Test5.a=3;
System.out.println(a);
Test5 t=new Test5();
t.f();
t.b=1000;
System.out.println(t.b);
}
static{
Test5.a=4;
System.out.println(a);
}
public static void main(String[] args) {
// TODO 自动生成方法存根
}
static{
Test5.a=5;
System.out.println(a);
}
public void f(){
System.out.println("hhahhahah");
}
}
运行结果：
3
hhahhahah
1000
4
5
类方法（静态方法）
类方法属于所有对象实例共享
形式：访问修饰符 static 数据返回类型 方法名（）{}
注意：类方法中 不能访问非静态变量（非类变量），类变量原则上用类方法去访问，为防止因普通成员函数访问类变量引起的歧义
使用：类名.类方法名 或 对象名.类方法名
JAVA四大特征
抽象 ：把一类事物的共有的属性和行为提取出来，形成一个模板。
封装 ：就是把抽象出来的数据和对数据的操作封装在一起，数据被保护在内部，程序的其 他部分只有通过被授权的操作（成员方法），才能对数据进行操作。
封装(encapsulation，数据隐藏)：实现封装的关键在于绝对不能让类中的方法直接地访问其他类的实例域。
可以通过一个成员方法去控制盒访问私有的属性
JAVA中的四种访问控制修饰符：(用于成员变量 和 成员方法)
1、公开级别 public :对外公开
2、受保护级别 protected: 对子类和同一个包中的类公开
3、默认级别：没有修饰符号，向同一个包的类公开
4、私有级别 private ：只有类本身可以访问，不对外公开（外部可通过一个成员函数去控 制盒返回私有变量）
包：
打包命令：package com.xiaoming; //将生成的字节码（class码）放在com.xiaoming的包里，打包命令一般放在文件开始
包的命名：小写，用 ‘ . ‘ 隔开
常用的包：
引入包：import 包；//引入包后可以使 用该包下的类
继承 ：解决代码复用，在父类中定义相同的属性和方法，则在子类中不需要重新定义这些属性和方法，只需要通过extends语句来声明继承父类；
class 子类 extends 父类 // 子类自动拥有父类定义的属性和方法（private 属性和方法不能被子类继承）
注意：
1、子类只能直接继承一个父类 ；
2、JAVA所有类都是Object类的子类；
3、做开发是，多查看JDK帮助文档；
方法重载（overloading）同一个类中（函数签名不同）
方法重载： 一个类中有多个方法名相同，但参数类型不同，采用哪种方法取决于调用者给出的参数。
（1） 方法重载是让类以统一的方式处理不同类型数据的一种手段。多个同名函数同时存在，具有不同的参数个数/类型。重载Overloading是一个类中多态性的一种表现。
（2） Java的方法重载，就是在类中可以创建多个方法，它们具有相同的名字，但具有不同的参数和不同的定义。调用方法时通过传递给它们的不同参数个数和参数类型来决定具体使用哪个方法, 这就是多态性。
（3） 重载的时候，方法名要一样，但是参数类型和个数不一样，返回值类型可以相同也可以不相同。无法以返回型别作为重载函数的区分标准。
注意：
1、方法名相同
2、方法的参数的类型，个数，顺序至少有一个不同；
3、如果仅仅是返回类型或访问控制修饰符 不一样，不能构成重载
4、 方法返回类型 、修饰符 可以不同
方法覆盖/重写（override） 父类与子类中
（1） 父类与子类之间的多态性，对父类的函数进行重新定义。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。在Java中，子类可继承父类中的方法，而不需要重新编写相同的方法。但有时子类并不想原封不动地继承父类的方法，而是想作一定的修改，这就需要采用方法的重写。方法重写又称方法覆盖。
（2）若子类中的方法与父类中的某一方法具有相同的方法名、返回类型和参数表，则新方法将覆盖原有的方法。如需使用父类中原有的方法，可使用super关键字，该关键字引用了当前类的父类。
（3）子类函数的访问修饰权限不能少于父类的；重写方法只能存在于具有继承关系中，重写方法只能重写父类非私有的方法。Father类speak()方法一但被final时，无论该方法被public,protected及默认所修饰时，Son类根本不能重写Father类speak()方法，试图编译代码时，编译器会报错。Father类speak()方法被默认修饰时，只能在同一包中，被其子类被重写，如果不在同一包则不能重写。Father类speak()方法被protoeted时，不仅在同一包中，被其子类被重写，还可以不同包的子类重写。
重写方法的规则：（名称、返回类型，参数一样，修饰符可以不同）
1、参数列表必须完全与被重写的方法相同，否则不能称其为重写而是重载。
2、返回的类型必须一直与被重写的方法的返回类型相同，否则不能称其为重写而是重载。
3、访问修饰符的限制一定要大于被重写方法的访问修饰符（子类的修饰符 > 父类修饰符）（public>protected>default>private）
4、重写方法一定不能抛出新的检查异常或者比被重写方法申明更加宽泛的检查型异常。例如：父类的一个方法申明了一个检查异常IOException，在重写这个方法是就不能抛出Exception,只能抛出IOException的子类异常，可以抛出非检查异常。
多态：
1、JAVA允许父类引用子类的 对象（把子类交给父类，自动完成）；
2、在某些情况下 子类可以转换为父类。
//多态
Animal an = new Cat();
an.cry();
an = new Dog(); //an会根据右边的类型来决定自己的类型，简单的多态
an.cry();
//Cat，Dog分别为Animal的子类，且覆盖了Animal中的cry（），这样an便能 根据需要，随时访问cat或dog中的cry（），而不需要新建一个类，方便使用。正因为在Animal中有cry（），所以子类cat，dog中可以覆盖cry（）方法，以实现多态。
抽象类和抽象方法
定义：
在java中，含有抽象方法的类称为抽象类，同样不能生成对象。抽象类是不完整的，它只能用作基类。
当一个类继承的父类是抽象类时，需要将抽象类中的所有抽象方法全部实现
如
abstract class Animal
{
String name;
abstract public void cry();//抽象方法只能在子类中是实现
public void a()
{
// 抽象类中可以有 实现的，非抽象方法
}
}
class Cat extends Animal
{
//实现父类cry(）抽象方法
public void cry()
{
//没写什么也算实现
}
}
注意：
1、 抽象类不能被实例化。如 Animal an = new Animal(); //Animal 是抽象类，不能实例化
2、抽象类 可以没有抽象（abstract）方法。
3、一旦类包含了abstract方法，则这个类必须声明为abstract方法；
4、抽象方法不能有 主体，既 方法的实现只能通过在子类中 覆盖来实现；
abstract void a() {}; 既方框中的内容不能有；
接口
接口就是给出一些没有内容 方法，封装到一起，到某个类要使用的时候，根据具体情况吧这些方法写出来。
语法格式：
interface 接口
{
变量；
方法；
}
class 类名 implements 接口 //编写一个类并实现接口
{
变量；
方法；
}
注：当一个类实现了一个接口就要求该类把这个接口的所有方法统统实现，类实现了接口则这个类的实例能交给接口使用，有点类似与多态。
接口使用注意事项：
1、接口不能被实例化
2 、接口中的所有方法都不能有主体，既所有方法都不能在接口中实现，和抽象类的区别 是抽象类只有抽象方法不能在该类中实现，要在子类中实现。
3、一个类可以实现多个接口；
4、接口中可以有变量（变量不能用private 和 protected 修饰）
a、接口中的变量本质上都是static的（静态全局共享），而且是final,无论有没加static修 饰。
b、把经常使用到的变量，定义在接口中，作为全局变量 使用，访问形式：接口名.变量 名
5、一个接口不能继承其他的类，但是可以继承别的接口。
//继承和实现可以同时使用，java是单继承的，只能有一个父类
class 类名 extends 父类 implements 接口名
{
}
实现接口 VS 继承类
1、实现接口可以看做是对JAVA单继承的一种补充。
2、实现接口可在不打破继承关系的前提下，对某个类功能扩张，非常灵活。
3、多层继承关系下，有可能因为顶端父类的改变而影响到所有的子类，而接口则只有在实现接口的类中有影响。
final
1、被final修饰的方法，在子类类中不能被覆盖（重写）；
2、被final修饰的变量，其值不能被改变，变量必须初始化。
3、被final修饰的类，不能被继承。
数组：
使用数组保存对象时应注意：对象数组每个元素保存的是对每个对象的引用，需要NEW操作
1、开辟一个数组；
2、对每个数组元素都要进行new 操作，否则会发生空指针异常；
如下：
class Dogs
{
String name;
}
Dogs[] dog = new Dogs[3];
dog[0] = new Dogs();
比较
==：比较数值大小是否相等，当对比的内容为对象或String时，对比的是对象的地址是否相等。
equals : 比较二者内容是否相等，可用于对象间的比较(如用于String的比较)。
string类型的字符常量在JVM中是共享的，此时的string可以用== 和equals比较大小。
数组大小可变，可以从控制台输入
Scanner input = new Scanner(System.in);
numStu = input.nextInt();
int[] score = new int[numStu];//数组大小可变，可以从控制台输入
位移： JAVA中没有无符号数
>>算术右移；
>>>逻辑右移；
~ ：按位取反
& ：按位与
| ：按位或
^ :位异或
|| ：逻辑或
&& ：逻辑与
算术右移，算术左移 运算规则：>>,<<
算数右移：低位溢出，符号位不变，并用符号位补溢出的高位
算术左移：符号位不变，低位补0；
逻辑右移>>> 运算规则：低位溢出，高位补0；
JAVA常用集合： Vector, ArrayList, Stack, HashMap, Hashtable, LinkedList
泛型
泛型优点:
1、类型安全
2、向后兼容
3、层次清晰
4、性能较高，用GJ（Genericity Java）编写的代码可以为java编译器 和 虚拟机带来更多类型信息，便于对程序做进一步优化提供条件
异常
1、检查性异常： java.lang.Exception
2、运行期异常：java.lang.RuntimeException
3、错误：java.lang.Error
try {} //在出现异常的地方终止执行代码，然后进入catch，有多个catch时则进入匹配异常的那个catch块
catch{} //捕获异常后执行catch块
finally{} // 不论有没异常都能执行finally块 ，一般说，把需要关闭的资源放在这里（文件，连接，内存）
finally{}不能执行的情况：
1、finally 块中发生了异常
2、程序所在线程死亡
3、在前面的代码中用了System.exit();
4、关闭CPU
图形用户界面
AWT、SWING、SWT、JFace关系
lcd：本地化
Swing 是将AWT完善，大部分软件公司使用Swing
布局管理器
1、定义：组件在容器中的位置和大小是由布局管理器来决定的，所有的容器都会使用一个布局管理器来自动进行组件的布局管理。
2、开发GUI程序步骤
1、继承JFrame
2、定义需要的组件
3、创建组件
4、设置布局管理器
5、 添加组件
6.设置窗体属性，并显示窗体
3、常见布局管理器：
流式布局管理器（FlowLazyout）：按照组件的添加次序将组件从左到右放置在容器中，当到达容器边界时，组件将放置在下一行中。
边界布局管理器（BorderLayout）:将容器划分为东南西北中，5个区域，中间最大，是JFrame,JDialoge 的默认布局管理器
网格布局管理器（GridLayout）：将容器分割成多行多列，组件被填充到每个网格中，添加到容器中的组件首先放置在左上角的网格中然后从左到右放置其他的组件，当占满改行的所有网格后，接着继续在下一行从左到右放置组件
注意：
边界布局管理器（BorderLayout）:
1、不是5个部分都必须添加
2、中部组件会自动调节大小
3、JFrame，JDialog默认布局管理器就是BorderLayout
流式布局管理器（FlowLazyout）：
1、不限制他所管理的组件大小，允许他们有最佳大小
2、当容器被缩放时，组件的位置可能变化但组件的大小不变
3、默认组件是居中对齐，可以通过FlowLayout(int align)函数来指定对齐方式
网格布局管理器（GridLayout）：
1、组件的相对位置不随容器的缩放而变化，但大小会变化
2,、所有组件的大小相同
3、可以通过GridLayout(int rows,int cols,int hgap,int vgap)来指定网格的行、列，水平间隙，垂直间隙。 rows :行数 cols :列数 hgap : 垂直间隙 vgap : 水平间隙
面板JPanel组件
1、JPanel是JComponent的子类
2、属于容器类组件，可以加入别的组件
3、默认布局管理器是 流式布局（FlowLayout）
JAVA的输入与输出
File对象封装文件或路径属性，但不包含从/向文件读写数据的方法，进行I/O操作要使用JAVA I/O类创建对象，这些对象包含 读写数据的方法。
文本I/O类：对存储在文本文件中的数据进行读写操作
二进制I/O类：对存储在 二进制文件中的 数据进行读写操作
文本I/O类：
例：
import java.io.File;
File file = new File("scores.txt");//创建文件
if(file.exits())
{
System.out.println("file already exists");
System.exit(0);
}
事件监听
任何 一个类，只要它实现了相应的接口，就可以去监听某个事件源
如： class Cat implents ActionListener //实现动作监听接口
一个类要实现监听的步骤：
1、实现相应的接口
2、把接口的处理方法根据需要重新编写
3、在事件源上注册监听者；
4、事件传递是靠事件对象的（ActionEvent类的对象）。
事件源是一个产生事件的对象，当事件源发生变化时会产生某种类型的事件，若某个对象希望得到事件源产生的事件信息，就需要在这个事件源上注册。
字符串
应该使用StringBuilder进行字符串拼接操作，而不是将String直接拼接。（java基础p50）
原文：http://www.cnblogs.com/cxyshine/p/3602474.html