精华内容
下载资源
问答
  • 对象的上转型对象有怎样的特点

    千次阅读 2019-12-24 14:46:49
    一、问答题 1.子类可以有多个父类吗? 答案:不可以 2.java.lang包中Object类是所有其他类祖先类吗? 答案:是 3.如果子类和父类不在同...答案:子类重写方法类型和父类方法类型一致或者是父类方法...

    一、问答题
    1.子类可以有多个父类吗?
    答案:不可以
    2.java.lang包中的Object类是所有其他类的祖先类吗?
    答案:是
    3.如果子类和父类不在同一个包中,子类是否继承父类的友好成员? 答案:不继承
    4.子类怎样隐藏继承的成员变量?
    答案: 声明与父类同名的成员变量
    5.子类重写方法的规则是怎样的?重写方法的目的是什么?
    答案:子类重写的方法类型和父类的方法的类型一致或者是父类的方法的类型的子类型,重写的方法的名字、参数个数、参数的类型和父类的方法完全相同。重写方法的目的是隐藏继承的方法。
    6.父类的final方法可以被子类重写吗?
    答案:不可以
    7.什么类中可以有abstract方法?
    答案:abstract类
    8.对象的上转型对象有怎样的特点?
    答案:上转型对象不能操作子类新增的成员变量;不能使用子类新增的方法。上转型对象可以操作子类继承或者隐藏的成员变量,也可以使用子类继承的或者重写的方法。上转型对象操作子类继承或重写的方法,其作用等价于子类对象去调用这些方法。因此,如果子类重写了父类的某个方法,则当对象的上转型对象调用这个方法时一定是调用了这个重写的方法。
    9.一个类的各个子类是怎样体现多态的?
    答案:通过重写
    10.面向抽象编程的目的和核心是什么?
    答案:目的是为了应对用户需求的变化,核心是让类中每种可能的变化对应地交给抽象类的一个子类类去负责,从而让该类的设计者不去关心具体实现。
    二、选择题
    1.下列哪个叙述是正确的?

    A. 子类继承父类的构造方法。

    B. abstract类的子类必须是非abstract类。

    C. 子类继承的方法只能操作子类继承和隐藏的成员变量。

    D. 子类重写或新增的方法也能直接操作被子类隐藏的成员变量。
    答案:C
    2.下列哪个叙述是正确的?

    A. final 类可以有子类。

    B. abstract类中只可以有abstract方法。

    C. abstract类中可以有非abstract方法,但该方法不可以用final修饰。

    D. 不可以同时用final和abstract修饰同一个方法。

    E. 允许使用static修饰abstract方法。
    答案:D
    3.下列程序中注释的哪两个代码(A,B,C,D)是错误的(无法通过编译)?
    class Father {
    private int money =12;
    float height;
    int seeMoney(){
    return money ; //A
    }
    }
    class Son extends Father {
    int height;
    int lookMoney() {
    int m = seeMoney(); //B
    return m;
    }
    }
    class E {
    public static void main(String args[]) {
    Son erzi = new Son();
    erzi.money = 300; //C
    erzi.height = 1.78F; //D
    }
    }
    答案:CD
    4.假设C是B的子类,B是A的子类,cat是C类的一个对象,bird是B类的一个对象,下列哪个叙述是错误的?

    A. cat instanceof B的值是true。

    B. bird instanceof A的值是true。

    C. cat instanceof A的值是true。

    D. bird instanceof C的值是true。
    答案:D
    5.下列程序中注释的哪个代码(A,B,C,D)是错误的(无法通过编译)?
    class A {
    static int m;
    static void f(){
    m = 20 ; //A
    }
    }
    class B extends A {
    void f() //B
    { m = 222 ; //C
    }
    }
    class E {
    public static void main(String args[]) {
    A.f(); // D
    }
    }
    答案:B
    6.下列代码中标注的(A,B,C,D)中,哪一个是错误的?
    abstract class Takecare {
    protected void speakHello() {} //A
    public abstract static void cry(); //B
    static int f(){ return 0 ;} //C
    abstract float g(); //D
    }
    答案:B
    7.下列程序中注释的哪个代码(A,B,C,D)是错误的(无法通过编译)?
    abstract class A {
    abstract float getFloat (); //A
    void f() //B
    { }
    }
    public class B extends A {
    private float m = 1.0f; //C
    private float getFloat () //D
    { return m;
    }
    }
    答案:D
    8.将下列哪个代码(A,B,C,D)放入程序中标注的【代码】处将导致编译错误?
    A. public float getNum(){return 4.0f;}
    B. public void getNum(){ }
    C. public void getNum(double d){ }
    D. public double getNum(float d){return 4.0d;}
    class A {
    public float getNum() {
    return 3.0f;
    }
    }
    public class B extends A {
    【代码】
    }
    答案:B
    9.对于下列代码,下列哪个叙述是正确的?
    A. 程序提示编译错误(原因是A类没有不带参数的构造方法)
    B. 编译无错误,【代码】输出结果是0。
    C. 编译无错误,【代码】输出结果是1。
    D. 编译无错误,【代码】输出结果是2。
    class A {
    public int i=0;
    A(int m) {
    i = 1;
    }
    }
    public class B extends A {
    B(int m) {
    i = 2;
    }
    public static void main(String args[]){
    B b = new B(100);
    System.out.println(b.i); //【代码】
    }
    }
    答案:A
    三、阅读程序
    1.请说出E类中【代码1】,【代码2】的输出结果。
    class A {
    double f(double x,double y) {
    return x+y;
    }
    }
    class B extends A {
    double f(int x,int y) {
    return xy;
    }
    }
    public class E {
    public static void main(String args[]) {
    B b=new B();
    System.out.println(b.f(3,5)); //【代码1】
    System.out.println(b.f(3.0,5.0)); //【代码2】
    }
    }
    答案:1、15.0 2、8.0
    2.说出下列B类中【代码1】,【代码2】的输出结果。
    class A {
    public int getNumber(int a) {
    return a+1;
    }
    }
    class B extends A {
    public int getNumber (int a) {
    return a+100;
    }
    public static void main (String args[]) {
    A a =new A();
    System.out.println(a.getNumber(10)); //【代码1】
    a = new B();
    System.out.println(a.getNumber(10)); //【代码2】
    }
    }
    答案:1、11 2、11
    3.请说出E类中【代码1】~【代码4】的输出结果。
    class A {
    double f(double x,double y) {
    return x+y;
    }
    static int g(int n) {
    return n
    n;
    }
    }
    class B extends A {
    double f(double x,double y) {
    double m = super.f(x,y);
    return m+x*y;
    }
    static int g(int n) {
    int m = A.g(n);
    return m+n;
    }
    }
    public class E {
    public static void main(String args[]) {
    B b = new B();
    System.out.println(b.f(10.0,8.0)); //【代码1】
    System.out.println(b.g(3)); //【代码2】
    A a = new B();
    System.out.println(a.f(10.0,8.0)); //【代码3】
    System.out.println(a.g(3)); //【代码4】
    }
    }
    答案:1、98.0 2、12 3、98.0 4、9
    4.请说出E类中【代码1】~【代码3】的输出结果。
    class A {
    int m;
    int getM() {
    return m;
    }
    int seeM() {
    return m;
    }
    }
    class B extends A {
    int m ;
    int getM() {
    return m+100;
    }
    }
    public class E {
    public static void main(String args[]) {
    B b = new B();
    b.m = 20;
    System.out.println(b.getM()); //【代码1】
    A a = b;
    a.m = -100; // 上转型对象访问的是被隐藏的m
    System.out.println(a.getM()); //【代码2】上转型对象调用的一定是子类重写的getM()方法
    System.out.println(b.seeM()); //【代码3】子类继承的seeM()方法操作的m是被子类隐藏的m
    }
    }
    答案:1、120 2、120 3、-100
    四、编程题(参考例子13)
    设计一个动物声音“模拟器”,希望模拟器可以模拟许多动物的叫声。要求如下:
     编写抽象类Animal
    Animal抽象类有2个抽象方法cry()和getAnimaName(),即要求各种具体的动物给出自己的叫声和种类名称。
     编写模拟器类Simulator
    该类有一个playSound(Animal animal)方法,该方法的参数是Animal类型。即参数animal可以调用Animal的子类重写的cry()方法播放具体动物的声音、调用子类重写的getAnimalName()方法显示动物种类的名称。
     编写Animal类的子类:Dog,Cat类
    编写主类Application(用户程序)
    在主类Application的main方法中至少包含如下代码:
    Simulator simulator = new Simulator();
    simulator.playSound(new Dog());
    simulator.playSound(new Cat());

    第六章课后习题

    一、问答题
    1.接口中能声明变量吗?
    答案:不能
    2.接口中能定义非抽象方法吗?
    答案:不能
    3.什么叫接口的回调?
    答案:接口回调是指:可以把实现某一接口的类创建的对象的引用赋给该接口声明的接口变量中,那么该接口变量就可以调用被类重写的接口方法。实际上,当接口变量调用被类重写的接口方法时,就是通知相应的对象调用这个方法。
    4.接口中的常量可以不指定初值吗?
    答案:不可以
    5.可以在接口中只声明常量,不声明抽象方法吗?
    答案:可以
    二、选择题
    1.下列哪个叙述是正确的
    A.一个类最多可以实现两个接口。
    B.如果一个抽象类实现某个接口,那么它必须要重写接口中的全部方法。
    C.如果一个非抽象类实现某个接口,那么它可以只重写接口中的部分方法。
    D.允许接口中只有一个抽象方法。
    答案:A
    2.下列接口中标注的(A,B,C,D)中,哪两个是错误的?
    interface Takecare {
    protected void speakHello(); //A
    public abstract static void cry(); //B
    int f(); //C
    abstract float g(); //D
    }
    答案:AB
    3.将下列(A,B,C,D)哪个代码替换下列程序中的【代码】不会导致编译错误。
    A.public int f(){return 100+M;}
    B.int f(){return 100;}
    C.public double f(){return 2.6;}。
    D.public abstract int f();
    interface Com {
    int M = 200;
    int f();
    }
    class ImpCom implements Com {
    【代码】
    }
    答案:B

    三、阅读程序
    1.请说出E类中【代码1】,【代码2】的输出结果。
    interface A {
    double f(double x,double y);
    }
    class B implements A {
    public double f(double x,double y) {
    return x*y;
    }
    int g(int a,int b) {
    return a+b;
    }
    }
    public class E {
    public static void main(String args[]) {
    A a = new B();
    System.out.println(a.f(3,5)); //【代码1】
    B b = (B)a;
    System.out.println(b.g(3,5)); //【代码2】
    }
    }
    答案:1、15.0 2、8
    2.请说出E类中【代码1】,【代码2】的输出结果。
    interface Com {
    int add(int a,int b);
    }
    abstract class A {
    abstract int add(int a,int b);
    }
    class B extends A implements Com{
    public int add(int a,int b) {
    return a+b;
    }
    }
    public class E {
    public static void main(String args[]) {
    B b = new B();
    Com com = b;
    System.out.println(com.add(12,6)); //【代码1】
    A a = b;
    System.out.println(a.add(10,5)); //【代码2】
    }
    }
    答案:1、18 2、15
    四、编程题(参考例子6)
    该题目和第5章习题5的编程题类似,只不过这里要求使用接口而已。
    设计一个动物声音“模拟器”,希望模拟器可以模拟许多动物的叫声。要求如下:
     编写接口Animal
    Animal接口有2个抽象方法cry()和getAnimaName(),即要求实现该接口的各种具体动物类给出自己的叫声和种类名称。
     编写模拟器类Simulator
    该类有一个playSound(Animal animal)方法,该方法的参数是Animal类型。即参数animal可以调用实现Animal接口类重写的cry()方法播放具体动物的声音、调用重写的getAnimalName()方法显示动物种类的名称。
     编写实现Animal接口的Dog类和Cat类
    图6.14是Simulator、Animal、Dog、Cat的UML图。
     编写主类Application(用户程序)
    在主类Application的main方法中至少包含如下代码:
    Simulator simulator = new Simulator();
    simulator.playSound(new Dog());
    simulator.playSound(new Cat());

    展开全文
  • 上转型对象的特点

    千次阅读 2018-06-18 18:19:40
    假设Animal类是Tiger类的父类,当用子类创建一个对象,并把这个对象的引用放到父类的对象中时,比如: Animal a; a=new Tiger();... 这时,称对象a是对象b的上转型对象(好比说“老虎是动物”)。 ...

     假设Animal类是Tiger类的父类,当用子类创建一个对象,并把这个对象的引用放到父类的对象中时,比如:

            Animal a;

            a=new Tiger();

            或

            Animal a;

            Tiger b=new Tiger();

            a=b;

            这时,称对象a是对象b的上转型对象(好比说“老虎是动物”)。

            对象的上转型对象的实体是子类负责创建的,但上转型对象会失去原对象的一些属性和功能(上转型对象相当于子类对象的一个“简化”对象)。上转型对象具有如下特点:

    1)上转型对象不能操作子类新增的成员变量(失掉了这部分属性),不能调用子类新增的方法(失掉了一些行为)。

    2)上转型对象可以访问子类继承和隐藏的成员变量,也可以调用子类继承的方法或子类重写的方法。上转型对象操作子类继承的方法或子类重写的实例方法,其作用等价于子类对象去调用这些方法。因此,如果子类重写了父类的某个实例方法后,当对象的上转型调用这个实例方法时一定是调用了子类重写的实例方法。

    注:(1)不要将父类创建的对象和子类对象的上转型对象混淆。

            (2)可以将对象的上转型对象强制转换得到一个子类对象,这时,该子类又具备了子类所有的属性和功能。

            (3)不可以将父类创建的对象的引用复值给子类声明的对象(不能说"人是美国人")。

            (4)如果子类重写了父类静态方法,那么子类对象的上转型对象不能调用子类的静态方法,只能调用父类的静态方法。

    exmaple:

    class A
    {
    void crySpeak(String s)
    {
    System.out.println(s);
    }
    }


    class B extends  A
    {
    void computer(int a,int b)
    {
    int c=a*b;
    System.out.println(c);
    }
    void crySpeak(String s)
    {
    System.out.println("***"+s+"***");
    }
    }


    public class Example1 {
    public static void main(String[] args) {
    A a=new B();
    a.crySpeak("I love this game");
    B b=(B)a;
    b.computer(10,10);
    }
    }

     运行结果:***I love this game***

    展开全文
  • 对象的上转型对象

    2017-07-12 17:40:20
    1. 定义 如果B类是A类的子类或间接子类,当...则称A类对象a是子类B对象b的上转型对象。 2. 性质 对象b的上转型a的实体是有子类B创建的,但是上转型对象会失去子类B的一些属性和功能。上转型对象具有以下特点

    1. 定义

    如果B类是A类的子类或间接子类,当用B类创建对象b并将这个对象b的引用赋给A类对象a时,如:

    A a;
    a = new B();
    OR
    A a;
    B b = new B();
    a = b;

    则称A类对象a是子类B对象b的上转型对象。


    2. 性质

    对象b的上转型a的实体是有子类B创建的,但是上转型对象会失去子类B的一些属性和功能。上转型对象具有以下特点:

    1. 上转型对象不能操作子类新增加的成员变量,不能使用子类新增的方法。即为较子类B失去一些属性和功能,这些属性和功能是新增的。
    2. 上转型对象可以操作子类继承或隐藏的成员变量,也可以使用子类继承的或重写的方法。即为上转型对象可以操纵父类原有的属性和功能,无论这些方法是否被重写。
    3. 上转型对象调用方法时,就是调用子类继承和重写过的方法。而不会是新增的方法,也不是父类原有的方法。
    4. 可以将对象的上转型对象再强制转换到一个子类对象,强制转换过的对象具有子类所有属性和功能。

    3. 举例

    如:

    OutputStream output;
    output = new FileOutputStream(filename);

    并且根据Java API知

    java.lang.Object
      java.io.OutputStream
         java.io.FileOutputStream

    这时,output就是上转型对象啦。有什么特殊呢?就是output可以使用FileOutputStream从父类OutputStream那里继承来的方法和重写的方法,而不能使用子类FileOutputStream自己新增的方法啦。最后,这种方法是很常用的哦。。。当父类有很多子类时,就能实现方法的多态。^_^

    展开全文
  • 对象的上转型对象是实体的子类负责创建的,但是上转型对象就会失去原来对象的一些属性和功能,上转型对象相当于子类对象 的一个简单化对象,上转型对象具有如下的特点, 上转型对象不能操作子类的新增的成员变量和...

      对象的上转型对象是实体的子类负责创建的,但是上转型对象就会失去原来对象的一些属性和功能,上转型对象相当于子类对象 的一个简单化对象,上转型对象具有如下的特点,

       上转型对象不能操作子类的新增的成员变量和新增的成员变量方法,当重写了父类的方法时,上转型对象调用的一定是重写的方法。

       不可以将父类创建的对象的引用赋值给子类声明的对象。

      可以将上转型对象强制转化给子类的对象。

    面对对象就是:
    把数据及对应数据的操作方法放在一起,作为一个相互依存的整体——对象。对同类对象抽象出其共性,形成类。类中的大多数数据,只能用本类的方法进行处理。
    类通过一个简单的外部接口与外界发生关系,对象与对象之间通过消息进行通信。程序流程由用户在使用中决定。

    面向过程就是:
    自顶向下顺序执行,逐步求精;其程序结构是按功能划分为若干个基本模块,这些模块形成一个树状结构;各模块之间的关系尽可能简单,
    在功能上相对独立;每一模块内部均是由顺序、选择和循环三种基本结构组成;其模块化实现的具体方法是使用子程序。程序流程在写程序时就已决定。
    面向对象程序设计中的每一个对象都应该能够接受数据、处理数据并将数据传达给其它对象,因此它们都可以被看作一个小型的“机器”,即对象。[2] 

    转载于:https://www.cnblogs.com/jianxin-lilang/p/6497508.html

    展开全文
  • 1. 定义 ...则称A类对象a是子类B对象b的上转型对象。 2. 性质 对象b的上转型a的实体是有子类B创建的,但是上转型对象会失去子类B的一些属性和功能。上转型对象具有以下特点: 上转型对象...
  • Java5-3 对象的上转型对象 1.上转型对象: 如果B类是A类的子类或间接子类,当用B类创建对象b并将这个对象b的引用赋给A类对象a时,则称A类对象a是子类B对象b的上转型对象。 如: A a; a = new B(); OR A a; B b = new...
  • 由子类转换成为父类,在继承图是向上移动,称之为向上转型特点: 1、首先是安全,但是可能会导致子类方法丢失。 2、父类引用指向子类的对象 与之相反是向下转型 特点: 1、不安全 2、子类...
  •  对象的上转型对象的特点:(1)上转型对象不能操作子类新增的成员变量和方法(2)上转型对象调用的是隐藏的成员变量和重写的方法(发生隐藏/重写时),即子类的成员(3)可以将上转型对象强制转到子类的对象,这时该对象就...
  • 上转型对象

    2014-03-12 10:15:19
    上转型对象具有如下特点: 1)上转型对象不能操作子类新增的成员变量(失掉了这部分属性),不能使用子类新增的方法...因此,如果子类重写了父类的某个方法后,对象的上转型对象调用这个方法时,一定是调用了这个重写的方法.
  • 关于java的上转型对象

    2016-05-05 13:34:00
    则称A类对象a是子类B对象b的上转型对象。 2. 性质 对象b的上转型a的实体是有子类B创建的,但是上转型对象会失去子类B的一些属性和功能。上转型对象具有以下特点: 上转型对象不能操作子...
  • Java 上转型对象

    2019-10-14 21:56:56
    上转型对象具有如下特点: 上转型对象不能操作子类新增加成员变量,不能使用子类新增方法。即上转型对象较子类B失去一些属性和功能,这些属性和功能是子类新增上转型对象可以操作子类继承或隐藏成员...
  • JAVA 上转型对象

    2017-01-10 13:29:19
    JAVA 上转型对象 ... 那么就称对象a是子类对象b的上转型对象对象的上转型对象的实体是子类负责创建的,但上转型对象会失去原对象的一些属性和功能。 上转型对象具有如下特点
  • Java上转型对象

    2018-03-03 20:53:45
    则称Parent类对象p是子类Son对象s的上转型对象。2. 性质对象b的上转型a的实体是有子类B创建的,但是上转型对象会失去子类B的一些属性和功能。上转型对象具有以下特点:上转型对象不能操作子类新增加的成员变量,不能...
  • 称这个父类对象 a,是子类对象b的上转型对象。好比说“老虎是哺乳动物”。对象的上转型对象的实体是子类负责创建的,但上转型对象会失去原对象的一些属性和功能。上转型对象具有如下特点:1 上转型对象不能操作子类...
  • ***1、***有一种类型转换,叫造型(也叫强制类型转换) 2、在强制类型转换中,需要注意: 我们可以把一个类换成另一个类,但是只允许子类...4、上转型对象特点对象的上转型对象的实体是子类负责创建的,但上转型对象
  • java上转型的特点

    2020-06-06 14:33:34
    上转型对象:子类创建一个对象,并且把该对象的引用放到父类声明的变量中。 特点: (1)上转型对象不能操作子类新增的成员变量和成员方法。上转型不能直接操作子类中和父类同名的成员变量,需要借助于get和set方法...
  • 对象的上转型对象的尸体时子类负责创建的,但上转型对象会失去原对象的一些属性和功能(上转型对象相当于子类对象的一个简化对象)。上转型对象具有如下特点: 上转型对象不能操作子类新增的成员变量(失掉了这部分...
  • Java基础之上转型对象

    2021-01-15 12:54:08
    上转型对象相当于子类对象的一个简化对象,比如说老虎是动物,失去了老虎特有的属性如老虎的爪子,而上转型对象有以下特点 1.上转型对象不能操作子类新增的成员变量,不能调用子类新增的方法 2.上转型对象可以访问...
  • java、上转型对象

    2015-07-07 23:54:39
    则称A类对象a是子类B对象b的上转型对象。2. 性质对象b的上转型a的实体是有子类B创建的,但是上转型对象会失去子类B的一些属性和功能。上转型对象具有以下特点:上转型对象不能操作子类新增加的成...
  • 对象向上转型

    2021-01-21 20:24:23
    对象的上转型 定义:假设B是A的子类或者间接子类,用类B创 建一个对象,并把这个对象的引用赋值给类A的一 个引用 A a; B b=new B(); //等价于A a=new B(); a=b; 对象上转型与运行时多态 如果一个类有很多子类,并且...
  • 一、对象的上转型对象 假设A类是B类的父类,用子类创建一个对象,并把这个对象的引用放到父类的对象中,此时这个父类的对象就称之为子类创建的对象的上转型对象。 A a=new B();//用子类的构造对象创建一个父类...
  • 上转型对象: ...则称a是b的上转型对象。 对象b的上转型a的实体是有子类B创建的,但是上转型对象会失去子类B的一些属性和功能。 上转型对象具有以下特点 上转型对象不能操作子类新增加的成...
  • 而对象的多态主要指同一事物具有多种表现形态,如猫狗既可以叫它们猫狗又可以叫它们动物,其实这里的多态就是描述对象的抽象层次的差别。 应用 多态的主要应用是简化程序代码,提高程序扩展性。具体来讲,子类复写...
  • (3)如果子类重写了父类的某个方法后,对象的上转型对象调用这个方法时,一定是调用了这个重写的方法。 (4)可以将对象的上转型对象再强制转化为一个子类对象,这时,该子类对象又具备子类的所有属性和功能。
  • 1.上转型 假如现在有两个类,一个是父类,一个是继承了...假如父类的对象是子类上转型而来,将这个**父类对象强转成子类对象**,就是下转型 特点 就是相当于重新new了一个子类对象,不是上转型得来的对象不能下转型

空空如也

空空如也

1 2 3 4 5
收藏数 98
精华内容 39
关键字:

对象的上转型对象特点