Java/Class/Inheritance Composition

Материал из Java эксперт
Версия от 09:36, 1 июня 2010; Admin (обсуждение | вклад) (1 версия)
(разн.) ← Предыдущая | Текущая версия (разн.) | Следующая → (разн.)
Перейти к: навигация, поиск

Cleanup and inheritance

   <source lang="java">

// : c07:Frog.java // Cleanup and inheritance. // From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002 // www.BruceEckel.ru. See copyright notice in CopyRight.txt. class Characteristic {

 private String s;
 Characteristic(String s) {
   this.s = s;
   System.out.println("Creating Characteristic " + s);
 }
 protected void dispose() {
   System.out.println("finalizing Characteristic " + s);
 }

} class Description {

 private String s;
 Description(String s) {
   this.s = s;
   System.out.println("Creating Description " + s);
 }
 protected void dispose() {
   System.out.println("finalizing Description " + s);
 }

} class LivingCreature {

 private Characteristic p = new Characteristic("is alive");
 private Description t = new Description("Basic Living Creature");
 LivingCreature() {
   System.out.println("LivingCreature()");
 }
 protected void dispose() {
   System.out.println("LivingCreature dispose");
   t.dispose();
   p.dispose();
 }

} class Animal extends LivingCreature {

 private Characteristic p = new Characteristic("has heart");
 private Description t = new Description("Animal not Vegetable");
 Animal() {
   System.out.println("Animal()");
 }
 protected void dispose() {
   System.out.println("Animal dispose");
   t.dispose();
   p.dispose();
   super.dispose();
 }

} class Amphibian extends Animal {

 private Characteristic p = new Characteristic("can live in water");
 private Description t = new Description("Both water and land");
 Amphibian() {
   System.out.println("Amphibian()");
 }
 protected void dispose() {
   System.out.println("Amphibian dispose");
   t.dispose();
   p.dispose();
   super.dispose();
 }

} public class Frog extends Amphibian {

 private Characteristic p = new Characteristic("Croaks");
 private Description t = new Description("Eats Bugs");
 public Frog() {
   System.out.println("Frog()");
 }
 protected void dispose() {
   System.out.println("Frog dispose");
   t.dispose();
   p.dispose();
   super.dispose();
 }
 public static void main(String[] args) {
   Frog frog = new Frog();
   System.out.println("Bye!");
   frog.dispose();
 }

} ///:~


      </source>
   
  
 
  



Combining composition and inheritance

   <source lang="java">

// : c06:PlaceSetting.java // Combining composition & inheritance. // From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002 // www.BruceEckel.ru. See copyright notice in CopyRight.txt. class Plate {

 Plate(int i) {
   System.out.println("Plate constructor");
 }

} class DinnerPlate extends Plate {

 DinnerPlate(int i) {
   super(i);
   System.out.println("DinnerPlate constructor");
 }

} class Utensil {

 Utensil(int i) {
   System.out.println("Utensil constructor");
 }

} class Spoon extends Utensil {

 Spoon(int i) {
   super(i);
   System.out.println("Spoon constructor");
 }

} class Fork extends Utensil {

 Fork(int i) {
   super(i);
   System.out.println("Fork constructor");
 }

} class Knife extends Utensil {

 Knife(int i) {
   super(i);
   System.out.println("Knife constructor");
 }

} // A cultural way of doing something: class Custom {

 Custom(int i) {
   System.out.println("Custom constructor");
 }

} public class PlaceSetting extends Custom {

 private Spoon sp;
 private Fork frk;
 private Knife kn;
 private DinnerPlate pl;
 public PlaceSetting(int i) {
   super(i + 1);
   sp = new Spoon(i + 2);
   frk = new Fork(i + 3);
   kn = new Knife(i + 4);
   pl = new DinnerPlate(i + 5);
   System.out.println("PlaceSetting constructor");
 }
 public static void main(String[] args) {
   PlaceSetting x = new PlaceSetting(9);
 }

} ///:~


      </source>
   
  
 
  



Composition for code reuse

   <source lang="java">

