我写了这样的东西:
public abstract class A {
static String name = "A";
public static String getName() {
return this.name;
}
}
public class B extends A {
static String name = "B";
}
public class C extends A {
static String name = "C";
}
当我调用B b = new B();
public class Draw<T extends Print> (Print is a interface) 其他类: public interface Print {
static void info(String message) {
System.out.println("failed");
}
}
public class Test implements Print {
static void info(String message) {
System.out.println(message)
我希望允许我的所有子对象实现静态方法。例如:
public abstract class A {}
public class B : A {}
public class C : A {}
我希望B和C有DoSomething()静态方法,在A中有DoSomething()的默认实现。
bes这样做的实践是什么?
我正在研究静态和动态多态性,并获得了以下链接:
在所有这些链接中,有人说重载是多态性的一个例子,然后我又遇到了另外两个地方,有人说重载与多态性无关,链接是:
Head First Java第二版第7章(继承和多态)最后一个主题:重载方法
。
现在我不能确定它是否是一种多态性,如果不是,在OOPs中有没有什么叫做静态多态性的东西?
我有一些用Java编写代码的经验,但现在我发现自己不得不用Python编写代码。我想要做的是开发一个从抽象类文档扩展到多个文档类型的类结构,这些文档类型将根据数据库的类型从数据库中检索不同的信息。由于可能至少有100种不同的文档类型,我觉得使用抽象来卸载尽可能多的代码--在结构上越高越好--这是我最好的选择。
在Java中,我会写这样的东西:
public abstract class Document(){
private String department
private String date
...
public Document(){
...}
class parents {
public function __call( $name , $arguments ) {
var_dump( __CLASS__ );
}
public function test () {
var_dump( __CLASS__ );
}
}
class child extends parents{
public function __call( $name , $arguments ) {
var_dump( __CLASS__ );
}
public function test () {
var
我是一个Java/C#/PHP开发人员,通过我的OOP编程经验,我发现自己也在问同样的问题:为什么静态成员不能是抽象的,并且不能实现多态性,特别是在涉及工厂方法的情况下,例如:
abstract class Resource {
public void doSomething();
}
abstract class User<resource extends Resource> {
//if i want to instantiate resource,
//my only option here is to create an abstract fa
public class B extends A{
public static void main(String[] args) {
new B().privateMethod();//no error -output B-privateMethod.Sounds like overriding
new B().staticMethod(); //no error -output B-StaticMethod.Sounds like overriding
}
private void privateMethod() {
System.
我尝试将hello方法放在基类A中,并希望它显示在子类中设置的x的值。
A的实例永远不会调用hello方法-该类是一个纯基类,并且永远不会被实例化。
x变量是一个分类器,用来表示调用hello方法的位置(这个值实际上持久化到数据库中);
如果在子类中调用hello,如何确保x的值是在子类中设置的值?
public class A{
protected static String x = "A";
public void hello(){
System.out.println(x);
}
}
public class B extends A{
pr
我知道为了传递一个函数作为参数,我们需要让它成为一个函数指针。但是,为什么我们需要在另一个函数中传递函数指针作为参数,而我们可以在另一个函数定义中调用该函数呢?
//Why this
int (*f1)(int);
int testFunction(int (*f)(int));
//Instead of this
int f1(int);
int testFunction()
{
int f1Value = f1(2); //call the fucntion and store the value
}
这个例子可能没有任何意义。
当我们倾向于传递函数指针而不是仅仅调用函数时?
我不喜欢直接使用models对象,因为这会破坏封装。相反,我更喜欢。
当我尝试实现一个简单的存储库时
public abstract class BaseRepository<T extends Model> {
public T findOne(String query, Object... params) {
GenericModel.JPAQuery result = T.find(query, params);
return result.first();
}
}
public class UserRepository ext
我在c#中有这个(Gameobject来自unity3d)
namespace DLLTest
{
public class buttong : MonoBehaviour
{
public GameObject BButtn([ParamDictionary] IDictionary kwargs)
这是python init中的内容:
engine.Runtime.LoadAssembly(System.Reflection.Assembly.GetAssembly(typeof(DLLTest.buttong)));
这是Python中的:
from D
我已经阅读了下面的文章
他们似乎都非常接近我的问题,并且有很好的答案,但他们似乎没有回答我的问题,只是说我需要使这个方法非静态的。
举个例子:
abstract public class baseClass
{
private static List<string> attributeNames = new List(new string {"property1","property2"});
// code for property definition and access
virtual public static b
最近,我的老师在教授多态性,他告诉我们,多态性有两个方面
运行时多态性
编译时多态性
然后他给我们看了这个密码
class A {
void ab(){
System.out.println("ab() in class A");
}
}
class B extends A {
void ab(){
System.out.println("ab() in class B");
}
}
class ObCo {
public static void main(String