Java工作笔记(必看经典)

网上不整理的JAVA笔记。

JAVA的面向对象编程--------课堂笔记

面向对象主要针对面向过程。

面向过程的基本单元是函数。

什么是对象：EVERYTHING IS OBJECT（万物皆对象）

所有的事物都有两个方面：

有什么（属性）：用来描述对象。

能够做什么（方法）：告诉外界对象有那些功能。

后者以前者为基础。

大的对象的属性也可以是一个对象。

为什么要使用面向对象：

首先，面向对象符合人类看待事物的一般规律。

对象的方法的实现细节是屏蔽的，只有对象方法的实现者了解细节。

方法的定义非常重要。方法有参数，也可能有返回值。

注意区分：对象（本身）、对象的实现者、对象的调用者。

分析对象主要从方法开始。

我们通过类来看待对象，类是对象的抽象。

其次，采用面向对象方法可以使系统各部分各司其职、各尽所能。

对象之间的耦合性一定要低（比如不同硬盘和不同主板之间的关系）。这样才能使每个对象本身做成最好的。

对于对象的要求：高内聚、低耦合，这样容易拼装成为一个系统。

实现高内聚就是要最大限度低提高复用性（复用性好是因为高内聚）。

可复用性是OOP的基础。

比较面向过程的思想和面向对象的思想：

面向过程的思想：由过程、步骤、函数组成，以过程为核心；

面向对象的思想：以对象为中心，先开发类，得到对象，通过对象之间相互通信实现功能。

面向过程是先有算法，后有数据结构。

面向对象是先有数据结构，然后再有算法。

在用面向对象思想开发的过程中，可以复用对象就进行复用，如无法进行复用则开发新的对象。 开发过程是用对个简单的对象的多个简单的方法，来实现复杂的功能 。

从语法上来看，一个类是一个新的数据类型。

在面向对象编程中，除了简单数据类型，就是对象类型。

定义类的格式：

class Student{

代码

}

注意类名中单词的首字母大写。

实例变量：定义在类中但在任何方法之外。（New出来的均有初值）

局部变量：定义在方法之中的变量。

网上不整理的JAVA笔记。

局部变量要先赋值，再进行运算，而实例变量均已经赋初值。这是局部变量和实例变量的一大区别。 实例变量的对象赋值为null。

局部变量不允许范围内定义两个同名变量。实例变量的作用域在本类中完全有效，当被其他的类调用的时候也可能有效。

实例变量和局部变量允许命名冲突。

书写方法的格式：

修饰符 返回值 方法名 调用过程中 方法体

可能出现的例外

public int/void addNumber(参数) throw Excepion {}

例：

public int addNumber(int a,int b){

}

注：方法名中的参数int a,int b为局部变量

类方法中的一类特殊方法：构造方法。

构造方法是当用类生成对象时，系统在生成对象的过程中利用的方法。

注意：构造方法在生成对象的时候会被调用，但并不是构造方法生成了对象。

构造方法没有返回值。格式为：public 方法名。

构造方法的方法名与类名相同。

构造方法是在对象生成的过程中自动调用，不可能利用指令去调用。

在一个对象的生成周期中构造方法只用一次，一旦这个对象生成，那么这个构造方法失效。

用类来生成对象的语句：

Student s=new Student()。

第一个Student表示这是用Student类进行定义。“Student()”表示调用一个无参数的构造方法。 如果()中有参数，则系统构造对象的过程中调用有参的方法。

此时S称为一个对象变量。

Student s的存储区域存放的是地址：一个对象在硬盘上占有一个连续地址，首地址赋予s空间。 S称为对象Student的引用。

注意：在对象变量中存放的是引用（地址）；在简单变量中存放的是数值。

可以构造多个构造方法，但多个构造方法的参数表一定不同，参数顺序不同即属于不同的构造方法： public student(string name,int a){

}

public student(int a,string name){

}

为两个不同的构造方法。

如果我们未给系统提供一个构造方法，那么系统会自动提供一个为空的构造方法。

练习：写一个类，定义一个对象，定义两个构造方法：一个有参，一个无参。

（编写一个程序验证对象的传递的值为地址）

注意下面这种形式：

static void changename(student stu){stu.setName “LUCY”}

注意生成新的对象与旧对象指向无关，生成新对象生命消亡与旧对象无关。

面向对象方法的重载（overloading）和覆盖（overriding）。

在有些JAVA书籍中将overriding称为重载，overloading称为过载。

Overloading

网上不整理的JAVA笔记。

返回值也可能相同。

在程序的编译过程中根据变量类型来找相应的方法。因此也有人认为 overloading是编译时的多态，以后我们还会学到运行时多态。

