三分时时彩1010CC

1010cc时时彩标准版 > 三分时时彩1010CC > 输出易错笔试题收集_3,Java中对域和静态方法的

原标题:输出易错笔试题收集_3,Java中对域和静态方法的

浏览次数:65 时间:2019-08-10

Java中对域和静态方法的拜候不享有多态性,java多态

1.将艺术调用同方法主体关系起来被称之为

2.编写翻译期绑定(静态)是在程序编写翻译阶段就规定了援引对象的种类

3.运维期绑定(动态绑定)是指在实施时期判别所引述对象的莫过于类型,依据其实际的品种调用其对应的法子

4.除了static方法和final方法(private方法属于final方法),其余具有办法都以前期绑定,Java中具备的章程都以由此动态绑定来贯彻多态

5.访谈某些域的一言一动不享有多态性

package polymorphism;

class SuperField {
 public int field = 1;

 public int getField() {
  return field;
 }
}

class SubField extends SuperField {
 public int field = 2;

 public int getField() {
  return field;
 }

 public int getSuperField() {
  return super.field;
 }
}

public class FieldPolymorphism {

 public static void main(String[] args) {
  SuperField sup = new SubField();
  System.out.println("sup.field = "   sup.field   ", sup.getField() = "   sup.getField());
  SubField sub = new SubField();
  System.out.println("sub.field = "   sub.field   ", sub.getField() = "   sub.getField()  
    ", sub.getSuperField() = "   sub.getSuperField());
 }

}

 输出结果:

sup.field = 1, sup.getField() = 2
sub.field = 2, sub.getField() = 2, sub.getSuperField() = 1

 

当SubField对象转型为Super援用时,任何域访问操作都将由编写翻译器剖判,由此不是多态的,SubField实际富含多个称呼田野同志的域:自个儿的和从SuperField处传承来的

常备将域设置成private,不能够直接访谈,也无法被接续,通过调用方法来拜见

6.访谈有个别静态方法不享有多态性,不与单个对象相关联

package polymorphism;

class Super {

 public static String staticMethod() {
  return "Super staticMethod()";
 }
}

class Sub extends Super {
 public static String staticMethod() {
  return "Sub staticMethod()";
 }
}

public class StaticPolymorphism {

 public static void main(String[] args) {
  Super sup = new Sub();
  System.out.println(sup.staticMethod());
  System.out.println(Sub.staticMethod());
 }

}

 输出结果:

Super staticMethod()
Sub staticMethod()

 

1.将艺术调用同方法主体关系起来被称为 2.编写翻译期绑定(静态)是在程序编写翻译阶段就确...

1.将艺术调用同方法主体关系起来被称之为

1.将艺术调用同方法主体关系起来被叫做

#include

多态是面向对象的三大特色之一
聊起多态,不得不提的正是,多态中的成员绑定难题.

2.编译期绑定(静态)是在先后编写翻译阶段就分明了援引对象的档期的顺序

2.编写翻译期绑定(静态)是在程序编写翻译阶段就鲜明了援用对象的类型

using namespace std;

格局绑定

将三个办法调用同三个办法主体关系起来被喻为1010cc时时彩标准版,绑定.若在程序施行前进行绑定(假使有的话,由编写翻译器和一连程序完结),叫做中期绑定.在运维时依据指标的花色进行绑定,称为末代绑定,也称为动态绑定或者运作时绑定.

Java中除去static方法和final方法(private方法属于final方法)之外,其余全体的章程都是早先时期绑定.

public class Shape {
    public void draw() {
        System.out.println("Shape draw.");
    }

    public void erase() {
        System.out.println("Shape erase");
    }
}

public class Circle extends Shape {
    public void draw() {
        System.out.println("Circle draw.");
    }

    public void erase() {
        System.out.println("Circle erase.");
    }
}

public class Shapes {
    public static void main(String[] args) {
        Shape shape = new Circle();
        shape.draw();
    }
}

//output
Circle draw.

3.运营期绑定(动态绑定)是指在施行时期剖断所引述对象的莫过于类型,依据其实际的类型调用其相应的法子

3.运维期绑定(动态绑定)是指在奉行时期推断所引用对象的莫过于类型,依据其实际的等级次序调用其相应的措施

class A

症结:"覆盖"私有方法

public class PrivateOverride {
    private void f(){
        System.out.println("private f()");
    }

