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

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

}