Interface Interface vs. Abtract

[snooc]

Hey Leute, ich habe nun schon seit ein paar Tagen ein Problem mich für
ein bestimmtes Design für eine kleine Hobby-Unternehmung zu entscheiden.
Ich hoffe wirklich, dass mir hier jemand helfen kann..

Einleitung:
Ich möchte ein Framework in Java schreiben welches HTML abkapselt
und bei Anwendung HTML5-validen Code erzeugt.

Überlegung:
HTML-Tags sind eigene Objekte und deren Attribute (z.B.: <img src=".." alt="..">
ebenso. Da verschiedene HTML-Elemente auch verschiedene Attribute haben
stellt sich die Frage, wie man das am vernünftigsten anstellt, sodass man nicht
irgendwelche Dinge doppelt oder dreifach implementiert. Ein HTML-Element muss
über seine Attribute bescheid wissen, da diese manchmal auch
abhängig voneinander sind. In C++ würde ich die jew. Attribute
an das jew. HTML-Element durch Mehrfachvererbung weitergeben z.B.:

class img : public srcAttribute, public altAttribute {
  // ...
}

In Java geht das nicht.
Nun steht ich vor dem Problem (seit Tagen) wie ich das am vernünftisten machen kann.
Aber egal wie ich es drehe und wende, ich komme auf mehrfache Implementationen oder
auf abstruse Konstrukte die man in C++ evtl. vermeiden könnte.

Die Frage lautet also:
Wie würdet ihr das angehen? Die HTML-Elemente müssen ihre Attribute
selber verwalten. Manche Attribute sind von anderen wiederum
abhängig usw. Mir fällt kein gutes Design ein.

Und hier noch eine fundamentale Frage:
Auf Wikipedia gibts ein Beispiel zum Strategy-Pattern.
Würde man die klasse

interface Strategy {
    int execute(int a, int b); 
}

auf

public abstract class Strategy {
    abstract int execute(int a, int b); 
}

Dürfte das doch zum selben Ergebnis führen oder?

Ich hoffe mir kann jemand bei diesen Fragen helfen. Im wesentlichen geht es
darum dass ich den Vorteil nicht erkenne den mir ein

interface

wohl
bieten soll bzw. ich wohl etwas zu sehr an der Mehrfachvererbung hänge.

Vielen Dank für jede Form der Hilfe!

 

[Volvagia]

Jeder Tag hat ja bloß einen Namen und einen Wert. Würde da eine einfache Instanz nicht ausreichen, die beides speichert? Oder eine HashMap, der Tag hat diesen Wert. Wobei sie dann aber pro Element nur 1 mal vorkommen dürften.

Ein Interface ist in der Anwendung eine abstrakte Klasse, die ausschließlich abstrakte Methoden und Konstanten beinhaltet, damit noch von etwas anderen geerbt werden kann. Also ja, vom weitem betrachtet ist es genau das Selbe, nur wenn die Klasse verwendet wird kann von keiner anderen Klasse mehr geerbt werden.

 

[Kevin94]

Ich denke du machst dein konzept schwieriger als nötig.
Bei dem C++ beispiel dreht es mir den Magen um: ein img-Tag ist weder ein srcAttribut noch ein altAttribut.Wenn dann mit interfaces: HasSrcAttribute und HasAltAttribut

Muss jeder Tagtyp und jedes Attribut eine eigene Klasse oder reicht eine Klasse Tag und eine Klasse Attribut.

Ich würde folgendes vorschlagen:

public enum TagType
{
    img,a,h1,...;

    AttributeType[] expectedAttributes,optionalAttributes;
}

public enum AttributeType
{
    src,alt,href,...;
}

public class Tag
{
    TagType tagType;
    Vector<Attribute> attribute;

}

public class Attribute
{
    AtributeType attrType;
}

 

[Empire Phoenix]

Ich bi nciht ganz sicher, will der O html code validiren doer neuen erstellen? Beim erstellen würde ja nen J2EE gehen im xhtml modus, da das regilär ist und einfach überprüft werden kann kann man bei entsprechner einstellung sicherstellend as nur valider code produziert wird.

 

[snooc]

Hallo Leute,

erstmal danke für eure Antworten.
Also ich schildere mal das Design für welches ich mich entschieden habe:

Eine Basisklasse

Attribute

bietet grundlegende Funktionalitäten die dann
auf SinglevalueAttribute (z.B. href) und MultivalueAttribute (z.B. class) abgeleitet
wird. Diese beiden kann man dann zum Beispiel als Basisklasse für das eben genannte
class-Attribute verwenden.

Ein HTML-Tag hat eine Basisklasse

HtmlObject

. Diese Klasse bietet ebenfalls
Grundfunktionalitäten für den HTML-Tag (z.B. einen Container für dessen konkrete Attribute.
Diese Attribute werden nun in solch einer Klasse wie folgt hinzugefügt:

package html.blocklevel.textcontainer;

import html.attributes.elements.ColsAttribute;
import html.attributes.elements.DisabledAttribute;
import html.attributes.elements.LanguageAttribute;
import html.attributes.elements.NameAttribute;
import html.attributes.elements.PlaceholderAttribute;
import html.attributes.elements.ReadonlyAttribute;
import html.attributes.elements.RowsAttribute;
import html.attributes.elements.TitleAttribute;
import html.blocklevel.base.BlocklevelTextcontainer;

public class Textarea  extends BlocklevelTextcontainer {
	
	
	public ColsAttribute _cols					= new ColsAttribute();
	public RowsAttribute _rows 					= new RowsAttribute();
	public DisabledAttribute _disabled 			= new DisabledAttribute();
	public NameAttribute _name					= new NameAttribute();
	public ReadonlyAttribute _readonly			= new ReadonlyAttribute();
	public LanguageAttribute _lang				= new LanguageAttribute();
	public TitleAttribute _title				= new TitleAttribute();
	public PlaceholderAttribute _placeholder	= new PlaceholderAttribute();

	
	public Textarea() {
		
		super("textarea");
		addMyAttributes();
	}

	@Override
	protected void addMyAttributes() {
		
		super.addHtmlObjectSpecificAttribute(_cols);
		super.addHtmlObjectSpecificAttribute(_rows);
		super.addHtmlObjectSpecificAttribute(_disabled);
		super.addHtmlObjectSpecificAttribute(_name);
		super.addHtmlObjectSpecificAttribute(_readonly);
		super.addHtmlObjectSpecificAttribute(_lang);
		super.addHtmlObjectSpecificAttribute(_title);
		super.addHtmlObjectSpecificAttribute(_placeholder);
	}
	
} // End of class Textarea

public abstract class HtmlObject {

    protected		Vector<Attribute> 	m_attributes_container 	= new Vector<Attribute>();

    // ...

	protected void addHtmlObjectSpecificAttribute(Attribute attribute) {
		
		if(attribute != null) {
			m_attributes_container.add(attribute);
		}
	}
    // ...
} // End of class HtmlObject

Das was mir hier nun nicht gefällt ist die Anwendung, denn ich kann
die Attribute dann nur über den Zugriff auf eine public-Variable manipulieren.

 

[bERt0r]

Verstehe das Problem nicht, schreib dir doch eine get Methode... Wie soll denn deine Anwendung in deinen Wunschträumen funktionieren?

 

[TheDarkRose]

Schon mal was von Gettern und Settern gehört? und lass den Unterstrich beim den Klassenmembern weg.

 

[snooc]

Dann muss ich für jedes HTML-Element die Getter und Setter schreiben, und das obwohl die Attribute bereits diese Funktionen besitzen. Und genau diese Mehrfachimplementierung würde ich gerne verhindern.

Die Underlines sind für mich immer das Kennzeichen einer public-Membervariable ^^

 

[TheDarkRose]

Dann lass sie dir halt von deiner IDE einfach generieren..

 

[Volvagia]

Wenn ich das richtig verstanden habe (der Satz sollte vielleicht in meine Signatur), dann wäre das Element eine Fasade dafür. Finde ich persönlich schöner, ich baue gerne Subsysteme auf und greife über eine Klasse als Schnittstelle darauf zu.
Aber theoretisch könntest du dir einfach die Attribute im äußeren Programmteil über einen Getter am Element hohlen und direkt darauf zugreifen. Allerdings könnte es dabei nötig sein, dass das Element sich per Listener über Änderungen informieren lässt, je nach dem wie du es designt hast.

 

[snooc]

Also wäre das gar nicht so "hässlich" wenn ich das so mache?

Also ein Attribut kann zum beispiel so aussehen:

public class ClassAttribute extends MultiValueAttribute {

	private final static String m_attribute_name = "class";
	
	public ClassAttribute() {
		super(m_attribute_name);
	}
	
	public void addClass(String class_name) {

		addValue(class_name);
	}
	
	
	public boolean removeClass(String class_name) {
		
		if( removeValue(class_name) == null )
			return false;
		else 
			return true;
	}
	
	public boolean containsClass(String class_name) {
		
		return containsValue(class_name);
	}
}

Und irgendein Html-Objekt könnte dieses nun beinhalten. Das würde dann so aussehen
(wenn ich das Attribut private verwenden will und nur über Getter und Setter Zugriff zulasse).

public abstract class HtmlElement extends HtmlObject {
	
	
	protected AccesskeyAttribute m_accesskey 				= null;
	protected ClassAttribute m_class 						= null;
	protected ContenteditableAttribute m_contenteditable 	= null;
	protected ContextmenuAttribute m_contextmenu			= null;
	
	protected HtmlElement(String html_tag_name, int categorie, int content_model) {
		
		super(html_tag_name, categorie, content_model);
	}
	
	public void addClass(String class_name) {
		m_class.addClass(class_name);
	}
	
	public void removeClass(String class_name) {
		m_class.removeClass(class_name);
	}
	
} // End of class HtmlObjectWithStandardAttributes

 

[bERt0r]

Hast du da nicht mehr arbeit, wenn du für jedes Attribut wieder eigene add und remove Funktionen schreiben musst?
Eine Alternative wäre Volvagias Vorschalg, eine enum deiner Attributetypen zu Erstellen und eine Map<Attributtyp,Attribut> für deine HTML Objekte zu machen.

 

[snooc]

Ein enum allein würde nicht ausreichen. Die Attribute dürfen nur bestimmte Werte zugewiesen
bekommen. Darum habe ich eine abstrakte klasse Attribut, die abgeleitet wird und dann je nach
Attribut was anderes annehmen darf.

<table border="hallo">

wäre z.B. nicht HTML5 konform.

Beispiel:

package html.attributes.elements;

import html.attributes.base.SingleValueAttribute;
import html.attributes.values.RelValue;
import html.exceptions.attributes.InvalidValueException;

public class RelAttribute extends SingleValueAttribute  {
	
	private final static String m_attribute_name = "rel";

	public RelAttribute() {
		
		super(m_attribute_name);
	}
	

	/**
	 * setRel
	 * 
	 * @param value_code
	 * Valid codes can be found in 
	 * html.attributes.values.RelValues
	 * @throws InvalidValueException 
	 */
	public void setRel(RelValue rel_value) throws InvalidValueException {
		
		switch(rel_value)
		{
		case ALTERNATE:
			super.setValue("alternate");
			break;
			
		case AUTHOR:
			super.setValue("author");
			break;
			
		case HELP:
			super.setValue("help");
			break;
			
		case ICON:
			super.setValue("icon");
			break;
			
		case LICENCE:
			super.setValue("licence");
			break;
			
		case NEXT:
			super.setValue("next");
			break;
			
		case PINGBACK:
			super.setValue("pingback");
			break;
			
		case PREFETCH:
			super.setValue("prefetch");
			break;
			
		case PREV:
			super.setValue("prev");
			break;
			
		case SEARCH:
			super.setValue("search");
			break;
			
		case SIDEBAR:
			super.setValue("sidebar");
			break;
			
		case STYLESHEET:
			super.setValue("stylesheet");
			break;
			
		case TAG:
			super.setValue("tag");
			break;
			
			default:
				throw new InvalidValueException();
		}
		
	}

	
	/**
	 * getRel
	 * 
	 * The rel attribute specifies the relationship between 
	 * the current document and the linked document.
	 * Note: Browsers do not use this attribute in any way. 
	 * However, search engines can use this attribute to 
	 * get more information about a link.
	 * 
	 * @return
	 * The active rel-value
	 */
	public String getRel() {
		
		return super.getValue();
	}


} // End of class RelAttribute

 

[bERt0r]

Ich sagte eine enum für deine Attributtypen. Z.b
enum AttributTyp { bgcolor, text, src, onclick}
Dadurch kannst du dann bequem und eindeutig auf die Attribute in der Map zugreifen.
z.b map.put(AttributTyp.bgcolor,new BGColorAttribute(Color.red));

 

[snooc]

Wäre es so nicht schöner:

Body.setBgcolor(Color.Red);
Body.setId("main_body");

...