java 对象extend 继承重写属性

文章目录

• 判断题
• 单选题
• 程序填空题
• 函数题

• jmu-Java-03面向对象基础-覆盖与equals
• 从抽象类shape类扩展出一个圆形类Circle

• 编程题

• jmu-Java-03面向对象-06-继承覆盖综合练习-Person、Student、Employee、Company
• jmu-Java-04面向对象进阶--02-接口-Comparator

判断题

如果一个类的声明中没有使用extends关键字，这个类被系统默认为是继承Object类。（T）
解释：在Java中，如果一个类的声明中没有使用extends关键字指定父类，那么这个类会默认继承Object类。Object类是Java中所有类的根类，它位于java.lang包中，包含了一些基本的方法，如equals()、hashCode()、toString()等。

构造方法可以调用本类中重载的构造方法和它的父类的构造方法。（T）
解释：在Java中，构造方法可以调用本类中重载的构造方法和它的父类的构造方法。这种调用构造方法的方式称为构造方法的重载和构造方法的链式调用。

Java只支持单继承，也就是说子类只能有一个直接父类 。（T）

Object类是所有其它类的直接或间接父类。（T）

设类B是类C的父类，语句B x1=new C( ); 是正确的。（T）

单选题

类Teacher和Student是类Person的子类,下面的代码中最后一句语句的运行结果是 ( C ).

Person p;
Teacher t;
Student s;
//p,t and s are all non-null.
if(t instanceof Person)  {s=(Student)t;}

A.编译时正确，但运行时错误
B.将构造一个Student对象
C.表达式是错误的
D.表达式是合法的

作者 郑如滨
单位 集美大学
以下程序运行结果是（A）

public class Test extends Father{
    private String name="test";
    public static void main(String[] args){
        Test test = new Test();
        System.out.println(test.getName());
    }
}
class Father{
    private String name="father";
    public String getName() {
        return name;
    }
}

A.father
B.编译出错
C.test
D.运行出错，无输出

作者 郑如滨
单位 集美大学
下列选项中关于java中super关键字的说法错误的是（B）
A.super关键字是在子类对象内部指代其父类对象的引用
B.super关键字不仅可以指代子类的直接父类，还可以指代父类的父类
C.子类可以通过super关键字调用父类的方法
D.子类可以通过super关键字调用父类的属性

作者 殷伟凤
单位 浙江传媒学院
下面描述中正确的是？（B）
A.创建子类的对象时，先调用子类自己的构造方法，然后调用父类的构造方法。
B.子类无法继承父类的构造方法。
C.子类无条件地继承父类不含参数的构造方法。
D.子类必须在自己的构造方法中用super关键字显式地调用父类的构造方法。

作者 周雪芹
单位 山东理工大学
关于关键字instanceof的说法不正确的是：（C）。
A.它不能作为标识符名称出现
B.它用来表示某变量所指向的对象是否是另一种类型的实例
C.

Scanner sc=new Scanner(System.in);
boolean b=sc instanceof String;
//这种用法是正确的

D.

Scanner sc=new Scanner(System.in);
boolean b=sc instanceof Object;
//这种用法是正确的

作者 周雪芹
单位 山东理工大学
有如下程序代码，程序编译(执行)的结果为：（B）

class A {
 int v1 = 10;
 int v2 = 10;
 public A() {
 }
 public void m1() {
  System.out.println("A m1");
 }
 public void m2() {
  System.out.println("A m2");
 }
}

class B extends A {
 int v2 = 20;
 int v3 = 20;
 public B() {
 }
 public void m2() {
  System.out.println("B m2");
 }
 public void m3() {
  System.out.println("B m3");
 }
}
public class Main {
 public static void main(String[] args) {
  B b = new B();
  b.m1();
  b.m2();
  b.m3();
  System.out.println(b.v1);
  System.out.println(b.v2);
  System.out.println(b.v3);
 }
}

A.

B m1
B m2
B m3
20
20
20

B.

