补全下列代码
class MyExpection extends Expection{
String message;
MyExpection(String str){
【1】//把参数的引用传给message成员变量
}
public String getMessage() {
return message;//返回message成员变量
}
}
abstract class A {
abstract int f(int x, int y) throws MyException;
}
class B extends A{
int f(int x,int y)throws MyException{
if(【2】)//判断x、y都不大于100
【4】//抛出一个MyException对象，构造方法参数为“乘数超过100”
return x*y;
}
}
public class eClass{
public static void main(String args[]){
A a;
【5】//用B类上传转型对象为a赋值
try{
System.out.println(a.f(12,10));
【6】//调用f()方法并传入乘数110、1
}catch(MyExpection e){
e.printStackTrace;
}
}
}
输出效果：Myexception:乘数超过100
at B.f(eClass.java:20)
at eClass.main(eClass.java:30)
可以参考下
package test;
class MyExpection extends Exception{
String message;
MyExpection(String str){
message = str;//把参数的引用传给message成员变量
}
public String getMessage() {
return message;//返回message成员变量
}
}
abstract class A {
abstract int f(int x, int y) throws MyExpection;
}
class B extends A{
int f(int x,int y)throws MyExpection{
if(x < 100 && y < 100)//判断x、y都不大于100
throw new MyExpection("乘数超过100");//抛出一个MyException对象，构造方法参数为“乘数超过100”
return x*y;
}
}
public class eClass{
public static void main(String args[]){
A a;
a = new B();//用B类上传转型对象为a赋值
try{
System.out.println(a.f(12,10));
a.f(110, 1);//调用f()方法并传入乘数110、1
}catch(MyExpection e){
e.printStackTrace();
}
}
}
class MyExpection extends Exception{
String message;
MyExpection(String str){
this.message = str;
}
public String getMessage() {
return message;
}
}
abstract class A {
abstract int f(int x, int y) throws MyExpection;
}
class B extends A{
int f(int x,int y)throws MyExpection{
if(x <= 100 && y <= 100){
throw new MyExpection("乘数超过100");
}
return x*y;
}
}
public class eClass{
public static void main(String args[]){
A a;
a = new B();
try{
System.out.println(a.f(12,10));
a.f(110,1);
}catch(MyExpection e){
e.printStackTrace();
}
}
}
归并排序通过不断的将原数组进行拆分(通常拆分成左右两项)，一直到剩下一项，然后分别将拆分的子数组进行合并，此时，两个子数组已经是排好序的，所以合并排序只需要进行一趟排序即可完成，所以此类排序需要两个步骤：1.拆分原数组
2.合并子数组。因此此算法是经典的分治算法。