为什么会存在overloading技术呢？作为应对方法的细节。

利用类型的差异来影响对方法的调用。

吃（）可以分为吃肉，吃菜，吃药，在一个类中可以定义多个吃方法。

构造方法也可以实现overloading。例：

public void teach(){};

public void teach(int a){};

public void teach(String a){}为三种不同的方法。

Overloading方法是从低向高转。

Byte—short—float—int—long—double。

在构造方法中，this表示本类的其他构造方法：

student(){};

student(string n){

this();//表示调用student()

}

如果调用student(int a)则为this(int a)。

特别注意：用this调用其他构造方法时，this必须为第一条语句，然后才是其他语句。

This表示当前对象。

Public void printNum(){

Int number=40；

System.out.println(this.number);

}

此时打印的是实例变量，而非局部变量，即定义在类中而非方法中的变量。

This.number表示实例变量。

谁调用this.number那么谁即为当前(this)对象的number方法。

封装：使对象的属性尽可能私有，对象的方法尽可能的公开。用private表示此成员属性为该类的私有属性。

Public表示该属性（方法）公开；

Private表示该属性（方法）为只有本类内部可以访问（类内部可见）。

（想用private还要用set和get方法供其他方法调用，这样可以保证对属性的访问方式统一，并且便于维护访问权限以及属性数据合法性）

如果没有特殊情况，属性一定私有，方法该公开的公开。

如果不指明谁调用方法，则默认为this。

区分实例变量和局部变量时一定要写this。

11.29

继承：

父类（SuperClass）和 子类（SonClass）。

网上不整理的JAVA笔记。

父类的非私有化属性和方法可以默认继承到子类。

Class Son extends Father{

}

而如果父类中的私有方法被子类调用的话，则编译报错。

父类的构造方法子类不可以继承，更不存在覆盖的问题。（非构造方法可以）

如果子类访问父类的构造方法，则在编译的时候提示访问不到该方法。

JAVA中不允许多继承，一个类有且只有一个父类（单继承）。

JAVA的数据结构为树型结构，而非网状。（JAVA通过接口和内部类实现多继承）

方法的覆盖（overriding）

方法的重载并不一定是在一个类中：子类可以从父类继承一个方法，也可以定义一个同名异参的方法，也称为overloading。

当子类从父类继承一个无参方法，而又定义了一个同样的无参方法，则子类新写的方法覆盖父类的方法，称为覆盖。（注意返回值类型也必须相同，否则编译出错。）

如果方法不同，则成重载。

对于方法的修饰词，子类方法要比父类的方法范围更加的宽泛。

父类为public，那么子类为private则出现错误。

之所以构造方法先运行父类再运行子类是因为构造方法是无法覆盖的。

以下范围依次由严到宽：

private ：本类访问；

default ：表示默认，不仅本类访问，而且是同包可见。

Protected：同包可见+不同包的子类可见

Public ：表示所有的地方均可见。

当构造一个对象的时候，系统先构造父类对象，再构造子类对象。

构造一个对象的顺序：（注意：构造父类对象的时候也是这几步）

① 递归地构造父类对象；

② 顺序地调用本类成员属性赋初值语句；

③ 本类的构造方法。

Super()表示调用父类的构造方法。

Super()也和this一样必须放在第一行。

This()用于调用本类的构造方法。

如果没有定义构造方法，那么就会调用父类的无参构造方法，即super()。

要养成良好的编程习惯：就是要加上默认的父类无参的构造方法。

思考：可是如果我们没有定义无参的构造方法，而在程序中构造了有参的构造方法，那么如果方法中没有参数，那么系统还会调用有参的构造方法么？应该不会。

多态：多态指的是编译时类型变化，而运行时类型不变。

多态分两种：

① 编译时多态：编译时动态重载；

② 运行时多态：指一个对象可以具有多个类型。

对象是客观的，人对对象的认识是主观的。

例：

Animal a=new Dog()；查看格式名称；

网上不整理的JAVA笔记。

Dog d=(Dog)a。声明父类来引用子类。

（思考上面的格式）

运行时多态的三原则：（应用时为覆盖）

1、 对象不变；（改变的是主观认识）

2、 对于对象的调用只能限于编译时类型的方法，如调用运行时类型方法报错。

在上面的例子中：Animal a=new Dog()；对象a的编译时类型为Animal，运行时类型为dog。 注意：编译时类型一定要为运行时类型的父类（或者同类型）。

对于语句：Dog d=(Dog)a。将d强制声明为a类型，此时d为Dog()，此时d就可以调用运行时类型。注意：a和d指向同一对象。