    public static void main(String[] args){
        PrivateOverride privateOverride = new Derived();
        privateOverride.f();
    }
}

class Derived extends PrivateOverride{
    public void f(){
        System.out.println("public f()");
    }
}

//output
private f()

咱俩盼望的出口是public f(),可是由于private方法被自动认为是final方法,何况对导出类(子类)是遮挡的.由此,在这种场合下,Derived类中的f()方法就是三个斩新的章程,既然基类中的f()方法在子类Derived中不可知,因而依旧也不能够被重载.

4.除了static方法和final方法(private方法属于final方法),其余具有办法都以早先时期绑定,Java中存有的点子都以透过动态绑定来落到实处多态

4.除了static方法和final方法(private方法属于final方法),别的全部办法都从前期绑定,Java中享有的格局都以经过动态绑定来促成多态

{

劣势:域与静态方法

借使你直接待上访谈有个别域,那几个访谈就就要编写翻译期进行深入分析,仿佛上面包车型大巴示范所示范的:

class Super {
    public int field = 0;

    public int getField() {
        return field;
    }
}

class Sub extends Super {
    public int field = 1;

    public int getField() {
        return field;
    }

    public int getSuperField() {
        return super.field;
    }
}

public class FieldAccess {
    public static void main(String[] args) {
        Super sup = new Sub();
        System.out.println("sup.field = "   sup.field   ", sup.getField() = "   sup.getField());

        Sub sub = new Sub();
        System.out.println("sub.field = "   sub.field   ", sub.getField() = "   sub.getField());
        System.out.println("sub.getSuperField() = "   sub.getSuperField());
    }
}

//output
sup.field = 0, sup.getField() = 1
sub.field = 1, sub.getField() = 1
sub.getSuperField() = 0

当Sub对象转型为Super援引时,任何域访谈操作都将由编写翻译器深入分析,由此不是多态的.在本例中,为Super.田野和Sub.田野(field)分配了分化的蕴藏空间.那样,Sub实际上满含了多个叫做田野同志的域:它本身的和它从Super处得到的.但是,在援用Sub中的田野先生时产生的暗中同意域并不是Super版本的田野(field)域.

假定某些方法是静态的,它的一举一动就不富有多态性:

class StaticSuper {
    public static String staticGet() {
        return "Base staticGet()";
    }

    public String dynamicGet() {
        return "Base dynamicGet()";
    }
}

class StaticSub extends StaticSuper {
    public static String staticGet() {
        return "Derived staticGet()";
    }

    public String dynamicGet() {
        return "Derived dynamicGet()";
    }
}

public class StaticPolymorphism {
    public static void main(String[] args) {
        StaticSuper sup = new StaticSub();
        System.out.println(sup.staticGet());
        System.out.println(sup.dynamicGet());
    }
}

//outp
Base staticGet()
Derived dynamicGet()

5.拜访某些域的作为不持有多态性

5.访谈某些域的表现不具备多态性

int x;

package polymorphism;

class SuperField {
    public int field = 1;

    public int getField() {
        return field;
    }
}

class SubField extends SuperField {
    public int field = 2;

    public int getField() {
        return field;
    }

    public int getSuperField() {
        return super.field;
    }
}

public class FieldPolymorphism {

    public static void main(String[] args) {
        SuperField sup = new SubField();
        System.out.println("sup.field = "   sup.field   ", sup.getField() = "   sup.getField());
        SubField sub = new SubField();
        System.out.println("sub.field = "   sub.field   ", sub.getField() = "   sub.getField()  
                ", sub.getSuperField() = "   sub.getSuperField());
    }

}
package polymorphism;

class SuperField {
    public int field = 1;

    public int getField() {
        return field;
    }
}

class SubField extends SuperField {
    public int field = 2;

    public int getField() {
        return field;
    }

    public int getSuperField() {
        return super.field;
    }
}

public class FieldPolymorphism {

    public static void main(String[] args) {
        SuperField sup = new SubField();
        System.out.println("sup.field = "   sup.field   ", sup.getField() = "   sup.getField());
        SubField sub = new SubField();
        System.out.println("sub.field = "   sub.field   ", sub.getField() = "   sub.getField()  
                ", sub.getSuperField() = "   sub.getSuperField());
    }

}

public:

 输出结果:

 输出结果:

A() { cout << "A's constructor called " << endl; }

sup.field = 1, sup.getField() = 2
sub.field = 2, sub.getField() = 2, sub.getSuperField() = 1

sup.field = 1, sup.getField() = 2
sub.field = 2, sub.getField() = 2, sub.getSuperField() = 1

};

 

 

