Application Error - The connection to the server was unsuccessful. 
(file:///android_asset/www/index.html) 

 

这个应该是PhoneGap某些版本的BUG，尤其在index.html加载的内容较多时容易出现。

 

方法1：更新到PhoneGap的最新版本；

方法2：设置加载超时属性

super.setIntegerProperty("loadUrlTimeoutValue",10000);  

完整代码如下（设置超时为 10 秒）

@Override
publicvoid onCreate(Bundle savedInstanceState){
    super.onCreate(savedInstanceState);
    super.loadUrl("file:///android_asset/www/home/index.html");
    super.setIntegerProperty("loadUrlTimeoutValue",10000);

方法3：改名法

我不明白为什么我的输出不是我认为应该的.我认为应该是狗吠线断线猫咪.但没有什么.

码：

namespace ConsoleApplication2
{
  class Program
  {
    static void Main(string[] args)
    {
      Pets pet1 = new Dog();
      Pets pet2 = new Cat();
      pet1.Say();
      pet2.Say();
      Console.ReadKey();
    }
  }

  class Pets
  {
   public void Say() { }
  }

  class Dog : Pets
  {
   new public void Say() { Console.WriteLine("Dog barks."); }
  }

  class Cat : Pets 
  {
   new public void Say() { Console.WriteLine("Cat meows."); }
  }
}

我试图通过c# programming guide on MSDN,但是我觉得很难理解那里的一些例子.如果有人可以链接到一个很好的“假人遗产”网站,那将是非常感激的.

将您的基类中的Say功能虚拟化,然后在派生类中覆盖此函数：

namespace ConsoleApplication2
{
  class Program
  {
    static void Main(string[] args)
    {
      Pets pet1 = new Dog();
      Pets pet2 = new Cat();
      pet1.Say();
      pet2.Say();
      Console.ReadKey();
    }
  }

  class Pets
  {
   public virtual void Say() {
      Console.WriteLine("Pet makes generic noise");
 }
  }

  class Dog : Pets
  {
    public override void Say() { Console.WriteLine("Dog barks."); }
  }

  class Cat : Pets 
  {
    public override void Say() { Console.WriteLine("Cat meows."); }
  }
}

我想添加不同类型的对象,这些对象派生自具有泛型的一个类到基类型列表.我得到这个编译错误

Error   2   Argument 1: cannot convert from 'ConsoleApplication1.Stable' to 'ConsoleApplication1.ShelterBase<ConsoleApplication1.AnimalBase>'   C:\Users\ysn\Desktop\ConsoleApplication1\ConsoleApplication1\Program.cs 43  26  ConsoleApplication1

我看不到这个问题,你能为我提供另一种做这种事情的方法吗？

abstract class AnimalBase { public int SomeCommonProperty;}

abstract class ShelterBase<T> where T : AnimalBase
{
    public abstract List<T> GetAnimals();
    public abstract void FeedAnimals(List<T> animals);
}


class Horse : AnimalBase { }

class Stable : ShelterBase<Horse>
{
    public override List<Horse> GetAnimals()
    {
        return new List<Horse>();
    }

    public override void FeedAnimals(List<Horse> animals)
    {
        // Feed them
    }
}


class Duck : AnimalBase { }

class HenHouse : ShelterBase<Duck>
{
    public override List<Duck> GetAnimals()
    {
        return new List<Duck>();
    }

    public override void FeedAnimals(List<Duck> animals)
    {
        // Feed them
    }
}

class Program
{
    static void Main(string[] args)
    {
        List<ShelterBase<AnimalBase>> shelters = new List<ShelterBase<AnimalBase>>();

        ///////////////////////////// following two lines do not compile
        shelters.Add(new Stable()); 
        shelters.Add(new HenHouse());
        /////////////////////////////

        foreach (var shelter in shelters)
        {
            var animals = shelter.GetAnimals();
            // do sth with 'animals' collection
        }
    }
}

您可以使用 contravariance,但只有当您将抽象类更改为接口,并将GetAnimals的返回类型更改为IEnumerable< T>,因为List< T>不支持此功能.

工作原理：

abstract class AnimalBase { public int SomeCommonProperty;}

interface IShelterBase<out T> where T : AnimalBase
{
    IEnumerable<T> GetAnimals();
}

class Horse : AnimalBase { }

class Stable : IShelterBase<Horse>
{
    public IEnumerable<Horse> GetAnimals()
    {
        return new List<Horse>();
    }
}

class Duck : AnimalBase { }

class HenHouse : IShelterBase<Duck>
{
    public IEnumerable<Duck> GetAnimals()
    {
        return new List<Duck>();
    }
}

void Main()
{
    List<IShelterBase<AnimalBase>> shelters = new List<IShelterBase<AnimalBase>>();

    shelters.Add(new Stable());
    shelters.Add(new HenHouse());

    foreach (var shelter in shelters)
    {
        var animals = shelter.GetAnimals();
        // do something with 'animals' collection
    }
}

我正在创建一个抽象基类,其中包含由其他类实现的函数.我的怀疑如下

1)我是否需要在每个需要被子类覆盖的函数前面给出“虚拟”？我看到一些没有虚拟关键字的示例,但仍然可以覆盖它们.

2)我需要有一个将在基类中实现的函数,我不希望它被子类重写.我添加了该功能的“固定”关键字.编译器开始抱怨“成员”无法密封,因为它不是覆盖.我在这里做错了吗？

abstract public class ShapeBase
    {
        private ShapeDetails _shapedDetails;

        public CampusCardBase(ShapeDetails shDetails)
        {
            _shapedDetails= shDetails;
        }

        public virtual void Draw();
        public virtual float getWidth();
        public virtual void Swap();
        public virtual void Erase();

        public sealed ShapeDetails getShapeDetails()
        {
            return _shapedDetails;
        }


    };

>对于在抽象类中没有实现的方法,也使用abstract：

abstract public void Draw();
abstract public float getWidth();
abstract public void Swap();
abstract public void Erase();

>默认情况下,方法不可覆盖;如果声明为abstract,virtual或override(但不覆盖密封),它们只允许派生类重写.

因此,您不需要为getShapeDetails()提供除public之外的任何其他修饰符：

public ShapeDetails getShapeDetails()
{
    return _shapedDetails;
}

另外,您应该坚持使用.NET命名约定并使用Pascal大小写大写方法名称,因此getWidth()变为GetWidth(),getShapeDetails()变为GetShapeDetails().

实际上你应该为你的_shapedDetails字段使用property getter而不是getShapeDetails()方法：

private ShapeDetails _shapedDetails;

public ShapeDetails ShapedDetails
{
    get { return _shapedDetails; }
}