我最近开始自己练习和学习java,我很难理解如何使用多态性来进行更好的编码实践。如何使用多态重构来消除下面代码中的if和get条件?
我有一个家长课水果,有孩子课,猕猴桃,苹果和其他一堆水果。例如:苹果是甜的,猕猴桃是酸的。
我有一个家长班人,有孩子班的男孩和女孩。男孩喜欢甜的味道,女孩喜欢酸的。我创建了一个水果对象数组,并使用if语句根据每个水果的口味来检查谁喜欢它。
Fruit[] fruit = new Fruit[2];
fruit[0] = new Apple ();
fruit[1] = new Kiwi ();
Boy boy1 = new Boy ();
String boyT
假设我有两个类,如下:
class Fruit
{
public string color { get; set; }
}
class Orange : Fruit
{
public double diameter { get; set; }
}
然后在一个水果变量中创建一个橙色对象
Fruit fruit = new Orange() { color = "Orange", diameter = 10.0 };
// This line prints 10 even though the Fruit class doesn't contain a
/
我有一些模型,看起来像这样:
class Basket
has_many :fruits, :dependent => :destroy
end
class Fruit
belongs_to :basket # do I need a polymorphic association here?
end
class Apple < Fruit
validate :crunchy
end
class Banana < Fruit
validate :peelable
end
水果在某种意义上是抽象的,你永远不会创建、更新等水果,而是苹果或香蕉。这意味着我不
我有一个水果班和一个从水果中继承下来的苹果。假设我有一系列不同种类的水果。我可以说苹果,香蕉和其他水果。
问题:当我试图从数组的元素(水果的子元素)获取值时,它不会编译.
class Fruit{
public:
Fruit();
}
class Apple : public Fruit{
public:
Apple();
int count; //number of apples in the store
}
int main(){
Fruit market[3];
market[0] = Apple();
int apples =
我有一个Python对象的集合,让我们称它们为水果。这些水果中的一些可能是错误的。要检查这些错误,我有许多执行不同检查的函数,并返回未通过检查的水果列表:
def not_delicious(fruits, limit):
return fruit for fruit in fruits if fruit.tastyness < limit
def not_ripe(fruits):
return fruit for fruit in fruits if not fruit.ripe
现在,我希望有一个方法,让我可以灵活地记录这些检查的结果。一种天真的方法是这样的:
d
爪哇新手来了。
Banana and Apple extend Fruit (Fruit可能也是一个抽象类,因为任何水果都不会被实例化)。
Banana和Apple都有一个(非常不同的) toString()方法。
某个地方的方法--我们称之为processFruit(Fruit fruit) --接受Fruit作为参数,然后调用实际接收到的Fruit的toString()方法(意思是香蕉或苹果),以便进行日志记录。我该怎么做?
我想做fruit.toString(),并让它根据实际的结果运行Apple.toString()或Banana.toString()方法。
我宁愿不做的事情(因为有很
我希望我的代码是可扩展的,在运行时我可以创建对象。
例如,假设我有一个Grocery类,它有一个水果数组,我想用从水果派生的对象填充这个水果数组。
class Fruit{
};
class Grocery{
std::vector<Fruit*> m_fruits;
};
class Apple: Fruit{
};
class Pineapple: Fruit{
};
现在,在运行时,我希望我的杂货类向量m_fruits由苹果和凤梨的类对象填充。所以有没有可能在某种程度上。
如果我将来添加另一个水果作为草莓,它的对象将被动态创建并添加到Grocery的向量
基本上,我有一个包含不同水果的自定义列表类。假设每个水果都有存储在列表中的ID号。
是否最好有:
new AppleList();
new OrangeList();
new LemonList();
或
new FruitList<Fruit.Apple>();
new FruitList<Fruit.Orange>();
new FruitList<Fruit.Lemon>();
需要考虑的事项:
所有ID都是int类型。
水果的类型不会影响清单本身的执行。它将仅供列表的客户端使用,如外部方法等。
我想使用的是更清晰,更好的设计,更快,更
我有一个包含水果列表的字符串。我的C#程序不能直接使用水果,它需要把它们投给香蕉或苹果。json中的constructor属性中包含了有关如何转换它们的信息。
注意:我使用的是JSON.NET。
这就是我想要达到的目标:
class Fruit{ public string constructor;}
class Banana : Fruit { public int monkey;}
class Apple : Fruit { public string shape;}
string json = @"[
{
我尝试将Objectify与一组继承自抽象基类的类一起使用:
class Container {
@Id Long id;
@Embedded Set<MyAbstract> children = new HashSet<MyAbstract>();
}
@Entity
abstract class MyAbstract {
@Id Long id;
}
@Subclass class Derived1 extends MyAbstract {}
@Subclass class Derived2 extends MyAbstract {}
你知道如何为
我怎样才能拥有一个类Fruit的多个扩展,并且基于对象所列出的类/类型,在这个结果上执行相同的方法,但具有不同的功能呢?
示例:我正在使用FruitManager向水果存储添加一个新的Fruit fruit = new Apple();。如果这个水果是一个苹果,我当然想把这个添加到苹果列表中。Elso to bananas list。现在,如果我有10种水果,我不想创建像addBanana()、addApple()等10个函数。我也不想为了获得正确的水果列表而使用凌乱的if-else语句。
我可以仅仅根据我添加的对象类型来获得水果列表吗?
class Fruit;
class Apple ex
尝试在基类中设置ForeignKeyAttribute时出现错误
class User { }
abstract class FruitBase
{
[ForeignKey("CreateById")]
public User CreateBy{ get; set; }
public int CreateById{ get; set; }
}
class Banana : FruitBase { }
class DataContext : DbContext
{
public DbSet<Banana> Ba
我有一个允许的水果列表,并且必须确保配置文件包含所有这些水果,并且每个水果都位于一个单独的行中,因为below.The配置文件有其他配置lines.Lets,比如允许的水果是苹果、香蕉、樱桃,那么有效的配置文件将如下所示:
fruit apple
some other config line
############
fruit banana
fruit cherry
other config 1
other config n
使用java regex来检查是否列出了所有三个允许的水果,只有那些fruits.For,例如:如果第四个水果列在单独的行中,那么配置文件是无效的。
我可以使用
我有一个这样的方法-
public List<Apples> returnFruits(String arg1){
List<Apples> fruits = new ArrayList<Apples>();
Apple a = new Apple();
fruits.add(a);
return fruits;
}
我想要更改它,这样我就可以从方法调用中指定水果类型并返回该水果列表。因此,第二条语句应该动态实例化我传递的水果列表。我想到了这个-
public List<?> returnFruits(String arg1){
List<
我在一个文本文件中有一个水果名称列表。每次你按下一个按钮,水果的名字就会以相反的顺序显示。用户应该破解水果名称并将其写入文本字段。当用户按下按钮时,应在水果名称的文本文件列表中验证该单词。如果用户提供的水果名称是正确的,用户应该得到一个分数,并继续使用另一个水果name.if,如果不正确,分数保持不变。
每次水果名称正确时,我都很难给出一个分数。这是我的java代码函数,请帮助:
public int scoreWord() {
int scores = 0;
String filePath = "C:\\names.txt";
ArrayList<
首先,请参阅这些Java代码:
Drawable.java
package examples.simple.model;
public interface Drawable {
public void draw();
}
Shape.java
package examples.simple.model;
public abstract class Shape implements Drawable {
private Point center;
public Point getCenter() {
return center;
}
我对编程并不陌生,但对面向对象程序设计( OOP )还比较陌生,所以我有一个设计问题。事实上,我有两个问题都是在同一个问题中解决的。
为了简单起见,假设我正在设计一个FruitBasket类。除了FruitBasket类之外,我还将设计一个Apple类、一个Orange类和一个Pear类。每当我实例化一个FruitBasket类型的对象时,它就会在一个关系中自动实例化这些其他类。
class Apple { //Apple implementation here }
class Orange { //Orange implementation here }
class Pear { //P
我现在正在从Java迁移到C++,每当Java中常用的概念不能直接映射到C++时,我就会遇到一些困难。例如,在Java中,我会这样做:
Fruit GetFruit(String fruitName) {
Fruit fruit;
if(fruitName == "apple") fruit = new Fruit("apple");
else if(fruitName == "banana") fruit = new Fruit("banana");
else fruit = new Fruit(
我想要创建水果的不区分大小写的最终TreeSet值。是否有任何方法,我可以改变一些在水果1-变量声明,以便我可以得到所需的结果,并可以避免方法addFruits()
import java.util.Arrays;
import java.util.SortedSet;
import java.util.TreeSet;
public class Fruits {
public static SortedSet<String> fruits = new TreeSet<>(String.CASE_INSENSITIVE_ORDER);
//public stat
我试图创建一个类来表示水果商店,并希望输出按价格排序的可用水果,从最低到最昂贵。然而,即使我把价格按最便宜到最贵的顺序添加到我的FruitPricesMap中,它总是按相同的顺序打印水果吗?我怎么能让它不这样做呢?
****FruitStore.java****
import java.util.*;
public class FruitStore {
private Map<String, Double> fruitPricesMap;
public FruitStore() {
fruitPricesMap = new HashMap<
我目前正在为容器设计一个接口,该容器应该存储来自公共超级类型的不同实例的引用。它的类比如下:
假设有水果商店,人们可以在那里放不同种类的水果。水果商店应该为它目前拥有的每一种水果提供检索相同类型的所有水果的能力。
水果
public abstract class Fruit {}
public class Apple extends Fruit {}
public class Pear extends Fruit {}
public class Orange extends Fruit {}
我最初的设计是为每一种水果创建单独的数据结构。当列出特定类型的水果时,我们只需要从对应的数据结构
每次在java中调用构造函数时,是否都会创建对象?这里苹果类继承自Fruit.Apple对象是created.As,它继承自水果,水果的构造函数称为(构造函数链).That表示水果的对象已经初始化。
但是输出结果表明,只创建了一个对象,Apple object.Both具有相同的哈希码。
有人能解释一下吗?我希望两个对象是there.First水果对象应该已经初始化,然后苹果对象。
//一个Java程序,用于演示超类//和子类构造函数都引用同一个对象
// super class
class Fruit
{
public Fruit()
{
System.out
我想迭代所有继承自同一个超类的不同对象。这意味着我有一个这样的超级阶级:
class fruit
{
public:
fruit()
{
}
};
我有这样的子类,它们定义了在我的代码中使用的对象:
class apple: public fruit
{
public:
apple()
{
}
};
class banana: public fruit
{
public:
banana()
{
}
};
现在我想反复讨论所有的水果(苹果,香蕉):
for ( f
我正在将一些Java代码移植到C#上,并且在复制这种行为时遇到了困难:
* JAVA代码*
public abstract class Fruit<T extends Fruit>{
//Fruit implementation
}
这很好,因为我只想要扩展果树的泛型类型。然后,我可以为所有的混凝土水果对象存储引用,如下所示:
Banana banana = new Banana(); //This class extends Fruit
Strawberry strawberry = new Strawberry (); //This class extends Fruit
import java.io.*;
public class test
{
public static void main(String[] args)throws IOException
{
double apples = 1.7;
//showSum(5, 10);
}
public static void apples(double fruit)
{
System.out.println("number of fruit: " + fruit);
}
}
我不知道为什么苹果这个方法不显示水果