3、 在程序的运行时，动态类型判定。运行时调用运行时类型，即它调用覆盖后的方法。

关系运算符：instanceof

a instanceof Animal;(这个式子的结果是一个布尔表达式)

a为对象变量，Animal是类名。

上面语句是判定a是否可以贴Animal标签。如果可以贴则返回true，否则返回false。

在上面的题目中： a instanceof Animal返回 True，

a instanceof Dog也返回 True，

instanceof用于判定是否将前面的对象变量赋值后边的类名。

Instanceof一般用于在强制类型转换之前判定变量是否可以强制转换。

如果Animal a=new Animal()；

Dog d=Dog()a;

此时编译无误，但运行则会报错。

Animal a=new Dog()相当于下面语句的功能：

Animal a=getAnimal()；

Public static Animal.getAnimal;

Return new Dog()；

封装、继承、多态为面向对象的三大基石（特性）。

运行时的动态类型判定针对的是方法。运行程序访问的属性仍为编译时属性。

Overloading针对的是编译时类型，不存在运行时的多态。

习题：建立一个shape类，有circle和rect子类。

Shape类有zhouchang()和area()两种方法。

（正方形）squ为rect子类，rect有cha()用于比较长宽的差。

覆盖时考虑子类的private及父类的public（考虑多态），之所以这样是避免调用A时出现实际调用B的情况。而出现错误。

11.29下午讲的是教程上的Module6

Module6-7包括：面向对象高级、内部类、集合、反射（暂时不讲）、例外。

面向对象高级、集合和例外都是面向对象的核心内容。

面向对象高级： 修饰符：

static:①可修饰变量（属性）；②可修饰方法；③可修饰代码块。

网上不整理的JAVA笔记。

Static int data语句说明data为类变量，为一个类的共享变量，属于整个类。

Int data为实例变量。

例：

static int data;

m1.data=0;

m1.data++的结果为1,此时m2.data的结果也为1。

Static定义的是一块为整个类共有的一块存储区域，其发生变化时访问到的数据都时经过变化的。 其变量可以通过类名去访问：类名.变量名。与通过访问对象的编译时类型访问类变量为等价的。 表明此类方法为类方法（静态方法）

静态方法不需要有对象，可以使用类名调用。

静态方法中不允许访问类的非静态成员，包括成员的变量和方法，因为此时是通过类调用的，没有对象的概念。This.data是不可用的。

一般情况下，主方法是静态方法，所以可调用静态方法，主方法为静态方法是因为它是整个软件系统的入口，而进入入口时系统中没有任何对象，只能使用类调用。

覆盖不适用于静态方法。

静态方法不可被覆盖。（允许在子类中定义同名静态方法，但是没有多态，严格的讲，方法间没有多态就不能称为覆盖）

当static修饰代码块时（注：此代码块要在此类的任何一个方法之外），那么这个代码块在代码被装载进虚拟机生成对象的时候可被装载一次，以后再也不执行了。

一般静态代码块被用来初始化静态成员。

Static通常用于Singleton模式开发：

Singleton是一种设计模式，高于语法，可以保证一个类在整个系统中仅有一个对象。

11.30

final可以修饰类、属性、方法。

当用final修饰类的时候，此类不可被继承，即final类没有子类。这样可以用final保证用户调用时动作的一致性，可以防止子类覆盖情况的发生。

当利用final修饰一个属性（变量）的时候，此时的属性成为常量。

JAVA利用final定义常量（注意在JAVA命名规范中常量需要全部字母都大写）：

Final int AGE=10；

常量的地址不可改变，但在地址中保存的值（即对象的属性）是可以改变的。

Final可以配合static使用。 ？

Static final int age=10；

在JAVA中利用public static final的组合方式对常量进行标识（固定格式）。

对于在构造方法中利用final进行赋值的时候，此时在构造之前系统设置的默认值相对于构造方法失效。

网上不整理的JAVA笔记。

常量（这里的常量指的是实例常量：即成员变量）赋值：

①在初始化的时候通过显式声明赋值。Final int x=3；

②在构造的时候赋值。

局部变量可以随时赋值。

利用final定义方法：这样的方法为一个不可覆盖的方法。

Public final void print(){}；

为了保证方法的一致性（即不被改变），可将方法用final定义。

如果在父类中有final定义的方法，那么在子类中继承同一个方法。

如果一个方法前有修饰词private或static，则系统会自动在前面加上final。即private和static方法默认均为final方法。

注：final并不涉及继承，继承取决于类的修饰符是否为private、default、protected还是public。也就是说，是否继承取决于这个方法对于子类是否可见。

Abstract(抽象)可以修饰类、方法

