黑马程序员——面向对象（三）（多态和异常简述）
------" target="blank">Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------
一、多态概念
多态：事物存在的多种体现形态。
多态的体现：父类的引用指向了自己的子类对象，父类的引用也可以接收自己的子类对象。
多态的前提：必须是类与类之间有关系，要么继承，要么实现。
多态的优点：提高程序的扩展性。
多态的弊端：提高了扩展性，但只能使用父类的引用访问父类中的成员。
package 博客4_面向对象之多态;
abstract class Animal//创建猫和狗的共性类，都属于动物
{
abstract void eat();//都有吃的方法，但是吃什么东西不确定，所以是抽象方法
}
class Cat extends Animal
{
public void eat()
{
System.out.println("吃鱼");
}
public void catchMouse()
{
System.out.println("抓老鼠");
}
}
class Dog extends Animal
{
void eat()
{
System.out.println("吃骨头");
}
public void catchCat()
{
System.out.println("抓猫");
}
}
public class 多态Demo {
public static void main(String[] args) {
// TODO Auto-generated method stub
Animal ai = new Cat();//父类引用指向子类对象，是类型提升过程
ai.eat();
Animal ai_2= new Dog();
ai_2.eat();
Cat c = (Cat)ai;//想调用子类特有方法时，需要强制将父类引用转成子类类型，也称向下转型
c.catchMouse();
Dog d = (Dog)ai_2;
d.catchCat();
}
}在多态中成员函数的特点：在编译时期，参阅引用型变量所属的类中是否有调用的方法，如果有，编译通过。如果没有，则编译失败。在运行时期，参阅对象所属的类中是否有调用的方法。简言之，成员函数在多态调用时，编译看左边，运行看右边。
在多态中成员变量的特点：无论编译还是运行，都参考左边。
二、内部类
内部类：将一个类定义在另一个类的里面，对里面那个类就成为内部类（内置类，嵌套类）。
内部类访问规则：
1，内部类可以直接访问外部类中的成员，包括私有成员。因为内部类中持有外部类的引用---外部类名.this 。
2，外部类要访问内部类，必须建立内部类 对象。
3，内部类可以被私有。
package 博客4_面向对象之多态;
class Outer
{
private int x = 3;
class Inner//定义内部类
{
void fuction()
{
System.out.println(x);//内部类可以直接访问外部类成员，包括私有
}
}
void method()
{
Inner in = new Inner();//外部类访问内部类中的成员需要建立内部类对象
in.fuction();
}
}
public class 内部类 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Outer out = new Outer();
out.method();
}
}
内部类在成员位置上时，可以被成员修饰符所修饰。
如：
private：将内部类在外部类中进行封装。
static：内部类具备静态特性。
当内部类被static修饰后，只能直接访问外部类中的静态成员，出现了访问局限。
在外部其他类中，直接访问静态内部类的非静态成员格式：new Outer.Inner().function();
在外部其他类中，直接访问静态内部类的静态成员格式：Outer.Inner.function();
注意：
1，当内部类中定义了静态成员，该内部类则必须是静态的。
2，当外部类中的静态方法访问内部类时，内部类也必须是静态的。
当内部类作为局部成员时：
1，不可以被成员修饰符所修饰。
2，可以直接访问外部类中的成员，但不可以访问它所在的局部变量，只能访问被final修饰的局部变量。
匿名内部类：
1，匿名内部类是内部类的简写格式。
2，定义匿名内部类的前提是内部类必须是继承一个类或实现接口。
3，匿名内部类是一个匿名的子类对象（带内容的对象）。
4，匿名内部类中定义的方法不要超过3个。
匿名内部类的格式：new 父类或者接口（）{定义子类的内容}。
package 博客4_面向对象之多态;
abstract class AbsDemo
{
abstract void show();
}
class Outer_1
{
int x = 3;
public void fuction()
{
/*
* class Inner extends AbsDemo
* {
* void show()
* {
* System.out.println(x);
* }
* }
* */
new AbsDemo()//匿名内部类，等同上面的代码。
{
void show()
{
System.out.println(x);
}
}.show();
}
}
public class 匿名内部类Demo {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
}
}
异常：就是程序在运行时出现的不正常现象。
异常产生的由来：问题也是现实生活中的一个具体的事物，所以也可以通过java的类的形式对其进行描述，并封装成对象。
异常就是java对不正常情况进行描述后产生的对象体系---throwable
Throwable
----Error：对于严重的问题，java通过Error类进行描述。对于Error，一般不编写针对性的代码对其进行处理。
----Exception：对于不严重的问题，java通过Exception类进行描述。对于Exception可以使用针对性的处理方式进行处理。
对于异常的处理：java提供了特有语句进行处理。
try{需要被检测的代码}
catch（异常类 变量）{处理异常的代码（处理方式）}
finally{一定会被执行的语句；}
throws关键字：可以在函数上声明异常。便于提高代码的安全性，让调用者进行处理，否则编译失败。后面跟着异常类，可以用逗号隔开跟多个异常类。
throw关键字：在函数内使用，后面跟着异常对象。如RuntimeException。
对多异常的处理：
1，声明异常时，建议声明更为具体的异常，这样处理的可以更为具体。
2，对方声明几个异常，就对应几个catch代码块处理，不要定义多余的。如果几个catch代码块中的异常出现继承关系，则父类的要放在最下面。
3，用catch进行异常处理时，应定义具体的处理方式。
自定义异常Demo：
package 博客4_面向对象之多态;
class FuShuException extends Exception//自定义的异常类
{
private int value;
FuShuException(String mes,int value)
{
super(mes);//因为自定义异常继承于Exception，而且Exception在继承Throwable的时候就已经复写了他的方法，所以可以直接引用
this.value=value;
}
public int getValue() {
// TODO Auto-generated method stub
return value;
}
}
class Demo
{
int div(int a ,int b)throws FuShuException//函数内抛出异常时，函数上应声明该异常
{
if(b<0)
throw new FuShuException("负数异常！出现负数了！",b);//如果除数是负数，则抛出自定义异常
return a/b;
}
}
public class 自定义异常Demo {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Demo d = new Demo();
try
{
int x = d.div(4, -1);
System.out.println(x);
}
catch(FuShuException e)
{
System.out.println(e.toString());//打印对自定义异常的描述
System.out.println("错误的负数时："+e.getValue());
}
}
}