相关疑难解决方法(0)

我有一个Preference类(模块),用于几个不同的应用程序.基本上它是首选项的缓存,因此系统不必一直调用后端.它类似于缓存,但有一些额外的细节,如isPreferenceSelected,有一些辅助方法等.

问题是我想在类中包含一个savePreference,以便任何使用它的人都可以覆盖该方法,无论是数据库,平面文件等等.关键是这个模块不想要照顾.问题是它不是一个抽象类,所以我不能覆盖静态方法,即使它是,我也不想创建一百万个实例,因为我不想每次都加载首选项.我也不能创建一个抽象的单例.

因此我不知道该怎么做.这是我想要评论的代码片段:

// Please ignore the missing Generics, etc.
public class Preference
{
  private static HashMap preferences = new HashMap();

  public static ... 

  // Some preferences are objects, such as images, etc.
  public static setPreference(String name, Object value)
  {
    .. some helper code
    preferences.put(name, value); // ignoring issues with if it already exists ;)
    savePreference(name, value); // saves to database, flatfile, etc.
  }
}

这是不同系统利用的核心类/代码.现在我想做的是在webapp,桌面应用程序等中说,能够在我的代码中使用这个类,例如:

public someFunction(...)
{
  .. do some cool code
  Preference.savePreference("logoImage", image); …

让我们假设我有这样的代码:

public interface JustAnInterface {
    void doSomething();
}

public class JustAnInterfaceImplementation implements JustAnInterface {

    @Override
    public static void doSomething() {

    }
}

为什么static doSomething()方法显示错误" 方法不覆盖其超类方法 "？

目前我正试图像这样调用它:

class Test {
    public static void test() {
        System.out.println("hi");
    }
    public static void main(String[] args) {
        Test t = null;
        t.test();
    }
}

代码的输出是hi

我无法理解为什么编译器在尝试编译此代码时会显示错误:

class A
{
    public static void f()
    {
        System.out.println("A.f()");
    }
}

class B extends A
{
    public static int f()
    {
        System.out.println("B.f()");
        return 0;
    }
}

A和B类中两个方法之间的差异是返回类型,我读到Java防止覆盖静态方法.所以我期望编译器不应该显示任何错误,因为最初没有任何重写!

如何在子类中将超类的实例方法重写为静态？我认为这是不可能的,但是有任何间接方式吗？

public class A {
   public void test(){
       System.out.println("");
   }
}

public class B extends A{
    public static void test(){//test() in B cannot override test() in A 
    //overriding method is static

   }
}

假设我有一个POJO User,我添加了一些静态方法来执行CRUD操作:

public class User {
    private String name;
    private int age;

    // getter and setter omitted
    //
    public static void add(User user) {
        // add person
    }

    public static int delete(Object id) {
        // delete person
        return 1;
    }
}

因为我有像User这样的其他实体,所以我想把这个add和delete方法抽象化,就像这样;

public class?interface Entity<T>{
    static add(T t);
    static delete(Object id);   
}

public class User extends Entity<User>{
    @override
    static add(User user){
        // add ...
    }

    ....
}

这可能吗？

该程序应该单独调用funFact每个子类,但它只调用该类中的funFact 方法Mammal.我究竟做错了什么？

 public class MammalFacts{
        public static class Mammal{
            public static String funFact(){
                return "If you are reading this, there's a 70% chance you're a mammal";
            }//end funFact

        }//end mammal
        public static class Primate extends Mammal{
            public static String funFact(){
                return "All primates can fly";
            }
        }//end Primate
        public static class Monkey extends Primate{
            public static String funFact(){
                return "Monkies will rule the earth someday";
            }
        }
        public static void main(String[]args){
            Mammal[]i = new Mammal[3]; …

当我尝试运行这段代码时,它给了我30.有人可以解释一下!我知道你不能在Java中覆盖静态方法,因为,多态和静态不会一起工作.静态方法在Class上调用,而不是在实例中调用.但有人可以进一步解释这个主题.我真的不明白为什么我得到30而不是10.谢谢!

class One {

    static int value = 0;
    One(){
        addValue ();
    }

    static int addValue () {
        return value+=10;
}

    int getValue () {
        return value;

     }

}

class Two extends One {

    Two () {
        addValue ();
    }

    static int addValue () {
        return value+=20;
    }

public static void main(String[] args ) {
    One t = new Two ();
    System.out.println(t.getValue());
}
}

好的。我有一个标准的归并排序类。

public class Merge extends SortAlgorithm {

public static void sort(Comparable[] a) {
    Comparable[] aux = new Comparable[a.length];
    sort(a, aux, 0, a.length -1);
}

protected static void sort(Comparable[] a, Comparable[] aux, int lo, int hi) {
    if(hi <= lo)
        return;
    int mid = (lo + hi)/2;
    sort(a, aux, lo, mid);
    sort(a, aux, mid+1, hi);
    if(less(a[mid+1], a[mid]))
        merge(a, aux, lo, mid, hi);
}

public static void main(String[] args) throws IOException {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    String[] a = br.readLine().split(" …

我对static关键字及其用法很熟悉。我知道static可以在子类中重新声明方法，但是方法的定义被隐藏，并且与父类相同。我提到的是我已经阅读的文章的一些链接：

https://www.geeksforgeeks.org/can-we-overload-or-override-static-methods-in-java/

Java为什么不允许覆盖静态方法？

静态和最终之间的区别？

当派生类定义的静态方法与基类中的静态方法具有相同的签名时，派生类中的方法会将方法隐藏在基类中。但是仍然将基类的方法称为display()基类的方法。

但是我很好奇为什么为什么以及何时需要重新声明派生类中的static 方法，base class如果它的定义不能在派生类中被覆盖/更改，而是显示基类的定义呢？

    /* Java program to show that if static method is redefined by 
a derived class, then it is not overriding. */

// Superclass 
class Base { 

    // Static method in base class which will be hidden in subclass 
    public static void display() { 
        System.out.println("Static or class method from Base"); 
    } 

    // Non-static method which will be overridden in derived class 
    public void print() …