Java入门教程笔记（六）

补充：
final关键词：
（1）修饰方法：方法在继承过程中保持不变（只读），虽然能够被继承，但是不能被Overriding。
（2）修饰类：被声明的类不能够作为super class

一、抽象方法

被abstract关键字修饰，且没有方法体的方法称为抽象方法。抽象方法不能够用private修饰
1.假如一个类含有一个或多个抽象方法，那么它就必须定义为“抽象”（abstract）的。
2.除了抽象的方法之外，抽象类还可以包含非抽象的数据以及方法。
3.一个抽象类（A）的所有的非抽象的后代都必须实现它（A）所定义的抽象方法。
4.一个类如果没有提供任何的抽象方法，也可以声明为抽象类。

二、Interface 接口
辅助实现多重继承

要理解接口，首先要理解以下语句

Student a = new Student("wckdzz",21,"male");

a并非是定义的Student类，而是指向Student类的指针

在C++中我们曾经想要实现以下功能

#include<iostream>
#include<cmath>
using namespace std; 
class shape
{
	public:
	 virtual double area(){}
};
class Circle:public shape
{
	private:
		double r;
	public:
		Circle(double a){r=a;}
		double area()
		{
			return 3.14*r*r;
		}
};
class Rectengle:public shape
{
	private:
		double l,h;
	public:
		Rectengle(double a,double b){l=a,h=b;}
		double area()
		{
			return l*h;
		}
};
class Triangle:public shape
{
	private:
		double x,y,z;
	public:
		Triangle(double a,double b,double c){x=a,y=b,z=c;}
		double area()
		{
			double p=(x+y+z)*0.5;
			return sqrt(p*(p-x)*(p-y)*(p-z));
		}
};
int n,opt;
double x1,x2,x3;
int main()
{
	shape* an[110];
	cin>>n;
	for(int i=1;i<=n;i++)
	{
		cin>>opt;
		if(opt==0)
		{
			cin>>x1;
			an[i] = new Circle(x1);
		}
		else if(opt==1)
		{
			cin>>x1>>x2;
			an[i] = new Rectengle(x1,x2);
		}
		else
		{
			cin>>x1>>x2>>x3;
			an[i] = new Triangle(x1,x2,x3);
		}
	}
	for(int i=1;i<=n;i++)
		cout<<an[i]->area()<<endl;
	return 0;
}

通过指向父类的指针，指向不同的子类，实现名称相同但内容不同的函数
以同样的写法写在Java里面的话：

//shape.java
package requestArea;

public abstract class shape {
	public abstract double area();
}
//Circle.java
package requestArea;

public class Circle extends shape {
	private double radius;
	public Circle(double r)
	{
		radius = r;
	}
	public double area()
	{
		return 3.14*radius*radius;
	}
}
//Rectangle.java
package requestArea;

public class Rectangle extends shape {
	private double length,height;
	public Rectangle(double l,double h)
	{
		length = l;
		height = h;
	}
	public double area()
	{
		return length*height;
	}
}
//Triangle.java
package requestArea;
import java.lang.Math;
public class Triangle extends shape {
	private double x,y,z;
	public Triangle(double a,double b,double c)
	{
		x=a;y=b;z=c;
	}
	public double area()
	{
		double p = (x+y+z)*0.5;
		return Math.sqrt(p*(p-x)*(p-y)*(p-z));
	}
}
//requreForArea.java
package requestArea;
import java.util.*;
public class requreForArea {

	public static void main(String[] args)
	{
		shape[] an = new shape[110];
		Scanner in = new Scanner(System.in);
		int n = in.nextInt();
		int opt;
		double x1,x2,x3;
		for(int i=1;i<=n;i++)
		{
			opt=in.nextInt();
			if(opt==0)
			{
				x1=in.nextDouble();
				an[i] = new Circle(x1);
			}
			else if(opt==1)
			{
				x1=in.nextDouble();
				x2=in.nextDouble();
				an[i] = new Rectangle(x1,x2);
			}
			else
			{
				x1=in.nextDouble();
				x2=in.nextDouble();
				x3=in.nextDouble();
				an[i] = new Triangle(x1,x2,x3);
			}
		}
		for(int i=1;i<=n;i++)
			System.out.println(an[i].area());
		in.close();
	}
}

