精华内容
下载资源
问答
  • Java继承习题

    2019-04-29 15:12:39
    java继承习题精选 包含可很多习题 同时也副有正确答案
  • java继承练习题

    2020-04-19 14:41:54
    java继承一、选择二、编程 一、选择 在Java中,以下程序的输出结果是 A. Super–>print   B. Test–>print   C. Super–>print Test–>print   D. 编译错误 public class Super { public void ...

    一、选择

    1. 在Java中,以下程序的输出结果是
      A. Super–>print   B. Test–>print   C. Super–>print Test–>print   D. 编译错误
    public class Super {
    	public void print() {
    		System.out.println("Supeer --> print");
    	}
    }
    public class Test extends Super {
    	public void print() {
    		System.out.println("Test --> print");
    	}
    	public static void main(String[] args) {
    		Super t = new Super();
    		t.print();
    	}
    }
    

    A

    1. 在Java中,以下关于方法重载和方法重写描述正确的是
      A. 方法重载和方法重写实现的功能相同
      B. 方法重载出现在父子关系中,方法重写是在同一类中
      C. 方法重载的返回类型必须一致,参数项必须不同
      D. 方法重写需要出现在满足继承关系的子类中

    D

    1. 哪个选项中的方法插入到(1)处可以正确实现方法重写
      A. public static void bark(){ }
      B. public final void display(){ }
      C. public void eat(String food){ }
      D. public boolean eat(String food){ }
    class Animal{
    	public void eat(String food) {
    	}
    	public static void bark() {
    	}
    	public final void display() {
    	}
    }
    class Cat extends Animal {
    	//(1)
    }
    

    C

    1. 在下面程序的注释1处补充上下列()方法,会导致在编译过程中发生错误
      A. public float getNum() { return 4.0f; }
      B. private float getNum() {return 4.0f;}
      C. public void getNum(double d){ }
      D. public double getNum(float d){ return 4.0f; }

    B

    1. 如下Java源文件,编译并运行Child.java后,以下结果描述正确的是
      A. 编译错误:没有找到构造器Child()
      B. 编译错误:没有找到构造器Parent1()
      C. 正确运行,没有输出值
      D. 正确运行,输出结果为:parent2
    public class Parent1 {
    	Super(String s) {
    		System.out.println(s);
    	}
    }
    public class Test extends Parent2 {
    	Parent2() {
    		System.out.println("parent2");
    	}
    }
    public class Child extends Parent2 {
    	public static void main(String[] args) {
    		Child child = new Child();
    	}
    }
    

    B

    1. 分析如下所示的Java代码,则选项中的说法正确的是
      A. 第2行错误,Test类的构造函数中参数名称应与其父类构造函数中的参数名相同
      B. 第3行错误,应使用super关键字调用父类的name属性,改为super.name=“hello”
      C. 第4行错误,调用父类构造方法的语句必须放在子类构造方法中的第一行
      D. 程序编译通过,无错误
    public class Parent {
    	public String name;
    	Super(String pName) {
    		this.name = pName;
    	}
    }
    public class Test extends Parent {
    	public Test(String Name) { //2
    		name = "hello"; //3
    		super("kittv"); //4
    	}
    }
    

    C

    1. 关于super的说法正确的是
      A. 是指当前子类的对象   B. 是指当前类的对象   C. 是指当前父类的对象   D. 可以用在main()方法中

    C

    1. 阅读下面JAVA代码片段,正确的选项是
      A. 第1行编译错误,但能输出正确结果
      B. 第2行编译错误,但能输出正确结果
      C. 第3行编译错误,不能输出正确结果
      D. 第4行编译错误,不能输出正确结果
    public class Car {
    	String color;
    	String motor;
    	public Car(String color, String motor) { //1
    		this.color = color;
    		this.motor = motor;
    	}
    }
    public class Truck extends Car {
    	double weight;
    	public Truck() {  //2
    		
    	}
    	public Truck(String color, String motor, double weight) { //3
    		super(color,motor); 
    		this.weight = weight; 
    		
    	}
    	public void display() { 
    		System.out.println("颜色:" + color + "\t发动机的型号:" + motor + "\t载重量:" + weight );
    		
    	}
    	public static void main(String[] args) {
    		Truck truck = new Truck("红色","玉柴",1.5); //4
    		truck.display();
    	}
    }
    

    B

    1. 下列关于super和this的说法正确的是(多选)
      A. this关键字通常指当前对象
      B. super关键字则指父类对象
      C. 在一个类中this只可以调用当前类中公有属性和方法
      D. 在一个类中super可以调用父类中允许被访问的属性和方法

    A B D

    1. 下列关于Object类的叙述错误的是
      A. Object类是所有类的父类
      B. 所有类都可以继承Object中允许被继承的方法
      C. 一个类没有使用extends关键字明确标识继承关系,则默认继承Object类
      D. 要想继承Object类,必须使用extends关键字标识继承关系,否则不会实现继承

    D

    1. 该段代码的运行结果为
      A. true   B. 相等   C. 不相等   D. false
    public class Father {
    	private String name;
    	private int age;
    	public Father(String name, int age) {
    		this.name = name;
    		this.age = age;
    	}
    	public static void main(String[] args) {
    		Father fa1 = new Father("晓明",13);
    		Father fa2 = new Father("晓明",13);
    		boolean flag = fa1.equals(fa2);
    		System.out.println(flag);
    
    

    D

    1. 在Java中,关于继承的说法错误的是
      A. 使用extends关键字实现一个类继承另一个类 B. 所有的Java类都直接或间接地继承了java.lang.Object类 C. 在子类的构造方法中,必须显式调用父类的构造方法 D. 在子类的构造方法中,可以通过super关键字调用父类的构造方法

    C

    二、编程

    1. 编程练习:某公司要开发“XX车行管理系统”,请使用面向对象的思想,设计自定义类描述自行 车、电动车和三轮车。
      1. 第一步:分析自行车、电动车和三轮车的共性:
        都是非机动车,具有非机动车的基本特征 2. 都有运行的方法
      2. 第二步:根据共性,定义非机动车
        属性:品牌、颜色、轮子(默认2个)、座椅(默认 1个)
        方法:
        1. 编写无参构造方法、双参构造方法和四参构造方法,其中,在双参构造方法中,完成对品牌和 颜色的赋值;在四参构造方法中,完成对所有属性的赋值
        2. 编写运行的方法,描述内容为:这是一辆 * 颜色的,* 牌的非机动车,有 * 个轮子,有 * 个座椅 的非机动车。其中 * 的数据由属性提供
      3. 第三步:定义自行车、电动车和三轮车分别继承自行车类,要求:
        • 自行车类:
          1. 在构造方法中调用父类多参构造,完成属性赋值
          2. 重写运行方法,描述内容为:这是一辆 * 颜色的, * 牌的自行车。其中 * 的数据由属性提供
        • 电动车类:
          1. 增加“电池品牌”属性
          2. 重写运行方法,描述内容为:这是一辆使用 * 牌电池的电动车。其中 * 的数据由属性提供
        • 三轮车类:
          1. 在无参构造中实现对轮子属性值进行修改
          2. 重写运行方法,描述内容为:三轮车是一款有 * 个轮子的非机动车。其中 * 的数据由属性提供
    /**
    * 父类:非机动车
    **/
    public class Vehicle {
    	//定义父类非机动车属性
    	private String logo;
    	private String color;
    	private int wheel;
    	private int seat;
    	//get/set方法
    	public String getLogo() {
    		return logo;
    	}
    	public void setLogo(String logo) {
    		this.logo = logo;
    	}
    	public String getColor() {
    		return color;
    	}
    	public void setColor(String color) {
    		this.color = color;
    	}
    	public int getWheel() {
    		return wheel;
    	}
    	public void setWheel(int wheel) {
    		this.wheel = wheel;
    	}
    	public int getSeat() {
    		return seat;
    	}
    	public void setSeat(int seat) {
    		this.seat = seat;
    	}
    	//定义无参构造
    	public Vehicle() {
    		super();
    		this.setWheel(2);
    		this.setSeat(1);
    	}
    	//定义双参构造
    	public Vehicle(String logo, String color) {
    		super();
    		this.setLogo(logo);
    		this.setColor(color);
    	}
    	//定义四参构造
    	public Vehicle(String logo, String color, int wheel, int seat) {
    		super();
    		this.setLogo(logo);
    		this.setColor(color);
    		this.setWheel(wheel);
    		this.setSeat(seat);
    	}
    	//运行方法
    	public String info() {
    		String str = "这是一辆" + this.getColor() + "颜色的,";
    		str += this.getLogo() + "牌的非机动车,有" + this.getWheel() + "个轮子,";
    		str += "有" + this.getSeat() + "个座椅";
    		return str;
    	}
    }
    
    /**
    * 自行车类
    **/
    public class Bicycle extends Vehicle {
    	public Bicycle() {
    		super();
    	}
    	public Bicycle(String logo, String color) {
    		super(logo, color);
    	}
    	//重写运行方法
    	public String info() {
    		String str = "这是一辆" + this.getColor() + "颜色的,";
    		str += this.getLogo() + "牌的自行车";
    		return str;
    	}
    }
    
    /**
    * 电动车类
    **/
    public class ElecBicycle extends Vehicle {
    	//新增电池属性
    	private String eleclogo;
    	//set/get方法
    	public String getEleclogo() {
    		return eleclogo;
    	}
    	public void setEleclogo(String eleclogo) {
    		this.eleclogo = eleclogo;
    	}
    	//无参构造
    	public ElecBicycle() {
    		super();
    	}
    	//有参构造
    	public ElecBicycle(String eleclogo) {
    		this.setEleclogo(eleclogo);
    	}
    	//重写运行方法
    	public String info() {
    		String str = "这是一辆使用" + this.getEleclogo() + "牌电池的电动车";
    		return str;
    	}
    }
    
    /**
    * 三轮车类
    **/
    public class Tricycle extends Vehicle {
    	//无参构造
    	public Tricycle() {
    		super();
    		this.setWheel(3);
    	}
    	//重写运行方法
    	public String info() {
    		String str = "三轮车是一款有" + this.getWheel() + "个轮子的非机动车";
    		return str;
    	}
    }
    
    /**
    * 测试类
    **/
    public class Test {
    	public static void main(String[] args) {
    		Vehicle v = new Vehicle("天宇","红",4,2);
    		System.out.println("父类信息测试" + v.info());
    		Bicycle b = new Bicycle("捷安特","黄");
    		System.out.println("自行车类信息测试" + b.info());
    		ElecBicycle e = new ElecBicycle("飞鸽");
    		System.out.println("电动车类信息测试" + e.info());
    		Tricycle t = new Tricycle();
    		System.out.println("三轮车类信息测试" + t.info());
    	}
    }
    
    1. 请使用面向对象的思想,设计自定义类Person继承Object类,重写toString方法实现对象信息输出。
      • 创建一个 Person 类继承自 Object,其中类的结构要求为: 属性:name(姓名)、age(年龄)、sex(性别)
      • 方法: 创建带参(name、age、sex为参数)构造方法 重写 toString 方法,输出信息格式为:姓名:* 年龄: * 性别: * (其中, * 为对象对应属性值)
      • 创建测试类,在测试方法中,实例化 Person对 象,并传入三个属性值。然后,分别通过直接 打印Person对象以及利用重写的 toString 方法,打印输出2行对象信息。
    /**
    * Person类
    **/
    public class Person {
    	//私有属性:name(姓名)、age(年龄)、sex(性别)   
    	private String name;
    	private int age;
    	private String sex;
    	//带参构造方法(name、age、sex为参数)     
    	public Person(String name, int age, String sex) {
    		super();
    		this.name = name;
    		this.age = age;
    		this.sex = sex;
    	}
    	//无参构造方法
    	public Person() {
    		super();
    	}
    	//通过封装实现对属性的get/set方法设定 
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public int getAge() {
    		return age;
    	}
    	public void setAge(int age) {
    		this.age = age;
    	}
    	public String getSex() {
    		return sex;
    	}
    	public void setSex(String sex) {
    		this.sex = sex;
    	}
    	//重写toString方法,表示形式为:姓名:+**+  年龄:+**+  性别:+**
    	public String toString() {
    		String str = "姓名:" + this.getName() + "   ";
    		str += "年龄:" + this.getAge() + "   ";
    		str += "性别:" + this.getSex();
    		return str;
    	}
    }
    
    /**
    * 测试类
    **/
    public class Test {
    	public static void main(String[] args) {
    		Person p = new Person("李明",18,"男");
    		System.out.println(p);
    		System.out.println(p.toString());
    	}
    }
    
    展开全文
  • Java继承练习题

    千次阅读 2020-05-11 20:18:34
    一、选择 A A. Super–>print B. Test–>print C. Super–>print Test–>print D. 编译错误 2.在Java中,以下关于方法重载和方法重写描述正确的是 A A. 方法重载和方法重写实现的功能相同 B. 方法...

    一、选择题

    1.A在这里插入图片描述
    A. Super–>print
    B. Test–>print
    C. Super–>print
    Test–>print
    D. 编译错误

    2.在Java中,以下关于方法重载和方法重写描述正确的是 A
    A. 方法重载和方法重写实现的功能相同
    B. 方法重载出现在父子关系中,方法重写是在同一类中
    C. 方法重载的返回类型必须一致,参数项必须不同
    D. 方法重写需要出现在满足继承关系的子类中

    3.C在这里插入图片描述
    A. public static void bark(){}
    B. public final void display(){}
    C. public void eat(String food){}
    D. public boolean eat(String food){}

    4.在下面程序的注释1处补充上下列()方法,会导致在编译过程中发生错误 D
    A. public float getNum() { return 4.0f; }
    B. private float getNum() {return 4.0f;}
    C. public void getNum(double d){}
    D. public double getNum(float d){ return 4.0f; }

    5.如下Java源文件,编译并运行Child.java后,以下结果描述正确的是 B
    在这里插入图片描述
    A. 编译错误:没有找到构造器Child()
    B. 编译错误:没有找到构造器Parent1()
    C. 正确运行,没有输出值
    D. 正确运行,输出结果为:parent2

    6.分析如下所示的Java代码,则选项中的说法正确的是 A
    在这里插入图片描述
    A. 第2行错误,Test类的构造函数中参数名称应与其父类构造函数中的参数名相同
    B. 第3行错误,应使用super关键字调用父类的name属性,改为super.name=“hello”
    C. 第4行错误,调用父类构造方法的语句必须放在子类构造方法中的第一行
    D. 程序编译通过,无错误

    7.关于super的说法正确的是 C
    A. 是指当前子类的对象
    B. 是指当前类的对象
    C. 是指当前父类的对象
    D. 可以用在main()方法中

    1. 阅读下面JAVA代码片段,正确的选项是 B
      在这里插入图片描述
      A. 第1行编译错误,但能输出正确结果
      B. 第2行编译错误,但能输出正确结果
      C. 第3行编译错误,不能输出正确结果
      D. 第4行编译错误,不能输出正确结果

    2. 下列关于super和this的说法正确的是(多选)ABD
      A. this关键字通常指当前对象
      B. super关键字则指父类对象
      C. 在一个类中this只可以调用当前类中公有属性和方法
      D. 在一个类中super可以调用父类中允许被访问的属性和方法

    3. 下列关于Object类的叙述错误的是 D
      A. Object类是所有类的父类
      B. 所有类都可以继承Object中允许被继承的方法
      C. 一个类没有使用extends关键字明确标识继承关系,则默认继承Object类
      D. 要想继承Object类,必须使用extends关键字标识继承关系,否则不会实现继承

    4. A
      在这里插入图片描述

    A. true
    B. 相等
    C. 不相等
    D. false

    1. 在Java中,关于继承的说法错误的是 C
      A. 使用extends关键字实现一个类继承另一个类
      B. 所有的Java类都直接或间接地继承了java.lang.Object类
      C. 在子类的构造方法中,必须显式调用父类的构造方法
      D. 在子类的构造方法中,可以通过super关键字调用父类的构造方法

    2. 下列关于final的说法错误的是 C
      A. final修饰的变量值不允许被修改
      B. final修饰的方法不可被重写
      C. final可以修饰所有方法
      D. final不可以修饰构造方法

    二、编程题
    1.某公司要开发“XX车行管理系统”,请使用面向对象的思想,设计自定义类描述自行
    车、电动车和三轮车。
    程序参考运行效果图如下:
    在这里插入图片描述
    任务分析;
    第一步:分析自行车、电动车和三轮车的共性:
    都是非机动车,具有非机动车的基本特征
    都有运行的方法
    第二步:根据共性,定义非机动车
    属性:品牌、颜色、轮子(默认2个)、座椅(默认 1个)
    方法:
    编写无参构造方法、双参构造方法和四参构造方法,其中,在双参构造方法中,完成对品牌和
    颜色的赋值;在四参构造方法中,完成对所有属性的赋值
    编写运行的方法,描述内容为:这是一辆颜色的,牌的非机动车,有个轮子,有个座椅
    的非机动车。其中的数据由属性提供
    第三步:定义自行车、电动车和三轮车分别继承自行车类,要求:
    自行车类:
    在构造方法中调用父类多参构造,完成属性赋值
    重写运行方法,描述内容为:这是一辆
    颜色的,牌的自行车。其中的数据由属性提供
    电动车:
    增加“电池品牌”属性
    重写运行方法,描述内容为:这是一辆使用牌电池的电动车。其中的数据由属性提供
    三轮车:
    在无参构造中实现对轮子属性值进行修改
    重写运行方法,描述内容为:三轮车是一款有个轮子的非机动车。其中的数据由属性提供

    父类
    在这里插入图片描述
    在这里插入图片描述
    自行车类
    在这里插入图片描述
    电动车类
    在这里插入图片描述
    三轮车类
    在这里插入图片描述
    测试类
    在这里插入图片描述
    2.请使用面向对象的思想,设计自定义类Person继承Object类,重写toString方法实现对象信息输
    出。
    运行效果如下图所示:
    在这里插入图片描述
    思路分析
    创建一个 Person 类继承自 Object,其中类的结构要求为:
    属性:name(姓名)、age(年龄)、sex(性别)
    方法:
    创建带参(name、age、sex为参数)构造方法
    重写 toString 方法,输出信息格式为:姓名:** 年龄:** 性别:(其中,为对象对应
    属性值)
    创建测试类,在测试方法中,实例化 Person对 象,并传入三个属性值。然后,分别通过直接
    打印Person对象以及利用重写的 toString 方法,打印输出2行对象信息。
    在这里插入图片描述
    在这里插入图片描述
    3.请使用面向对象的思想,实现杨梅和仙人蕉的信息描述。
    程序参考运行效果图如下:
    在这里插入图片描述
    思路分析:
    1、根据杨梅和香蕉的共性,抽取父类水果(Fruits)
    私有属性:水果的形状(shape)和口感(taste)
    方法:
    带参构造函数(参数为shape和taste)
    创建无参无返回值得方法eat(描述内容为:水果可供人们食用!)
    重写equals方法,比较两个对象是否相等(比较shape,taste)
    2、子类Waxberry
    私有属性:颜色(color)
    方法:
    调用父类的构造方法,完成属性赋值
    创建不允许重写的face方法,描述为:杨梅:
    ,果味酸甜适中。
    重写父类eat方法,描述为:杨梅酸甜适中,非常好吃!
    重写toString方法,输出的表现形式不同(输出shape,color,taste)
    要求Waxberry类不允许有子类
    3、子类:Banana
    私有属性:品种(variety)
    方法:
    带参构造方法为所有属性赋值
    创建无参无返回值的advantage方法,描述为:果形,果肉香甜,可供生食。
    重载要求(2)中的advantage方法(带参数color),描述为:颜色为
    4、测试,运行效果参照效果图:
    实例化2个父类对象,并传入两组相同的参数值
    调用父类eat方法
    测试重写equals方法,判断两个对象是否相等
    实例化子类Wacberry对象,并传入相关参数值
    调用子类face方法和重写父类eat方法后的eat方法
    测试重写toString方法,输出子类对象的信息
    实例化Banana类对象,并传入相关参数值
    调用子类的advantage和它的重载方法

    父类
    在这里插入图片描述
    Waxberry类
    在这里插入图片描述
    Banner类
    在这里插入图片描述
    test类
    在这里插入图片描述

    展开全文
  • 写一个能输出各个属性值的方法showInfo()),定义一个学生类(属性有性别),学生继承人类要求:(1)父类的属性赋值用构造方法来实现(分别用有参数构造方法和无参数构造方法实现)(2)子类的属性也用构造方法来赋值。...

    一.extends和super的使用和方法的重写

    1. 定义一个人的类(属性有名字,年龄。写一个能输出各个属性值的方法showInfo()),定义一个学生类(属性有性别),学生继承人类

    要求:(1)父类的属性赋值用构造方法来实现(分别用有参数构造方法和无参数构造方法实现)

    (2)子类的属性也用构造方法来赋值。

    (3)在子类中重写父类的showInfo()方法

    (4)声明学生类的对象,调用学生的显示信息的方法。

    2

    定义Animal父类,含有属性name,sex,age,方法sleep,run,编写一个子类Person,继承Animal类,然后调用父类的属性和方法

    二.

    1、 试编写三个具有继承关系的类,A、B、C(B继承A,C继承B)。要求A中包含方法a1()、a2(),B类中的方法b1()访问了a1()和a2(),C类中的方法c1()访问了a1()、a2()、b1()。

    提示:(a1(),a2(),b1(),c1()这些方法体除了实现题目要求之外,其余内容可以任意编写。)

    2、请编码实现动物世界的继承关系:

    动物(Animal)具有行为:吃(eat)、睡觉(sleep)

    动物包括:兔子(Rabbit),老虎(Tiger)

    这些动物吃的行为各不相同(兔子吃草,老虎吃肉);但睡觉的行为是一致的。

    请通过继承实现以上需求,并编写测试类AnimalTest进行测试。

    3、父类 Person 包含like()方法 子类 Son 重写父类方法并打印输出

    4、(选做)父类Employee 属性:name、sex , 带一个构造方法Employee(String n, char s)

    子类 Worker继承自Employee 属性:char category;//类别 boolean dressAllowance; //是否提供服装津贴 , 有一个构造方法 负责构造所有属性,还有一个自定义方法 isDressAll() 这个方法 负责通过判断dressAllowance的值输出 ,是否提供服装津贴。

    新建一个类测试类InheDemo

    在main方法中新建一个Worker对象,输出这个对象的所有属性

    并调用isDressAll()方法得到津贴信息

    展开阅读全文

    展开全文
  • Java 继承练习题

    千次阅读 2018-04-23 17:16:51
    b中未定义 print方法 所以直接调用的是从父类a里面继承的print方法。根据 就近原则 自然调用的是a类的i,Java中重写指的是方法的重写,而不是属性的重写,还有 多态 也只是方法的多态 ,没有属性的多态。确切的说java...
    class A {}
    class B extends A {
    void print() {
    System.out.println(super.getClass().getName());
    }
    public static void main(String[] args) {
    B b = new B();
    b.print();
    }
    }
    输出结果是什么?为什么?如果你懂了再讲讲下面这个问题:
    class A {
    int i = 1;
    void print() {
    System.out.println(i);
    }
    }
    class B extends A {
    int i = 2;
    public static void main(String[] args) {
    B b = new B();
    b.print();
    }
    }
    我不是问输出结果是什么,而是为什么会输出这样的结果?请大家帮帮忙啊~~~
    采纳率:44% 11级 2013.08.10
    哦 这个题目哦 最近在背面试题 刚好看到过...
    第一题:
    getClass().getName()方法,返回的是B类名
    由于getClass()在Object类中定义成了final,子类不能覆盖该方法,所以,在B类方法中调用super.getClass().getName()方法返回的也应该是B自己的类名。

    第二题:
    b中未定义 print方法 所以直接调用的是从父类a里面继承的print方法。根据 就近原则自然调用的是a类的i,Java中重写指的是方法的重写,而不是属性的重写,还有 多态也只是方法的多态 ,没有属性的多态。确切的说java 没有属性的覆盖这一说法。属性是编译时候就确定了的,而所谓的覆盖方法则是运行的时候动态绑定的。在子类调用与父类属性同名的属性时应该说 “父类的属性被子类的属性挡住了”. 不过确实很 多人还是习惯叫“覆盖”,一些精辟的 概念,都需要精准的词来修饰,不然有可能大家都理解其中的概念,但是说给别人听 就全乱了 .... 楼主可不要被混淆了啊~

    展开全文
  • java继承习题

    2020-05-11 21:00:42
    练习 一、选择 在Java中,以下程序的输出结果是(B ) 在Java中,以下关于方法重载和方法重写描述正确的是(D ) A. 方法重载和方法重写实现的功能相同 B. 方法重载出现在父子关系中,方法重写是在同一类中 C. ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 14,752
精华内容 5,900
关键字:

java继承练习题

java 订阅