class B

当SubField对象转型为Super援用时,任何域访问操作都将由编写翻译器解析,因而不是多态的,SubField实际包涵八个称呼田野同志的域:自身的和从Super菲尔德处承袭来的

当SubField对象转型为Super引用时,任何域访问操作都将由编写翻译器深入分析,由此不是多态的,SubField实际包涵多少个名字为田野先生的域:自身的和从SuperField处承袭来的

{

经常将域设置成private,不可能直接待上访谈,也无法被一连,通过调用方法来会见

常见将域设置成private,不能够直接待上访谈,也无法被三回九转,通过调用方法来拜望

static A a;

6.做客某些静态方法不辜负有多态性,不与单个对象相关联

6.走访有个别静态方法不抱有多态性,不与单个对象相关联

public:

package polymorphism;

class Super {

    public static String staticMethod() {
        return "Super staticMethod()";
    }
}

class Sub extends Super {
    public static String staticMethod() {
        return "Sub staticMethod()";
    }
}

public class StaticPolymorphism {

    public static void main(String[] args) {
        Super sup = new Sub();
        System.out.println(sup.staticMethod());
        System.out.println(Sub.staticMethod());
    }

}
package polymorphism;

class Super {

    public static String staticMethod() {
        return "Super staticMethod()";
    }
}

class Sub extends Super {
    public static String staticMethod() {
        return "Sub staticMethod()";
    }
}

public class StaticPolymorphism {

    public static void main(String[] args) {
        Super sup = new Sub();
        System.out.println(sup.staticMethod());
        System.out.println(Sub.staticMethod());
    }

}

B() { cout << "B's constructor called " << endl; }

 输出结果:

 输出结果:

static A getA() { return a; }

Super staticMethod()
Sub staticMethod()

Super staticMethod()
Sub staticMethod()

};

 

 

A B::a; // definition of a

int main()

{

B b1, b2, b3;

A a = b1.getA();

return 0;

}

背景:

读书音信

Java编制程序理念首要笔记(Java开荒不可不看)

[日期:2015-01-09]

来源:Linux社区

作者:lanxuezaipiao

[字体:大 中 小]

Java编程思想,Java学习必读非凡,不管是初学者依旧大腕都值得一读,这里总计书中的重视知识,那几个文化不仅仅平时现身在各大名牌公司的笔试面试进程中,而且在大型项目开辟中也是常用的学问,既有差相当少的定义驾驭题(比方is-a关系和has-a关系的分别),也有深入的涉嫌RTTI和JVM底层反编写翻译知识。

  1. Java中的多态性精晓(注意与C 区分)

Java中除了static方法和final方法(private方法本质上属于final方法,因为不可能被子类访问)之外,其余具备的方法都是动态绑定,那意味着日常状态下,大家无需剖断是不是应该举办动态绑定—它会自动发出。

final方法会使编译器生成更管用的代码,那也是干什么说表明为final方法能在一定水平上加强品质(效果不明显)。

设若某些方法是静态的,它的作为就不富有多态性:

class StaticSuper {

public static String staticGet() {

return "Base static九度快排系统 )";

}

public String dynamicGet() {

return "Base dynamicGet()";

}

}

class StaticSub extends StaticSuper {

public static String staticGet() {

return "Derived staticGet()";

}

public String dynamicGet() {

return "Derived dynamicGet()";

}

}

public class StaticPolymorphism {

public static void main(String[] args) {

StaticSuper sup = new StaticSub();

System.out.println(sup.staticGet());

System.out.println(sup.dynamicGet());

}

}

输出:

Base staticGet()

Derived dynamicGet()

构造函数并不具备多态性,它们其实是static方法,只可是该static申明是隐式的。因而,构造函数不可能被override。

在父类构造函数内部调用具备多态行为的函数将促成力不胜任预计的结果,因为那时候子类对象还没起头化,此时调用子类方法不会获得大家想要的结果。

class Glyph {

void draw() {

本文由1010cc时时彩标准版发布于三分时时彩1010CC,转载请注明出处:输出易错笔试题收集_3,Java中对域和静态方法的

关键词:

上一篇:没有了

下一篇:没有了