A m1
B m2
B m3
10
20
20

C.

A m1
B m2
B m3
20
20
20

D.

A m1
B m2
B m3
20
10
20

作者 周雪芹
单位 山东理工大学
以下关于继承的叙述正确的是（C）。
A.在Java中类只允许单一继承
B.在Java中,一个类只能实现一个接口
C.在Java中，一个类不能同时继承一个类和实现一个接口
D.在Java中，接口也具有单继承性

作者 殷伟凤
单位 浙江传媒学院
在某个类中存在一个方法：void getSort(int x),以下能作为这个方法的重载的声明的是 ©
A.public get (float x)
B.int getSort(int y)
C.double getSort(int x,. int y)
D.void get(int x, int y)

分数 2
作者 周雪芹
单位 山东理工大学
下面程序的输出结果为：（A）。

class A {
 double f(double x, double y) {
  return x * y;
 }
}

class B extends A {
 double f(double x, double y) {
  return x + y;
 }
}

public class Test {
 public static void main(String args[]) {
  A obj = new B();
  System.out.println(obj.f(4, 6));
 }
}

A.10.0
B.24.0
C.2.0
D.11.0

分数 2
作者 周雪芹
单位 山东理工大学
在下面的代码中，若要在子child类中对父类的addvalue方法进行重写，下面对于child类中的addvalue方法的声明哪个是正确的：（A）。

class father {
 public int addvalue(int a, int b) {
  int s = a + b;
  return s;
 }
}

class child extends father {

}

A.public int addvalue(int i,int j)
B.void addvalue(int a,int b)
C.void addvalue(double i)
D.int addvalue(int a)

作者 崔振宇
单位 山东科技大学
下列关于抽象类的说法哪一个是错误的。（B）
A.含抽象方法的类为抽象类
B.抽象类能创建(new)实例
C.子类有未实现父类的抽象方法时仍为抽象类
D.子类实现所有抽象方法时不再是抽象类

作者 殷伟凤
单位 浙江传媒学院
下面类的定义，哪个是合法的抽象类定义。（C）
A.class A { abstract void unfinished() { } }
B.class A { abstract void unfinished(); }
C.abstract class A { abstract void unfinished(); }
D.public class abstract A { abstract void unfinished(); }

作者 郑如滨
单位 集美大学
以下对接口描述错误的有（D）
A.接口没有提供构造方法
B.接口中的方法默认使用public、abstract修饰
C.接口中的属性默认使用public、static、final修饰
D.接口不允许多继承

作者 李妙妍
单位 沈阳师范大学
给定以下代码，请问下列选项中哪个是正确的？（D）

public interface Top{
  void twiddle(String s);
}

A.

public abstract class Sub implements Top{
  public abstract void twiddle(String s){ }
}

B.

public class Sub implements Top{
  public void twiddle(Integer i){ }
}

C.

public class Sub implements Top{
  void twiddle(String s){ }
}

D.

public class Sub implements Top{
  public void twiddle(String s){ }
  public void twiddle(Integer i){ }
}

作者 郑如滨
单位 集美大学
多态的表现形式有 （A）
A.重写
B.继承
C.抽象
D.封装

作者 殷伟凤
单位 浙江传媒学院
已知类的继承关系如下：

class Employee;

class Manager extends Employee;

class Director extends Employee;

则以下语句哪个能通过编译？ (A)。
A.Employee e = new Manager();
B.Director d = new Manager();
C.Director d = new Employee();
D.Manager m = new Director();

程序填空题

本题目要求两个类Sum和Pro分别实现接口OneToN。Sum类求整数1至n的和，Pro求整数1至n的积。

