java学习笔记

源文件声明规则：
1.一个源文件只能有一个public类，可以有多个非public类
2.原文件名称与public类名称相同
3.package语句放在源文件首行
4.import语句和package语句对源文件中定义的所有类都有效
5.同意源文件下，不能给不同类不同的包声明

函数就是把一部分功能封装起来，被重复使用
函数格式：
修饰符 返回值类型 函数名（参数类型 形式参数1， 参数类型 形式参数2）
{
执行语句；
return 返回值；
}
函数必须学会
int getResult(int num)
{
return num * 3 + 5;
}
jvm：java虚拟机 java virtual machine
jre：java运行环境 java runtime environment= jvm + Java类库
jdk：java软件开发包 java development kit = jre + 开发工具
.java文件 —> java编译器 —> .class文件
编译只检查语法错误。

函数只有被调用才能执行
如何定义一个函数：（精简为：输出结果+输入参数）
1.既然函数是一个独立的功能，先明确运算结果，这是在明确函是返回值类型
2.在明确该功能的时要考虑是否需要外界变量参与运算，是否需要未知内容参与，这是在明确函数的返回值列表
需求：定义一个功能，完成三加四的运算
1.明确功能的结果：一个整数的和
2.在实现该过程中是否有位置内容参与，没有
其实这两个功能在明确函数的定义：
1.明确函数返回值类型
2.明确函数的参数列表（参数类型和参数的个数）
但以上无扩展性，要用户去指定加数和被加数

函数的重载（参数列表不同即可）
但定义功能相同，但参与运算的未知内容不同，就定义一个函数名称以表示相同的功能，通过参数列表的不同来区分。提高代码复用性。参数的有顺序的，注意：重载与返回值类型无关。

数组
存储数据的容器。
格式1：元素类型[] 数组名 = new 元素类型[元素个数或数组长度]

格式2：元素类型[] 数组名 = new 元素类型[]{元素，元素，…}// 一般不用
格式3：元素类型[] 数组名 = {元素，元素，…}

栈内存：存储局部变量，用完退栈自动释放空间。
堆空间：new后的定义其中，数组名存放于栈内存，指向数组第一个元素的地址。加一个new，在内存中就新开辟一个空间，且不释放空格。

ArrayIndexOutOfBoundsException:数组角标元素异常
NullPointerException 空指针异常：引用没有指向任何值
数组.length 获取数组长度

获取数组中最大值：
1.定义变量，初始化数组中任意一个元素即可为最大值或
2.通过循环语句对数据进行遍历
3.在变量过程中定义判断条件，如果遍历到的元素比变量大，就赋值给该变量
可以将临时变量初始化定义为零，只要将其设置为数组的角标就行。

选择排序：

