java练习 不对之处请斧正

不定项选择

1、错误的是：

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

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

发生覆盖的条件：

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

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

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

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

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

http://blog.youkuaiyun.com/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.youkuaiyun.com/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以内完数