如果将一个类设置为abstract，则此类必须被继承使用。此类不可生成对象，必须被继承使用。 Abstract可以将子类的共性最大限度的抽取出来，放在父类中，以提高程序的简洁性。

Abstract虽然不能生成对象，但是可以声明，作为编译时类型，但不能作为运行时类型。

Final和abstract永远不会同时出现。

当abstract用于修饰方法时，此时该方法为抽象方法，此时方法不需要实现，实现留给子类覆盖，子类覆盖该方法之后方法才能够生效。

注意比较：

private void print(){}；此语句表示方法的空实现。

Abstract void print()； 此语句表示方法的抽象，无实现。

如果一个类中有一个抽象方法，那么这个类一定为一个抽象类。

反之，如果一个类为抽象类，那么其中可能有非抽象的方法。

如果让一个非抽象类继承一个含抽象方法的抽象类，则编译时会发生错误。因为当一个非抽象类继承一个抽象方法的时候，本着只有一个类中有一个抽象方法，那么这个类必须为抽象类的原则。这个类必须为抽象类，这与此类为非抽象冲突，所以报错。

所以子类的方法必须覆盖父类的抽象方法。方法才能够起作用。

只有将理论被熟练运用在实际的程序设计的过程中之后，才能说理论被完全掌握！

为了实现多态，那么父类必须有定义。而父类并不实现，留给子类去实现。此时可将父类定义成abstract类。如果没有定义抽象的父类，那么编译会出现错误。

Abstract和static不能放在一起，否则便会出现错误。（这是因为static不可被覆盖，而abstract为了生效必须被覆盖。）

例：（本例已存在\CODING\abstract\TestClass.java文件中）

public class TestClass{

public static void main(String[] args){

SuperClass sc=new SubClass();

网上不整理的JAVA笔记。

Sc.print();

}

Abstract class SuperClass{

Abstract void print();}

}

class SubClass extends SuperClass(){

void print(){

System.out.println(“print”);}

}

JAVA的核心概念：接口（interface）

接口与类属于同一层次，实际上，接口是一种特殊的抽象类。

如:

interface IA{

}

public interface：公开接口

与类相似，一个文件只能有一个public接口，且与文件名相同。

在一个文件中不可同时定义一个public接口和一个public类。

一个接口中，所有方法为公开、抽象方法；所有的属性都是公开、静态、常量。

一个类实现一个接口的格式：

class IAImple implements IA{

};

一个类实现接口，相当于它继承一个抽象类。

类必须实现接口中的方法，否则其为一抽象类。

实现中接口和类相同。

接口中可不写public，但在子类中实现接口的过程中public不可省。

（如果剩去public则在编译的时候提示出错：对象无法从接口中实现方法。）

注：

① 一个类除继承另外一个类，还可以实现接口； class IAImpl extends java.util.Arrylist implement IA{}

继承类 实现接口

这样可以实现变相的多继承。

② 一个类只能继承另外一个类，但是它可以继承多个接口，中间用“，”隔开。

Implements IA,IB

所谓实现一个接口，就是指实现接口中的方法。

③ 接口和接口之间可以定义继承关系，并且接口之间允许实现多继承。

例：interface IC extends IA,IB{};

接口也可以用于定义对象

IA I=new IAImpl();

实现的类从父类和接口继承的都可做运行时类型。

IAImple extends A implement IA,IB

IB I=new IAImple();

I instance of IAImple;

网上不整理的JAVA笔记。

I instance of A;

I instance of IA;

I instance of IB;

返回的结果均为true.

接口和多态都为JAVA技术的核心。

接口往往被我们定义成一类XX的东西。

接口实际上是定义一个规范、标准。

① 通过接口可以实现不同层次、不同体系对象的共同属性；

通过接口实现write once as anywhere.

以JAVA数据库连接为例子：JDBC制定标准；数据厂商实现标准；用户使用标准。

接口通常用来屏蔽底层的差异。

②接口也因为上述原因被用来保持架构的稳定性。

JAVA中有一个特殊的类： Object。它是JAVA体系中所有类的父类（直接父类或者间接父类）。

此类中的方法可以使所的类均继承。

以下介绍的三种方法属于Object:

(1) finalize方法：当一个对象被垃圾回收的时候调用的方法。

(2) toString():是利用字符串来表示对象。

当我们直接打印定义的对象的时候，隐含的是打印toString()的返回值。

可以通过子类作为一个toString()来覆盖父类的toString()。

以取得我们想得到的表现形式，即当我们想利用一个自定义的方式描述对象的时候，我们应该覆盖toString()。

(3)equal

首先试比较下例：

String A=new String(“hello”);