interface OneToN{
int disp(int n);
}
class Sum implements OneToN//代码在这
{   // 继承接口
public int disp(int n){      // 实现接口中的disp方法
int s = 0,i;
for(i = 1;i <= n;i ++)  s += i;
return s;
}    
}
class Pro implements OneToN//代码在这
{   // 继承接口
public int disp(int n){      // 实现接口中的disp方法
int m = 1,i;
for(i = 1;i <= n;i ++)  
 m *= i;//代码在这
return m;
}
}
public class Main{
public static void main(String args[]){
int n = 10;
Sum s = new Sum();//代码在这
Pro p = new Pro();//代码在这

System.out.println("sum of1 to n = " + s.disp(n));
System.out.println("pro of 1to n = " + p.disp(n));
}
}

函数题

jmu-Java-03面向对象基础-覆盖与equals

有Person类，Company类，Employee类。

其中Employee类继承自Person类，属性为：

private Company company;
private double salary;

现在要求覆盖Employee类的equals方法，判定两个Employee对象是否相等，请见如下判断方法：

1.其继承自父类Person的属性值都相等，其company属性对象equals返回true，且其salary也相等。

2.salary是double型，比较时，使用DecimalFormat df = new DecimalFormat(“#.##”);使salary保留两位小数，然后再进行比较。

注意：要考虑company为null的情况。

函数接口定义：

public boolean equals(Object obj)

输入样例：
此题无输入样例。main方法中已经包含多种不同的测试情况，下面的输出就是这多种测试情况的输出。

输出样例：

false
true
false
true
false
true
false

Java代码：

//Java代码
public boolean equals(Object obj) {
        //直接比较引用的地址码是否相同
		if (this == obj) return true;
        //判断传入的参数是否为null
		if (obj == null) return false;
        //判断父类的属性是否相同
    	if (!super.equals(obj)) return false;
        //浮点数的比较和company为null的情况的辨析
		DecimalFormat df = new DecimalFormat("#.##");
		Employee other = (Employee) obj;
        if (company == null && other.company == null) 
        	return df.format(salary).equals(df.format(other.salary));
        else if (company == null || other.company == null) return false;
		return company.equals(other.company)
				&& df.format(salary).equals(df.format(other.salary));
	}

从抽象类shape类扩展出一个圆形类Circle

请从下列的抽象类shape类扩展出一个圆形类Circle,这个类圆形的半径radius作为私有成员，类中应包含初始化半径的构造方法。

public abstract class shape {// 抽象类

public abstract double getArea();// 求面积

public abstract double getPerimeter(); // 求周长
}

主类从键盘输入圆形的半径值，创建一个圆形对象，然后输出圆形的面积和周长。保留4位小数。

圆形类名Circle

裁判测试程序样例：

class Circle extends shape
{
	double radius;
	final static double PI = 3.1415926535;
	public Circle(double radius) {
		this.radius = radius;
	}
	@Override
	public double getArea() {
		// TODO Auto-generated method stub
		return PI*radius*radius;
	}
	@Override
	public double getPerimeter() {
		// TODO Auto-generated method stub
		return 2*PI*radius;
	}
	
}

输入样例：

3.1415926

输出样例：

31.0063 19.7392Java代码：

//Java代码
public boolean equals(Object obj) {
        //直接比较引用的地址码是否相同
		if (this == obj) return true;
        //判断传入的参数是否为null
		if (obj == null) return false;
        //判断父类的属性是否相同
    	if (!super.equals(obj)) return false;
        //浮点数的比较和company为null的情况的辨析
		DecimalFormat df = new DecimalFormat("#.##");
		Employee other = (Employee) obj;
        if (company == null && other.company == null) 
        	return df.format(salary).equals(df.format(other.salary));
        else if (company == null || other.company == null) return false;
		return company.equals(other.company)
				&& df.format(salary).equals(df.format(other.salary));
	}

编程题

jmu-Java-03面向对象-06-继承覆盖综合练习-Person、Student、Employee、Company

定义Person抽象类，Student类、Company类，Employee类。

Person类的属性：String name, int age, boolean genderPerson类的方法:

public Person(String name, int age, boolean gender);
public String toString();         //返回"name-age-gender"格式的字符串
public boolean equals(Object obj);//比较name、age、gender,都相同返回true,否则返回false

Student类继承自Person，属性:String stuNo, String clazzStudent类的方法:

//建议使用super复用Person类的相关有参构造函数
public Student(String name, int age, boolean gender, String stuNo, String clazz);
public String toString();         //返回 “Student:person的toString-stuNo-clazz”格式的字符串
public boolean equals(Object obj);//首先调用父类的equals方法,如果返回true，则继续比较stuNo与clazz。

Company类属性：String nameCompany类方法:

public Company(String name);
public String toString();         //直接返回name
public boolean equals(Object obj);//name相同返回true

Employee类继承自Person，属性：Company company, double salaryEmployee类方法：

//建议使用super复用Person类的相关有参构造函数
public Employee(String name, int age, boolean gender, double salary, Company company);
public String toString();         //返回"Employee:person的toString-company-salary"格式的字符串
public boolean equals(Object obj);//首先调用父类的equals方法,如果返回true。再比较company与salary。
//比较salary属性时，使用DecimalFormat df = new DecimalFormat("#.#");保留1位小数

编写equals方法重要说明：

1. 对Employee的company属性的比较。要考虑传入为null的情况。如果company不为null且传入为null，返回false
2. 对所有String字符类型比较时，也要考虑null情况。
   提示

1.排序可使用Collections.sort
2.equals方法要考虑周全

main方法说明

1. 创建若干Student对象、Employee对象。
   输入s，然后依次输入name age gender stuNo clazz创建Student对象。
   输入e，然后依次输入name age gender salary company创建Employee对象。
   然后将创建好的对象放入List<Person> personList。输入其他字符，则结束创建。
   创建说明: 对于String类型，如果为null则不创建对象，而赋值为null。对于company属性，如果为null则赋值为null，否则创建相应的Company对象。
2. 对personList中的元素实现先按照姓名升序排序，姓名相同再按照年龄升序排序。提示：可使用Comparable<Person>或Comparator<Person>
3. 接受输入，如果输入为exit则return退出程序，否则继续下面步骤。

将personList中的元素按照类型分别放到stuList与empList。注意：不要将两个内容相同的对象放入列表（是否相同是根据equals返回结果进行判定）。

输出字符串stuList，然后输出stuList中的每个对象。

输出字符串empList，然后输出empList中的每个对象。

1-3为一个测试点
4-6为一个测试点

输入样例：

s zhang 23 false 001 net15
e wang 18 true 3000.51 IBM
s zhang 23 false 001 net15
e bo 25 true 5000.51 IBM
e bo 25 true 5000.52 IBM
e bo 18 true 5000.54 IBM
e tan 25 true 5000.56 IBM
e tan 25 true 5000.51 IBM
s wang 17 false 002 null
s wang 17 false 002 null
e hua 16 false 1000 null
s wang 17 false 002 net16
e hua 16 false 1000 null
e hua 18 false 1234 MicroSoft
!
continue

输出样例：

Employee:bo-18-true-IBM-5000.54
Employee:bo-25-true-IBM-5000.51
Employee:bo-25-true-IBM-5000.52
Employee:hua-16-false-null-1000.0
Employee:hua-16-false-null-1000.0
Employee:hua-18-false-MicroSoft-1234.0
Employee:tan-25-true-IBM-5000.56
Employee:tan-25-true-IBM-5000.51
Student:wang-17-false-002-null
Student:wang-17-false-002-null
Student:wang-17-false-002-net16
Employee:wang-18-true-IBM-3000.51
Student:zhang-23-false-001-net15
Student:zhang-23-false-001-net15
stuList
Student:wang-17-false-002-null
Student:wang-17-false-002-net16
Student:zhang-23-false-001-net15
empList
Employee:bo-18-true-IBM-5000.54
Employee:bo-25-true-IBM-5000.51
Employee:hua-16-false-null-1000.0
Employee:hua-18-false-MicroSoft-1234.0
Employee:tan-25-true-IBM-5000.56
Employee:tan-25-true-IBM-5000.51
Employee:wang-18-true-IBM-3000.51

Java代码：

//Java代码
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Scanner;

class Person {
    private String name;
    private int age;
    private boolean gender;
    private String str;

    Person(String name, int age, boolean gender, String str) {
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.str = str;
    }

    public String toString() {
        return name + "-" + age + "-" + gender;
    }

    @Override
    public boolean equals(Object obj) {
        Person aPerson = (Person) obj;
        if (aPerson.name == null || this.name == null) {
            return false;
        }
        return aPerson.name.compareTo(this.name) == 0 && aPerson.age == this.age && aPerson.gender == this.gender;
    }

    String getName() {
        return name;
    }

    int getAge() {
        return age;
    }

    String getStr() {
        return str;
    }
}

class Student extends Person {
    private String stuNo;
    private String clazz;

    Student(String name, int age, boolean gender, String str, String stuNo, String clazz) {
        super(name, age, gender, str);
        this.stuNo = stuNo;
        this.clazz = clazz;
    }

    public String toString() {
        return super.toString() + "-" + stuNo + "-" + clazz;
    }

    public boolean equals(Object obj) {
        Student a = (Student) obj;
        if (super.equals(obj)) {
            if (this.stuNo == null | this.clazz == null || a.clazz == null || a.stuNo == null) {
                return false;
            }
            return this.clazz.compareTo(a.clazz) == 0 && this.stuNo.compareTo(a.stuNo) == 0;
        }
        return false;
    }

}

class Company {
    private String name;

    Company(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return name;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Company other = (Company) obj;
        if (name == null) {
            return other.name == null;
        } else return name.equals(other.name);
    }
}

class Employee extends Person {
    private Company company;
    private double salary;

    Employee(String name, int age, boolean gender, String str, Company company, double salary) {
        super(name, age, gender, str);
        this.company = company;
        this.salary = salary;
    }

    @Override
    public String toString() {
        return super.toString() + "-" + company.toString() + "-" + salary;
    }

    @Override
    public boolean equals(Object obj) {
        if (super.equals(obj)) {
            Employee other = (Employee) obj;
            if (this.company.toString() == null || other.company.toString() == null) {
                return false;
            }
            String df1 = new DecimalFormat("#.#").format(this.salary);
            String df2 = new DecimalFormat("#.#").format(other.salary);
            return this.company.toString().compareTo(other.company.toString()) == 0 && df1.compareTo(df2) == 0;
        }
        return false;
    }

}

public class Main {
  
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String c;
        String nameString;
        int age;
        boolean gender;
        ArrayList<Person> persons = new ArrayList<>();
        ArrayList<Student> students = new ArrayList<>();
        ArrayList<Employee> employees = new ArrayList<>();
        String tempString;
        String stuNoString;
        String company;
        String clazzString;
        double salary;
        while (true) {
            c = sc.next();
            if (c.compareTo("s") == 0) {
                nameString = sc.next();
                age = sc.nextInt();
                gender = sc.nextBoolean();
                stuNoString = sc.next();
                clazzString = sc.next();
                Student tempStudent = new Student(nameString, age, gender, c, stuNoString, clazzString);
                persons.add(tempStudent);
            } else if (c.compareTo("e") == 0) {
                nameString = sc.next();
                age = sc.nextInt();
                gender = sc.nextBoolean();
                salary = sc.nextDouble();
                company = sc.next();
                Company company2 = new Company(company);
                Employee tempEmployee = new Employee(nameString, age, gender, c, company2, salary);
                persons.add(tempEmployee);
            } else {
                persons.sort(Comparator.comparing(Person::getName).thenComparingInt(Person::getAge));
                for (Person person : persons) {
                    if (person.getStr().compareTo("s") == 0) {
                        System.out.println("Student:" + person.toString());
                        int flag = 0;
                        for (Student student : students) {
                            if (student.equals(person)) {
                                flag = 1;
                                break;
                            }
                        }
                        if (flag == 0) {
                            students.add((Student) person);
                        }

                    } else {
                        System.out.println("Employee:" + person.toString());
                        int flag = 0;
                        for (Employee employee : employees) {
                            if (employee.equals(person)) {
                                flag = 1;
                                break;
                            }
                        }
                        if (flag == 0) {
                            employees.add((Employee) person);
                        }

                    }
                }
                tempString = sc.next();
                if (tempString.compareTo("exit") == 0 || tempString.compareTo("return") == 0) {
                    return;
                }
                System.out.println("stuList");
                for (Student student : students) {
                    System.out.println("Student:" + student.toString());
                }
                System.out.println("empList");
                for (Employee employee : employees) {
                    System.out.println("Employee:" + employee.toString());
                }

            }
        }
    }
}

