java练习 不对之处请斧正

不定项选择

1、错误的是:

A、覆盖包括成员方法的覆盖和成员变量的覆盖                                 

分析:覆盖 (override):也叫重写,就是在当父类中的某些方法不能满足要求时,子类中改写父类的方法。当父类中的方法被覆盖了后,除非用super关键字,否则就无法再调用父类中的方法了。

发生覆盖的条件:

1、“三同一不低” 子类和父类的方法名称参数列表返回类型必须完全相同,而且子类方法的访问修饰符的权限不能比父类

2、子类方法不能抛出比父类方法更多的异常。即子类方法所抛出的异常必须和父类方法所抛出的异常一致,或者是其子类,或者什么也不抛出

3、被覆盖的方法不能是final类型的。因为final修饰的方法是无法覆盖的。

4、被覆盖的方法不能为private。否则在其子类中只是新定义了一个方法,并没有对其进行覆盖。

5、被覆盖的方法不能为static。所以如果父类中的方法为静态的,而子类中的方法不是静态的,但是两个方法除了这一点外其他都满足覆盖条件,那么会发生编译错误。反之亦然。即使父类和子类中的方法都是静态的,并且满足覆盖条件,但是仍然不会发生覆盖,因为静态方法是在编译的时候把静态方法和类的引用类型进行匹配。

http://blog.csdn.net/iamluole/article/details/7977259  //覆盖 隐藏 重载

所以A错

B、成员方法的覆盖是多态的一种表现形式                                                                              

多态的定义:指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。(发送消息就是函数调用)多态有两种表现形式:重载和覆盖

http://www.cnblogs.com/chenssy/p/3372798.html  //多态详解

Java实现多态有三个必要条件:继承、重写、向上转型。

C.子类可以调用父类中被覆盖的方法                                                                                      

super就是调用父类的方法。

D、任何方法都可以被覆盖                                                                            

如构造方法mian方法等

——>AD

2、正确的是:

A、instanceof是用来判定某个类是否抽象类                                                                                    

java 中的instanceof 运算符是用来在运行时指出对象是否是特定类的一个实例。instanceof通过返回一个布尔值来指出 

B、final关键字修饰的成员变量不许初始化                                                                                 错

C、接口方法都是抽象方法jdk1.8以前 并且没有方法体                        对

D、继承一个抽象类我们必须实现抽象类的抽象方法                           错

继承抽象类的子类若为抽象类则不须

E、向上转型过程中,父类子类有同名字的成员方法(非静态)访问子类该方法;父子有相同名字成员变量,访问子类成员变量                                        错

前半句对了,后半句父子有相同名字成员变量访问父类成员变量

F、内部类访问外部类方法,不用创建外部类对象直接访问外部类方法           错

定义在类内部的类有两种情况:一种是被static关键字修饰的,叫做静态内部类,另一种是不被static关键字修饰的,就是普通内部类。在下文中所提到的内部类都是指这种不被static关键字修饰的普通内部类。静态内部类虽然也定义在外部类的里面,但是它只是在形式上(写法上)和外部类有关系,其实在逻辑上和外部类并没有直接的关系

普通内部类与外部类的逻辑关系:

1 内部类对象的创建依赖于外部类对象;

2 内部类对象持有指向外部类对象的引用。

上边的第二条可以解释为什么在内部类中可以访问外部类的成员。就是因为内部类对象持有外部类对象的引用。

但是

1、内部类可以随意获取外部类一些属性方法

2、内部类访问外部类方法要实例化外部类对象

G、内部类的变量不能设置为static也不能设置为final                          错

静态内部类可以

http://blog.csdn.net/fgakjfd/article/details/5282646  //静态内部类与非静态内部类区别

H、多态的变量常用来作为参数传入或者作为返回值返回                       对

——>CH

3、不正确的是:

A.不能和abstract一起使用的修饰符有staticfinal public                         错

abstract不能与static finalstatic的话,抽象类是不能实例化的,反推不能调用;而定义为final就不能重写;此外不能为private    ;但是abstract可以定义为public

B、抽象类之间是继承关系,接口之间也是                                   对

 接口与接口之间应该也是继承的一种

这个选项逻辑本身就不清楚。1、抽象类可以继承接口 2、接口不能继承抽象类

C、接口不能存在普通方法和常量                                           错

接口只能由抽象方法不能有普通方法(jdk1.8以前,1.8+可以定义普通方法defalut static )

接口不能有变量,只能有常量 

D、局部内部类可以用publicprivate 修饰                                   错

成员内部类可以用是四种修饰符修饰

局部内部类不用修饰符修饰(你可以把局部内部类看做局部变量)

E、接口不可以直接实例化,抽象类可以                                     错

接口和抽象类都不可以直接实例化

——>ACDE

4、正确的是:

A、instanceof是一个二元操作符,作用是判断左边对象是否右边类的实例,返回布尔型

         instanceof运算符是用来在运行时指出对象是否是特定类的一个实例。instanceof通过返回一个布尔值来指出,这个对象是否是这个特定类或者是它的子类的一个实例。                                                                                                                                                                       错

B、private protectedstatic 都不可以修饰接口                                             对

C、this.属性名访问的是本类中属性,如本类没有就从父类中继续查找            对

D、对象是类的抽象化                                                    错

类是对象的抽象化反了

E、接口中可以有常量                                                                                                                                   对

——>BCE

5、正确的是:

对于方法内形参

A、必须定义多个形参

B、可以没有

C、至少有一个

D、只能是简单变量

——>B

6、正确的是:

A、对于局部内部类不能再class前加任何权限修饰符                                对

B、只要没有定义不带参数的构造函数,jvm都会为类自动生成一个默认的             错

定义了有参数构造函数,就不会自动给生成了

C、向上转型中,父与子有相同名字普通成员方法,访问子类成员方法                对

D、单例模式中构造函数用private修饰,声明私有,这样就不能在类的外部使用new关键字创建实例对象了                                                            对

——>ACD

7、

public classt7 extendsS{

public finalvoidmb_method(inti){

   System.out.println(i);

}

   public static void main(String[] args) {

      // TODO Auto-generated method stub

    t7 demo01= newt7();

    demo01.mb_method();

    demo01.mb_method(2);

}}

class S{

   public final void mb_method(){

      System.out.print("1");

   }

}

分析:S中mb_method();方法是final定义的不能被重写  而且t7中的mb_menthod();参数都跟S中的不同(重写返回类型修饰符可以不一样,方法名字参数跟父类一样)所以第一个调用demo01.mb_method();其实是子类对没重写的父类方法的调用

所以输出12

——>A

8、正确的是:

A、抽象方法是一种功能契约,不实现抽象方法就无法构造对象                    对 

B、接口中的抽象方法只能是public的,而抽象类中的抽象方法可以用其他权限修饰       

        接口里的抽象方法若无修饰符则默认添加publicabstract                                                       对    

C、类是对象的构造模型,刻画了对象中的所有信息                              对

D、抽象方法不能用final来修饰,可以用static修饰   

不能用static  private final修饰                                                 错

E、对计算公式中已经不需要更改的数学函数,常用public  static final 修饰          对

F、若类中有final abstract 修饰的方法,必须实现该方法才能构造对象                   错

G、引用是对象的名字,引用值是对象的起始地址                                       对——>ABCEG

9、错误的是:

A、抽象类必须被子类继承 ,子类在某些情况下可以不必覆写抽象类中全部方法      对

B、 向上转型后,拥有相同名字的普通成员变量,访问的是子类里面的              错

变量是父类的,普通方法子类的,静态方法父类

C、super主要功能是完成子类调用父类的内容,且只能放在子类构造方法的第一行    错?

Super调用构造方法放子构造第一行 ,其他的不必 如super.s();

D、接口方法必须定义为public访问权限,并且方法只能是抽象方法(jdk1.8前)        错?   

——>B

10、错误的是:

A、instanceof 是一个二元操作符 ,只用来判断左边对象是否右边类的实例,返回的是

布尔类型                                                                   错

B、成员内部类可以使用任何修饰符,可以定义常量和静态变量

成员内部类可以用四种修饰符;可以static;可以定义常量 不得定义静态变量         错

C、this属性名访问的是本类中的属性,如果本类没有就从父类中继续查找            对

D、在成员方法的内部类叫局部内部类,可以访问外部类属性和使用任何修饰符,但是

使用局部内部类方法时,必须实例化内部类对象                                   对

——>AB

11、正确的有:

A、接口只能做方法申明,抽象类中可以做方法申明也可作方法实现                   对

B、抽象类中抽象方法只能申明不能实现,abstract void abc();不可写作abstract void abc(){};

{}是方法体的一部分,抽象方法没有方法体                                        对

C、抽象方法要被实现所以不能是静态的也不能是私有的                            对

D、接口内只能有公共方法,1.8+后也可有普通方法和成员变量                       对

E、类实现接口利用关键字implement完成                                         错

——>ABCD

12、不正确的是:

A、拥有抽象方法的类为抽象类                                                                                                   对

B、抽象类的方法是抽象方法                                                   错

抽象类里可以有抽象方法也可以有普通方法

C、继承抽象类的子类为抽象类                                                 错

   抽象类的子类可能为抽象类,里面还有未实现的抽象方法;也可以为实现了所有抽象方法的普通类

D、实现接口的类为抽象类                                                     错

可以为抽象类也可以为普通类

——>BCD

13、正确的是:

A、java程序的main方法必须写在类里面                                         对