String A=new String(“hello”);

A==B(此时程序返回为FALSE)

因为此时AB中存的是地址，因为创建了新的对象，所以存放的是不同的地址。

附加知识：

字符串类为JAVA中的特殊类，String中为final类，一个字符串的值不可重复。因此在JAVA VM（虚拟机）中有一个字符串池，专门用来存储字符串。如果遇到String a=”hello”时（注意没有NEW，不是创建新串），系统在字符串池中寻找是否有”hello”，此时字符串池中没有”hello”，那么系统将此字符串存到字符串池中，然后将”hello”在字符串池中的地址返回a。如果系统再遇到String b=”hello”，此时系统可以在字符串池中找到 “hello”。则会把地址返回b，此时a与b为相同。

String a=”hello”;

System.out.println(a==”hello”);

系统的返回值为true。

故如果要比较两个字符串是否相同（而不是他们的地址是否相同）。可以对a调用equal:

System.out.println(a.equal(b));

equal用来比较两个对象中字符串的顺序。

网上不整理的JAVA笔记。

a.equal(b)是a与b的值的比较。

注意下面程序：

student a=new student(“LUCY”,20);

student b=new student(“LUCY”,20);

System.out.println(a==b);

System.out.println(a.equal(b));

此时返回的结果均为false。

以下为定义equal（加上这个定义，返回ture或false）