jmu-Java-04面向对象进阶–02-接口-Comparator

Arrays.sort可以对所有实现Comparable的对象进行排序。但如果有多种排序需求，如有时候需对name进行降序排序，有时候只需要对年龄进行排序。使用Comparable无法满足这样的需求。可以编写不同的Comparator来满足多样的排序需求。

1.编写PersonSortable2类
属性：private name(String)、private age(int) 有参构造函数：参数为name,age toString方法：返回格式name-age

2 编写Comparator类
编写NameComparator类，实现对name进行升序排序
编写AgeComparator类，对age进行升序排序

3.main方法中

1. 输入n
2. 输入n行name age，并创建n个对象放入数组
3. 对数组按照name进行升序排序后输出。
4. 在3的基础上对数组按照age进行升序排序后输出。
5. 最后最后两行使用如下代码输出NameComparator与AgeComparator所实现的所有接口。

System.out.println(Arrays.toString(NameComparator.class.getInterfaces()));
System.out.println(Arrays.toString(AgeComparator.class.getInterfaces()));

输入样例:

5
zhang 15
zhang 12
wang 14
Wang 17
li 17

输出样例:

NameComparator:sort
Wang-17
li-17
wang-14
zhang-15
zhang-12
AgeComparator:sort
zhang-12
wang-14
zhang-15
Wang-17
li-17
//最后两行是标识信息