public static void selectSort(int[] arr){
for (int x = 0; x < arr.length-1； x++){
for (int y = x+1；y < arr.length;y++){
if(arr[x]>arr[y]){
int temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
}
}
}
内循环结束一次，最值出现头角标位置

冒泡排序：
相邻的两个元素进行比较，如果符合条件换位。
以上两种排序方式只在堆内存中换位置，空间利用率低，效率低。
位置置换功能抽取：（无论什么排序都要进行位置的置换，封装）
public static void swap(int[] arr, int x, int y)
{
int temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}

Array.sort(arr) //java中常用的排序方式

数组查找操作：获取key第一次出现在数组中的位置。
public static void GetIndex(int[] arr,int key){
for (int x = 0; x< arr.length; x++){
if (arr[x] == key)
return x;
}
return -1;
}
折半查找：（提高搜索效率，但必须是有序数组）
public static int halfSearch(int[] arr, int key)
{
int min,max,mid;
min = 0;
max = arr.length - 1;
mid = (max+min)/2;
while (arr[mid]!=key)
{
if (key > arr[mid])
min = mid + 1;
else if (key < arr[mid])
max = mid - 1;
if (min > max)
return -1;
mid = (max+min)/2;
}

}

折半第二种方式：

public static int halfSearch(int[] arr, int key)
{
int min = 0,max = arr.length - 1,mid;

while (min <= max)
{
	mid = (max+min)>>1; //右移一位
	if (key > arr[mid])	
		min = mid + 1;

	else if (key < arr[mid])	
		max = mid - 1;
	else	
		return mid;
}
return -1; 

}
return无法输出数字到屏幕上。

---

调试一个程序，首先检查输出是否按要求输出，是否是按照语言的规范格式输出的，然后检查输入，输入是否存在以及输入是否合乎规范，最后在程序内部查找，首先语法，其次各个语句的输出，输入，内部的顺序检查。

---

查表法：将所有的元素临时存储起来，建立对应关系。
二维数组：
格式一： int[][] arr = new int[3][2]; 然后分别赋值
格式二：int[][] arr = {{},{},{}};
格式三：int[][] arr = new int[5][];//五行的长度，列的长度自定义

int[] x,y[]; //x一维,y二维
int[] y[];
面向对象：强调了行为发出的对象。将行为封装到一个对象当中，然后对对象进行操作。
面向行为：强调了对象发出的行为。按时间顺序依次执行的行动。
是一种思考方式，将问题简单化，只需要操作一个对象即可，从执行者转变到指挥者。

面向过程封装到了面向对象中。
名词提炼法，提取对象。
人开门
人{
开门（门）{
门.开（）；
}
}
门{
开（）{
操作等。
}
}

面向对象特征：封装，继承，多态
开发：找对象，用对象，建对象，并维护对象的关系。提高程序的复用性。
类和对象的关系：
类：对现实事物的一个抽象描述。提取对象中共性内容。
对象：真实存在的事物。
描述事物就是描述事物的属性和行为。 属性类中变量 行为类中函数（方法）
class Car{ //Car类
}
Car c = new Car(); //这是一个类类型变量，在堆内存中产生一个实体。凡是new就在堆内存中开辟一个空间
new关键字的作用
1.为对象分配内存空间
2.引起对象构造方法的调用
3.为对象返回一个引用

成员变量和局部变量
成员变量作用于整个类中，局部变量作用于语句中或函数中
成员变量：在堆内存中，由于对象的存在而存在。
局部变量：在栈内存中

在一个类中也可以定义一个main函数，一般不写，但只在主类中写，有一个入口即可。

匿名对象：
Car c = new Car();
c.num = 5;
以上可些为：
new Car.num = 5;
new Car.num = 5;这是两个对象，不是同一个了。
当对对象的方法只调用一次是，可以使用，简化程序。对次调用不能使用。
可以将匿名对象作为实际参数进行传递：
//需求：汽车设计厂，对汽车改装，改成黑车，三个轮子
public static void show(Car c)
{
c.num = 3;
c.color = “black”;
c.run();
}
main()
{
//Car q = new Car();
//show(q);
show(new Car());//同上
}

封装：隐藏对象的属性和实现方式，仅对外提供公共访问方式。

private：权限修饰符，用于修饰类中成员，只在本类中使用。私有化后不能直接访问了。
一个成员变量都有设置和获取两个功能。
私有也是封装的一种。私有可以控制出入的数据，对访问的数据进行操作，提高代码的健壮性。
类中的函数可以互相调用。

封装的原则：
将不需要对外提供的内容都隐藏起来。
把属性都隐藏，提供公共方法对其访问。

构造函数：
1.函数名与类名同
2.不用定义返回值类型
3.不可以写retrurn
class Person
{
Person()
{
System.out.println(“hello world”);
}
}

对象一建立就会调用相应的构造函数，用于给对象初始化。若没有构造函数，系统会自动加入一个空参数的构造函数，方便对象初始化。
一般方法（函数）只在对象调用时才执行，可以调用多次，给对象添加具备的功能。构造函数只执行一次。
什么时候定义构造函数：
在分析事物时，就具备一些属性和行为时，天生的一些行为和方法，可以定义构造函数。
构造代码块：统一给不同的对象初始化，构造函数是给不同的对象初始化，而构造代码块是给所有对象初始化。且比构造函数优先执行。构造函数也可以私有化。
class Person
{
{
//构造代码块
}
}
this.name this关键字
特点：代表本类对象本身
this代表所在函数所属对象大的引用（那个对象在调用this所在的函数，this就代表那个对象，谁调用就那代表谁）
this.name = name; //把name赋值给对象的成员变量
this的应用：当定义类中功能（函数）时，该函数内部要用到调用该函数的对象时，这时用this来表示这个对象。但凡本类功能内部用到本类对象时都用this表示。先看懂this代表什么，在看这段表示什么
构造函数间调用：
this（name）
this语句，用于构造函数间互相调用。然后和函数一样使用。且只能放在构造函数的第一行。

从静态函数中无法有引用非静态函数。
static关键字：
是一个修饰符，用于修饰成员（成员变量，成员函数）。静态修饰内容被对象所共享。成员被静态修饰后，除了被对象调用，可以被类名直接调用（即不用建对象）：类名.静态成员。

特有内容随着数据存储在堆内存中。static修饰的成员不含有任何对象的特征，不含有特殊的特征或指向。

static修饰存储区：
方法区内存（共享区，数据区）：类中方法，类中共享数据。

static特点：
1.随着类的加载而加载：类被执行，static修饰的参数就在内存中划分一块地方，非静态变量（成员变量，实例变量）只有在对像存在而存在。
2.被所有对象所共享
3.优先于对象存在
4.可以直接被类名所调用
static String name; //类变量
static对内存消耗大，如果有多个对象共享，则设为static，不是不用设置。
1.存放位置：类变量随着类的加载存在与方法区中。实例对象随着对象的建立存在于堆内存中。
2.生命周期：类变量生命周期最长，随类的消失而消失，实例变量随着对象消失而消失。

静态使用注意事项：
1.静态方法只能访问静态成员。非静态方法可以访问静态成员。
2.静态方法中不能定义this，super关键字。因为this代表对象，但static方法优先于对象存在，连对象都没有哪来的成员方法。
3.主函数是静态的。

pubic static void main(String[] args)
主函数：是一个特殊的的函数，程序的入口，可以被jvm调用
public：函数访问权限最大
static：主函数随类的加载就才能在了
void：无具体返回值
main：特殊函数，只有jvm识别
（String[] args）:函数的参数，字符串数组
主函数固定格式，jvm识别
args可以换//arguments
主函数有函数重载。
jvm调用主函数时，传入的是new String[0]
什么时候使用静态：
静态修饰内容：成员变量 和函数
什么时候定义静态变量：当对象中出现共享数据时，该数据被静态所修饰，对象中特有数据，要定义为非静态，存在与堆内存中。
什么时候定义静态函数：当功能内没有访问到非静态数据（对象特有数据），该功能定义为静态的
静态的应用：
每一个应用程序中都有相同的功能，可以将这些功能进行抽取，独立封装，以便复用。

class Tool
{
private Tool(){} //指这个类被私有化了

private static void sdfawf()
{
}

}
Tool.printArray(arr);类名.静态方法
将方法都静态后，可以方便使用，但是该类还可以被其他程序创建对象，为了更加严谨，强制让该类不能创建对象，可以通过将构造函数私有化。如上所示。

将.class文件发送给其他人，就可以使用了，但需要写说明书：
开始制作程序的说明书，java说明书通过文档注释来完成
/**

这是一个。。。。。。。
@author 名字
@version v1.1
@param 参数
@return 返回等
*/
一个类中默认会有一个空参数的构造函数。
默认构造函数的权限随着类的变化而变化，public权限最大。
javadoc -d my -author -version ArrayTool.java
生成帮助文档
Person p = new Person(“efwef”);
该句话做了什么事情：
1.因为new用到了Person.class文件，所以会找到Person.class文件并加载。
2.执行该类中的static代码块，如果有的话，给Person.class类进行初始化。
3.在堆内存中开辟空间，分配内存地址。
4.在堆内存中建立对象的特有属性 ，并进行默认初始化。
5.对属性进行显示初始化
6.对对象进行构造代码块的初始化。
7.对对象进行对应的构造代码块初始化。
8.将内存地址付给栈内存中的p变量。

设计模式：解决某一类问题的最行之有效的方法。java中有23中。
单例设计模式：解决一个类在内存中只存在一个对象。

继承：
class 类名1 extends 类名2
{
继承了类名2的内容
}
提高了代码的复用性，让类与类产生了关系。
继承后看一下父类中是不是子类中要继承的内容
定义为类后，找到共性内容，生成父类。
java支持单继承，不支持多继承，易带来安全隐患:当多个父类中定义了相同的功能，当功能内容不同时，易产生混淆。，不知道运行那个。但支持多层继承，，继承体系。继承类树。要分清楚共性内容和个性内容。
使用继承体系时首先查看父类的内容，再看子类的内容。

类中成员内容：
1.变量
2.函数
3.构造函数
super.num//父类对象引用
this.num//子类对象引用，子类，直接与对象对接的类。
在方法区（共享区）中，先加载父类，再加载子类

1.变量
如果子类中出现非私有的同名成员变量时，子类要访问子类变量用this，子类访问父类变量，用super
super和this使用几乎一致
this代表是对本类的引用。
super代表父类对象的引用。

2.子父类中的函数
子父类方法一致，只运行子类的，称之为重写（覆盖）。
当子类继承父类，沿袭子类的功能，到类中。
子类中有功能与父类同但输出不同，可以用重写功能。
源码不要改动。使用重写功能。
class Tel
{

}

class NewTel extends Tel
{
//重写内容，将Tel的内容覆盖掉了。
}
覆盖：子类权限大于等于父类权限才可以，静态不能覆盖非静态，只能覆盖静态。默认权限介于private和public之间。
重载只看同名函数的参数列表。
重写：子父类方法（函数）一模一样才行

3.子父类中的构造函数
子类中调用父类构造函数super（）；
子类调用子类的this（）；
子类运行时，会先运行父类中的构造函数，再运行子类的构造函数。

子类的实例化过程：
为什么子类一定访问父类构造函数：
子类要先查看父类中数据的初始化，如果要访问父类特定的构造函数，手动super（）函数即可。
子类中至少有一个构造函数要访问父类的构造函数。

final关键字：
1.可以修饰类，变量，函数。
2.被final修饰的类不能被继承。最终类
3.被final修饰的方法不能被重写。最终方法
4.被final修饰的变量是一个常量只能赋值一次，成员变量或局部变量。最终变量：在描述事物时，一些数据的出现是固定的，不变的。常量用大写。
public static final double PI = 3.14;//全局常量
类修饰符：public，final

当多个类中出现相同的功能，但实现功能的过程不同，也可以进行抽取。只抽取功能定义，主体实现部分不抽取，并用abstract关键字标识。
abstract class Student{
abstract void show();
}
1.抽象方法在抽象类中
2.抽象方法和抽象类都必须被abstract修饰，抽象类不能用new创建对象，因为调用抽象无意义。
3.抽象类中抽象方法要被使用，必须由子类覆写所有方法后，建立子类对象调用。如果子类没有全覆盖父类的抽象方法，那么子类依旧是一个抽象类，子类前加abstract关键字，这是的子类依旧只能按抽象的特点去使用。
抽象类中也可以定义非抽象方法。
抽象类和非抽象类没有太大不同，该怎么描述事物就怎么描述。只是该类中出现了些看不懂的东西。
抽象类比一般类多了抽象方法，抽象类不能实例化。abstract只能修饰类和方法，抽象类中可以不定义抽象方法，作用就是不让该类创建对象。

抽象方法比对应抽象类，全要加abstract，有抽象方法必有抽象类，有抽象类不一定有抽象方法。

模板方法设计模式：
定义一个模板结构，将部分或全部具体内容延迟到子类中去实现。
在不改变模板结构的前提下在子类中重新定义模板的内容，子类对模板是继承关系。
Abstract class{} ----> Concrete class{}
抽象模板：定义模板结构（一个或多个抽象方法，以便让子类去具体实现）
具有模板：具体实现抽象类的抽象方法。

步骤1： 创建抽象模板结构（Abstract Class）：炒菜的步骤

public abstract class Abstract Class {
//模板方法，用来控制炒菜的流程 （炒菜的流程是一样的-复用）
//申明为final，不希望子类覆盖这个方法，防止更改流程的执行顺序
final void cookProcess(){
//第一步：倒油
this.pourOil()；
//第二步：热油
this.HeatOil();
//第三步：倒蔬菜
this.pourVegetable();
//第四步：倒调味料
this.pourSauce（）；
//第五步：翻炒
this.fry();
}

//定义结构里哪些方法是所有过程都是一样的可复用的，哪些是需要子类进行实现的

//第一步：倒油是一样的，所以直接实现
void pourOil(){
System.out.println(“倒油”);
}

//第二步：热油是一样的，所以直接实现
void HeatOil(){
System.out.println(“热油”);
}

//第三步：倒蔬菜是不一样的（一个下包菜，一个是下菜心）
//所以声明为抽象方法，具体由子类实现
abstract void pourVegetable()；

//第四步：倒调味料是不一样的（一个下辣椒，一个是下蒜蓉）
//所以声明为抽象方法，具体由子类实现
abstract void pourSauce（）；

//第五步：翻炒是一样的，所以直接实现
void fry();{
System.out.println(“炒啊炒啊炒到熟啊”);
}
}

步骤2： 创建具体模板（Concrete Class）,即”手撕包菜“和”蒜蓉炒菜心“的具体步骤
//炒手撕包菜的类
public class ConcreteClass_BaoCai extend Abstract Class{
@Override
public void pourVegetable(){
System.out.println(”下锅的蔬菜是包菜“);
}
@Override
public void pourSauce（）{
System.out.println(”下锅的酱料是辣椒“);
}
}
//炒蒜蓉菜心的类
public class ConcreteClass_CaiXin extend Abstract Class{
@Override
public void pourVegetable(){
System.out.println(”下锅的蔬菜是菜心“);
}
@Override
public void pourSauce（）{
System.out.println(”下锅的酱料是蒜蓉“);
}
}

步骤3： 客户端调用-炒菜了
public class Template Method{
public static void main(String[] args){

//炒 - 手撕包菜
ConcreteClass_BaoCai BaoCai = new ConcreteClass_BaoCai（）；
BaoCai.cookProcess()；

//炒 - 蒜蓉菜心
ConcreteClass_ CaiXin = new ConcreteClass_CaiXin（）；
CaiXin.cookProcess()；
}

}

接口：
class 定义类
interface 定义接口

定义接口时，格式特点：
1.常见定义：常量，抽象方法
2，接口中成员有固定的修饰符：
常量：public static final
方法：public abstract
接口中成员都是public
类对接口是实现关系，对其他类继承关系

interface Inter
{

}

interface Inter1
{

}
class text implements Inter, Inter1
{

}
接口不能创建对象，因为有抽象方法，需要被子类实现。多实现。接口是增加功能用的。
接口与接口是继承关系。存在多继承，类鱼类之间只有单继承。
interface A{

}
interface B extends A{

}
interface C extends B{

}
class D implements C{

}

一个类可以实现多个接口。

多态：事物存在的多种体现形式
1.基本体现
父类的引用指向自己的子类对象
父类的引用也可以接受自己的对象
Animal c = new Cat();//类型提升，向上转型，子类向父类转型。
这行代码是多态

public static void(Animal a)//多态，提高代码复用性
{
a.cat();
}
2.前提
必须是类与类之间有关系，继承或实现
通常还有一个前提，存在覆盖。
3.好处
提高了程序的拓展性
4.应用
5.弊端
只能使用父类的引用访问父类中的成员
6.特点

在多态中成员函数的特点：
编译时：参阅引用型变量所属的类中是否有调用方法，如果有，编译通过
在运行时：参阅对象所属的类中是否有调用的方法
简单总结：成员函数在多态调用时，编译看左边，运行看右边。

Object：是所有对象的超类，具备所有对象的功能。
任何一个类
class Demo // extends Object

abstract class 动物
{
abstract void eat();
}

class Dog extends 动物
{
public void eat()
{
//骨头;
}
}

class 猫 extends 动物
{
public void eat()
{
//吃鱼；
}
}

class 猪 extends 动物
{
public void eat()
{
//饲料；
}
}

class Demo
{
public void method(动物 x)//new Dog(); new 猫();
{
x.eat();
}
/*
public void method(猫 x)
{
x.eat();
}
public void method(Dog x)
{
x.eat();
}
public void method(猪 x)
{
x.eat();
}
*/
}

class Main
{
public static void main(String[] args)
{
Demo d = new Demo();
d.method(new Dog());
d.method(new 猫());
}
}

动物 x = new 猫（）；
//猫 x = new 猫（）；

一。表现：
父类或者接口的引用指向了或者接收了自己的子类对象。

二。前提：
1，类与类之间要有关系。继承，实现。
2，通常都会有覆盖。

三。好处：
预先定义的程序可以运行后期程序的内容。
增强了程序的扩展性。

四。弊端：
虽然可以预先使用，但是只能访问父类中已有的功能，运行的是后期子类的功能内容。
不能预先使用子类中定义的特有功能。

五。多态的注意事项：
在代码中。
对于成员函数：Fu f = new Zi(); f.method();
编译时期：看左边。找Fu类中是否有method()函数，如果没有编译无法通过
运行时期：看右边。运行时显示的结果为子类中的函数结果，非父类中的
因为成员函数有一个覆盖操作。

对于非私有的实例变量，
静态变量，静态方法。
编译和运行都看左边。

六。转型。
子类对象被父类引用：子类对象在向上转型。
将指向子类对象的父类应用转换成子类类型引用：向下转型。

毕姥爷和毕老师的故事。
class 毕姥爷
{}

class 毕老师 extends 毕姥爷
{}

毕姥爷 ly = new 毕老师();//毕老师向上转型为了毕姥爷。向上转型

毕老师 ls = (毕老师)ly; //将代表毕老师对象的父类引用ly强制转换成了毕老师类型。向下转型。

class MainBoard
{
public void run()
{
//主板运行;
}
public void usePCI(PCI p)//PCI p = new NetCard();
{
if(p!=null)
{
p.open();
p.close();
}
}
}

//为了提高主板功能的扩展性。
//定义了规则。让后期的出现的功能板块，只要覆盖该规则，就可以被这个主板使用。
interface PCI
{
void open();
void close();
}

class MainDemo
{
public static void main(String[] args)
{
MainBoard mb = new MainBoard();
mb.run();
mb.usePCI(null);
mb.usePCI(new NetCard());

}

}

class NetCard implements PCI
{
public void open(){}
public void close(){}
}

Object:是java中所有对象的直接或者间接的父类。
它里面的方法都所有对象都具备的。
常见方法：
boolean equals(Object obj):用于比较两个对象是否相同。
String toString(): 获取对象的字符串表现形式 类名@哈希值
getClass().getName()+"@"+Integer.toHexString(hashCode());
Class getClass():获取正在运行的对象所属的字节码文件的对象。也就是说如果Demo d = new Demo();
d.getClass():获取的就是d执行的对象所属的字节码文件Demo.class对象。

通常在自定义对象时，因为对象中都有自己特有的描述，
所以都会建立对象自身的特有比较方法，或者字符串表现形式。
也就是说，会覆盖Object中的方法。

/*
Demo d1 = new Demo();
Demo d2 = new Demo();
d1.getClass() == d2.getClass();
*/

class Demo //extends Object
{
public String toString()
{
this.getClass().getName()+"#"+Integer.toHexString(this.hashCode());
}
}

class Fu
{
void show(){System.out.println(“fu show”);}
}
class Zi extends Fu
{
void function()
{
super.show();
//this.show();
}
void show(){System.out.println(“zi show”);}
}

/*

class Computer
{
private MainBoard mb;

Computer()
{
	mb = new MainBoard();
}
public void play()
{
	mb.run();
}

}
*/

内部类：
内部类可以直接访问外部类中的成员，包括私有
外部类访问内部类，必须建立内部类方法
外部类变量名.内部类变量名 = 外部类对象.内部类对象

异常：程序在运行时出现不正常的情况
严重的Error类描述
异常的Exception类描述
只有Exception使用针对性的代码处理

代码：
try
{
需要被检测代码
}
catch（异常类 变量）
{
处理异常的代码，处理方式
}
finally
{
一定会执行语句
}

Exception e = new ArithmeticException();//catch后的变量赋值
e.getMessage(); //异常的信息
e.toString(); //异常名称：异常信息
以上两个方法有返回值
e.printStackTrace(); //异常名称，异常信息，异常出现位置，这个就是jvm默认的异常处理机制，打印异常的堆栈的跟踪信息

该功能有异常标识：
class Demo
{
int div()throws Exception//功能上通过throws关键字声明该功能有可能有问题
{

}

}
这种方法必须用try…catch…finally处理
或者：
public static void main(String[] args) throws Exception//抛出异常，让java虚拟机处理。

对多异常处理：
1.声明异常时，建议声明更为具体的异常
public static int dd()throws ArichmeticException，ArryIndexOutOfBoundsException//具体的异常
主程序加两个catch

try
{

}
catch(ArichmetchExceotion e)
{

}
catch(ArryIndexOutOfBoundsException e)
{

}

catch后写针对性的异常

2.对方声明几个异常，就对应几个catch块
多个catch块中异常出现继承，把父类放在最下面

建立catch处理时，catch中定义具体的处理方式

自定义异常：
针对项目中特有的问题。

class FushuException extends Exception
{

}
throw new FushuException(“写异常信息”)//手动通过throw关键字手动抛出自定义异常
此时的方法后也要写明()throws FushuException

自定义异常的自定义信息：
子类只要在构造时将异常信息传递给父类通过super语句，就可以通过getMessage函数获取信息了

继承Exception原因：
异常体系有一个特点：因为异常类和异常对象都被抛出。
他们都具备可抛性。这个可抛性是Throwable这个体系中独有特点。

只有这个体系中的类和对象才可以被throws和throw操作。

throws和throw的区别
throws使用在函数上。
throw使用在函数内。

throws后面跟的异常类。可以跟多个。用逗号隔开。
throw后跟的是异常对象。

Exception中特殊的异常，RuntimeException异常，如果在函数内容抛出该异常，函数上可以不用声明，编译一样通过。

如果在函数上声明了该异常。调用者可以不用进行处理。编译一样通过；

之所以不用在函数声明，是因为不需要让调用者处理。
当该异常发生，希望程序停止。因为在运行时，出现了无法继续运算的情况，希望停止程序后，
对代码进行修正。

包（package）
对类文件进行分类管理
给类提供多层命名空间
写在程序文件的第一行
类名的全称 ：包类.类名
包也是一种封装形式