黑马程序员——面向对象（三）（多态和异常简述）

------<a href="http://www.itheima.com"
target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

一、多态概念

多态：事物存在的多种体现形态。

多态的体现：父类的引用指向了自己的子类对象，父类的引用也可以接收自己的子类对象。

多态的前提：必须是类与类之间有关系，要么继承，要么实现。

多态的优点：提高程序的扩展性。

多态的弊端：提高了扩展性，但只能使用父类的引用访问父类中的成员。

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());
}
}

}