Main方法也是方法,必须写在类里

B、java程序中可以有多个main方法                                              错

Main方法相当于程序入口 ,一个程序只能有一个

C、java程序中类名必须与文件名一样                                             错

Public修饰的类与文件名字一样

D、java程序的main方法中如果只有一条语句可以不用{}括起来  

                                                                            错

E、在类中声明一个整数数组作为成员变量,如若没有给他赋值,数值元素值为空       错

是为零不是为空 

F、数组本身是一个对象

——>AF

14、

public classt14 extendsB{

 

   public t14(String s) {

      super(s);

      System.out.println("D");

   }

   public static void main(String[] args) {

      new t14("C");

   }

}

class B{

   public B(String s){

      System.out.println("B");

   }

}

         分析:new t14(“c”);中的c是参数 而t14继承B ,t14new了对象会调用父类构造(当然是参数相同那个)

——>BD

15、正确的是:

A、try块不可以省略

B、可以使用多重catch块

C、finally块可以省略

D、catch块和finally块可以同时省略

——>ABC

16、对自定义异常描述正确的是:

A、自定义异常必须继承Exception

B、自定义异常可以继承自Error

C、自定义异常可以更加明确定位异常出错的位置和给出详细出错信息

D、程序中已经提供了丰富异常类,自定义异常没有意义

——>AC

17、


public class T11 {
public int div(int a,int b)
{
try
{
return a/b;
}catch(NullPointerException e)
{System.out.println("ArithmeticException");}
catch(ArithmeticException e)
{System.out.println("ArithmeticException");}
catch(Exception e)
{System.out.println("Exception");}
finally
{
System.out.println("finally");
}
return 0;
}

public static void main(String[] args) {
// TODO Auto-generated method stub
T11 demo=new T11();
System.out.println("商是:"+demo.div(9, 0));
}

}

——>B

18、

package jks0326;

 

public classt18 {

   publicstaticvoidmain(String[] args){

//    Manbody= new Man().new Body();

      Man body =new Body();

      body.method(body.a);

   }

}

class Man{

   int a=20;

   public void method(int a){

      a+=10;

      System.out.println(this.a);

   }

}

class Body extendsMan{

   int a =30;

   public void method(){

      a=a+10;

      System.out.println(this.a);

   }

}

分析:向上转型中父类子类成员变量一样,访问父类的

——>A

19、classStaticStuff{                  

Staticint x=10;

Static{x+=5}

Publicstatic void main(String args[])

{

System.out.println(“x=”+x);

}

Static {x/=3;}

}

C、编译通过执行结果为:x=5

——>C

20、正确的是:

A、抽象类可以被实例化                                                                                                                             错

B、如果一个类中有一个方法被声明为抽象的,那么这个类必须是抽象类             对

C、抽象类的方法必须都是抽象的                                               错

D、声明抽象类必须带有关键字abstract                                          对

——>BD

                                                     

程序分析

1、

package jks0326;

 

public classDemo01 {

   {

      System.out.println("Demo01");

   }

   static{

      System.out.println("Demo01.static");

   }

   public static void main(String[] args) {

      Chinesechinese= newChinese();

   }

}

 

class Chinese{

   {

      System.out.println("Chinese");

   }

   static{

      System.out.println("Chinese static");

   }

   public Chinese(){

      this.cry();

      System.out.println("构造函数");

   }

   static void cry(){

      System.out.println("静态方法");

   }

}

分析:Demo01没有生成本类的对象,不调用它的构造块

Demo01.static

Chinese static

Chinese

静态方法

构造函数

2、

package jks0326;

 

public classLeso {

   public static void main(String args[]){

      Le.show();

      Lel =new Le(5,6);

      l.show(2);

      Le.show();

   }

}

class Le{

   public static int i;

   static{++i;}

   public Le(){

     

   }

   public Le(int i,int j){

      this.i=j;

   }

   void show(int i){

      this.show();

      System.out.println(i++);

   }

   static void show(){

      System.out.println(++i);

   }

}

——>2728

3、

4、

package jks0326;

 

public classTest {

   public static void main(String[] args) {

      Personp1 =new Person();

      p1.name="李雷";

      p1.age=12;

      Personp2 =null;

      p2=p1;p2.age=14;

      p1.tell();

      p2.tell();

      p2.name="韩梅梅";

      System.out.println("age"+p1.age+p2.age);

   }

}

class Person{

   Stringname;

   int age;

   public void tell(){

      System.out.println("name"+name+"age"+age);  }

}

 

name李雷age14

name李雷age14

age1414

 

编程题

1、二分法查找数组int[]{10,20,30,40,50,60}某元素位置

2、一个数恰好等于它的因子之和则这个数为“完数”,如6=1+2+3  找出1000以内完数

        

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

  • 2
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值