实验四 类的继承
实验目的
理解抽象类与接口的使用；
了解包的作用，掌握包的设计方法。
实验要求
掌握使用抽象类的方法。
掌握使用系统接口的技术和创建自定义接口的方法。
了解 Java 系统包的结构。
掌握创建自定义包的方法。
实验内容
（一）抽象类的使用
1.设计一个类层次，定义一个抽象类--形状，其中包括有求形状的面积的抽象方法。 继承该抽象类定义三角型、矩形、圆。 分别创建一个三角形、矩形、圆存对象，将各类图形的面积输出。
注：三角形面积s=sqrt(p(p-a)(p-b)*(p-c)) 其中，a,b,c为三条边，p=(a+b+c)/2。
实验代码：
package o;
import java.util.Scanner;
abstract class Shapes
{
public abstract void area();}
class Triangle extends Shapes{
private double a,b,c;
private double p;
Triangle(double a, double b, double c, double p){
this.a = a;
this.b = b;
this.c = c;
this.p = (a+b+c)/2;}
public void area()
{
System.out.println(Math.sqrt(p*(p-a)*(p-b)*(p-c)));
}
}
class Rectangle extends Shapes{
private double h,g;
Rectangle(double h, double g){
this.h = h;
this.g = g;
}
public void area() {
System.out.println(h*g);
}
}
class Cricle extends Shapes{
private double r;
Cricle(double r){
this.r=r;
}
public void area()
{
System.out.println(Math.pow(r,2)*Math.PI);
}
}
public class a{
public static void main(String[] args)
{
Scanner boniu=new Scanner(System.in);
System.out.println("triangle length a：" );
double a=boniu.nextDouble();
System.out.println("triangle length b：" );
double b=boniu.nextDouble();
System.out.println("triangle length c：" );
double c=boniu.nextDouble();
Triangle triangle=new Triangle(a,b,c,(a+b+c)/2);
System.out.println("area of triangle：");
triangle.area();
System.out.println("length of rectangle h：");
double h=boniu.nextDouble();
System.out.println("width of rectangle g：");
double g=boniu.nextDouble();
Rectangle rectangle=new Rectangle(h,g);
System.out.println("area of rectangle：");
rectangle.area();
System.out.println("radius of circle：");
double r=boniu.nextDouble();
Cricle cricle=new Cricle(r);
System.out.println("area of circle：");
cricle.area();
}
}
实验截图：
2.编程技巧
(1) 抽象类定义的方法在具体类要实现；
(2) 使用抽象类的引用变量可引用子类的对象；
(3) 通过父类引用子类对象，通过该引用访问对象方法时实际用的是子类的方法。可将所有对象存入到父类定义的数组中。
（二）使用接口技术
1.定义接口Shape，其中包括一个方法size（）,设计“直线”、“圆”、类实现Shape接口。分别创建一个“直线”、“圆”对象，将各类图形的大小输出。
实验代码：
package o;
import java.util.Scanner;
interface Shape
{
void size();}
class line implements Shape
{
private double length;
line(double length) {
this.length=length;
}
public void size(){
System.out.println(length);
}
}
class cirlce implements Shape{
private double radius;
cirlce(double radius){
this.radius=radius;
}
public void size(){
System.out.println(Math.PI*2*radius);
}
}
public class a{
public static void main(String[] args)
{
System.out.println("line length");
Scanner dd=new Scanner(System.in);
double length=dd.nextDouble();
line line=new line(length);
System.out.println("line size：");
line.size();
System.out.println("radius of circle");
double radius=dd.nextDouble();
cirlce cirlce=new cirlce(radius);
System.out.println("ciecumference：");
cirlce.size();
}
}
实验截图：
2.编程技巧
(1) 接口中定义的方法在实现接口的具体类中要重写实现；
(2) 利用接口类型的变量可引用实现该接口的类创建的对象。
总结
抽象类和抽象方法的特点
①抽象类和抽象方法必须用abstract关键字来修饰，抽象方法没有方法体，即不能有{};
②抽象类中不一定要有抽象方法，即也可以都是非抽象方法或两者并存，但是拥有抽象方法的类一定要定义为抽象类；
③抽象类不能被实例化，但是抽象类依然有构造方法，抽象类的构造方法用于子类访问父类数据的初始化。
④抽象类的子类可以是抽象类，但如果不是抽象类，必须重写抽象类中定义的所有抽象方法。
抽象类成员的特点
①成员变量：可以为常量（例如final修饰的常量），也可以为变量；
②静态成员变量：可以有，可以被继承，但是不会被重写
③构造方法：上面提到过，可以有，用于子类访问父类时数据初始化；
④成员方法：可以是抽象的成员方法（子类必须要实现重写的），也可以是非抽象的成员方法
⑤静态成员方法：抽象类中可以有静态成员方法，可以被继承但不能被子类重写
抽象关键字abstract和其他关键字的冲突关系
①不能和private一起使用：private修饰的方法不被继承，而抽象的方法必须要继承，所以会冲突报错。
②和static一起使用无意义：static修饰的方法可以通过类名去访问，而抽象的方法没有实现方法体，所以无意义。
③不能和final一起使用：final修饰的方法不被重写，而抽象的方法必须被非抽象子类重写，所以会报错。
常见的异常类型
Exception 异常层次结构的根类
ArithmeticException 算数错误情形
ArrayIndexOutOfBoundsException 数组下标越界
NullPointerException 尝试访问null对象成员
ClassNotFoundException 不能加载所需的类
InputMismatchException 欲得到的数据类型与实际输入的类型不匹配
IllegalArgumentException 方法接受到非法参数
ClassCastException 对象强制类型转换出错
NumberFormatException 数字格式转换异常
System.err.println();这种输出方式可以输出错误的消息，在控制台呈现红色。
System.out用于正常的输出，也就是程序真正想输出的内容。而System.err用于出错信息的输出，也就是本来不期待看到的东西。
在写异常处理的时候，一定要把异常范围小的放在前面，范围大的放在后面，Exception这个异常的根类一定要刚在最后一个catch里面，如果放在前面或者中间，任何异常都会和Exception匹配的，就会报已捕获到...异常的错误
Q：java try catch 异常后还会继续执行吗？
问了室友后得知 A：catch 中如果你没有再抛出异常 , 那么catch之后的代码是可以继续执行的 , 但是try中 , 报错的那一行代码之后 一直到try结束为止的这一段代码 , 是不会再执行的。
//代码1
public static void test() throws Exception {
throw new Exception("参数越界");
System.out.println("异常后"); //编译错误，「无法访问的语句」
}
//代码2
try{
throw new Exception("参数越界");
}catch(Exception e) {
e.printStackTrace();
}
System.out.println("异常后");//可以执行
//代码3
if(true) {
throw new Exception("参数越界");
}
System.out.println("异常后"); //抛出异常，不会执行
若一段代码前有异常抛出，并且这个异常没有被捕获，这段代码将产生编译时错误「无法访问的语句」。如代码1；
若一段代码前有异常抛出，并且这个异常被try…catch所捕获，若此时catch语句中没有抛出新的异常，则这段代码能够被执行，否则，同第1条。如代码2；
若在一个条件语句中抛出异常，则程序能被编译，但后面的语句不会被执行。如代码3
