1.多态：某一类事物的多种存在形态。
2.多态的体现
a>父类的引用指向了自己的子类对象。Fu f = new Zi();
b>父类的引用也可以接收自己的子类对象。
3.多态的前提
a>必须是类与类之间有关系，要么是继承，要么是实现。
b>存在覆盖。
4.多态的利弊
a>利：多态提高了程序的扩展性。
b>弊：提高了扩展性，但是只能使用父类的引用访问父类的成员。
abstract classAnimal
{
abstract void eat();//父类定义了一个eat()抽象方法
}
class Dogextends Animal
{
void eat()//覆盖父类的eat()方法
{
System.out.println("啃骨头");
}
void lookHome()
{
System.out.println("看家");
}
}
class Catextends Animal
{
void eat()
{
System.out.println("吃鱼");//覆盖父类的eat()方法
}
void catchMouse()
{
System.out.println("抓老鼠");
}
}
class DuoTaiDemo
{
public static void main(String[] args)
{
Animal a = new Cat();//类型提升，向上转型。
method(new Cat());
method(new Dog());
}
public static void method(Animal a)
{
a.eat();
}
}
5.多态的应用
1>类型转换：只能在多态中进行转换。多态自始至终都是子类对象在做变化。
a>类型提升（向上转型）
Animal a = new Cat();
b>向下转型：转换完后可以调用子类对象自己特有的方法。
Animal a = new Cat();
Cat c = (Cat) a;//向下转换，转换完用c装着
6.多态中成员的特点
1>在多态中成员函数的特点：
在编译时期：参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过，如果没有编译失败。
在运行期：参阅对象所属的类中是否有调用的方法。
成员函数，编译看左边，运行看右边。
2>在多态中成员变量的特点：
无论是编译还是运行，都参考左边（引用型变量所属类）。
3>在多态中静态成员函数的特点;
无论是编译还是运行，都参考左边。
多态的出现更好的实现程序的扩展性。
内部类
1.定义：将一个类的定义在另一个类的里面，对里面的那个类就称为内部类。
2.访问特点：
1>内部类可以直接访问外部类中的成员，包括私有成员。
之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用。 格式：外部类名.this
2>外部类要访问内部类中的成员必须要建立内部类的对象。
3.访问格式
1>当内部类定义在外部类的成员位置上，而非私有，可以在外部其他类中。可以直接建立内部类对象。
格式：外部类名.内部类名变量名 = 外部类对象.内部类对象；
例： Outer.Inner in = new Outer().newInner();
2>当内部类在成员位置上，就可以被成员修饰符所修饰。
例：private：将内部类在外部类中进行封装。
static：内部类就具备static的特性，只能直接访问外部类中的static成员，出现访问局限。
3>在外部其他类中，怎么直接访问static内部类的非静态成员？
new 外部类名.内部类名().非静态成员; 例：newOuter.Inner().method()
4>在外部其他类中，怎么直接访问static内部类的static成员？
外部类名.内部类名.静态成员; 例：Outer.Inner.method()
注意：当内部类定义了static成员，则该内部类必须是static。
当外部类中的静态方法访问内部类，内部类也必须是静态的。
5>内部类定义在局部时(如函数内)
a>不可以被成员修饰符修饰
b>可以直接访问外部类中的成员，因为还持有外部类中的引用。但是不可以访问它所在的局部中的任意变量，只能访问被final修饰的局部变量。
内部类可以直接继承外部其他类
二：匿名内部类
1.匿名内部类其实就是内部类的简写格式
2.定义匿名内部类的前提：内部类必须继承一个类，或者实现接口。
3.匿名内部类的格式：
new 父类或者接口（）{定义子类的内容}
4.其实匿名内部类就是一个匿名子类对象。
5.匿名内部类中定义的方法最好不要超过3个。
三：异常机制
1.异常：就是程序在运行时出现不正常情况。
程序执行时，发生异常程序就结束，因此不可能同时发生几个异常。
2.异常的处理
try
{
需要被检测的代码;
}catch(异常类变量)
{
处理异常的代码;(处理方式)
}
/*finally代码块，定义一定执行的代码，通常用于关闭资源。即使前面有return。
但是有一种情况是不执行的：System.exit(0)在之前执行，则关闭虚拟机不会执 行finally块
*/
finally
{
一定会执行的语句;
}
3.对多异常的处理
a>声明异常时，建议声明更具体的异常。这样处理的可以更具体。
b>多个catch块，catch是至上而下执行的。对声明几个异常，就对应有几个catch块。如果多个catch块中的异常出现继承关系，父类异常catch块放在最下面。
4.自定义异常
class FuShuException extends Exceptiom //自定义异常继承Exception
{
FuShuException(String msg)
{
/*<3>因为在自定义异常的父类异常已经把信息都操作完了，
所以子类只要在构造时，将异常信息通过super()语句传递给父类。
那么就可以直接通过getmessage()方法获取自定义的异常信息。
*/
super(msg);
}
}
class Demo
{
/*<2>在函数内部手动throw抛出异常对象时，那么就要给对应的处理动作。
1.在函数内部try catch处理
2.在函数上声明让调用者处理，即throws继续向外抛异常
*/
int div(int a, int b)throwsFuShuException
{
if(b < 0)//分母为负数时异常处理
{
/*<1>在自定义异常时，需要用throw关键字手动抛出异常。
而且thorw后面跟的是自定义异常对象。
*/
throw new FuShuException(“出现除数是负数情况”);
}
return a/b;
}
}
class ExceptionDemo
{
public static void mian(String [] args)
{
Demo d = new Demo();
try
{
int x = d.div(4,-1);
}catch(FuShuException e)
{
System,out.println(e.toString());
}
}
}
自定义异常：
1>必须是自定义类继承Exception。或者RuntimeException
继承Exception的原因：异常体现有一个特点，是异常类和异常对象都被抛出。
它们都具备可抛性，这个可抛性是Throwable这个体系 中独有的特点。只有这个体系中的类和对象才可以被 throws和throw操作。
5.throws和throw的区别：
1>throws使用在函数上，throw使用在函数内。
2>throws后面跟的是异常类，可以跟多个，用逗号隔开，表示抛出多个异常。
throw后面跟的是异常对象。
当出现异常时throw抛出，此时程序结束，throw后语句不执行。因此throw在特殊情况下也是结束标识符。
6.RuntimeException运行时异常：Exception中的一个特殊子类异常
1>如果在函数内容抛出该异常，函数上可以不用声明，编译一样通过。
2>如果在函数上声明了该异样，调用者可以不用进行处理，编译一样通过。
当发生该异常时，程序停止。
自定义异常时，如果该异常的发生，无法再继续进行运算，就让自定义异常继承RuntimeException。
7.两种异常：
1>编译时被检测的异常。
该异常在编译时，如果没有处理，编译失败。
2>编译时不被检测的异常（运行异常，RuntimeException以及其子类）。
在编译时，编译器不检查，异常发生，程序停止。
8.异常的三种格式：
1>try{
}catch(){
}
2>try{
}catch(){
}finally{
}
3>try{
}finally{
}
catch是用于处理异常的，如果没有catch就代表异常没有被处理过。
9.异常在子父类覆盖中的体现
1>子类在覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法，只能抛出父类的异常或者该异常的子类。
2>如果父类方法抛出多个异常，那么子类在覆盖该方法时，只能抛出父类异常的子集。
3>如果父类或者接口的方法中没有异常的抛出，那么子类在覆盖方法时，也不可以抛出异常。如果子类方法发生了异常，就必须进行try处理，绝对不能抛。
一句话：子类抛出的异常必须“小于”父类的。
四：包
1.包的概述：
1>对类文件进行分类管理
2>给类提供了多层命名空间
3>写在程序文件的第一行
4>类名的全称是：包名.类名
5>包也是一种封装形式
2.包与包之间的访问
1>包与包之间进行访问，被访问的包中的类以及类中的成员，需要public修饰。
2>不同包中的子类还可以直接访问父类中被protected权限修饰的成员。
3>包与包之间可以使用的权限有两种：protected，public
|
| public | protected | default | private |
| 同一个类中 | 可以 | 可以 | 可以 | 可以 |
| 同一个包中 | 可以 | 可以 | 可以 |
|
| 子类 | 可以 | 可以 |
|
|
| 不同包中 | 可以 |
|
|
|
3.import
1>导入包中的类。
2>import pack.*：导入pack包中所有类。
建议不要写通配符“*”，需要用到包中哪个类，就导入哪个类。例：import pack.A
建议定义包名不要重复，可以使用反写url来完成定义，url是唯一的。
4.jar包
Java的压缩包。
使用jar包时，只要将jar包设置到classpath就可以使用。
jar -cf a.jar packa packb：将packa和packb建立一个名为a.jar的jar包。
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
