精华内容
下载资源
问答
  • 以下关于继承叙述正确的是()。A. 在Java中类只允许单一继承B. 在Java中一个类只能实现一个接更多相关问题解下列方程:(1)|5x-2|=3;(2)|x|-15-1=6-|x|5.小华在做解方程作业时,不小心将方程中的一个常数污染...

    以下关于继承的叙述正确的是()。A. 在Java中类只允许单一继承B. 在Java中一个类只能实现一个接

    更多相关问题

    解下列方程:(1)|5x-2|=3;(2)|x|-15-1=6-|x|5.

    小华在做解方程作业时,不小心将方程中的一个常数污染了看不清楚,被污染的方程是y-13=13y-■,怎么办呢?小明想

    当x=4时,多项式ax-4x-1的值是-1,那么当x=5时,这个多项式的值是多少?

    解方程|4x+2|=x-1.

    (1)解不等式:x+13-2≥2x-42;(2)解方程:43[34(15x-2)-6]=1.

    解方程|x-1|=-2x+1.

    解方程:(1)2(x-1)-(x+3)=3(2)2x+13-5x-16=1.

    解方程2|x-1|-53=1.

    已知x、y是互为相反数,且(x+y-2)(x-y)=6,则x=______,y=______.

    已知4是关于的方程x2+m=mx-m的解,则m的值为______.

    当x取______时,代数式3(2-x)和2(3-x)的值相等.

    解方程|x-1|=-2x+1.

    在方程(3+m-1)x=6-(2m+3)中,当x=2时,m的值是()A.m=-14B.m=14C.m=-4D.m=4

    方程2y-12=12y-3的解是()A.-35B.35C.53D.-53

    下列方程变形中,正确的是()A.由x3=0,得x=3B.由5x=-4,得x=-54C.由2x-3=3x,得x=3D.由2x+3=x-1,得2x-x=-1-3

    如果关于x的方程(1)x+23=m2的解也是不等式组(2)1-x2>x-22(x-3)≤x-8的一个解,求m的取值范围.

    解下列方程或方程组.(1)2x-13=1-x2(2)m2+n3=13m3-n4=3..

    m取什么样的负整数时,关于x的方程12x-1=m的解不小于-3.

    当x=______时,代数式3x-5与2x-8的值互为相反数.

    已知x、y是互为相反数,且(x+y-2)(x-y)=6,则x=______,y=______.

    关于x的不等式2a-3x<6的解集为x>2,则a值为______.

    给出下面四个方程及变形:①4x+10=0,变形为2x+5=0,②x+7=5-3x,变形为4x=12,③23x=5,变形为2x=15,④16x=-8,变形为

    2x+y=1.53.2x+2.4y=5.2.

    解方程:(1)3x+1=2x-5(2)x+23-1=x-12.

    已知△ABC有两边的长分别为3和7,第三边的长是关于x的方程x+a2=x+1解,求a的取值范围.

    已知5m+13和m4-1互为相反数,那么m=______.

    已知4是关于的方程x2+m=mx-m的解,则m的值为______.

    已知5m+13和m4-1互为相反数,那么m=______.

    关于x的不等式2a-3x<6的解集为x>2,则a值为______.

    若关于x的不等式x-a>2的解集是x>1,则a2010=______.

    解方程:2[43x-(23x-12)]=34x.

    当x=______时,代数式4x-5与3x-6的值互为相反数.

    当x=4时,多项式ax-4x-1的值是-1,那么当x=5时,这个多项式的值是多少?

    给出下面四个方程及变形:①4x+10=0,变形为2x+5=0,②x+7=5-3x,变形为4x=12,③23x=5,变形为2x=15,④16x=-8,变形为

    解方程x-1a-1-xb=a+bab.

    捐 赠如果您觉得这篇文章有用处,请支持作者!鼓励作者写出更好更多的文章!

    展开全文
  • Java继承

    2020-05-11 23:32:46
    Java中,以下关于方法重载和方法重写描述正确的是 A. 方法重载和方法重写实现的功能相同 B. 方法重载出现在父子关系中,方法重写是在同一类中 C. 方法重载的返回类型必须一致,参数项必须不同 D. 方法重写需要出现...
    1. 在Java中,以下程序的输出结果是 A
      在这里插入图片描述
      A. Super–>print
      B. Test–>print
      C. Super–>print
      Test–>print
      D. 编译错误
    2. 在Java中,以下关于方法重载和方法重写描述正确的是 D
      A. 方法重载和方法重写实现的功能相同
      B. 方法重载出现在父子关系中,方法重写是在同一类中
      C. 方法重载的返回类型必须一致,参数项必须不同
      D. 方法重写需要出现在满足继承关系的子类中
    3. 哪个选项中的方法插入到(1)处可以正确实现方法重写 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代码,则选项中的说法正确的是 C
      在这里插入图片描述
      A. 第2行错误,Test类的构造函数中参数名称应与其父类构造函数中的参数名相同
      B. 第3行错误,应使用super关键字调用父类的name属性,改为super.name=“hello”
      C. 第4行错误,调用父类构造方法的语句必须放在子类构造方法中的第一行
      D. 程序编译通过,无错误
    7. 关于super的说法正确的是 C
      A. 是指当前子类的对象
      B. 是指当前类的对象
      C. 是指当前父类的对象
      D. 可以用在main()方法中
    8. 阅读下面JAVA代码片段,正确的选项是 B
      在这里插入图片描述
      A. 第1行编译错误,但能输出正确结果
      B. 第2行编译错误,但能输出正确结果
      C. 第3行编译错误,不能输出正确结果
      D. 第4行编译错误,不能输出正确结果
    9. 下列关于super和this的说法正确的是(多选)ABD
      A. this关键字通常指当前对象
      B. super关键字则指父类对象
      C. 在一个类中this只可以调用当前类中公有属性和方法
      D. 在一个类中super可以调用父类中允许被访问的属性和方法
    10. 下列关于Object类的叙述错误的是 D
      A. Object类是所有类的父类
      B. 所有类都可以继承Object中允许被继承的方法
      C. 一个类没有使用extends关键字明确标识继承关系,则默认继承Object类
      D. 要想继承Object类,必须使用extends关键字标识继承关系,否则不会实现继承
    11. 该段代码的运行结果为 D
      在这里插入图片描述
      A. true
      B. 相等
      C. 不相等
      D. false
    12. 在Java中,关于继承的说法错误的是 C
      A. 使用extends关键字实现一个类继承另一个类
      B. 所有的Java类都直接或间接地继承了java.lang.Object类
      C. 在子类的构造方法中,必须显式调用父类的构造方法
      D. 在子类的构造方法中,可以通过super关键字调用父类的构造方法
    13. 下列关于final的说法错误的是 C
      A. final修饰的变量值不允许被修改
      B. final修饰的方法不可被重写
      C. final可以修饰所有方法
      D. final不可以修饰构造方法
      二、编程
      1、编程练习:某公司要开发“XX车行管理系统”,请使用面向对象的思想,设计自定义类描述自行
      车、电动车和三轮车。
      程序参考运行效果图如下:
      在这里插入图片描述
      任务
      任务分析;
      第一步:分析自行车、电动车和三轮车的共性:
      1、都是非机动车,具有非机动车的基本特征
      2、都有运行的方法
      第二步:根据共性,定义非机动车
      属性:品牌、颜色、轮子(默认2个)、座椅(默认 1个)
      方法:
      1、编写无参构造方法、双参构造方法和四参构造方法,其中,在双参构造方法中,完成对品牌和
      颜色的赋值;在四参构造方法中,完成对所有属性的赋值
      2、编写运行的方法,描述内容为:这是一辆颜色的,牌的非机动车,有个轮子,有个座椅
      的非机动车。其中的数据由属性提供
      第三步:定义自行车、电动车和三轮车分别继承自行车类,要求:
      自行车类:
      1、在构造方法中调用父类多参构造,完成属性赋值
      2、重写运行方法,描述内容为:这是一辆
      颜色的,牌的自行车。其中的数据由属性提供
      电动车:
      1、增加“电池品牌”属性
      2、重写运行方法,描述内容为:这是一辆使用牌电池的电动车。其中的数据由属性提供
      三轮车:
      1、在无参构造中实现对轮子属性值进行修改
      2、重写运行方法,描述内容为:三轮车是一款有个轮子的非机动车。其中的数据由属性提供
      在这里插入图片描述
      在这里插入图片描述
      在这里插入图片描述
      在这里插入图片描述
      在这里插入图片描述
      在这里插入图片描述
      在这里插入图片描述
      2、请使用面向对象的思想,设计自定义类Person继承Object类,重写toString方法实现对象信息输
      出。
      运行效果如下图所示:
      在这里插入图片描述
      思路分析
      创建一个 Person 类继承自 Object,其中类的结构要求为:
      属性:name(姓名)、age(年龄)、sex(性别)
      方法:
      创建带参(name、age、sex为参数)构造方法
      重写 toString 方法,输出信息格式为:姓名:** 年龄:** 性别:(其中,为对象对应
      属性值)
      创建测试类,在测试方法中,实例化 Person对 象,并传入三个属性值。然后,分别通过直接
      打印Person对象以及利用重写的 toString 方法,打印输出2行对象信息。
      public class Person{
      //私有属性:name(姓名)、age(年龄)、sex(性别)
      //带参构造方法(name、age、sex为参数)
      //通过封装实现对属性的get/set方法设定
      //重写toString方法,表示形式为:姓名:+
      + 年龄:+
      + 性别:+**
      }
      在这里插入图片描述
      在这里插入图片描述
      在这里插入图片描述

    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和它的重载方法
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • Java继承练习

    2020-07-22 16:39:12
    2、在Java中,以下关于方法重载和方法重写描述正确的是D A. 方法重载和方法重写实现的功能相同 B. 方法重载出现在父子关系中,方法重写是在同一类中 C. 方法重载的返回类型必须一致,参数项必须不同 D. 方法重写需要...

    练习
    一、选择

    1、在Java中,以下程序的输出结果是A
    在这里插入图片描述

    A. Super–>print
    B. Test–>print
    C. Super–>print
    Test–>print
    D. 编译错误
    2、在Java中,以下关于方法重载和方法重写描述正确的是D
    A. 方法重载和方法重写实现的功能相同
    B. 方法重载出现在父子关系中,方法重写是在同一类中
    C. 方法重载的返回类型必须一致,参数项必须不同
    D. 方法重写需要出现在满足继承关系的子类中
    3、哪个选项中的方法插入到(1)处可以正确实现方法重写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处补充上下列()方法,会导致在编译过程中发生错误
    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代码,则选项中的说法正确的是C
    在这里插入图片描述

    A. 第2行错误,Test类的构造函数中参数名称应与其父类构造函数中的参数名相同
    B. 第3行错误,应使用super关键字调用父类的name属性,改为super.name=“hello”
    C. 第4行错误,调用父类构造方法的语句必须放在子类构造方法中的第一行
    D. 程序编译通过,无错误
    7、关于super的说法正确的是C
    A. 是指当前子类的对象
    B. 是指当前类的对象
    C. 是指当前父类的对象
    D. 可以用在main()方法中
    8、阅读下面JAVA代码片段,正确的选项是B
    在这里插入图片描述

    A. 第1行编译错误,但能输出正确结果
    B. 第2行编译错误,但能输出正确结果
    C. 第3行编译错误,不能输出正确结果
    D. 第4行编译错误,不能输出正确结果
    9、下列关于super和this的说法正确的是(多选)ABD
    A. this关键字通常指当前对象
    B. super关键字则指父类对象
    C. 在一个类中this只可以调用当前类中公有属性和方法
    D. 在一个类中super可以调用父类中允许被访问的属性和方法
    10、下列关于Object类的叙述错误的是D
    A. Object类是所有类的父类
    B. 所有类都可以继承Object中允许被继承的方法
    C. 一个类没有使用extends关键字明确标识继承关系,则默认继承Object类
    D. 要想继承Object类,必须使用extends关键字标识继承关系,否则不会实现继承
    11、该段代码的运行结果为D
    在这里插入图片描述

    A. true
    B. 相等
    C. 不相等
    D. false
    12、在Java中,关于继承的说法错误的是C
    A. 使用extends关键字实现一个类继承另一个类
    B. 所有的Java类都直接或间接地继承了java.lang.Object类
    C. 在子类的构造方法中,必须显式调用父类的构造方法
    D. 在子类的构造方法中,可以通过super关键字调用父类的构造方法
    13、下列关于final的说法错误的是C
    A. final修饰的变量值不允许被修改
    B. final修饰的方法不可被重写
    C. final可以修饰所有方法
    D. final不可以修饰构造方法
    二、编程

    1、编程练习:某公司要开发“XX车行管理系统”,请使用面向对象的思想,设计自定义类描述自行车、电动车和三轮车。
    程序参考运行效果图如下:
    在这里插入图片描述

    任务
    任务分析;
    第一步:分析自行车、电动车和三轮车的共性:

    1、都是非机动车,具有非机动车的基本特征
    2、都有运行的方法
    第二步:根据共性,定义非机动车
    属性:品牌、颜色、轮子(默认2个)、座椅(默认 1个)
    方法:

    1. 编写无参构造方法、双参构造方法和四参构造方法,其中,在双参构造方法中,完成对品牌和颜色的赋值;在四参构造方法中,完成对所有属性的赋值
    2. 编写运行的方法,描述内容为:这是一辆颜色的,牌的非机动车,有个轮子,有个座椅的非机动车。其中**的数据由属性提供

    第三步:定义自行车、电动车和三轮车分别继承自行车类,要求:

    自行车类:
    1、在构造方法中调用父类多参构造,完成属性赋值
    2、重写运行方法,描述内容为:这是一辆颜色的,牌的自行车。其中的数据由属性提供
    电动车:
    1、增加“电池品牌”属性
    2、重写运行方法,描述内容为:这是一辆使用
    牌电池的电动车。其中的数据由属性提供
    三轮车:
    1、在无参构造中实现对轮子属性值进行修改
    2、重写运行方法,描述内容为:三轮车是一款有
    个轮子的非机动车。其中**的数据由属性提供

    非机动车类:

    package com.dodoke.car.fatherclass;
    
    public class NonMotor {
        // 私有属性:品牌、颜色、轮子(默认2个)、座椅(默认 1个)
        private String name;
        private String color;
        private int lunzi=2;
        private int seat=1;
        
        // 无参构造方法
        public NonMotor() {
        
        }
    
        // 双参构造方法,完成对品牌和颜色的赋值
        public NonMotor(String name,String color) {
        	this.name=name;
        	this.color=color;
        }
    
        // 四参构造方法,分别对所有属性赋值
        public NonMotor(String name,String color,int lunzi,int seat) {
        	this.name=name;
        	this.color=color;
        	this.lunzi=lunzi;
        	this.seat=seat;
        }
    
        // 公有的get/set方法完成属性封装
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
        	this.name = name;
        }
    
        public String getColor() {
        	return color;
        }
    
        public void setColor(String color) {
        	this.color = color;
        }
    
        public int getLunzi() {
        	return lunzi;
        }
    
        public void setLunzi(int lunzi) {
        	this.lunzi = lunzi;
        }
    
        public int getSeat() {
        	return seat;
        }
    
        public void setSeat(int seat) {
        	this.seat = seat;
        }
    
        // 方法:运行,描述内容为:这是一辆**颜色的,**牌的非机动车,有**个轮子,有**个座椅的非机动车。其中**的数据由属性提供
        public String work() {
        	String str="这是一辆"+getColor()+"颜色的,"+getName()+"牌的非机动车,有"+getLunzi()+"个轮子,有"+getSeat()+"个座椅";
        	return str;
        }
    
    }
    

    自行车类:

    package com.dodoke.car.sonclass;
    
    import com.dodoke.car.fatherclass.NonMotor;
    
    public class Bicycle extends NonMotor {
        // 在构造方法中调用父类多参构造,完成属性赋值
        public Bicycle() {
            super("捷安特","黄");
        }
    
        // 重写运行方法,描述内容为:这是一辆**颜色的,**牌的自行车。其中**的数据由属性提供
        public String work() {
        	String str="这是一辆"+getColor()+"颜色的,"+getName()+"牌的自行车。";
        	return str;
        }
    
    }
    

    电动车类:

    package com.dodoke.car.sonclass;
    
    import com.dodoke.car.fatherclass.NonMotor;
    
    public class Electric extends NonMotor {
        // 私有属性:电池品牌
        private String battery;
        //无参构造方法
        public Electric() {
            
        }
    
        //带参构造方法
        public Electric(String battery) {
        	this.battery=battery;
        }
        // 公有的get/set方法完成属性封装
        public String getBattery() {
        	return battery;
        }
    
        public void setBattery(String battery) {
        	this.battery = battery;
        }
    
        // 重写运行方法,描述内容为:这是一辆使用**牌电池的电动车。其中**的数据由属性提供
        public String work() {
        	String str="这是一辆使用"+getBattery()+"牌电池的电动车";
        	return str;
        }
    
    }
    

    三轮车类:

    package com.dodoke.car.sonclass;
    
    import com.dodoke.car.fatherclass.NonMotor;
    
    public class Tricycle extends NonMotor {
        // 在无参构造中实现对轮子属性值进行修改
        public Tricycle() {
            setLunzi(3);
        }
    
        // 重写运行方法,描述内容为:三轮车是一款有**个轮子的非机动车。其中**的数据由属性提供
        public String work() {
        	String str="三轮车是一款有"+getLunzi()+"个轮子的非机动车。";
        	return str;
        }
    
    }
    
    

    测试类:

    package com.dodoke.car.test;
    import com.dodoke.car.fatherclass.NonMotor;
    import com.dodoke.car.sonclass.*;
    public class Test {
    
    public static void main(String[] args) {
        System.out.print("父类信息测试:");
        NonMotor motor=new NonMotor("天宇","红",4,2);
        System.out.println(motor.work());
        
        System.out.print("自行车类信息测试:");
        Bicycle bike=new Bicycle();
        System.out.println(bike.work());
        
        System.out.print("电动车类信息测试:");
        Electric evehicle=new Electric("飞鸽");
        System.out.println(evehicle.work());
        
        System.out.print("三轮车类信息测试:");
        Tricycle tcycle=new Tricycle();
        System.out.println(tcycle.work());
    
    }
    
    }
    

    2、请使用面向对象的思想,设计自定义类Person继承Object类,重写toString方法实现对象信息输出。
    运行效果如下图所示:
    在这里插入图片描述

    思路分析

    创建一个 Person 类继承自 Object,其中类的结构要求为:
    属性:name(姓名)、age(年龄)、sex(性别)
    方法:
    创建带参(name、age、sex为参数)构造方法
    重写 toString 方法,输出信息格式为:姓名:** 年龄:** 性别:**(其中,**为对象对应属性值)
    创建测试类,在测试方法中,实例化 Person对 象,并传入三个属性值。然后,分别通过直接打印Person对象以及利用重写的 toString 方法,打印输出2行对象信息。

    Person类:

    package com.dodoke.person.fatherclass;
    
    public class Person {
        //私有属性:name(姓名)、age(年龄)、sex(性别)
        private String name;
        private int age;
        private String sex;
        
        //无参构造方法
        public Person() {
        
        }
    
        //带参构造方法(name、age、sex为参数)
        public Person(String name,int age,String sex) {
        	this.name=name;
        	this.age=age;
        	this.sex=sex;
        }
    
        //通过封装实现对属性的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() {
        	return "姓名:"+getName()+"  年龄:"+getAge()+"  性别:"+getSex();
        }
    
    }
    

    测试类:

    package com.dodoke.person.test;
    
    import com.dodoke.person.fatherclass.Person;
    
    public class Test {
    
    	public static void main(String[] args) {
    		//实例化对象,传入属性值(李明, 男,18)
    		Person LiMing=new Person("李明",18,"男");
        
    		//打印输出对象信息
    		System.out.println(LiMing);
    		System.out.println(LiMing.toString());
    
    	}
    
    }
    

    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和它的重载方法

    父类水果类:

    package com.dodoke.fruits.fatherclass;
    
    public class Fruits {
        // 私有属性:水果的形状(shape)和口感(taste)
        private String shape;
        private String taste;
    
        public Fruits() {
    
        }
    
        // 带参构造函数(参数为shape和taste)
        public Fruits(String shape,String taste) {
        	this.shape=shape;
        	this.taste=taste;
        }
    
        //通过封装实现对私有属性的get/set访问
        public String getShape() {
        	return shape;
        }
    
        public void setShape(String shape) {
        	this.shape = shape;
        }
    
        public String getTaste() {
        	return taste;
        }
    
        public void setTaste(String taste) {
        	this.taste = taste;
        }
    
        // 创建无参无返回值得方法eat(描述内容为:水果可供人们食用!)
        public String eat() {
        	return "水果可供人们食用!";
        }
    
        // 重写equals方法,比较两个对象是否相等(比较shape,taste)
        public boolean equals(Object obj) {
        	// 1. 首先判断传入的对象是否为null
        	if(obj==null){
        		// 如果是null则直接返回false
        		return false;
        	}else{
        		// 2. 接着判断两个对象中的属性值是否一致
        		// 此时是引用数据类型的强制类型转换,形式也是类似于之前学习过的基本数据类型强制类型转换
        		Fruits temp=(Fruits)obj;
        		if(this.getShape().equals(temp.getShape())&&this.getTaste().equals(temp.getTaste())){
        			return true;
        		}else{
        			return false;
        		}
                
        	}
            
        }
    }
    
    

    子类杨梅类:

    package com.dodoke.fruits.sonclass;
    
    import com.dodoke.fruits.fatherclass.Fruits;
    
    //要求Waxberry类不允许有子类
    public final class Waxberry extends Fruits {
          // 私有属性:颜色(color)
          private String color;
    
          //创建构造方法,完成调用父类的构造方法,完成属性赋值
          public Waxberry() {
        	  super("圆形","酸甜适中");
          }
    
    
    
          public String getColor() {
        	  return color;
          }
    
          public void setColor(String color) {
        	  this.color = color;
          }
      
          //创建不允许重写的face方法,描述为:杨梅:**、**,果味酸甜适中
          public final String face() {
        	  return "杨梅:"+getColor()+"、"+getShape()+",果味酸甜适中。";
          }
              
          //重写父类eat方法,描述为:杨梅酸甜适中,非常好吃!
          public String eat() {
        	  return "杨梅酸甜适中,非常好吃!";
          }
      
          //重写toString方法,输出的表现形式不同(输出shape,color,taste)
          public String toString() {
        	  return "杨梅的信息:果实为"+getShape()+"、"+getColor()+","+getTaste()+",非常好吃!";
          }
    
    }
    

    子类仙人焦类:

    package com.dodoke.fruits.sonclass;
    
    import com.dodoke.fruits.fatherclass.Fruits;
    
    public class Banana extends Fruits{
        // 私有属性:品种(variety)
        private String variety;
    
        public String getVariety() {
        	return variety;
        }
    
        public void setVariety(String variety) {
        	this.variety = variety;
        }
    
    
            
        //无参构造方法
        public Banana() {
        
        }
        //创建带参构造方法为所有属性赋值
        public Banana(String variety) {
        	this.variety=variety;
        }
    
        //创建无参无返回值的advantage方法,描述为:**果形**,果肉香甜,可供生食。
        public void advantage() {
        	System.out.println(getVariety()+"果形"+getShape()+",果肉香甜,可供生食。");
        }
        
        //创建重载advantage方法(带参数color),描述为:**颜色为**
        public void advantage(String color) {
        	System.out.println(getVariety()+"颜色为"+color);
        }
    
    }
    
    

    测试类:

    package com.dodoke.fruits.test;
    
    import com.dodoke.fruits.fatherclass.Fruits;
    import com.dodoke.fruits.sonclass.Banana;
    import com.dodoke.fruits.sonclass.Waxberry;
    
    public class Test {
    
    	public static void main(String[] args) {
    		// 实例化2个父类对象,传入两组相同的参数值
    		Fruits f1=new Fruits("圆形","果肉香甜");
    		Fruits f2=new Fruits("圆形","果肉香甜");
    		// 调用父类eat方法
    		System.out.println(f1.eat());
    		// 测试重写equals方法,判断两个对象是否相等
            boolean flag=f1.equals(f2) ;
            System.out.println("fru1和fru2的引用比较:"+flag);
    
            System.out.println("——————————————————————————————————————————————");
            // 实例化子类对象,并传入相关参数值
            Waxberry wax=new Waxberry();
            wax.setColor("紫红色");
    
            // 调用子类face方法和eat方法
            System.out.println(wax.face());
            System.out.println(wax.eat());
    
            // 测试重写toString方法,输出子类对象的信息
            System.out.println(wax.toString());
    
            System.out.println("——————————————————————————————————————————————");
            // 实例化Banana类对象,并传入相关参数值
            Banana ban=new Banana("仙人蕉");
            ban.setShape("短而稍圆");
    
            // 调用子类的advantage和它的重载方法
            ban.advantage();
            ban.advantage("黄色");
    
    	}
    
    }
    
    展开全文
  • java继承习题

    2020-05-11 21:00:42
    Java中,以下关于方法重载和方法重写描述正确的是(D ) A. 方法重载和方法重写实现的功能相同 B. 方法重载出现在父子关系中,方法重写是在同一类中 C. 方法重载的返回类型必须一致,参数项必须不同 D. 方法重写...

    练习
    一、选择

    1. 在Java中,以下程序的输出结果是(A)
      在这里插入图片描述

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

    3. 哪个选项中的方法插入到(1)处可以正确实现方法重写(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()方法中

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

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

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

    11. 该段代码的运行结果为(D )
      在这里插入图片描述
      A. true
      B. 相等
      C. 不相等
      D. false

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

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

    14. 编程练习:某公司要开发“XX车行管理系统”,请使用面向对象的思想,设计自定义类描述自行 车、电动车和三轮车。 程序参考运行效果图如下:
      在这里插入图片描述
      任务分析; 第一步:分析自行车、电动车和三轮车的共性:

    15. 都是非机动车,具有非机动车的基本特征 2. 都有运行的方法
      第二步:根据共性,定义非机动车 属性:品牌、颜色、轮子(默认2个)、座椅(默认 1个) 方法: 1. 编写无参构造方法、双参构造方法和四参构造方法,其中,在双参构造方法中,完成对品牌和 颜色的赋值;在四参构造方法中,完成对所有属性的赋值 2. 编写运行的方法,描述内容为:这是一辆颜色的,牌的非机动车,有个轮子,有个座椅 的非机动车。其中**的数据由属性提供 第三步:定义自行车、电动车和三轮车分别继承自行车类,要求:
      自行车类:

    16. 在构造方法中调用父类多参构造,完成属性赋值 2. 重写运行方法,描述内容为:这是一辆**颜色的,牌的自行车。其中的数据由属性提供
      电动车:

    17. 增加“电池品牌”属性 2. 重写运行方法,描述内容为:这是一辆使用牌电池的电动车。其中的数据由属性提供
      三轮车:

    18. 在无参构造中实现对轮子属性值进行修改 2. 重写运行方法,描述内容为:三轮车是一款有个轮子的非机动车。其中的数据由属性提供
      在这里插入图片描述
      在这里插入图片描述
      在这里插入图片描述
      在这里插入图片描述
      在这里插入图片描述

    19. 请使用面向对象的思想,设计自定义类Person继承Object类,重写toString方法实现对象信息输 出。 运行效果如下图所示:
      在这里插入图片描述
      思路分析
      创建一个 Person 类继承自 Object,其中类的结构要求为: 属性:name(姓名)、age(年龄)、sex(性别)
      方法: 创建带参(name、age、sex为参数)构造方法 重写 toString 方法,输出信息格式为:姓名:** 年龄:** 性别:**(其中,**为对象对应 属性值) 创建测试类,在测试方法中,实例化 Person对 象,并传入三个属性值。然后,分别通过直接 打印Person对象以及利用重写的 toString 方法,打印输出2行对象信息。
      public class Person{ //私有属性:name(姓名)、age(年龄)、sex(性别)

    //带参构造方法(name、age、sex为参数) //通过封装实现对属性的get/set方法设定

    //重写toString方法,表示形式为:姓名:++ 年龄:++ 性别:+**

    } 
    

    在这里插入图片描述
    3. 请使用面向对象的思想,实现杨梅和仙人蕉的信息描述。 程序参考运行效果图如下:
    在这里插入图片描述
    带参构造函数(参数为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和它的重载方法
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 关于Java以下描述正确的有( ) Class类是Object类的超类 Object类是一个final类 String类是一个final类 Class类可以装载其它类 A.class类是Object的派生类 B.每个类都使用Object类作为超类,而final修饰的...
  • 初识java继承

    千次阅读 2014-04-07 19:04:50
     实验练习 Employee层次结构     程序模板是一个完整的、可实际运行的JAVA程序,其中关键的1行或者多行代码已经替换为注释。请先阅读问题描述,分析示例输出;然后研究模板的代码。...l 创建正确调用
  • Java继承题目练习

    千次阅读 2020-07-22 22:51:36
    Java中,以下关于方法重载和方法重写描述正确的是B A. 方法重载和方法重写实现的功能相同 B. 方法重载出现在父子关系中,方法重写是在同一类中 C. 方法重载的返回类型必须一致,参数项必须不同 D. 方法重写需要...
  • 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 ...
  • JAVA中,下面对继承的说法,正确的是() A. 子类能继承父类的所有成员 B. 子类继承父类的非私有方法和状态 C. 子类只能继承父类的public方法和状态 D. 子类只能继承父类的方法 答案:A 解析: 我们有时候会分不清...
  • Java继承练习题

    千次阅读 2020-05-11 20:18:34
    2.在Java中,以下关于方法重载和方法重写描述正确的是 A A. 方法重载和方法重写实现的功能相同 B. 方法重载出现在父子关系中,方法重写是在同一类中 C. 方法重载的返回类型必须一致,参数项必须不同 D. 方法重写需要...
  • 本系列文章将整理到我在GitHub上的《Java面试指南》仓库,更多精彩内容请到我的仓库里查看 https://github.com/h2pl/Java-Tutorial 喜欢的话麻烦点下Star哈 文章首发于我的个人博客: www.how2playlife.com 本文...
  • Java基础之继承

    2019-04-13 14:24:35
    什么是继承? 多个类存在相同的属性和行为时,将这些内容抽取到单独的一个类中,那么多个类无需再定义这些属性和行为,只需要...1.Java只支持单继承,不支持多继承(一个类只能有一个父类,不可能有多个父类) 2...
  • 关于java继承,初学的时候,一直认为父类中private修饰的东西时无法被子类继承。后来随着学习的深入,见得多了一些,看到一些文章博客的另一种观点:其实父类中的东西,除了构造方法之外,其它的全都是可以被继承...
  • java中关于继承的问题

    千次阅读 2016-12-20 19:46:30
    java中关于继承
  • 文章目录第1关:练习-Java继承和多态之综合练习答案 第1关:练习-Java继承和多态之综合练习 任务描述 本关任务:按照动物、宠物、猫和蜘蛛的关系,通过编程实现各自的关系并声明自己的属性和方法。 编程要求 仔细...
  • Java继承的实现

    千次阅读 2019-01-30 20:28:51
    继承描述的是一种能力:可以使用现有类的所有功能,并在无需重新编写原有类的情况下进行功能上的扩展。 要使用继承,必须满足 is-a 原则(代码复用),定义的语法为:子类 extends 父类。 子类:又称为派生类,...
  • java继承的注意事项

    2019-10-30 21:48:18
    1:java中类只支持单继承,不支持多继承; 2:java中的类支持多层继承; //父类 /* 爷爷类 */ public class Home { public void drink(){ System.out.println("爷爷爱喝酒"); } } //子类 ```java /* ...
  • 简记:最近,康康考了一场Easy模式的JAVA小测,输给选择判断题了,还是简单记录下错题吧,爆了接口和继承的雷。 判断题: 1、一个类可以实现多个接口 解析:这句话是正确的,一个类可以实现多个接口。 注意:一个类...
  • Java继承经典面试题

    千次阅读 热门讨论 2018-04-01 21:25:31
    一、面试题 面试题 LVXQ.java 代码如下public class LJXQ { public static void main(String[] args) { A a = new A(); B b = new B(); C c = new C(); D d = new D(); System.out.println(a.get(a) + &...
  • 对于继承父类的子类而言,有时我们需要在子类中访问父类的方法,此时便可以使用 super 关键字。 在 Java 里面,对于 super 关键字的用法: 子父类存在着同名的成员(包括变量和方法)时,在子类中默认是访问子类的...
  • 文章目录任务描述编程要求测试说明参考答案 任务描述 本关任务:按照动物、宠物、猫和蜘蛛的关系,通过编程实现各自的关系并声明自己的属性和方法。 编程要求 仔细阅读右侧编辑区内给出的代码框架及注释,在 Begin-...
  • 文章目录任务描述相关知识final 关键字的使用final 关键字修饰类、成员变量和成员方法编程要求测试说明...在 Java 中声明类、属性和方法时,可使用关键字 final 来修饰。 final 标记的类不能被继承; final 标记的方
  • 为什么Java继承是有害的

    千次阅读 2005-04-27 19:38:00
    JAVA设计模式”一书详细阐述了怎样用接口继承代替实现继承。这篇文章描述设计者为什么会这么作。 Extends是有害的;也许对于Charles Manson这个级别的不是,但是足够糟糕的它应该在任何可能的时候被避开。“JAVA...
  • Java笔记—继承

    千次阅读 2019-11-21 17:37:43
    Java笔记——继承 创建时间:2019.11.21 说明:持续更新ing 继承源于自然 就比如:兔子和羊属于食草动物类,狮子和豹属于食肉动物类。食草动物和食肉动物又是属于动物类。虽然食草动物和食肉动物都是属于动物,...
  • Java 中重载是指一个类中可以有多个方法具有相同的名字,但这些方法的参数必须不同。这里需要注意的是参数不同需要满足 2 个条件:一个是参数的个数不同;一个是参数个数相同,但参数列表中对应的某个参数的类型不同...
  • 任务描述 编程要求 测试说明 任务描述 本关任务:按照动物、宠物、猫和蜘蛛的关系,通过编程实现各自的关系并声明自己的属性和方法。 编程要求 仔细阅读右侧编辑区内给出的代码框架及注释,在 Begin-End 中实现如下...
  • 在UML中表示Java继承和接口

    千次阅读 2008-03-13 15:30:00
    继承Java中,我们可以声明一个类扩展(extends)另一个类,还可以声明一个类实现(implements)一个或者多个接口。下面我们来看看如何在UML中表达这些概念。下面是三个Java类的基本骨架。第一个类是代表某种支付...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 109,554
精华内容 43,821
热门标签
关键字:

java继承描述正确的是

java 订阅