（40）异常、多态、|与||的分析结果题目
①考查对catch和finally的理解
public static void func()
{
try
{
throw new Exception();/*类内写编译异常对象，要么有trycatch,要么方法上声明，
* 此处都没有，所以编译异常
*/
}
finally
{
System.out.println("B");
}
}
public static void main(String[] args) {
// TODO Auto-generated method stub
/*Rectangle re=new Rectangle(-3,2);
re.area();
}
*/
try {
func();
System.out.println("A");
}
catch(Exception e){
System.out.println("C");
}
System.out.println("D");
}
//若代码修改后（public static void func()throws Exception
），运行发生异常，执行结果：BCD(注意A不会执行)
}
②继承中构造函数执行问题（子类的实例化过程）
public class Test {
Test(){
System.out.println("Test");
}
}
public class Demo extends Test {
Demo(){
super();//若不写，则默认调用，也可以显式的写出
System.out.println("Demo");
}
public static void main(String[] args) {
new Demo();
new Test();
}
}
结果为：Test Demo Test
③接口指向子类对象
public interface A {
}
public class Demo {
public static void main(String[] args) {
A a=new Test();//接口类型指向子类对象(多态)，必须是接口有的方法才能使用
System.out.println(a.func);
}
}
编译失败！！ 因为A接口中并未定义func方法，func方法是子类特有的。
③多态父类指向子类对象
覆盖
public class Test {
boolean show(char a) {
System.out.println(a);
return true;
}
}
public class Demo extends Test {
boolean show(char a) {
System.out.println(a);
return false;
}
public static void main(String[] args) {
int i=0;
Test t=new Demo();
Demo d=new Demo();
for(t.show('A');t.show('B')&&(i<2);t.show('C')) {
i++;
d.show('D');
}
}
}
输出：A B
因为t.show('B'),调用的是Demo的方法返回值为false④接口指向子类对象
public interface A {
}
public class Test implements A {
public String test() {
return "yes";
}
}
public class Demo {
static A get() {
return new Test();
}
public static void main(String[] args) {
A a=get();//A a=new Test();
System.out.println(a.test());
}
}
编译不通过！修改方法：①在接口中定义public String test();方法②将a强制转换为Test对象：Test t=(Test)a; System.out.println(t.test());
⑤子类构造函数默认执行父类的某个构造函数
public class Test implements A {
int i=0;
public Test(String a) {
System.out.println("A");
i=1;
}
public Test() {
System.out.println("B");
i+=2;
}
}public class Demo extends Test {
public Demo(String a) {
//super();默认
System.out.println("C");
i=5;
}
public static void main(String[] args) {
int i=4;//根本没有用到
Test t=new Demo("A");
System.out.println(t.i);
}
}
main中的i和对象中的i不是同一个i
分析：当执行Test t=new Demo("A");创建子类对象时，执行构造函数时，先执行父类的public Test()构造函数，输出B,此时i=2
然后执行子类的构造函数，输出C i=5
输出：B C 5
⑥覆盖和重载
public class Test {
int show(int a,int b) {
return 0;
}
}
子类中可以有以下的方法吗？
public int show(int a,int b) //可以，因为覆盖
{
return 0;
}
private int show(int a,int b)//不可以，子类覆盖父类，必须保证子类函数权限大于等于父类函数权限。此处private权限小
{
return 0;
}
private int show(int a,long b)//可以，重载，没有覆盖
{
return 0;
}public short show(int a,int b) //The return type is incompatible with Test.show(int, int),既不是重载，也不是
覆盖，造成了二义性
{
return 0;
}
static int show(int a,int b) //不可以，静态只能覆盖静态
{
return 0;
}
⑦
多态成员变量特点：
无论编译和运行，都参考左边（引用型变量所属的类）
public class Test {
int num=4;
}
public class Demo extends Test {
int num=5;
void show () {
System.out.println("showzi");
}
public static void main(String[] args) {
Test t=new Demo();
System.out.println( t.num);
}
}
⑦补充代码
public interface A {
public abstract void show();
}
public interface B {
public abstract void add(int a,int b);
}
public class Test implements A,B {
//补充代码，实现Demo中的功能
}
public class Demo {
public static void main(String[] args) {
Test t=new Test();
t.add(3, 4);
t.show();//输出两个数相加的和
}
}
思路一：因为要让一个没有参数的函数输出两个数的和，可以将这两个数设为这个类中的私有变量，那么成员方法都都可以访问私有变量。再由t.add(3,4)可知，应该通过这个函数调用来给这个对象赋值，即替代构造函数的作用。实现代码如下：
private int a,b;
public void show() {
System.out.println(a+b);
}
public void add(int a,int b) {
this.a=a;
this.b=b;
}思路二：对思路一一个拓展，让sum来存储a+b，设置sum私有成员，在show中打印sum即可。
private int a,b，sum;
public void show() {
System.out.println(sum);
}
public void add(int a,int b) {
this.a=a;
this.b=b;
sum=a+b;
}⑧子类构造函数执行过程
class Super
{
int i=0;
public Super(String s)
{
i=1;
}
}
class Demo extends Super
{
public Demo(String s)
{
i=2;
}
public static void main(String[] args)
{
Demo d=new Demo("yes");
System.out.println(d.i);
}
}
//编译失败，因为父类中缺少空参数的构造函数。
//或者子类应该通过super语句指定要调用的父类中的构造函数。⑨对覆盖、重载理解，在继承中不要出现二义性
class Super
{
public int get(){return 4;}
}
class Demo15 extends Super
{
public long get(){return 5;}
public static void main(String[] args)
{
Super s=new Demo15();
System.out.println(s.get());
}
}
编译失败，因为子类父类中的get方法没有覆盖。但是子类调用时候不能明确返回的值是什么类型。
所以这样的函数不可以存在子父类中。
10.
class Demo
{
public static void func()
{
try
{
throw new Exception();//一定抛出异常
System.out.println("A");
}
catch(Exception e)
{
System.out.println("B");
}
}
public static void main(String[] args)
{
try
{
func();
}
catch(Exception e)
{
System.out.println("C");
}
System.out.println("D");
}
}
编译失败，因为打印"A"的输出语句一定执行不到。
记住：throw 单独存在，下面不要定义语句，因为执行不到。例如：return下不能定义语句
与下面的代码作区分：
class Demo
{
public static void main(String[] args)
{
try
{
showExce(); //调用这个方法可能出现问题，当不出现问题时，可打印“A”
System.out.println("A");
}
catch(Exception e)
{
System.out.println("B");
}
finally
{
System.out.println("C");
}
System.out.println("D");
}
public static void showExce()throws Exception
{
throw new Exception();
}
}11.静态变量+异常处理
public class Demo {
public static String output="";
public static void foo(int i) {
try {
if(i==1) {
throw new Exception();
}
output+="1";
}
catch(Exception e) {
output+="2";
return ;//finally还会执行，output+="4";不会执行
}
finally {
output+="3";
}
output+="4";
}
public static void main(String[] args) {
foo(0);
System.out.println(output);//134
foo(1);
System.out.println(output);//13423
}
考点①output是String类型，output+=“1”《==》output=output+“1”；是字符串相连，而不是相加
考点②output静态，当调用foo(0),已经将output修改成134了，全局局静态变量修改了。
12.求圆数组的半径的最大值
public class Circle {
private static double pi=3.14;
private double radius;
public Circle(double r) {
radius=r;
}
public static double compare(Circle [] cir) {
//求数组的最大值
double max=cir[0].radius;
for(int i=0;i<cir.length;i++) {
if(cir[i].radius>max)
max=cir[i].radius;
}
return max;
}
}
public class Demo {
public static void main(String[] args) {
Circle cir[]=new Circle[3];
cir[0]=new Circle(1.0);
cir[1]=new Circle(8.0);
cir[2]=new Circle(3.0);
System.out.println("最大的半径为："+Circle.compare(cir));
}
}
13|和||区别
|：第一个表达式无论真假，第二个表达式均会执行
||：当第一个表达式为真时，第二个表达式不执行。
public class Demo {
private static int j=0;
private static boolean methodB(int k) {
j+=k;
return true;
}
public static void methodA(int i) {
boolean b;
b=i<10|methodB(4);
b=i<10||methodB(4);
}
public static void main(String[] args) {
methodA(0);
System.out.println(j);
}
}
输出：4
浙公网安备 33010602011771号