devbox
羊村懒王
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

关于java面向对象的题目总结（自用）_下面implements用法正确的是()public class a extends b im

作者：羊村懒王 | 2024-03-01 18:42:42

赞

踩

下面implements用法正确的是()public class a extends b im

JavaSE_OOP技能考试

  1.  以下关于面向对象概念的描述中，不正确的一项是（B）。
A.在现实生活中，对象是指客观世界的实体 
B.程序中的对象就是现实生活中的对象 
C.在程序中，对象是通过一种抽象数据类型来描述的，这种抽象数据类型称为类（class） 
D.在程序中，对象是一组变量和相关方法的集合  
     //这道题B错误，那就意味着其他三个选项的内容可以作为对于面向对象概念的诠释；

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
  2.  public class Foo {
	int value;
	Foo(int value) {
		this.value = value;
	}
	public boolean equals(Object obj) {
		if (obj instanceof Foo) {
			Foo foo = (Foo) obj;
			return value == foo.value;
		} else {
			return false;
		}
    }
    运行下面程序段：
    ArrayList list = new ArrayList();
    HashSet set = new HashSet();
    list.add(new Foo(1));
    set.add(new Foo(1));
    System.out.println(list.contains(new Foo(1)) + ","
			+ set.contains(new Foo(1)));
//控制台输出的结果是( )。

//这道题主要考察的是set列表在调用contains方法时，会先先调用hashcode方法，判断两个值是否相等，在调用equals方法是否相等所以结果是true和flase

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
  3. public class A{…}
    public class B extends A implements D {…}
    public class C extends A {…}
    public interface D {…}
    变量a、b、c、d的定义如下：
    A a = new A();  B b = new B();  
    C c = new C();  D d = null;
    则下列语句会有编译错误的是( )。D
A.   
  a = b; //b是a的子类，属于向上转型，自动转型是对的
B.   
  d = b;  //b是实现接口d，所以也是向上转型
C.   
  d = (D)a; //D接口, 接口实现多继承, 一个类可以实现多个无关紧要接口，因为题目要求是编译错误，这个在编译的过程中并不会报错。
D.   
  c = (C)b; //b，c之间没有关系，所以错误


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
  4. class COne {
        public void f() {
        System.out.println("COne.f");
        }
    }
 
    class CTwo extends COne{
	public void f() {
		System.out.println("CTwo.f");
        }  
    }

    class CThree {
	public void g(COne one) {
		System.out.println("g(Cone)");
		one.f();
    }

    public void g(CTwo two) {
	System.out.println("g(Ctwo)");
	two.f();
        }
    }
    public class Main {
	public static void main(String[] args) {
		COne one = new CTwo();
        CThree three = new CThree();
		three.g(one);
        }
    }
    //控制台输出的结果是( )
//COne one = new CTwo();属于是向上转型，将CTwo对象向上转型给COne对象名是one，所以该对象，表面类型时COne，真实类型时CTwo。如果该对象被当做参数传递那么就会使用表面类型，如果调用子类的重写方法则会使用真实类型，所以最后会输出
// g(Cone)，使用表面类型传递传输，在重载方法里面使用COne参数对象的方法
//CTwo.f，在重载方法里面one.f()是对象名调用子类的重写方法，使用真实类型所以是CTwo.f

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
  5. class Foo {
	private int value = 5;
	public Foo() {
	System.out.println("Foo()");
	System.out.println(value);
        }
    }

    class Bar extends Foo{
	private int value = 10;
	public Bar() {
	System.out.println("Bar()");
	System.out.println(value);
        }
    }

    public class Main {
	public static void main(String[] args) {
	Bar bar = new Bar();
        }
    }
    //控制台输出的结果是( )。
//new Bar（）;就会调用Bar对象的无参构造方法，然后在无参构造方法的第一行省略了super（）；调用了父类的无参构造方法，所以第一行的父类无参构造方法会先实现因此输出结构为
//Foo() 
// 5
// Bar()
// 10 

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
  6. //实现Point类的equals方法，具体逻辑为：“成员变量x和y分别相等的Point对象被视为相等”。
    public class Point {
	private int x;
	private int y;
		...
	public boolean equals(Object obj) {
		//<填入代码>
	}
    }
//填入代码的那一行应该填什么能够满足题目的要求
//判断两个变量是否相等的Point对象，那么首先应该判断是否为Point对象可以用关键字instanceof判断数据类型是否相等，然后判断两个值是否相等因此答案为
//if(!(obj instanceof Point)) return false;
//    if(((Point)obj).x == this.x && ((Point)obj).y == this.y){
//         return true;
//    }
//            return false; 


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
  7. 下面说法正确的是A
A.   
  一个接口可以继承另外一个接口 
B.   
  一个类只能实现一个接口 //可以实现多个无关紧要的接口
C.   
  Java语言支持多继承 //只支持单继承或者多重继承
D.   
  抽象类中的非抽象方法不可以调用其抽象方法 //可以调用，具体的应用场景，就是子类实现了这个抽象类然后在其他类中调用


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
  8. 下面描述正确的是：D
A.   
  str是字符串变量，“java”.equals(str) 和 str.equlas("java")在任何时候都是等价的 //错误，当str为空时，会报空指针异常，这个时候就不会等价了
B.   
  成员访问修饰符按照可访问的范围由大到小的顺序是 public  default protected private //错误protected在不同包下的子类也可以访问，范围比缺省要大一点
C.   
  abstract 和 final 共同修饰一个类时，final应该放在abstract 的前面 //错误，一个是必须继承，一个是不能继承，本就自相矛盾，无法在一起就不存先后之分了
D.   
  当某一个类的int类型常量值（用static final修饰）经过修改并重新编译后。用到的该常量的其他类也必须重新编译后才能用的新修改后的值 


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
  9. 运行下面程序段：
    Calendar c = Calendar.getInstance();
      c.set(Calendar.YEAR, 2008);
      c.set(Calendar.MONTH, 1);
      c.set(Calendar.DATE, 32);	
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy/M/dd");
    System.out.println(sdf.format(c.getTime()));
    控制台输出的结果是（  ）。
//因为月份是固定12个月，所以是按数组存放的，0-11，所以1代表的2月份又因为2008年2月份是润年所以有29号，32天减去29天余3天，2月份进一，所以最后的答案应该是2008/3/03

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
  10. //下面各选项可以在A的子类中使用的是（）AC
class A {
protected int method (int a,  int b) {
return 0;
}
}
A.   
  public int method (int a,  int b) { return 0; } 
B.   
  private int method(int a,  int b) { return 0; } 
C.   
  private int method(int a,  long b) { return 0; } 
D.   
  public short method(int a,  int b) { return 0; } 
//首先子类继承父类，然后重写父类的方法，修饰符是可以改变的，改变的规则是>=父类修饰符的返回，范围修饰符的范围从大到小依次是public protected default private，所以A是可行的，但是C方法中的参数类型已经改变了，所以C方法跟父类方法不是用一个方法了，在子类中也可以使用，也是符合题意的要求

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
  11. 下列代码执行的结果是：
class Base
{
void test() { 
System.out.println("Base.test()");
}
}
public class Child extends Base {
void test() {
System.out.println("Child.test()");
}
public  static void main(String[] a) {
Child anObj = new Child();
Base baseObj = anObj;
baseObj.test();
} 
}
//Child anObj = new Child();
//Base baseObj = anObj;这两行代码是代表向上转型
//所以baseonj的表面类型时Base，真实类型则是Child
//baseObj.test();调用子类的重写方法，这个时候使用的真实类型
//所以等价于anObj.text();因此结构Child.test()

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
  12. class  HasStatic{ 
2．    private  static  int  x=100； 
3．    public  static  void  main(String  args[  ]){ 
4．        HasStatic  hs1=new  HasStatic(  ); 
5．        hs1.x++; 
6．        HasStatic  hs2=new  HasStatic(  ); 
7．        hs2.x++; 
8．        hs1=new  HasStatic( ); 
9．        hs1.x++; 
10．       HasStatic.x--; 
11．       System.out.println(“x=”+x); 
12．   } 
13．} 
//最后x的值是多少
//因为x是被static修饰的所以被称为类属性，意味着所有此类的对象都使用这个共同的类属性，所以x一次+1,+1,+1,-1结果为102

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
  13. 关于java.lang.String类，以下描述正确的一项是（ A  ）
A.   
  String类是final类故不可以继承； 
B.   
  String类是final类故可以继承； 
C.   
  String类不是final类故不可以继承； 
D.   
  String类不是final类故可以继承； 
//关于这个题目首先是知道String是否为final修饰的类，
//其次如果是final修饰又能不能继承
//观察源码可以知道String类是被final修饰的类
//如果被final修饰的类将不能够被继承，被final修饰的方法将不能够被子类重写，被final修饰的常量将不能被修改；

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
  14. 下列关于interface的说法正确的是：(  D  ) 
A.   
  interface中可以有private方法 //错误，接口就是从来实现的，被private修饰则不能被子类实现
B.   
  interface中可以有final方法 //错误，被final修饰，则不能被子类继承
C.   
  interface中可以有方法实现//错误，接口本来就是用来被实现了的，自己不能实现方法； 
D.   
  interface可以继承其他interface//可以，接口的继承同样也使用关键字extends
    

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
  15.  class Person { 
           private int a; 
           public int change(int m){return m;} 
          } 
      public class Teacher extends Person{ 
           public int b; 
           public static void main(String arg[]){ 
             Person p = new Person(); 
             Teacher t = new Teacher(); 
             int i; 
             // point x 
            } 
          } 

/*
下面哪些放在// point x行是正确的？
A.   
  i = b;被private修饰的属性，只能在本类中被访问，并且main方法是除外的，因main方法是特殊的，他是方法的入口。故错误
B.   
  i = p.a; 同上只能在本类中方法错误
C.   
  i = p.change(30); 正确，可以调用public修饰的方法，并且参数的返回类型也与i的类型一致
D.   
  i = t.b;  正确，被public修饰可以使用对象名.属性名访问
*/


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
  16. //下列选项中放置于“《插入代码》”处会编译出错的是C
interface IFace{}
class CFace implements IFace{}
class Base{}
public class ObRef extends Base{
    public static void main(String argv[]){
      ObRef ob = new ObRef();
      Base b = new Base();
      Object o1 = new Object();
      IFace o2 = new CFace();
     //《插入代码》
     }
}
/*
A.   
  o1=o2; //正确object类是所有类的父类，所以属于向上转型，自动转型正确
B.   
  b=ob; //ObRef继承了base类，所以同上也属于向上转型，正确
C.   
  ob=b; //反过来属于向下转型，需要强制转换错误，正确写法：ob=(ObRef)b
D.   
  o1=b; //同A，向上转型
*/

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
  17. Abstract method cannot be static. True or False ?A
A True
B False
//直接翻译原文意思不难看出：
//抽象方法不能够被static修饰，对还是错的
//显然是对的，抽象方法是必须给继承的，如果被static修饰将矛盾的
//同样抽象方法也不能够被final private修饰，违反本身的意愿

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
  18. //What will be the output when you compile and execute the following program.
class Base
{
void test() {
System.out.println("Base.test()");
}
}
public class Child extends Base {
void test() {
System.out.println("Child.test()");
}
static public void main(String[] a) {
Child anObj = new Child();
Base baseObj = (Base)anObj;
baseObj.test();
}
}
/*Select most appropriate answer.
A Child.test()
Base.test()
B Base.test()
Child.test()
C Base.test()
D Child.test()*/
//Child anObj = new Child();
//Base baseObj = (Base)anObj;
//属于向上在转型，可以自动转换，甚至可以省略（Base）
//所以baseObj的表面类型时Base，真实类型时Child
//baseObj.test();所以当他调用子类的重写方法时，使用的是真实类型
//因此结构为 Child.test()，D


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
  19. 下列关于修饰符混用的说法，错误的是（D ）：
A．abstract不能与final并列修饰同一个类
    //正确，一个是必须被继承，一个是不能继承，当然不能一起出现
B．abstract类中可以有private的成员
    //正确，抽象类中可以有，抽象方法，非抽象方法，构造方法，属性，而属性被什么修饰不做要求;拓展接口中只能包含*常量*和*抽象方法*，其他都不可
C．abstract方法必须在abstract类中
    //正确，在编译器中如果在非抽象类中写一个抽象方法会马上报错，会让你将这个类改成抽象类
D．static方法中能处理非static的属性
    //错误，静态方法使用静态资源，而不能使用非静态的资源


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
  20. 下列说法正确的有（C）
A． class中的constructor不可省略
    //错误，可以省略，如果你不写，会自动给一个无参构造的没有方法的构造方法，但是你如果写了，那么就不会在自动给
B． constructor必须与class同名，但方法不能与class同名
    //前半句是对的，普通方法也可以同名
C． constructor在一个对象被new时执行
    //正确，当被new就是调用构造方法，所以构造方法一般用来初始化属性
D．一个class只能定义一个constructor
    //错误，可以定义多个，可以根据开发的需求自己写需要的构造方法


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
  21. //使用final修饰的变量将变成常量，其中不能再被改变；使用final修饰的方法将无法被子类重载；使用final修饰的类将无法再被其他类继承。
	//TRUE

    • 1
    • 2
  22. //抽象方法不能含有方法体，并且必须定义在抽象类中。
    //TRUE

    • 1
    • 2
  23. //抽象类是指在class前加使用abstract关键字修饰，且可以存在抽象方法和普通方法的类。
	//TRUE

    • 1
    • 2
  24. //接口中只有常量，没有变量；只有抽象方法，并且全部都是public方法。	//TRUE

    • 1
  25. //抽象类和接口都不能实例化，都没有构造方法。
	//FLASE
//确实都不能实例化，但是抽象方法有构造方法

    • 1
    • 2
    • 3
  26. //接口并不要求实现类和接口在概念本质上一致的，仅仅是实现了接口定义的约定或者能力而已。接口定义了“做什么”，而实现类负责完成“怎么做”，体现了功能（规范）和实现分离的原则。
	//TRUE

    • 1
    • 2
  27. //内部类作为外部类成员，权限修饰符和其他成员一样，可声明为private、默认、protected或public。
	//TRUE

    • 1
    • 2
  28. //匿名内部类适合创建那种只需要使用一次的类，它可以实现一个或多个接口，或者继承一个父类。
	//TRUE

    • 1
    • 2
  29. //垃圾回收机制回收任何对象之前，总会先调用它gc( )方法，该方法是Object类提供的方法。不要主动调用某个对象的该方法，应该交给垃圾回收机制调用。
	//FLASE
//其中错误在GC是由System提供的

    • 1
    • 2
    • 3
  30. //final修饰的方法不能被重写，但可以被重载
	//TRUE

    • 1
    • 2
  31. //抽象方法的类必须是抽象类，同样抽象类也必须包含抽象方法
	//FLASE
//抽象类可以不包含抽象方法

    • 1
    • 2
    • 3
  32. //抽象类不能被new，抽象类的构造方法也不能被调用
	//FLASE
//抽象类确实不能被实例化，但是构造方法被子类继承就可以调用了

    • 1
    • 2
    • 3
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/羊村懒王/article/detail/176091
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号