也是可以的（好耶）
当然也可以用interface接口，写法如下：

//shape.java
interface shape
{
	public double area();
}
//
public class Circle implements shape
public class Rectangle implements shape
public class Triangle implements shape

只改这几部分的话，仍旧能实现我们预计的功能
md

把上面的代码当作是一个小练习吧
我们重新说回接口
接口的实现方法如上，interface之前可以用public修饰
Java接口（Interface），是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）
有两个及上的的类拥有相同的方法，但是实现功能不一样，就可以定义一个接口，将这个方法提炼出来，在需要使用该方法的类中去实现，就免除了多个类定义系统方法的麻烦

接口也可以继承（extends）
子接口继承父接口的所有的抽象方法和常量。
子接口可以增加自己的方法和常量
接口允许多重继承

三、Inner Class 内部类
在Class内部再声明一个类（可以在方法外部也可以在方法中）
可以用private修饰
对于驱动程序，内部类会比较方便

匿名类：

class Popcorn {
	public void pop() {
		System.out.println("popcorn");
	}
}

class Food {
	Popcorn p = new Popcorn() {
		public void pop() {
			System.out.println("anonymous popcorn");
		}
	}
}

匿名的内部类不能有构造方法，因为没有类名所以没法定义构造方法。
匿名类在定义类的同时创建了对象，所以匿名类只对应一个对象。
匿名类一般都是继承一个父类或者是实现一个接口。
如上例：该匿名类继承了父类Popcorn，并重写pop()方法
如下例：该匿名类实现Foo接口

class MyWonderfulClass {
	void go() {
		Bar b = new Bar();
		b.doStuff(new Foo() {
			public void foof() {
				System.out.println("foofy");
			} // end foof method
		}); // end inner class def, arg, and end statement
	} // end go()
} // end class
interface Foo {
	void foof();
}
class Bar {
	void doStuff(Foo f) { }
}

四、异常
1、异常实际上是导致正常指令流中断的一种事件
我们可以把异常理解为一种特殊的class

2、常见导致异常的错误：
（1）严重的硬件错误，如内存中某些芯片故障或者硬盘崩溃。
（2）需要使用系统中当前不可用的I/O设备
（3）试图用零去除
（4）试图通过超过边界的下标访问数组的元素
（5）整数溢出
（6）浮点数溢出
（7）试图打开不存在的文件以使用
（8）试图打破安全性，比如试图修改只读文件

3、异常捕获格式

try {
// 接受监视的程序块，在此区域可能产生异常
} catch (SomeExceptionType e) {
// 对SomeException出现时的处理
} catch (Exception e) {
// 对Exception出现时的处理
//一个try程序块后可以跟一个或多个catch程序块

处理除以0的异常

public class ExceptionTest{
	public static void main(String args[]){
		int b=0; int a;
		try { a=4/b;}
		catch(ArithmeticException e){
			System.out.println("divided by 0");}
		}
}

Java中已经定义的一些异常：

Unchecked Exception是指Error类和RuntimeException类及其他们的子类,在程序中可以不捕获Unchecked Error

Checked Exception是指除了Error类和RuntimeException类及其他们的子类之外的异常类
表示由于外界的因素造成的系统异常事件例如I/O错误，读取硬盘错误等，这一类异常在程序代码中是没有办法解决的
如果在代码中存在Checked Exception，必须要用try和catch程序块开处理这一类异常事件

不使用java内已经定义的异常时
我们可以使用throw语句：

throw <object  reference expression>;
//可以是Throwable及其子类的对象
//Throwable是Exception的父类

如果程序执行中遇到了throw语句则正常的流程中断，转入到catch程序块中处理异常

异常有一个统一的出口–finally{}程序块，finally内部的程序块一定会执行