public boolean equals(Object o){

student s=(student)o;

if (http://.equals(http://)&&s.age==this.age)

else return false;

}如果equals()返回的值为

以下为实现标准equals的流程：

public boolean equals(Object o){

if (this==o) return trun; //此时两者相同

if (o==null) return false;

if (! o instanceof strudent) return false; //不同类

studeng s=(student)o; //强制转换

if (http://.equals(http://)&&s.age==this.age) return true;

else return false;

}

以上过程为实现equals的标准过程。

练习：建立一个employee类，有String name,int id,double salary.运用get和set方法，使用toString，使用equals。

封装类：

JAVA为每一个简单数据类型提供了一个封装类，使每个简单数据类型可以被Object来装载。 除了int和char，其余类型首字母大写即成封装类。

转换字符的方式：

int I=10;

String s=I+” ”;

String s1=String.valueOf(i);

Int I=10;

Interger I_class=new integer(I);

看javadoc的帮助文档。

附加内容：

“==”在任何时候都是比较地址，这种比较永远不会被覆盖。

程序员自己编写的类和JDK类是一种合作关系。（因为多态的存在，可能存在我们调用JDK类的情况，

网上不整理的JAVA笔记。

也可能存在JDK自动调用我们的类的情况。）

注意：类型转换中double\interger\string之间的转换最多。

12.01

内部类：

（注：所有使用内部类的地方都可以不用内部类，使用内部类可以使程序更加的简洁，便于命名规范和划分层次结构）。

内部类是指在一个外部类的内部再定义一个类。

内部类作为外部类的一个成员，并且依附于外部类而存在的。

内部类可为静态，可用PROTECTED和PRIVATE修饰。（而外部类不可以：外部类只能使用PUBLIC和DEFAULT）。

内部类的分类：

成员内部类、

局部内部类、

静态内部类、

匿名内部类（图形是要用到，必须掌握）。

① 成员内部类：作为外部类的一个成员存在，与外部类的属性、方法并列。

内部类和外部类的实例变量可以共存。

在内部类中访问实例变量：this.属性

在内部类访问外部类的实例变量：外部类名.this.属性。

成员内部类的优点：

⑴内部类作为外部类的成员，可以访问外部类的私有成员或属性。（即使将外部类声明为PRIVATE，但是对于处于其内部的内部类还是可见的。）

⑵用内部类定义在外部类中不可访问的属性。这样就在外部类中实现了比外部类的private还要小的访问权限。

注意：内部类是一个编译时的概念，一旦编译成功，就会成为完全不同的两类。

对于一个名为outer的外部类和其内部定义的名为inner的内部类。编译完成后出现outer.class和outer$inner.class两类。

（编写一个程序检验：在一个TestOuter.java程序中验证内部类在编译完成之后，会出现几个class.）

成员内部类不可以有静态属性。（为什么？）

如果在外部类的外部访问内部类，使用out.inner.

建立内部类对象时应注意：

在外部类的内部可以直接使用inner s=new inner();（因为外部类知道inner是哪个类，所以可以生成对象。）

而在外部类的外部，要生成（new）一个内部类对象，需要首先建立一个外部类对象（外部类可用），然后在生成一个内部类对象。

Outer.Inner in=Outer.new.Inner()。

错误的定义方式：

Outer.Inner in=new Outer.Inner()。

注意：当Outer是一个private类时，外部类对于其外部访问是私有的，所以就无法建立外部类对象，进而也无法建立内部类对象。

网上不整理的JAVA笔记。

② 局部内部类：在方法中定义的内部类称为局部内部类。

与局部变量类似，在局部内部类前不加修饰符public和private，其范围为定义它的代码块。

注意：局部内部类不仅可以访问外部类实例变量，还可以访问外部类的局部变量（但此时要求外部类的局部变量必须为final）？？

在类外不可直接生成局部内部类（保证局部内部类对外是不可见的）。

要想使用局部内部类时需要生成对象，对象调用方法，在方法中才能调用其局部内部类。

③ 静态内部类：（注意：前三种内部类与变量类似，所以可以对照参考变量）

静态内部类定义在类中，任何方法外，用static定义。

静态内部类只能访问外部类的静态成员。

生成（new）一个静态内部类不需要外部类成员：这是静态内部类和成员内部类的区别。静态内部类的对象可以直接生成：

Outer.Inner in=new Outer.Inner()；

而不需要通过生成外部类对象来生成。这样实际上使静态内部类成为了一个顶级类。

静态内部类不可用private来进行定义。例子：

对于两个类，拥有相同的方法：

People

{

run();

}

Machine{

run();

}

此时有一个robot类：

class Robot extends People implement Machine.

此时run()不可直接实现。

注意：当类与接口（或者是接口与接口）发生方法命名冲突的时候，此时必须使用内部类来实现。 用接口不能完全地实现多继承，用接口配合内部类才能实现真正的多继承。

④ 匿名内部类（必须掌握）：

匿名内部类是一种特殊的局部内部类，它是通过匿名类实现接口。

IA被定义为接口。

IA I=new IA(){};

注：一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类，没有类名，根据多态，我们使用其父类名。

因其为局部内部类，那么局部内部类的所有限制都对其生效。

匿名内部类是唯一一种无构造方法类。

匿名内部类在编译的时候由系统自动起名Out$1.class。

如果一个对象编译时的类型是接口，那么其运行的类型为实现这个接口的类。

因匿名内部类无构造方法，所以其使用范围非常的有限。

（下午：）Exception（例外/异常）（教程上的MODEL7）

对于程序可能出现的错误应该做出预案。

例外是程序中所有出乎意料的结果。（关系到系统的健壮性）

JAVA会将所有的错误封装成为一个对象，其根本父类为Throwable。

Throwable有两个子类：Error和Exception。

一个Error对象表示一个程序错误，指的是底层的、低级的、不可恢复的严重错误。此时程序一定会退

网上不整理的JAVA笔记。

出，因为已经失去了运行所必须的物理环境。

对于Error错误我们无法进行处理，因为我们是通过程序来应对错误，可是程序已经退出了。 我们可以处理的Throwable对象中只有Exception对象（例外/异常）。

Exception有两个子类：Runtime exception（未检查异常）

非Runtime exception（已检查异常）

（注意：无论是未检查异常还是已检查异常在编译的时候都不会被发现，在编译的过程中检查的是程序的语法错误，而异常是一个运行时程序出错的概念。）

在Exception中，所有的非未检查异常都是已检查异常，没有另外的异常！！

未检查异常是因为程序员没有进行必要的检查，因为他的疏忽和错误而引起的异常。一定是属于虚拟机内部的异常（比如空指针）。

应对未检查异常就是养成良好的检查习惯。

已检查异常是不可避免的，对于已检查异常必须实现定义好应对的方法。

已检查异常肯定跨越出了虚拟机的范围。（比如“未找到文件”）

如何处理已检查异常（对于所有的已检查异常都要进行处理）：

首先了解异常形成的机制：

当一个方法中有一条语句出现了异常，它就会throw（抛出）一个例外对象，然后后面的语句不会执行返回上一级方法，其上一级方法接受到了例外对象之后，有可能对这个异常进行处理，也可能将这个异常转到它的上一级。

对于接收到的已检查异常有两种处理方式：throws和try方法。

注意：出错的方法有可能是JDK，也可能是程序员写的程序，无论谁写的，抛出一定用throw。

例：public void print() throws Exception.

对于方法a，如果它定义了throws Exception。那么当它调用的方法b返回异常对象时，方法a并不处理，而将这个异常对象向上一级返回，如果所有的方法均不进行处理，返回到主方法，程序中止。（要避免所有的方法都返回的使用方法，因为这样出现一个很小的异常就会令程序中止）。

如果在方法的程序中有一行throw new Exception()，返回错误，那么其后的程序不执行。因为错误返回后，后面的程序肯定没有机会执行，那么JAVA认为以后的程序没有存在的必要。

对于try catch格式：

try {可能出现错误的代码块} catch(exception e){进行处理的代码} ；

对象变量的声明

用这种方法，如果代码正确，那么程序不经过catch语句直接向下运行；

如果代码不正确，则将返回的异常对象和e进行匹配，如果匹配成功，则处理其后面的异常处理代码。（如果用exception来声明e的话，因为exception为所有exception对象的父类，所有肯定匹配成功）。处理完代码后这个例外就完全处理完毕，程序会接着从出现异常的地方向下执行（是从出现异常的地方还是在catch后面呢？利用程序进行验证）。最后程序正常退出。

Try中如果发现错误，即跳出try去匹配catch，那么try后面的语句就不会被执行。

一个try可以跟进多个catch语句，用于处理不同情况。当一个try只能匹配一个catch。

我们可以写多个catch语句，但是不能将父类型的exception的位置写在子类型的excepiton之前，因为这样父类型肯定先于子类型被匹配，所有子类型就成为废话。JAVA编译出错。

网上不整理的JAVA笔记。

在try，catch后还可以再跟一子句finally。其中的代码语句无论如何都会被执行（因为finally子句的这个特性，所以一般将释放资源，关闭连接的语句写在里面）。

如果在程序中书写了检查（抛出）exception但是没有对这个可能出现的检查结果进行处理，那么程序就会报错。

而如果只有处理情况（try）而没有相应的catch子句，则编译还是通不过。

如何知道在编写的程序中会出现例外呢

1． 调用方法，查看API中查看方法中是否有已检查错误。

2． 在编译的过程中看提示信息，然后加上相应的处理。

Exception有一个message属性。在使用catch的时候可以调用：

Catch(IOException e){System.out.println(e.message())};

Catch(IOException e){e.printStackTrace()};

上面这条语句回告诉我们出错类型所历经的过程，在调试的中非常有用。

开发中的两个道理：

①如何控制try的范围：根据操作的连动性和相关性，如果前面的程序代码块抛出的错误影响了后面程序代码的运行，那么这个我们就说这两个程序代码存在关联，应该放在同一个try中。

② 对已经查出来的例外，有throw(积极)和try catch（消极）两种处理方法。

对于try catch放在能够很好地处理例外的位置（即放在具备对例外进行处理的能力的位置）。如果没有处理能力就继续上抛。

当我们自己定义一个例外类的时候必须使其继承excepiton或者RuntimeException。

Throw是一个语句，用来做抛出例外的功能。

而throws是表示如果下级方法中如果有例外抛出，那么本方法不做处理，继续向上抛出。

Throws后跟的是例外类型。

断言是一种调试工具（assert）

其后跟的是布尔类型的表达式，如果表达式结果为真不影响程序运行。如果为假系统出现低级错误，在屏幕上出现assert信息。

Assert只是用于调试。在产品编译完成后上线assert代码就被删除了。

方法的覆盖中，如果子类的方法抛出的例外是父类方法抛出的例外的父类型，那么编译就会出错：子类无法覆盖父类。

结论：子类方法不可比父类方法抛出更多的例外。子类抛出的例外或者与父类抛出的例外一致，或者是父类抛出例外的子类型。或者子类型不抛出例外。

如果父类型无throws时，子类型也不允许出现throws。此时只能使用try catch。

练习：写一个方法：int add(int a,int b)

{

return a+b；

}

当a+b=100;抛出100为异常处理。

12.02

集合（从本部分开始涉及API）

集合是指一个对象容纳了多个对象，这个集合对象主要用来管理维护一系列相似的对象。

数组就是一种对象。（练习：如何编写一个数组程序，并进行遍历。）

java.util.*定义了一系列的接口和类，告诉我们用什么类NEW出一个对象，可以进行超越数组的操作。 （注：JAVA1.5对JAVA1.4的最大改进就是增加了对范型的支持）

网上不整理的JAVA笔记。

集合框架接口的分类：（分collection接口 和 map接口）

Collection接口 Map接口

List接口 Set接口 SortedMap接口

SortedSet接口

JAVA中所有与集合有关的实现类都是这六个接口的实现类。

Collection接口：集合中每一个元素为一个对象，这个接口将这些对象组织在一起，形成一维结构。

List接口代表按照元素一定的相关顺序来组织（在这个序列中顺序是主要的），List接口中数据可重复。

Set接口是数学中集合的概念：其元素无序，且不可重复。（正好与List对应）

SortedSet会按照数字将元素排列，为“可排序集合”。

Map接口中每一个元素不是一个对象，而是一个键对象和值对象组成的键值对（Key-Value）。

Key-Value是用一个不可重复的key集合对应可重复的value集合。（典型的例子是字典：通过页码的key值找字的value值）。

例子：

key1—value1;

key2—value2;

key3—value3.

SortedMap：如果一个Map可以根据key值排序，则称其为SortedMap。（如字典）

!!注意数组和集合的区别：数组中只能存简单数据类型。Collection接口和Map接口只能存对象。

以下介绍接口：

List接口：（介绍其下的两个实现类：ArrayList和LinkedList）

ArrayList和数组非常类似，其底层①也用数组组织数据，ArrayList是动态可变数组。

① 底层：指存储格式。说明ArrayList对象都是存在于数组中。

注：数组和集合都是从下标0开始。

ArrayList有一个add(Object o)方法用于插入数组。

ArrayList的使用：（完成这个程序）

先import java.util.*；

用ArrayList在一个数组中添加数据，并遍历。

ArrayList中数组的顺序与添加顺序一致。

只有List可用get和size。而Set则不可用（因其无序）。

Collection接口都是通过Iterator()（即迭代器）来对Set和List遍历。

通过语句：Iterator it=c.iterator(); 得到一个迭代器，将集合中所有元素顺序排列。然后可以通过interator方法进行遍历，迭代器有一个游标（指针）指向首位置。

Interator有hasNext()，用于判断元素右边是否还有数据，返回True说明有。然后就可以调用next动作。Next()会将游标移到下一个元素，并把它所跨过的元素返回。（这样就可以对元素进行遍历） 练习：写一个程序，输入对象信息，比较基本信息。

集合中每一个元素都有对象，如有字符串要经过强制类型转换。

Collections是工具类，所有方法均为有用方法，且方法为static。

有Sort方法用于给List排序。

Collections.Sort()分为两部分，一部分为排序规则；一部分为排序算法。

网上不整理的JAVA笔记。

规则用来判断对象；算法是考虑如何排序。

对于自定义对象，Sort不知道规则，所以无法比较。这种情况下一定要定义排序规则。方式有两种： ① http://ng下面有一个接口：Comparable（可比较的）

可以让自定义对象实现一个接口，这个接口只有一个方法comparableTo(Object o)

其规则是当前对象与o对象进行比较，其返回一个int值，系统根据此值来进行排序。

如 当前对象>o对象，则返回值>0；（可将返回值定义为1）

如 当前对象=o对象，则返回值=0；

如 当前对象<o对象，则返回值〈0。（可将返回值定义为-1）

看TestArraylist的java代码。

我们通过返回值1和-1位置的调换来实现升序和降序排列的转换。

② java.util下有一个Comparator(比较器)

它拥有compare()，用来比较两个方法。

要生成比较器，则用Sort中Sort（List,List(Compate)）

第二种方法更灵活，且在运行的时候不用编译。

注意：要想实现comparTo()就必须在主方法中写上implement comparable.

练习：生成一个EMPLOYEE类，然后将一系列对象放入到ArrayList。用Iterator遍历，排序之后，再进行遍历。

集合的最大缺点是无法进行类型判定（这个缺点在JAVA1.5中已经解决），这样就可能出现因为类型不同而出现类型错误。

解决的方法是添加类型的判断。

LinkedList接口（在代码的使用过程中和ArrayList没有什么区别）

ArrayList底层是object数组，所以ArrayList具有数组的查询速度快的优点以及增删速度慢的缺点。 而在LinkedList的底层是一种双向循环链表。在此链表上每一个数据节点都由三部分组成：前指针（指向前面的节点的位置），数据，后指针（指向后面的节点的位置）。最后一个节点的后指针指向第一个节点的前指针，形成一个循环。

双向循环链表的查询效率低但是增删效率高。所以LinkedList具有查询效率低但增删效率高的特点。 ArrayList和LinkedList在用法上没有区别，但是在功能上还是有区别的。

LinkedList经常用在增删操作较多而查询操作很少的情况下：队列和堆栈。

队列：先进先出的数据结构。

堆栈：后进先出的数据结构。

注意：使用堆栈的时候一定不能提供方法让不是最后一个元素的元素获得出栈的机会。

LinkedList提供以下方法：（ArrayList无此类方法）

addFirst();

removeFirst();

addLast();

removeLast();

在堆栈中，push为入栈操作，pop为出栈操作。

Push用addFirst()；pop用removeFirst()，实现后进先出。

用isEmpty()--其父类的方法，来判断栈是否为空。

在队列中，put为入队列操作，get为出队列操作。

Put用addFirst()，get用removeLast()实现队列。