黑马程序员————面向对象（继承，抽象类，接口，多态,异常）

继承

  继承的概念：在Java中，类的继承是指在现有类的基础上去构建一个新的类，构建出来的类被称为子类，现有类被称为父类，子类会自动拥有父类所有可继承的属性和方法。在程序中，如果想声明一个类继承另一个类，需要使用extends关键字。例如：

class Animal
{
	String name;
	void speak()
	{
	   System.out.println("动物");
	}
}
class Dog extends Animal
{
	public void speak()
	{
	   System.out.println("小狗");
	}
}
class Demo
{
	public static void main(String[] args)
	{
	   Animal ani=new Animal();
	   Dog dog=new Dog();
	   ani.speak();
	   dog.speak();
	}
}

注意：①在Java中。类只支持单继承，不允许多继承，也就是说一个类只能有一个直接父类。

    ②多个类可以继承一个父类。

    ③在Java中，多层继承是可以的，即一个类的父类可以再去继承另外的父类，例如C继承自B，B可以去继承A。

      ④在Java中，子类和父类是一个相对的概念，也就是说一个类是某个类的父类的同时也可能是某个类的子类。

（2）重写父类方法：在继承关系中，子类会自动继承父类的方法，但有时子类需要对继承的方法做一些修改，这就是重写父类方法。需要注意的是，子类重写的方法要和父类被重写的方法具有相同的方法名，参数列表和返回值类型

抽象类：

   在定义一个类时，常常需要定义一些方法来描述该类的行为特征，但有时这些实现方式是无法确定的。比如定义Animal类，动物都是要叫的，这是共性特征，但是不同的动物的叫的方式是不同的。针对上述问题，Java允许在定义方法时不写方法体，这样的方法就是抽象方法，抽象方法要用关键字abstract来修饰。当一个类中包含了抽象方法，该类必须用abstract来修饰，这样的类就是抽象类。

注意：在定义抽象类时，包含抽象方法的类必须声明为抽象类，但抽象类可以不包含任何抽象方法，只需要abstract修饰就行了。另外，抽象类是不能被实例化的，因为抽象类中含有抽象方法，抽象方法是没有实体的，不可以被调用。如果想调用抽象类中定义的方法，需要创建一个子类，在子类中将抽象类中的抽象方法进行实现。

例如：

abstract class Animal
{
	abstract void speak();
}
class Dog extends Animal
{
	public void speak()
	{
	   System.out.println("小狗");
	}
}
class Demo
{
	public static void main(String[] args)
	{
	   Dog dog=new Dog();
	   dog.speak();
	}
}

结果说明子类实现父类的抽象方法后，可以正常进行实例化，并通过实例化对象调用方法。

 

接口 ：

    如果一个类中所有的方法都是抽象的，则可以将这个类用另外一种方式来定义，即接口。在定义接口时，需要使用interface关键字来声明，例如：

interface Animal{

int ID = 1；

void breathe（）；

void run（）；

}

接口中定义的变量和方法都包含一些默认修饰符。接口中定义的默认方法默认使用“public abstract”来修饰，即抽象方法。接口中的变量默认使用“public static final”来修饰，即全局常量。由于接口中的方法都是抽象方法，因此不能通过实例化对象的方法来调用接口中的方法。此时需要定义一个类，并用implements关键字实现接口中的所有方法。

interface Animal
{
	 void run();
}
class Dog implements Animal
{
	public void run()
	{
	   System.out.println("小狗run");
	}
}
class Demo
{
	public static void main(String[] args)
	{
	   Dog dog=new Dog();
	   dog.run();
	}
}

在程序中，还可以定义一个接口使用extends关键字去实现另一个接口。

注意：

接口的方法都是抽象的，不能实例化对象。

当一个类实现接口时，如果这个类是抽象类，则实现这个接口的部分方法就行，否则要实现所有方法。

一个类通过implements关键字实现接口时，可以实现多个接口，被实现的多个接口之间用逗号隔开。

一个接口可以通过extends关键字继承多个接口，之间用逗号隔开。

一个类在继承另一个类同时还可以实现接口，此时，extends关键字必须位于implements之前。

