Существует ли способ передать, объявляют ковариантность?
Большинству языков вовлекли одну сильную руку в их источник и эволюцию. Думайте: Стена/Perl Larry, Guido/Python, Matz/Ruby, Odersky/Scala, Hickey/Clojure, и т.д. Эти парни являются всеми блестящими чуваками языка. Я дал бы левую руку, чтобы быть вдвое менее умным, чем любой из них.
Java на самом деле имел различие наличия не всего один, но и серия удивительных парней языка у руля - запускающийся с Gosling, но я также думаю о Guy Steele, Bill Joy, Gilad Bracha, Neal Gafter, и т.д. - все удивительные парни. Это на самом деле было хорошей вещью (я думаю). Это сделало язык лучше, но предотвратило застой.
, Но в течение прошлых лет пары, был реальный вакуум лидерства языка. В данный момент, ничье возражение против хранилища. Ничье принятие трудных решений относительно того, какие соответствия с Java прессуют и имеют смысл добавлять (или что еще более важно не добавлять). Я не знаю то, что это означает. Я надеюсь, что огромная популярность и достигает Java, и сильная основа JVM означают, что этот вакуум слишком привлекателен, чтобы не быть заполненным и данное направление в какой-то момент. Но я только осторожно полон надежд, потому что я не знаю, кем это будет.
John Rose то, что чувак на стороне JVM. Хотя, если бы я могу только получить инновации в одной или другом, я взял бы JVM прямо сейчас так или иначе.:)
2 ответа
Вы можете легко подделать его, но потеряете статическую проверку типа. Если вы замените dynamic_casts на static_casts , у вас будет то, что компилятор использует для внутренних целей, но у вас нет проверки динамического или статического типа:
class Foo;
class Bar;
class Foo
{
public:
Bar* bar();
protected:
virtual Bar* doBar();
};
class Bar;
{
public:
Foo* foo();
public:
virtual Foo* doFoo();
};
inline Bar* Foo::bar() { return doBar(); }
inline Foo* Bar::foo() { return doFoo(); }
class ConcreteFoo;
class ConcreteBar;
class ConcreteFoo : public Foo
{
public:
ConcreteBar* bar();
protected:
Bar* doBar();
};
class ConcreteBar : public Bar
{
public:
ConcreteFoo* foo();
public:
Foo* doFoo();
};
inline ConcreteBar* ConcreteFoo::bar() { return &dynamic_cast<ConcreteBar&>(*doBar()); }
inline ConcreteFoo* ConcreteBar::foo() { return &dynamic_cast<ConcreteFoo&>(*doFoo()); }
Фактически, как только вы назначите им идентификатор, они становятся общедоступной переменной-членом данного элемента. Так, например, если у вас есть
<mx:Canvas><mx:Label id="myLabel" /></mx:Canvas>
, вы можете получить к нему доступ по его id как имени переменной:
myLabel.text = "Hello world!";
Дайте мне знать, если вам нужны дополнительные пояснения. Если вы спрашиваете не об этом, не стесняйтесь комментировать, и я сделаю еще один удар.
С уважением,
- блокировка - логическая концепция.
- блокировка блокирует только то, что находится в блоке кода в фигурных скобках.
Но чтобы дать вам краткое представление:
блокировка - не что иное, как замена Monitor.Enter и Monitor.Exit . Только это с блокировкой Monitor.Exit помещается в блок finally.
Итак, то, что вы ДЕЙСТВИТЕЛЬНО блокируете (в вашем коде), является объектом блокировки. Итак, в любом месте вашего кода, если вы используете этот объект-шкафчик для блокировки, этот блок кода будет заблокирован.
Я предполагаю, что ваша блокировка работает так: (гуру, пожалуйста, поправьте меня, если я ошибаюсь)
if(locker.SyncBlockIndex <0)>
{
//obtain an index to free synch cache block
//assign the index obtained in previous step to obj.SyncBlockIndex
}
syncblock = syncblockCache[locker.SyncBlockIndex]
if(!syncblock is owned by the calling thread)
{
//susped the calling thread
}
Посмотрите, поможет ли вам эта ссылка разобраться в блокировке (я написал это сообщение некоторое время назад)
http://dotenetscribbles.blogspot.com/2008/10/calling-monitorenter-recursively.