精华内容
下载资源
问答
  • 头歌实践-Java继承与多态
    千次阅读
    2021-10-28 19:18:19

    第1关:练习-Java继承和多态之final关键字

    /**
     * 按照代码文件中提供的注释完成 Demo 类的编写,使得程序正常输出。
     */
    class DemoTest{
        int i = 10;
    }
    // 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
    /********* Begin *********/
    
    // 将Demo类改为 final形式
    final class Demo{
        // 定义一个final、static常量,名为PI,值为3.14
    	final static double PI=3.14;
        // 声明一个final类型的DemoTest对象,命名为demoTest
    	 final DemoTest demoTest = new DemoTest();//这里声明时应该初始化
    	
        // 声明一个不为final类型的DemoTest对象,命名为demoTest2
    	DemoTest demoTest2;
        // 声明一个final型的数组,类型为int,值为 1,2,3,命名为a
    	final int []a=new int[]{1,2,3};
        // 删除主函数中错误的代码,使得程序能够正确输出
        public static void main(String[] args) {
            Demo demo = new Demo();
            //demo.demoTest = new Test();
            //demo.PI = 20;//final变量一经定义赋值则不可以改变
            System.out.println(demo.PI);
            demo.demoTest2 = new DemoTest();
            System.out.println(demo.demoTest2.i);
            for (int i = 0; i < demo.a.length; i++){
                demo.a[i] = 9;
                System.out.println(demo.a[i]);
            }
        }
    }
    /********** End **********/
    

    第2关:学习-Java继承和多态之对象类型的转换

    任务描述

    本关任务:使用对象类型的转换,根据编程提示,完成猫类和动物类的转换,以及彼此方法和属性的调用。

    相关知识

    在之前的学习任务中,我们学习了基本类型之间的转换,这里我们来为大家介绍对象间的类型转换。

    Java 语言允许某个类型的引用变量引用子类的实例,而且可以对这个引用变量进行类型转换。如果把引用类型转换为子类类型,则称为向下转型;**如果把引用类型转换为父类类型,则称为向上转型。**注意:两者必须为父子关系。

    向上转型

    把子类对象赋值给父类类型的变量(隐式转换,不用进行强制类型转换),被称为向上转型。

    本质:父类的引用指向了子类的对象。

    语法:

    父类类型 引用名 = new 子类类型() ;

    例如:狗是动物的一种,那么也可以将狗看成一个动物对象。

    class Animal{
        public void info(){
            System.out.println("我是动物");
        }
    }
    class Dog extends Animal{
        public void eat(){
            System.out.println("狗在吃东西");
        }
        public static void main(String[] args) {
            Animal animal = new Dog(); // 向上转型
            animal.info();
        }
    }
    

    执行结果:

    我是动物

    狗对象可以调用该方法,那么同样猫也可以调用该方法,这就做到了在父类中定义一个方法可以完成各个子类的功能。由于向上转型是一个从较具体类到较抽象类的转换,所以它总是安全的,因为我们可以说狗是动物,但是不能说动物是狗。

    向上转型的特点如下:

    1. 向上转型对象不能操作子类新增的成员变量(失掉了这部分属性),不能使用子类新增的方法(失掉了一些功能);

    2. 向上转型对象可以操作子类继承或重写的成员变量,也可以使用子类继承的或重写的方法;

    3. 如果子类重写了父类的某个方法后,当对象的向上转型对象调用这个方法时一定是调用了这个重写的方法,因为程序在运行时知道,这个向上转型对象的实体是子类创建的,只不过损失了一些功能而已。

    向下转型

    向下转型是指子类引用父类对象,就是将父类对象能转换成子类对象,这时需要满足两个条件:一是必须执行强制类型转换;二是必须确保父类对象是子类的一个实例,否则抛出异常。

    语法:

    子类类型 引用名 = (子类类型)父类引用;

    class Animal{
        public void info(){
            System.out.println("我是动物");
        }
    }
    class Dog extends Animal{
        public void eat(){
            System.out.println("狗在吃东西");
        }
        public static void main(String[] args) {
            Animal animal = new Dog(); // 向上转型
            Dog animal1 = (Dog) animal; // 向下转型
            animal1.eat();
        }
    }
    

    执行结果:

    狗在吃东西

    向下转型的特点如下:

    1. 向下转型对象可以操作父类及子类成员变量和成员方法;

    2. 向下转型对象访问重写父类的方法时,操作的是子类的方法;

    3. 向下转型必须进行强制类型转换;

    4. 向下转型必须保证父类对象引用的是该子类的对象,如果引用的是父类的其他子类对象,会抛出类型不匹配异常。

    编程要求

    仔细阅读右侧编辑区内给出的代码框架及注释,在 Begin-End 中完成猫类和动物类的转换,以及彼此方法和属性的调用,具体要求如下:

    把猫类对象赋值给动物类;
    将动物类引用转换为猫类对象;
    输出 Animal 类的 name 变量;
    输出 Animal 类的 staticName 变量;
    输出 Cat 类的 eat() 方法;
    输出 Animal 类的 staticEat() 方法;
    调用 Cat 类的 str 变量;
    调用 Cat 类的 eatMethod() 方法。

    /**
     * 使用对象类型的转换,根据编程提示,完成猫类和动物类的转换,以及彼此方法和属性的调用
     * 	把猫类对象赋值给动物类;
    	将动物类引用转换为猫类对象;
    	输出 Animal 类的 name 变量;
    	输出 Animal 类的 staticName 变量;
    	输出 Cat 类的 eat() 方法;
    	输出 Animal 类的 staticEat() 方法;
    	调用 Cat 类的 str 变量;
    	调用 Cat 类的 eatMethod() 方法。
     */
     // 定义动物类
    class Animal{
    	// 定义动物类的属性
        public String name = "动物";
        public static String staticName = "可爱的动物";
        // 定义动物类的行为方法
        public void eat() {
            System.out.println("动物吃饭");
        }
        public static void staticEat() {
            System.out.println("可爱的动物正在在吃饭");
        }
    }
    // 定义猫类,该类继承动物类
    public class Cat extends Animal{
    	// 定义猫类的属性
        public String name = "猫";
        public String str = "可爱的小猫";
        public static String staticName = "我是喵星人";
        // 定义猫类的行为方法
        public void eat() {
            System.out.println("猫吃饭");
        }
        public static void staticEat() {
            System.out.println("喵星人在吃饭");
        }
        public void eatMethod() {
            System.out.println("猫喜欢吃鱼");
        }
    
        public static void main(String[] args) {
            // 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
            /********* Begin *********/
            // 向上转型,把猫类对象赋值给动物类
        	Animal animal =new Cat();
            // 向下转型,将动物类引用转换为猫类对象
        	Cat cat2=(Cat) animal;
            // 输出Animal类的name变量
        	System.out.println(animal.name);
            // 输出Animal类的staticName变量
        	//直接通过类名访问静态变量
        	System.out.println(Animal.staticName);
            // 输出Cat类的eat()方法
        	animal.eat();
            // 输出Animal类的staticEat()方法
        	Animal.staticEat();
            // 调用Cat类的str变量
        	System.out.println(cat2.str);
            // 调用Cat类的eatMethod()方法
        	cat2.eatMethod();
            /********** End **********/
        }
    }
    
    
    
    
    

    第3关:练习-Java继承和多态之方法重载

    任务描述

    本关任务:定义名为 print 的静态方法,携带一个参数,无论该参数是 int 型、double 型还是字符串型,都可以将该参数进行打印。

    编程要求

    仔细阅读右侧编辑区内给出的代码框架及注释,按照提示编写程序代码。

    
    /**
     * 任务:定义名为 print 的静态方法,携带一个参数,
     * 无论该参数是 int 型、double 型还是字符串型,都可以将该参数进行打印。
     */
    public class Print {
        // 请在下面的Begin-End之间编写正确的代码
        /********** Begin **********/
    	static void print(int num) {
    		System.out.println(num);
    	}
    	static void print(double num) {
    		System.out.println(num);
    	}
    	static void print(String str) {
    		System.out.println(str);
    	}
    	
    	public static void main(String []args) {
    		Print.print(16);
    		Print.print(16.0);
    		Print.print("16");
    	}
    
        /********** End **********/
    }
    

    第4关:练习-Java继承和多态之方法重写

    任务描述

    本关任务:计算球的表面积。

    编程要求

    仔细阅读右侧编辑区内给出的代码框架及注释,按照提示编写程序代码。

    /**
     * 重写 Shape 中的 area 方法,计算球的表面积。
     */
    
    class Shape {
        private double r; //球的半径
        // 球的体积
        public double area(){
            double s = (double)3/4*Math.PI*Math.pow(r,3);
            return s;
        }
    }
    public class Sphere extends Shape{
    
        private double r; //球的半径
        
        public Sphere(double r) {
            this.r = r;
        }
        // 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
        /********* Begin *********/
        // 重写 Shape 中的 area 方法,计算球的表面积,将计算结果返回
        public double area(){
            double s = (double)4*Math.PI*Math.pow(r,2);
            return s;
        }
        
        public static void main(String []args) {
        	Sphere sphere=new Sphere(2);
        	System.out.println("球的表面积是:"+sphere.area());
        	
        }
        /********** End **********/
    }
    
    
    
    更多相关内容
  • 描述内脏大神经由下列何种纤维组成9、错误在IVEAR定义条件下的波形系数kfe为为方便加工,继承机制图样中机件的每一个尺寸,可标注多次。描述属于面肌者尺寸界线可以直接利用轮廓线、错误轴线或对称中...

    9、继承机制在IVEAR定义条件下的波形系数kfe为

    13、描述可实现有源逆变的电路为.

    错误构成纤维膜后部的是

    831555.jpg

    小明今年十三岁,属于限制民事行为能力人,因此,他购买文具、继承机制零食等行为必须经家长认可才有效。

    描述内脏大神经由下列何种纤维组成

    9、错误在IVEAR定义条件下的波形系数kfe为

    为方便加工,继承机制图样中机件的每一个尺寸,可标注多次。

    描述属于面肌者

    尺寸界线可以直接利用轮廓线、错误轴线或对称中心线。

    16、晶闸管装置的容量愈大,对电网的影响就愈小。( )

    继承机制膝关节的错误说法是

    具有边分裂边分化特点的是()。

    描述What was the essential difference _____ selling and marketing?

    14、错误对低电压大电流的负载供电,应该用带平衡电抗器的双反星型可控整流装置。( )

    继承机制She told us briefly about how they succeeded in _____ the new product.

    15、描述晶闸管触发电路与主电路的同步,主要是通过同步变压器的不同结线方式来实现的( )

    错误所有组织均来源于( )。

    It has been quite a long time ____ the two companies established a business relationship.

    《机械制图》主要研究绘制和阅读?????????????????????? ____的原理和方法。

    展开全文
  • Java继承题目练习

    千次阅读 2020-07-22 22:51:36
    Java中,以下关于方法重载和方法重写描述正确的是B 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 虽然编译错误但是整个代码过程中都没有调用无参构造器所以选择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. 重写运行方法,描述内容为:三轮车是一款有**个轮子的非机动车。其中**的数据由属性提供
      3. package car;
        
        /**
         * 定义非机动车共有属性
         * 
         * @author user
         *
         */
        public class Car {
        	private String carName;// 品牌
        
        	private String carcol;// 颜色
        
        	private int cargulu = 2;// 轮子数量默认2个
        
        	private int cardown = 1;// 座椅数量默认1个
        
        	public String getCarName() {
        		return carName;
        	}
        
        	public void setCarName(String carName) {
        		this.carName = carName;
        	}
        
        	public String getCarcol() {
        		return carcol;
        	}
        
        	public void setCarcol(String carcol) {
        		this.carcol = carcol;
        	}
        
        	public int getCargulu() {
        		return cargulu;
        	}
        
        	public void setCargulu(int cargulu) {
        		this.cargulu = cargulu;
        	}
        
        	public int getCardown() {
        		return cardown;
        	}
        
        	public void setCardown(int cardown) {
        		this.cardown = cardown;
        	}
        
        	public Car() {
        		super();
        	}
        	
        
        	public Car(String carName, String carcol) {
        		super();
        		this.setCarName(carName);
        		this.setCarcol(carcol);
        	}
        
        	public Car(String carName, String carcol, int cargulu, int cardown) {
        		super();
        		this.setCarName(carName);
        		this.setCarcol(carcol);
        		this.setCargulu(cargulu);
        		this.setCardown(cardown);
        	}
        
        	public String info() {
        		String str = "父类信息测试:这是一辆" + this.getCarcol() + "颜色的," + this.getCarName() + "牌的非机动车,有" + this.getCargulu() + "个轮子,有"
        				+ this.getCardown() + "个座椅的非机动车。";
        		return str;
        	}
        }
        
        package car;
        /**
         * 自行车
         * @author user
         *
         */
        public class Zixinche extends Car{
        	public Zixinche(){
        		super();
        	}
        	
        	public Zixinche(String carcol, String carName){
        		super(carcol,carName);
        		System.out.println( "自行车类信息测试:这是一辆" + carcol + "颜色的," + carName + "牌的自行车。");
        	}
        }
        package car;
        /**
         * 电动车
         * @author user
         *
         */
        public class Diandongche extends Car {
        	private String dianchi;
        
        	public String getDianchi() {
        		return dianchi;
        	}
        
        	public void setDianchi(String dianchi) {
        		this.dianchi = dianchi;
        	}
        	
        	public Diandongche(){
        		super();
        	}
        
        	public Diandongche(String dianchi) {
        		super();
        		this.dianchi = dianchi;
        		System.out.println("电动车类信息测试:这是一辆使用" + this.getDianchi() + "牌电车的电动车。");
        	}
        	
        	
        }
        
        package car;
        /**
         * 三轮车
         * @author user
         *
         */
        public class Sanlunche extends Car {
        	public Sanlunche(){
        		super();
        		this.setCargulu(3);
        	}
        	
        	public String inpp(){
        		String str = "三轮车类信息测试:三轮车是一款有" + this.getCargulu() + "个轮子的非机动车。";
        		return str;
        	}
        }
        
        package test;
        
        import car.Car;
        import car.Diandongche;
        import car.Sanlunche;
        import car.Zixinche;
        
        public class Test {
        	public static void main(String[] args){
        		Car car = new Car("天宇", "紅色",4,2);
        		System.out.println(car.info());
        		Zixinche zxc = new Zixinche("红色","捷安特");
        		Diandongche ddc = new Diandongche("飞鸽");
        		Sanlunche slc = new Sanlunche();
        		System.out.println(slc.inpp());
        	}
        }
        

         

         

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

      思路分析

      • 创建一个 Person 类继承自 Object,其中类的结构要求为:
        属性:name(姓名)、age(年龄)、sex(性别)
        方法:
        • 创建带参(name、age、sex为参数)构造方法
        • 重写 toString 方法,输出信息格式为:姓名:** 年龄:** 性别:**(其中,**为对象对应属性值)
      • 创建测试类,在测试方法中,实例化 Person对 象,并传入三个属性值。然后,分别通过直接打印Person对象以及利用重写的 toString 方法,打印输出2行对象信息。
      • package person;
        
        public class Person {
        	private String name;
        	
        	private int age;
        	
        	private String sex;
        
        	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;
        	}
        	
        	public Person(){
        		super();
        	}
        
        	public Person(String name, int age, String sex) {
        		super();
        		this.setName(name);
        		this.setAge(age);
        		this.setSex(sex);
        	}
        	
        	@Override
        	public String toString() {
        		String str = "姓名:" + this.getName() + "  " + "年龄:" + this.getAge() + "   " + "性别:" + this.getSex();
        		return str;
        	}
        
        }
        
        package test;
        
        import person.Person;
        
        public class Test1 {
        	public static void main(String[] args) {
        		Person person = new Person("李明",18,"男");
        		System.out.println(person);
        		System.out.println(person.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和它的重载方法
    4. package fruits;
      /**
       * 水果类
       * 成员属性:shape形状 taste口感
       * @author user
       *
       */
      public class Fruits {
      	private String shape;
      	
      	private String taste;
      
      	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;
      	}
      
      	public Fruits() {
      		super();
      	}
      
      	public Fruits(String shape, String taste) {
      		super();
      		this.setShape(shape);
      		this.setTaste(taste);
      	}
      
      	public void eat() {
      		System.out.println("水果可供人们食用!");
      	}
      
      
      	@Override
      	public boolean equals(Object obj) {
      		if (obj == null) {
      			return false;
      		} else {
      			Fruits fruits = (Fruits) obj;
      			if (this.getShape().equals(fruits.getShape()) && this.getTaste().equals(fruits.getTaste())) {
      				return true;
      			} else {
      				return false;
      			}
      		}
      	}
      
      }
      
      package fruits;
      /**
       * 子类Waxberry类
       * 添加final属性阻止产生子类创建
       * @author user
       *
       */
      public final class Waxberry extends Fruits {
      	// 成员属性
      	private String color;
      
      	public String getColor() {
      		return color;
      	}
      
      	public void setColor(String color) {
      		this.color = color;
      	}
      
      	//无参构造器
      	public Waxberry() {
      		super();
      	}
      	
      	//多参构造器
      	public Waxberry(String shape, String taste, String color) {
      		super(shape, taste);
      		this.setColor(color);
      	}
      
      	//添加final阻止重写
      	public final void face() {
      		System.out.println("杨梅:" + this.getColor() + "、" + this.getShape() + "," + "果味" + this.getTaste() + "。");
      	}
      	
      	@Override
      	public void eat() {
      		System.out.println("杨梅酸甜适中,非常好吃!");
      	}
      	
      	//toString方法
      	@Override
      	public String toString() {
      		String str = "杨梅的信息:果实为" + this.getShape() + "、" + this.getColor() + "," + this.getTaste() + ",非常好吃!";
      		return str;
      	}
      
      }
      
      package fruits;
      /**
       * 子类:Banana
       * @author user
       *
       */
      public class Banana extends Fruits{
      	//添加私有属性品种为variety
      	private String variety;
      
      	public String getVariety() {
      		return variety;
      	}
      
      	public void setVariety(String variety) {
      		this.variety = variety;
      	}
      
      	//无参构造器
      	public Banana() {
      		super();
      	}
      
      	//多参构造器
      	public Banana(String shape, String taste, String variety) {
      		super(shape, taste);
      		this.setVariety(variety);
      	}
      
      	//无参描述
      	public void advantage() {
      		System.out.println(this.getVariety() + "过形" + this.getShape() + ",过肉" + this.getTaste() + ",可供审食。");
      	}
      	
      	//带参描述
      	public void advantage(String color) {
      		System.out.println(this.getVariety() + "颜色为" + color);
      	}
      
      }
      
      package test;
      
      import fruits.Banana;
      import fruits.Fruits;
      import fruits.Waxberry;
      
      public class Tested {
      	public static void main(String[] args) {
      		Fruits fru1 = new Fruits("圆形", "酸甜适中");
      		Fruits fru2 = new Fruits("圆形", "酸甜适中");
      		fru1.eat();
      		System.out.println("fru1和fru2的引用比较:" + fru1.equals(fru2));
      		System.out.println("————————————————————————————————————");
      		Waxberry wb = new Waxberry("圆形", "酸甜适中", "紫红色");
      		wb.face();
      		wb.eat();
      		System.out.println(wb);
      		System.out.println("————————————————————————————————————");
      		Banana banana = new Banana("短而稍圆", "香甜", "仙人蕉");
      		banana.advantage();
      		banana.advantage("黄色");
      	}
      
      }
      

       

    展开全文
  • Java继承练习题

    千次阅读 2020-05-11 20:18:34
    2.在Java中,以下关于方法重载和方法重写描述正确的是 A A. 方法重载和方法重写实现的功能相同 B. 方法重载出现在父子关系中,方法重写是在同一类中 C. 方法重载的返回类型必须一致,参数项必须不同 D. 方法重写需要...

    一、选择题

    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类
    在这里插入图片描述

    展开全文
  • java题库错题总结(1)

    千次阅读 2021-03-10 09:51:39
    1.Java是一门支持反射的语言,基于反射为Java提供了丰富的动态性支持,下面关于Java反射的描述,哪些是错误的:( ADF )AJava反射主要涉及的类如Class,Method,Filed,等,他们都在java.lang.reflet包下B通过反射可以...
  • Java继承的实现

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

    千次阅读 2016-12-20 19:46:30
    java中关于继承
  • java继承练习题

    千次阅读 2020-05-11 19:56:53
    Java中,以下程序的输出结果是 (A) public class Super { public void print() { System.out.println(“Super – >print”); } } public class Test extends Super { public void print() { System.out....
  • Java继承、多态、接口

    千次阅读 2021-01-31 16:36:57
    Java中的继承和接口 1、用类比引入继承概念 众所周知,Java是一门面向对象的语言。如果我们要设计多种多样的交通工具,比如汽车、火车、飞机,虽然这些工具功能不同、形态不同,但是他们很多的基本功能相同,比如...
  • 下面有关java final的基本规则,描述错误的是? Afinal修饰的类不能被继承 Bfinal修饰的成员变量只允许赋值一次,且只能在类方法赋值 Cfinal修饰的局部变量即为常量,只能赋值一次。 Dfinal修饰的方法不允许被子类...
  • Java继承的定义与使用

    万次阅读 多人点赞 2018-10-21 12:00:25
    1.2.2 Java只允许单继承不允许多继承(一个子类继承一个父类)1.2.3 在继承时,子类会继承父类的所有结构。阿里java校招笔试题 继承   继承的主要作用在于,在已有基础上继续进行功能的扩充。 定义两个类(学生...
  • java继承机制

    千次阅读 2018-03-15 11:01:40
    在面向对象程序中,用IS-A关系来描述类与类之间的关系,称之为继承(inheritance)。继承就是子类继承父类的特征和行为,使得子类对象(实例)具有父类的实例域和方法,或子类从父类继承方法...
  • Java中的集合类包括ArrayList、LinkedList、HashMap等,下列关于集合类描述错误的是(C) A.ArrayList和LinkedList均实现了List接口 B.ArrayList的访问速度比LinkedList快 C.随机添加和删除元素时,ArrayList的表现...
  • 一、基本概念Throwable是所有异常的根,java.lang.ThrowableError是错误java.lang.ErrorException是异常,java.lang.ExceptionThrowable: 有两个重要的子类:Exception(异常)和 Error(错误),二者都是 Java 异常...
  • 错误 注释类型 类/接口 每个类、接口、嵌套类和嵌套接口都有各自的页面。其中每个页面都由三部分(类/接口描述、摘要表,以及详细的成员描述)组成: 类继承图 直接子类 所有已知子接口 所有已知实现类 类/接口声明...
  • Java异常封装(自己定义错误码和描述,附源码)

    万次阅读 多人点赞 2016-01-29 22:30:54
    当然真正工作里面主动抛出的异常都是经过分装过的,自己可以定义错误码和异常描述。下面小宝鸽就为大家介绍一个Java异常简单封装的例子。在给出异常分装例子之前,需要给大家普及Java里面的checked异常和unchecked...
  • 看课本上所描述的,子类继承父类,子类拥有父类所有的属性和方法,于是使用程序去验证,发现父类的私有属性和私有方法,子类是不能访问的,当然一些父类的私有属性可能可以通过相应的方法访问到,需要父类提供public...
  • 一、基本概念Throwable是所有异常的根,java.lang.ThrowableError是错误java.lang.ErrorException是异常,java.lang.ExceptionThrowable:有两个重要的子类:Exception(异常)和 Error(错误),二者都是 Java 异常...
  • Java笔试题

    千次阅读 2021-03-12 23:22:01
    以下描述错误的是: A abstract 可以修饰类、接口、方法 B abstract 修饰的类主要用于被继承。 C abstract 可以修饰变量 D abstract 修饰的类的子类也可以是 abstract 类 答:C 29.以下描述正确的是? A 方法的重写...
  • 一、checked异常和unchecked异常 checked异常: unchecked异常: ...2.2、创建一个异常类BusinessException.java继承RuntimeException: 2.3、测试类ExceptionTest.java: 一、checked异常和unchec...
  • Java面向对象篇:封装、继承、多态

    千次阅读 2022-03-27 21:24:52
    简单理解:类就是对现实事物的一种描述 类的组成 属性:指事物的特征,例如:手机事物(品牌,价格,尺寸) 行为:指事物能执行的操作,例如:手机事物(打电话,发短信) 类和对象的关系 类:类是对现实...
  • 文章目录任务描述相关知识final 关键字的使用final 关键字修饰类、成员变量和成员方法编程要求测试说明...在 Java 中声明类、属性和方法时,可使用关键字 final 来修饰。 final 标记的类不能被继承; final 标记的方
  • 问题:Java语言只允许单继承,指每个类只能有一个 ( )更多相关问题用List命令显示表文件中的当前记录的命令格式是________。WHERE子句的条件表达式中,可以匹配0个到多个字符的通配符是( )。在Visual FoxPro中,每一...
  • java错误需要标识符

    千次阅读 2021-04-24 02:20:39
    Java 的类库中提供 Throwable 类来描述异常,它有 Error 和两个直接......保护问题 进行中序遍历的结果是 A)ACBDFEG B)ACBDFGE C)ABDCGEF D)FCADBEG (11)运行 Java 程序需要的工具软件所在的目录是 A)JDK 的 bin ...
  • Java面向对象编程三大特征 - 继承

    千次阅读 多人点赞 2020-03-31 18:24:08
    本文关键字:Java、面向对象、三大特征、继承继承是面向对象编程的三大特征之一,继承将面向对象的编程思想体现的更加淋漓尽致,允许类和类之间产生关联。
  • Java继承,接口和抽象类

    千次阅读 2019-05-08 09:55:00
    Java 继承 可以简单的理解为子类继承父类的所有类的特征和行为(除私有外),使得子类对象具有父类的实例域和方法,继承关键字为 extends; 需要注意的是 Java 不支持多继承,但支持多重继承 java不支持多继承...
  • Java程序设计》第02章在线测试《Java程序设计》第02章在线测试剩余时间:59:53答题须知...第一题、单项选择题(每题1分,5道题共5分)1、以下关于继承的叙述正确的是( B )。A、在Java中一个类只能实现一个接口B、在J...
  • java继承和接口的区别

    千次阅读 多人点赞 2015-06-03 23:41:32
    java继承和接口的区别
  • java题库2

    千次阅读 2021-03-13 17:20:42
    5、Java中( C )。一个子类可以有多个父类,一个父类也可以有多个子类 一个子类可以有多个父类,但一个父类只可以有一个子类 一个子类可以有一个父类,但一个父类可以有多个子类 上述说法都不对6、下列说法正确的是( ...
  • Java 错误和异常汇总

    万次阅读 2018-09-10 13:20:24
    Java中,根据错误性质将运行错误分为两大类:错误和异常。 Java中的所有异常都是由Throwable类的子类生成的对象,所有的异常类都是Throwable类的子类或子类的子类。Throwable类是Object类的直接子类,Error类和...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 154,295
精华内容 61,718
关键字:

java继承描述错误

java 订阅