// : c06:SprinklerSystem.java // Composition for code reuse. // From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002 // www.BruceEckel.ru. See copyright notice in CopyRight.txt. class WaterSource {

 private String s;
 WaterSource() {
   System.out.println("WaterSource()");
   s = new String("Constructed");
 }
 public String toString() {
   return s;
 }

} public class SprinklerSystem {

 private String valve1, valve2, valve3, valve4;
 private WaterSource source;
 private int i;
 private float f;
 public String toString() {
   return "valve1 = " + valve1 + "\n" + "valve2 = " + valve2 + "\n"
       + "valve3 = " + valve3 + "\n" + "valve4 = " + valve4 + "\n"
       + "i = " + i + "\n" + "f = " + f + "\n" + "source = " + source;
 }
 public static void main(String[] args) {
   SprinklerSystem sprinklers = new SprinklerSystem();
   System.out.println(sprinklers);
 }

} ///:~


      </source>
   
  
 
  



Extending an interface with inheritance

   <source lang="java">

// : c08:HorrorShow.java // Extending an interface with inheritance. // From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002 // www.BruceEckel.ru. See copyright notice in CopyRight.txt. interface Monster {

 void menace();

} interface DangerousMonster extends Monster {

 void destroy();

} interface Lethal {

 void kill();

} class DragonZilla implements DangerousMonster {

 public void menace() {
 }
 public void destroy() {
 }

} interface Vampire extends DangerousMonster, Lethal {

 void drinkBlood();

} class VeryBadVampire implements Vampire {

 public void menace() {
 }
 public void destroy() {
 }
 public void kill() {
 }
 public void drinkBlood() {
 }

} public class HorrorShow {

 static void u(Monster b) {
   b.menace();
 }
 static void v(DangerousMonster d) {
   d.menace();
   d.destroy();
 }
 static void w(Lethal l) {
   l.kill();
 }
 public static void main(String[] args) {
   DangerousMonster barney = new DragonZilla();
   u(barney);
   v(barney);
   Vampire vlad = new VeryBadVampire();
   u(vlad);
   v(vlad);
   w(vlad);
 }

} ///:~


      </source>
   
  
 
  



Inheritance, constructors and arguments

   <source lang="java">

// : c06:Chess.java // Inheritance, constructors and arguments. // From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002 // www.BruceEckel.ru. See copyright notice in CopyRight.txt. class Game {

 Game(int i) {
   System.out.println("Game constructor");
 }

} class BoardGame extends Game {

 BoardGame(int i) {
   super(i);
   System.out.println("BoardGame constructor");
 }

} public class Chess extends BoardGame {

 Chess() {
   super(11);
   System.out.println("Chess constructor");
 }
 public static void main(String[] args) {
   Chess x = new Chess();
 }

} ///:~


      </source>
   
  
 
  



Inheritance syntax and properties

   <source lang="java">

// : c06:Detergent.java // Inheritance syntax & properties. // From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002 // www.BruceEckel.ru. See copyright notice in CopyRight.txt. class Cleanser {

 private String s = new String("Cleanser");
 public void append(String a) {
   s += a;
 }
 public void dilute() {
   append(" dilute()");
 }
 public void apply() {
   append(" apply()");
 }
 public void scrub() {
   append(" scrub()");
 }
 public String toString() {
   return s;
 }
 public static void main(String[] args) {
   Cleanser x = new Cleanser();
   x.dilute();
   x.apply();
   x.scrub();
   System.out.println(x);
 }

} public class Detergent extends Cleanser {

 // Change a method:
 public void scrub() {
   append(" Detergent.scrub()");
   super.scrub(); // Call base-class version
 }
 // Add methods to the interface:
 public void foam() {
   append(" foam()");
 }
 // Test the new class:
 public static void main(String[] args) {
   Detergent x = new Detergent();
   x.dilute();
   x.apply();
   x.scrub();
   x.foam();
   System.out.println(x);
   System.out.println("Testing base class:");
   Cleanser.main(args);
 }

} ///:~


      </source>