精华内容
下载资源
问答
  • 一个关于java继承的题目

    千次阅读 2013-06-13 21:27:24
    一个关于java继承的题目,跟大家分享下。题目如下:  有三个类,一父二子:  父类: Java代码  public class Father {   static {   System.out.println("Father static Create...

    复制来的:

    一个关于java继承的题目,跟大家分享下。题目如下: 


    有三个类,一父二子: 
    父类:

    Java代码  收藏代码
    1. public class Father {  
    2.     static {  
    3.         System.out.println("Father static Create");  
    4.     }  
    5.     {  
    6.         System.out.println("Father Create");  
    7.     }  
    8.       
    9.     public static void StaticFunction(){  
    10.         System.out.println("Father static Function");  
    11.     }  
    12.   
    13.     public void Function(){  
    14.         System.out.println("Father Function");  
    15.     }  
    16. }  


    子类1

    Java代码  收藏代码
    1. public class ChildOne extends Father {  
    2.     static {  
    3.         System.out.println("ChildOne static Create");  
    4.     }  
    5.     {  
    6.         System.out.println("ChildOne Create");  
    7.     }  
    8.       
    9.     public static void StaticFunction(){  
    10.         System.out.println("ChildOne static Function");  
    11.     }  
    12.   
    13. }  


    子类2

    Java代码  收藏代码
    1. public class ChildTwo extends Father {  
    2.     static {  
    3.         System.out.println("ChildTwo static Create");  
    4.     }  
    5.     {  
    6.         System.out.println("ChildTwo Create");  
    7.     }  
    8.   
    9.     public static void StaticFunction() {  
    10.         System.out.println("ChildTwo static Function");  
    11.     }  
    12.   
    13.     public void Function() {  
    14.         System.out.println("ChildTwo Function");  
    15.     }  
    16. }  


    调用方法

    Java代码  收藏代码
    1. public class Main {  
    2.     public static void main(String[] args) {  
    3.         Father A = new ChildOne();  
    4.         Father B = new ChildTwo();  
    5.         A.StaticFunction();  
    6.         A.Function();  
    7.         B.StaticFunction();  
    8.         B.Function();  
    9.     }  

     


    输出结果:

     

     

    Father static Create

    ChildOne static Create

    Father Create

    ChildOne Create

    ChildTwo static Create

    Father Create

    ChildTwo Create

    Father static Function

    Father Function

    Father static Function

    ChildTwo Function




     

    展开全文
  • java有关继承的题目

    2012-10-18 18:27:38
    设计一个类体系描述这些动物,写出它们属性和方法。
  • java接口继承的题目

    2010-09-08 16:57:42
    关于Java的接口继承的题目: interface Playable { void play(); } interface Bounceable { void play(); } interface Rollable extends Playable, Bounceable { Ball ball = new Ball("...
    关于Java的接口继承的题目:
    interface Playable {
    void play();
    }

    interface Bounceable {
    void play();
    }

    interface Rollable extends Playable, Bounceable {
    Ball ball = new Ball("PingPang");
    }

    class Ball implements Rollable {
    private String name;

    public String getName() {
    return name;
    }

    public Ball(String name) {
    this.name = name;
    }

    public void play() {
    ball = new Ball("Football");
    System.out.println(ball.getName());
    }
    }
    指出上面的程序错误的地方,说明原因。

    答案:
    问题出在interface Rollable里的"Ball ball = new Ball("PingPang");"。
    任何在interface里声明的interface variable (接口变量,也可称成员变量),默认为public static final。
    也就是说"Ball ball = new Ball("PingPang")";
    实际上是"public static final Ball ball = new Ball("PingPang");"。
    在Ball类的Play()方法中,"ball = new Ball("Football");"
    改变了ball的reference,而这里的ball来自Rollable interface,Rollable interface里的ball是public static final的,
    final的object是不能被改变reference的。因此编译器将在"ball = new Ball("Football");"这里显示有错。
    展开全文
  • Java继承题目练习

    2020-07-22 22:51:36
    一、选择 在Java中,以下程序输出结果是A A....print B....C....D.... 在Java中,以下关于方法重载和方法重写描述正确是B ...A. 方法重载和方法重写实现... 方法重写需要出现在满足继承关系子类中 哪个选项中方..

    一、选择

    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("黄色");
      	}
      
      }
      

       

    展开全文
  • 第一题/*看程序写结果:A:成员变量就近原则B:this和super问题this访问本类成员super访问父类成员C:子类构造方法执行前默认先执行父类无参构造方法D:一个类初始化过程成员变量进行初始化默认初始化显示初始...

    第一题

    /*

    看程序写结果:

    A:成员变量就近原则

    B:this和super的问题

    this访问本类的成员

    super访问父类的成员

    C:子类构造方法执行前默认先执行父类的无参构造方法

    D:一个类的初始化过程

    成员变量进行初始化

    默认初始化

    显示初始化

    构造方法初始化     用参数去调用构造函数就是显式初始化,没有参数就是默认初始化,表现为直接声明对象和数组

    所以执行父类无参构造方法前会先执行成员变量的初始化,public int num = 10;,再执行无参构造方法,同理,执行完父类无参构造方法,再执行子类成员变量的初始化,public int num = 20;最后执行子类构造方法。

    结果:

    fu

    zi

    30

    20

    10

    */

    class Fu{

    public int num = 10;//public int num;这是第一步,不赋值,默认为0,称为默认初始化;第二步,把10赋予给num,这一步称为显式初始化,每个成员变量赋值都会在jvm的堆内存执行                                 //这样的两个步骤。

    public Fu(){

    System.out.println("fu");

    }

    }

    class Zi extends Fu{

    public int num = 20;

    public Zi(){

    System.out.println("zi");

    }

    public void show(){

    int num = 30;

    System.out.println(num); //30

    System.out.println(this.num); //20

    System.out.println(super.num); //10

    }

    }

    class ExtendsTest {

    public static void main(String[] args) {

    Zi z = new Zi();

    z.show();

    }

    }

    题目2

    /*

    看程序写结果:

    A:一个类的静态代码块,构造代码块,构造方法的执行流程

    静态代码块 > 构造代码块 > 构造方法

    B:静态的内容是随着类的加载而加载

    静态代码块的内容会优先执行

    C:子类初始化之前先会进行父类的初始化

    结果是:

    静态代码块Fu

    静态代码块Zi

    构造代码块Fu

    构造方法Fu

    构造代码块Zi

    构造方法Zi

    */

    class Fu {

    static {

    System.out.println("静态代码块Fu");

    }

    {

    System.out.println("构造代码块Fu");

    }

    public Fu() {

    System.out.println("构造方法Fu");

    }

    }

    class Zi extends Fu {

    static {

    System.out.println("静态代码块Zi");

    }

    {

    System.out.println("构造代码块Zi");

    }

    public Zi() {

    System.out.println("构造方法Zi");

    }

    }

    class ExtendsTest2 {

    public static void main(String[] args) {

    Zi z = new Zi();

    }

    }

    问题三

    /*

    看程序写结果:

    A:成员变量的问题

    int x = 10; //成员变量是基本类型

    Student s = new Student(); //成员变量是引用类型

    B:一个类的初始化过程

    成员变量的初始化

    默认初始化

    显示初始化

    构造方法初始化

    C:子父类的初始化(分层初始化)

    先进行父类初始化,然后进行子类初始化。

    结果:

    YXYZ

    问题:

    虽然子类中构造方法默认有一个super()

    初始化的时候,不是按照那个顺序进行的。

    而是按照分层初始化进行的。

    它仅仅表示要先初始化父类数据,再初始化子类数据。

    */

    class X {

    Y b = new Y();

    X() {

    System.out.print("X");

    }

    }

    class Y {

    Y() {

    System.out.print("Y");

    }

    }

    public class Z extends X {

    Y y = new Y();

    Z() {

    //super();

    System.out.print("Z");

    }

    public static void main(String[] args) {

    new Z();

    }

    }

    原文:http://www.cnblogs.com/canceler/p/4598641.html

    展开全文
  • 属性私有函数公开publicclassDemo{/***@paramargs*/publicstaticvoidmain(String[]args){//TODOAuto-generatedmethodstub}}abstractclassemployee{privateStringname;privateintnum;privatedoublesal...
  • java的题目 继承的测试题大神大神来看看
  • 因为第7步中shape是circle类型,所以程序会找circle类里面paint(),但是circle里面并没有paint(),所以程序到底是如何进行后续操作就不太理解了。 [img=...
  • 写程序中,无意中想到这个问题,随手搜了一下,发现大家对这个问题看法不一先看一下官方文档What You Can Do in a SubclassA subclass inherits all of thepublicandprotectedmembers of its parent, no matter ...
  • 在着手准备面试之前,很多人都会找一些面试题进行复习,不过对于一些高频考点的...1.java继承的实现方法通过extends关键字对子类和父类进行关联。值得注意的是,java只支持单继承,也就是说一个子类只能继承一个父类...
  • public class Employee extends Person { //Employee类属性包括office, date-hired,office hour和rank(工作时间和工作等级) private String office; private String date_hired; private int ...
  • 在着手准备面试之前,很多人都会找一些面试题进行复习,不过对于一些高频考点的...1.java继承的实现方法通过extends关键字对子类和父类进行关联。值得注意的是,java只支持单继承,也就是说一个子类只能继承一个父类...
  • java继承的练习

    千次阅读 2019-02-17 20:44:44
    前几天看完java继承的视频,感觉容易,没想到到后面的课程学习起来越来越吃力,就回来做了一些简单的关于继承的题目。 0.按要求编写一个Java应用程序: (1)定义一个类,描述一个矩形,包含有长、宽两种属性,和...
  • java 继承与多态练习题目

    千次阅读 2016-06-14 16:53:48
    //请写出以下程序运行结果.... public class A { public String show(D obj) { return ("A and D"); } public String show(A obj) { return ("A and A"); } public static void main(String[] ...
  • 第4章 继承与多态选择题1. 编译和运行以下两文件结果//文件P1.javapackage MyPackage;class P1{void afancymethod(){System.out.println("What a fancy method");}}//文件 P2.javapackage YourPackage;import ...
  • 下面要给大家带来的是一个java类的继承的例子,一起来看看详细的代码吧!一、题目1、定义一个Person类,这个类的属性有三个,分别是name、age、color。类有构造方法给三个属性赋值。run方法,可以计算出,十年之后的...
  • 第五章数组【实验目的】(1) 掌握一维、二维数组定义及初始化方法(2) 掌握循环结构域数组相结合解决问题方法(3) 理解数组下标和数组元素间关系(4) 掌握...import java.util.*;public class Prog1 {public st...
  • JAVA类数组继承测试题目 JAVA类、数组、继承测试题目 第一部分:选择题目 Question 1) 下面哪行语句在编译时不会出现错误或者警告信息: a) float f = 1.3; b) char c = “a“; c) byte b = 257; d) boolean b = ...
  • 题目:1./*定义一个Person类,这个类属性有:name、age、color类有构造方法给3个属性赋值类有run方法,能计算出十年后年龄并输出。类有eat方法,能改变自己name和color*/2./*定义一个Dog类,类有属性name属性...
  • [Java] 继承与抽象类相关题目

    千次阅读 2020-04-06 05:13:44
    本文介绍了 Java继承与抽象类相关题目。。。
  • JAVA继承实验报告JAVA语言程序设计实验报告实验一实验题目: 面 向 对 象 编 程指导老师: 卢照专业班级:计算机科学与技术系1106班姓 名:*****)2014年3月20日实验名称:面 向 对 象 编 程实验目的:1.熟悉Java开发...
  • Java 继承

    2019-10-03 08:47:42
    题目:编写一个应用程序,创建一个矩形类,类中具有长、宽两个成员变量和求周长方法。再创建一个矩形类子类-正方形类,类中定义求面积方法、重写求周长方法。在主类中,输入一个正方形边长,创建正方形对象,...
  • public class 坑爹 extends X { //第一步 先执行父类初始化,就是X创建对象 然后x无参 所有先输出Y和X    Y y = new Y();  坑爹() {  super();   System.out.print("坑爹");  }  ...
  • java继承方法重写

    2020-09-21 10:34:35
    java继承方法重写 题目: 1、编写java程序,分析如下需求,写出你分析类有哪些,以及功能。最后写一个测试类,针对每个类功能进行测试。 动物园里有很多种动物: 比如说,狗,猫等。 狗有姓名和年龄,猫也有...
  • 展开全部这个题目如下思路与实现思路:依照圆和圆柱描述抽象成Java程序里对象Cylinder与Circle,这也32313133353236313431303231363533e4b893e5b19e31333431373261是Java的特点之一圆与圆柱关系:圆柱继承圆写...
  • final修饰符(关键字)如果一个类被声明为final,意味着它不能再派生出新子类,不能作为父类被继承。因此一个类不能既被声明为 abstract,又被声明为final。将变量或方法声明为final,可以保证它们在使用中不被...
  • java继承和多态试题分析

    千次阅读 2018-08-02 19:27:25
    java继承和多态试题分析 第一题:写出下面题目的运行结果 题目: interface A{} class B implements A { public String func() { return "func"; } } class Demo { public stati...
  • 继承与static面试题目如下:请写出程序执行完成之后结果。package extend;public class X {Y y=new Y();static{System.out.println("tttt");}X(){System.out.println("X");}public static void main(String[] args...
  • 继承Person类设计Teacher类,增加职称、部门等字段;继承Person类设计Student类,增加学号、入学时间、专业等字段。定义各类构造方法和toString()方法,并分别创建对象进行测试。 public class Persons { public ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,275
精华内容 510
关键字:

java继承的题目

java 订阅