多态：

   在设计一个方法时，通常希望该方法具备一定的通用性。例如动物都有一个叫的方法，但是每种动物叫的方法是不同的，因此可以在方法中接受一个动物参数的类型，在传入不同的动物参数就可以发出不同的叫声。在一个方法中，由于参数类型不同而导致执行效果各异的现象就是多态。在Java中为了实现多态，允许使用一个父类类型的变量来引用一个子类类型的对象，根据被引用子类对象特征的不同，得到不同的结果.

interface Animal
{
	 void speak();
}
class Dog implements Animal
{
	public void speak()
	{
	   System.out.println("狗叫");
	}
}
class Cat implements Animal
{
	 public void speak()
	{
	  System.out.println("猫叫");
	}
}
class Demo
{
	public static void main(String[] args)
	{
	   Animal a1=new Dog();
	   Animal a2=new Cat();
	   a1.speak();
	   a2.speak();
	}
}

 

将子类对象当做父类使用时不需要任何显示声明，但是此时不能通过父类变量去调用子类中的某些方法。如果想要调用，需要进行强制转换，例如：Cat cat = （Cat）animal；这样就可以调用子类的方法，但是也有可能出错，比如Dog类型的不能强制转换为Cat类型的，这是，Java又提供了一个关键字instanceof用来判断一个对象是否为某个类或者接口的实例或子类实例。

Object:

  在JDK中提供了一个Object类，它是所有类的父类，即每个类都可以直接或间接继承自该类。

常用的toString()方法所包含的基本信息：

getClass().getName()代表返回对象所属类的类名

hashCode()代表返回该对象的哈希值。

Integer.toHexString(hashCode())代表返回对象的哈希值用十六进制表示。

在实际开发中，通常希望对象的toString（）方法返回的不仅仅是基本信息，而是一些特有的信息，这是一般需要重写Object的toString（）方法实现。

异常：

  在程序运行的过程中，会发生各种各样的非正常情况，比如磁盘空间不足，被加载的类不存在等，针对这种情况，Java引入了异常，以异常类的形式对这些非正常的情况进行封装，通过异常机制对程序运行时发生的各种问题进行处理。 在Java中提供了大量的异常类，这些类都继承自java.lang.Throwable类。 Throwable有两个直接子类Error和Exception。其中Error代表程序中产生的错误， Exception代表程序中产生的异常。

Error类称为错误类，它表示Java运行时产生的内部错误或资源消耗的错误，是比较严重的，紧靠修改程序本身是不能恢复执行的。

Exception类称为异常类，它表示程序本身可以处理的错误，在开发Java程序中进行的异常处理，都是针对 Exception类及其子类。

try{ }   catch（）{ }  finally { }

其中的try代码块中编写的是可能发生异常的语句，catch代码块编写针对异常进行处理的代码。当try中的程序发生了异常，系统会将异常的信息封装成一个异常对象，并将这个对象传递给catch代码块，catch代码块需要一个参数指明他所能够接收的异常类型。需要注意的是，在try代码块中，发生异常语句后面的代码是不能够被执行的。

在程序中，有时我们希望其中的一些语句无论是否发生异常都要执行，这是我们就在后面加上一个finally代码块，把必须要执行的代码块放在其中。

throws：

Java中允许在方法后面使用throws关键字对外声明该方法有可能发生的异常，这样调用者在调用方法时，就知道了该方法有异常，并且必须在程序中对异常进行处理，否则编译错误。

格式：

修饰符  返回值类型  方法名（参数列表）throws ExceptionTyre1.....

通常我们将这种做法称为方法声明抛出一个异常。

运行时异常，编译时异常：

①Java中，Exception类中除了RuntimeException类及其子类都是编译时异常，Java编译器会对其就行检查，方式如下：

使用try...catch语句进行捕获

使用throws关键字声明抛出异常，调用者对其进行处理。

  ②RuntimeException类及其子类都是运行时异常。Java编译器不会对其进行检查，程序编译可以通过。运行时异常一般都是程序中逻辑错误引起的，在程序运行时无法恢复。比如数组角标越界异常等等。

 自定义异常

JDK中定义了大量的异常类，虽然这些异常类可以描述大部分异常情况，但总会遇到特殊的情况，为了解决这个问题，Java允许用户自定义异常，但必须继承自Exception类或其子类