-1

一个基类：

abstract class Base
{
    abstract public function getLenth();
    abstract public function getName();
}

它的两个类：

final class ObjA extends Base
{
    public function getLenth()
    {
        return 1;
    }

    public function getName()
    {
        return 'Object A';
    }
}

.

final class ObjB extends Base
{
    public function getLenth()
    {
        return 6;
    }

    public function getName()
    {
        return 'Object B';
    }
}

那是一种解决方案。它可以重写为：

class Base
{
    public function getLenth()
    {
        return static::LENGTH;
    }

    public function getName()
    {
        return static::NAME;
    }
}

.

final class ObjA extends Base
{
    const LENGTH = 1;
    const NAME = 'Object A';
}

.

final class ObjB extends Base
{
    const LENGTH = 6;
    const NAME = 'Object B';
}

哪个版本更好，为什么？

编辑：

我投票给第二个：更短。但有趣的是，它怎么能用 Java 来完成，其中没有常量的后期静态绑定

4

1 回答 1

1 
    class Base
    {
        private String _name;

        private int _length;

        Base(int length, int name)
        {
            _length = length;
            _name = name;
        }

        public function getLenth()
        {
            return _length;
        }

        public function getName()
        {
            return _name;
        }
    }

    class ObjA extends Base
    {
        public ObjA()
        {
            Base(1, 'Object A');
        }
    }

我相信这是最好的解决方案

编辑：让我用一个更基本的例子来说明原因：

class Vehicle
{
    private int _wheels;

    Vehicle(int wheels)
    {
        _wheels = wheels;
    }
}

class Corvette extends Vehicle
{
    Corvette()
    {
        Vehicle(4);
    }
}

克尔维特总是有四个轮子，但把它弄成一个常数是不合适的。它是在这些类型的对象（= 车辆）之间共享的属性。

于 2014-10-11T15:08:37.940 回答