Java面向对象程序设计头歌答案面向对象程序设计java题库

转载

daleiwang 2023-09-30 15:42:01

文章标签 java java-ee 开发语言 System 文章分类 Java 后端开发

主题：`前面学的内容`，`面向对象（下）`

一、填空题

1、面向对象的三大特征是——，——和 ——。

继承、多态、封装。

2、面向对象程序设计的重点是——的设计，——是用来创建对象的模板。

类、类。

3、Java语言中，有一个类是所有类或接口的父类，这个类的名称是——。

Object类

4、面向对象程序设计语言支持两种形式的多态:——和——。

编辑时多态和运行时多态

5、在Java语言中, Java. lang包中定义了三种字符串类:——、——和——。

String、StringBuffer、StringBuilder.

二、判断题

1、Java中数组的元素可以是简单数据类型的量，也可以是某一类的对象。

对

2、this(和super(可以在static环境中使用，包括static方法和static语句块。

错

3、final是java中的修饰符，可以修饰类、接口、抽象类、方法和属性。

错，final不能修饰接口和抽象类

4、在Java中一个类只能实现-一个接口。

错，Java中一个类可实现多个接口

5、抽象类可以实例化，但不能被继承;最终类不能实例化，可以被继承。

错，抽象类不能实例化，可以被继承；而final类可以实例化，但不能被继承

三、选择题

1、类的定义必须包含在以下哪种符号之间（B ）

A、方括号[]

B、花括号{}

C、双引号“”

D、圆括号()

2、下面哪一个是正确的类的声明（ D ） A、 public void HH{…}

B、 public class Move()｛…｝

C、 public class void number{...}

D、 public class Car｛…｝

3、下列哪个叙述是正确的（ C ）

A、子类继承父类的构造方法。

B、abstract类的子类必须是非abstract类。

C、子类继承的方法只能操作子类继承和隐藏的成员变量。

D、子类重写或新增的方法也能直接操作被子类隐藏的成员变量。

4、下列关于静态成员的描述中，错误的是（ C）

A、静态成员都是使用static来说明的 B、静态成员是属于类的，不是属于某个对象的 C、静态成员只可以用类名加作用域运算符来引用，不可用对象引用 D、静态数据成员的初始化是在类体外进行的

5、以下对封装的描述正确的是( D )

A、只能对一个类中的方法进行封装，不能对属性进行封装

B、如果子类继承了父类,对于父类中进行封装的方法，子类仍然可以直接调用

C、封装的意义不大，因此在编码时尽量不要使用

D、封装的主要作用在于对外隐藏内部实现细节，增强程序的安全性

6、下列关于内部类的说法不正确的是 ( C )

A，内部类的类名只能在定义它的类或程序段中或在表达式内部匿名使用

B，内部类可以使用它所在类的静态成员变量和实例成员变量

C，内部类不可以用abstract修饰符定义为抽象类

D，内部类可作为其他类的成员，而且可访问它所在类的成员

7、(多选)下面哪些可以使用static关键字修饰？（ A、C、D）

A、成员变量

B、局部变量

C、成员方法

D、成员内部类

8、(多项)以下关于接口的说法中,正确的是( A、B、D )。

A.接口中全部方法都是抽象方法.所有方法必须是public访问权限

B. 接口中属性都使用public static final 修饰, 没有显式赋值时将使用默认值

C.接口可以有构造方法

D.一个类只能有一个父类,但可以同时实现多个接口

9、阅读以下Java代码

public class Person {
    publicvoidshow() {
        System.out.println("人类！");
    }
}

public class Student extends Person {
    publicvoidshow() {
        System.out.println("学生!");
    }
}

public class Doctor extends Person {
    publicvoidshow() {
        System.out.println("医生!");
    }
}

public class Temp {
    public static void main(String[] args) {
        Person per = newStudent();
        Person doc = newDoctor();
        per.show();
        doc.show();
    }
}

当程序运行后，输出结果正确的是（ A）

A、学生！

医生！

B、人类！

学生！

医生！

C、编译错误

D、运行错误

10、对于以下类:

class A {
}
class B extends A {
}
class C extends A {
}
public class Test {
    public static void main(String args[]) {
        A x = new A();
        B y =new B();
        C z = new C();
        //此处插入一条语句
    }
}

下面哪个语句可以放到插入行?( A )

A、x=y;

B、z=x;

C、z=(C)y;

D、 y=(A)y;

四、程序分析题

阅读下面的程序，分析代码是否能够编译通过，如果能编译通过，请列出运行的结果。否则请说明编译失败的原因。

代码一：

class A {
    private int secret = 5;

}

public class Test1 {

    public static void main(String[] args) {

        A a = new A();

        System.out.println(a.secret++);

    }

}

编辑无法通过，A类中secret被private修饰，而且没有设置相关的访问接口，因此在其他类中无法访问被private修饰的成员，从而造成编辑失败

代码二：

public class Test2 {

    int x = 50;

    static int y =200 ;

    public static void method() {

        System.out.println(x+y);

    }

    public static void main(String[] args) {

        Test2.method();

    }

}

编辑无法通过，x是非静态属性的成员变量，而在stasic修饰的方法中只能引用static修饰的方法或属性

代码三：

public class Outer {

    public String  name="Outer";

    private class Inner {

        String name="inner";

        void showName(){

            System.out.println(name);

        }

    }

    public static void main(String[] args) {

        Inner inner = new Outer().new Inner();

        System.out.println(inner.name);

    }

}

运行结果：inner

五、简答题

1、什么是值传递和引用传递？

值传递：值传递是指在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。
引用传递：所谓引用传递是指在调用函数时将实际参数的地址传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数。

2、什么是多态

多态：多态性（polymorphisn）是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。
实现多态，有二种方式，覆盖，重载。

3、什么是接口，为什么要定义接口

1.接口：我们把用于完成特定功能的若干属性组织成相对独立的属性集合。这种属性的集合就是接口。
2.接口的作用：由于定义接口与定义类非常相似。实际上完全可以把接口理解成为一种特殊的类，接口是由常量和抽象方法组成的特殊类。一个类只能由一个父类，但是它可以同时实现若干个接口。这种情况下如果把接口理解成特殊的类，那么这个类利用接口实际上就获得了多个父类，即实现了多重继承。与类定义相仿，声明接口时也需要给出访问控制符，不同的是接口的访问控制符只有public一个。用public修饰的接口是公共接口，可以被所有的类和接口使用，而没有public修饰符的接口则只能被同一个包中的其他类和接口利用。接口也具有继承性。定义一个接口是可以通过extends关键字声明该新接口是某个已经存在的父接口的派生接口，它将继承父接口的所有属性和方法。与类的继承不同的是一个接口可以有一个以上的父接口，它们之间用逗号分隔，形成父接口列表。新接口将继承所有父接口中的属性和方法。

4、抽象类和接口的区别

抽象类：抽象类是用来捕捉子类的通用特性的。它不能被实例化，只能被用作子类的超类。抽象类是被用来创建继承层级里子类的模板。
接口：接口是抽象方法的集合。如果一个类实现了某个接口，那么它就继承了这个接口的抽象方法。这就像契约模式，如果实现了这个接口，那么就必须确保使用这些方法。接口只是一种形式，接口自身不能做任何事情。
区别：抽象类中出了抽象方法还可以包含非抽象方法和属性，或者说抽象类就是多了抽象方法的普通类，但不能被实例化，必须被继承。接口中只能包含抽象方法和全局常量。

5、final关键字和static关键字的特点

1、为什么会有final 因为继承的出现提高了代码的复用性。但是有些类描述完成后不想被继承，或者来说有些类中的部分方法和功能是固定的不想让子类重写。这个时候就出现了final，final的意思是最终，不可变化的。 final的特点被final修饰的类不可以被继承，但是可以继承其他的类。被final修饰的方法不可以被重写被final修饰的变量是常量、这些变量只能被赋值一次被final修饰引用类型变量，不可变的是这个地址，对象的属性是可以修改的被final修饰的成员变量，需要在创建对象前赋值，否则会报错
2、static关键字特点被static修饰的成员变量是属于类，不属于对象。被static修饰的成员可以用类名直接访问
注意：静态内容是优先于对象存在的，只能访问静态，不能使用this/super。静态修饰的内容属于静态区。同一个类中静态成员只能访问静态成员。 main方法是静态的仅仅是程序的入口，可以放在任何一个类中，他不属于任何一个对象
另外如何定义静态常量：
public static final 数据类型变量名称= 值; 通常变更量名称都是大写，多个单词用下滑线连接
接口中每一个成员变量默认使用的就是 public static final修饰

六、编程题

1、（控制流程）打印水仙花数

水仙花数也被称为超完全数字不变数、自恋数、自幂数、阿姆斯壮数或阿姆斯特朗数，水仙花数是指一个 3位数，它的每个位上的数字的 3 次幂之和等于它本身（例如：1^3 + 5^3+ 3^3 = 15313+53+33=153）。

找到所有的水仙花并通过 System.out.println 语句打印所有的水仙花数，按从小到大的顺序输出。（打印时，每个水仙花数打印一行。）

public class Test{

public static void main(String[] args){

int i;

int a,b,c;

System.out.println("水仙花数为：");

for(i=100;i<1000;i++){

a=i%10;

b=i/10%10;

c=i/100;

if(i==a*a*a+b*b*b+c*c*c){

System.out.println(i);

}

}

}

}

2、（数组）二维数组

定义一个5X5的二维数组。然后使用随机数填充该二维数组。找出这个二维数组里，最大的那个值，并打印出其二维坐标。

0-100的随机整数的获取办法有多种，下面是参考办法之一:

(int) (Math.random() * 100)

public class Test{

public static void main(String[] args){

int i,j;

int a[][]=new int[5][5];

for(i=0;i<a.length;i++){

for(j=0;j<a[i].length;j++){

a[i][j]=(int)(Math.random()*100);

}

}

int max=a[0][0];

int row=0,colum=0;

System.out.println("二维数组：");

for(i=0;i<a.length;i++){

for(j=0;j<a[i].length;j++){

System.out.print(a[i][j]+"\t");

if(a[i][j]>max){

max=a[i][j];

row=i;

colum=j;

}

System.out.println("\n");

}

}

System.out.println("max:"+max);

System.out.println("maxIndex:["+row+","+colum+"]");

}
}

3、（字符串）

键盘录入一个字符串，把该字符串的首字母转成大写，其余为小写。(只考虑英文大小写字母字符)

package com.majunyi;
import java.util.Scanner;
import java.util.Arrays;

public class Test{

public static void main(String[] args){
Scanner string=new Scanner(System.in);
System.out.println("请输入一个字符串：");
String s=string.next();
char[] chs = s.toCharArray();
int i;
for(i=0;i<chs.length;i++){
    if(chs[i]>='A'&&chs[i]<='Z')
    {
        chs[i]+=32;
    }
    if(chs[i]>='a'&&chs[i]<='z')
    {
        chs[i]-=32;
    }
}
    System.out.println("处理后的字符串为：");
for(i=0;i<chs.length;i++){
    System.out.print(chs[i]);
}

}
    
}

键盘输入若干字符串，利用StringBuilder完成字符串反转。

package StringBuilder;
import java.util.Scanner;

public class Test{
  public static void main(String[] args) {
   Scanner sc = new Scanner(System.in);
   System.out.println("请输入一个字符串：");
   String line = sc.nextLine();
   String s = reverse(line);
   System.out.println("反转后的字符串：")
   System.out.println(s);

  }

  public static String reverse(String s){
 StringBuilder sb = new StringBuilder(s);
 sb.reverse();
 String ss = sb.toString();
  return ss;

  //return new StringBuilder(s).reverse().toString();
  }
}

4、（面向对象）

创建一个员工类(Employee)，其中包括： 1） 4个私有属性：员工姓名(name)、员工年龄(age)、员工职位(position)、工资(salary) 2）方法： Employee() ——给所有的属性指定初始值 setName（）——给name属性赋值 setAge（）——给age属性赋值，要求年龄必须在18岁以上，当年龄无效时，将年龄强制赋值为18 setPosition（）——给position属性赋值，只能是“售后服务”和“销售员”，如果不符合要求，则强制将职位赋值为“售后服务”。 setSalary（）——用于员工的工资：根据员工的年龄段不同，给工资属性赋值，具体要求：18-20岁之间，1000元，21-25岁之间，1500元，26-30岁之间，2000元，31-40岁之间，3000元，41-50岁之间，3500元，50岁以上,4000元 getName（）——返回name属性 getAge（）——返回age属性 getPosition（）——返回position属性 getSalary（）——返回salary属性

测试类TestEmployee，在该类中创建3个Employee对象，通过键盘输入给3个员工的名字、年龄、职位进行赋值，计算出每个员工的工资，显示出所有员工的信息

package com.majunyi;
import java.util.Scanner;


class Employee{
    private String name;
    private int age;
    private String position;
    private int salary;
    public Employee(){
        name="张三";
        age=18;
        position="售后服务";
        salary=1000;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        if (age<18){//判断年龄是否满足要求，不满足则强行赋值为18
            this.age=18;
        }
        else
        this.age = age;
    }

    public void setPosition(String position) {//判断是否为售后服务和销售员其中之一，若不是则强行规定为售后服务
        if ("售后服务".equals(position)==0&&"销售员".equals(position)==0){
            this.position="售后服务";
        }
        else
        this.position = position;
    }

    public void setSalary() {
        if(age>=18&&age<=20){
            salary=1000;
        }
        else if(age>=21&&age<=25){
            salary=1500;
        }
        else if(age>=26&&age<=30){
            salary=2000;
        }
        else if(aage>=31&&age<=40){
            salary=3000;
        }
        else if(age>=41&&age<=50){
            salary=3500;
        }
        else
            salary=4000;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public String getPosition() {
        return position;
    }

    public int getSalary() {
        return salary;
    }
    
}
public class TestEmployee{
    public stasic void main(String[] args){
        Scanner string=new Scanner(System.in);
        Employee stu[]=new Employee[3];//声明对象数组，并分配空间
        stu[0]=new Employee();
        stu[1]=new Employee();
        stu[2]=new Employee();
        String name;
        int age;
        String position;
        System.out.println("请输入三名员工姓名、年龄、职务：");
        for(int i=0;i<stu.length;i++){
            name=string.nextline;
            stu[i].setName(name);
            age=string.nextInt;
            stu[i].setAge(age);
            position=string.nextline;
            stu[i].setPosition(position);
        }
        for(int i=0;i<stu.length;i++){
            stu[i].setSalary();//计算工资
            System.out.println("姓名:"+stu[i].getName()+"\t年龄："+stu[i].getAge()+"\t职务："+stu[i].getPosition()
            +"\t工资："+stu[i].getSalary());
        }
    }
}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。