Java代码：

//Java代码
import java.util.*;
 
public class Main{
	public static void main(String[] args) {
		Scanner scan=new Scanner(System.in);
		int n=scan.nextInt();
		PersonSortable2 s[]=new PersonSortable2[n];
		for(int i=0;i<n;i++) {
			String name=scan.next();
			int age=scan.nextInt();
			s[i]=new PersonSortable2(name,age);
		}
		scan.close();
		Arrays.sort(s, new NameComparator());
		System.out.println("NameComparator:sort");
		for(PersonSortable2 i:s) {
			System.out.println(i);
		}
		Arrays.sort(s, new AgeComparator());
		System.out.println("AgeComparator:sort");
		for(PersonSortable2 i:s) {
			System.out.println(i.toString());
		}
		System.out.println(Arrays.toString(NameComparator.class.getInterfaces()));
		System.out.println(Arrays.toString(AgeComparator.class.getInterfaces()));
	}
}
class PersonSortable2{
	public String name;
	public int age;
	public PersonSortable2(String name,int age) {
		this.name=name;
		this.age=age;
	}
	@Override
	public String toString() {
		return name + "-" + age;
	}
	
}
class NameComparator implements Comparator<PersonSortable2>{
 
	@Override
	public int compare(PersonSortable2 o1, PersonSortable2 o2) {
		if(o1.name.compareTo(o2.name)>0)return 1;
		else if(o1.name.compareTo(o2.name)<0)return -1;
		else return o1.name.compareTo(o2.name);
	}
}
class AgeComparator implements Comparator<PersonSortable2>{
 
	@Override
	public int compare(PersonSortable2 o1, PersonSortable2 o2) {
		if(o1.age<o2.age)return -1;
		else return 1;
	}
}