Admin: 1 версия

2010-06-01T06:47:47Z

1 версия

в 18:01, 31 мая 2010

2010-05-31T18:01:45Z

Новая страница

== Abstract classes and methods ==



<source lang="java">
// : c07:PrivateOverride.java
// Abstract classes and methods.
// From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002
// www.BruceEckel.ru. See copyright notice in CopyRight.txt.
public class PrivateOverride {
private void f() {
System.out.println("private f()");
}
public static void main(String[] args) {
PrivateOverride po = new Derived();
po.f();
}
}
class Derived extends PrivateOverride {
public void f() {
System.out.println("public f()");
}
} ///:~

</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>



== Find out whether interfaces are inherited ==



<source lang="java">
/** Find out whether interfaces are inherited.
* Start with Thread which implements Runnable.
*/
public class InterfaceInherit extends Thread {
public static void main(String[] a) {
new InterfaceInherit().start();
}
public void run() {
if (this instanceof InterfaceInherit)
System.out.println("This is InterfaceInherit");
if (this instanceof Thread)
System.out.println("This is Thread");
if (this instanceof Runnable)
System.out.println("This is Thread -- Interfaces ARE inherited!");
}
}

</source>



== Holds a sequence of Objects ==



<source lang="java">
// : c08:Sequence.java
// Holds a sequence of Objects.
// From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002
// www.BruceEckel.ru. See copyright notice in CopyRight.txt.
interface Selector {
boolean end();
Object current();
void next();
}
public class Sequence {
private Object[] objects;
private int next = 0;
public Sequence(int size) {
objects = new Object[size];
}
public void add(Object x) {
if (next < objects.length)
objects[next++] = x;
}
private class SSelector implements Selector {
private int i = 0;
public boolean end() {
return i == objects.length;
}
public Object current() {
return objects[i];
}
public void next() {
if (i < objects.length)
i++;
}
}
public Selector getSelector() {
return new SSelector();
}
public static void main(String[] args) {
Sequence sequence = new Sequence(10);
for (int i = 0; i < 10; i++)
sequence.add(Integer.toString(i));
Selector selector = sequence.getSelector();
while (!selector.end()) {
System.out.println(selector.current());
selector.next();
}
}
} ///:~

</source>



== Implement multiple interfaces ==



<source lang="java">
/*
* Copyright (c) Ian F. Darwin, http://www.darwinsys.ru/, 1996-2002.
* All rights reserved. Software written by Ian F. Darwin and others.
* $Id: LICENSE,v 1.8 2004/02/09 03:33:38 ian Exp $
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS""
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Java, the Duke mascot, and all variants of Sun"s Java "steaming coffee
* cup" logo are trademarks of Sun Microsystems. Sun"s, and James Gosling"s,
* pioneering role in inventing and promulgating (and standardizing) the Java
* language and environment is gratefully acknowledged.
*
* The pioneering role of Dennis Ritchie and Bjarne Stroustrup, of AT&T, for
* inventing predecessor languages C and C++ is also gratefully acknowledged.
*/

interface I1 {
abstract void test(int i);
}
interface I2 {
abstract void test(String s);
}
/**
* To show what happens to the possible conflicts if you
* implement multiple interfaces: there are no conflicts.
* If multiple interfaces have the exact same method, you
* merely have to implement it.
* If multiple interfaces have similar methods, you must
* implement them all.
* There"s still no conflict.
*/
public class MultInterfaces implements I1, I2 {
public void test(int i) {
System.out.println("In MultInterfaces.I1.test");
}
public void test(String s) {
System.out.println("In MultInterfaces.I2.test");
}
public static void main(String[] a) {
MultInterfaces t = new MultInterfaces();
t.test(42);
t.test("Hello");
}
}

</source>



== Initializing interface fields with non-constant initializers ==



<source lang="java">
// : c08:RandVals.java
// Initializing interface fields with non-constant initializers.
// From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002
// www.BruceEckel.ru. See copyright notice in CopyRight.txt.
import java.util.Random;
public interface RandVals {
Random rand = new Random();
int randomInt = rand.nextInt(10);
long randomLong = rand.nextLong() * 10;
float randomFloat = rand.nextLong() * 10;
double randomDouble = rand.nextDouble() * 10;
} ///:~

</source>



== Interface Collision ==



<source lang="java">

// : c08:InterfaceCollision.java
// From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002
// www.BruceEckel.ru. See copyright notice in CopyRight.txt.
interface I1 {
void f();
}
interface I2 {
int f(int i);
}
interface I3 {
int f();
}
class C {
public int f() {
return 1;
}
}
class C2 implements I1, I2 {
public void f() {
}
public int f(int i) {
return 1;
} // overloaded
}
class C3 extends C implements I2 {
public int f(int i) {
return 1;
} // overloaded
}
class C4 extends C implements I3 {
// Identical, no problem:
public int f() {
return 1;
}
}
// Methods differ only by return type:
//! class C5 extends C implements I1 {}
//! interface I4 extends I1, I3 {} ///:~

</source>



== Interface Usage Example ==



<source lang="java">
interface Act {
void act();
}
class Actor1 implements Act {
public void act() {
System.out.println("To be, or not to be");
}
}
class Actor2 implements Act {
public void act() {
System.out.println("Wherefore art thou Romeo?");
}
}
public class TryOut {
public static void main(String args[]) {
Actor1 hamlet = new Actor1();
Actor2 juliet = new Actor2();
tryout(hamlet);
tryout(juliet);
}
private static void tryout(Act actor) {
actor.act();
}
}

</source>



== Multiple interfaces ==



<source lang="java">
// : c08:Adventure.java
// Multiple interfaces.
// From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002
// www.BruceEckel.ru. See copyright notice in CopyRight.txt.
interface CanFight {
void fight();
}
interface CanSwim {
void swim();
}
interface CanFly {
void fly();
}
class ActionCharacter {
public void fight() {
}
}
class Hero extends ActionCharacter implements CanFight, CanSwim, CanFly {
public void swim() {
}
public void fly() {
}
}
public class Adventure {
public static void t(CanFight x) {
x.fight();
}
public static void u(CanSwim x) {
x.swim();
}
public static void v(CanFly x) {
x.fly();
}
public static void w(ActionCharacter x) {
x.fight();
}
public static void main(String[] args) {
Hero h = new Hero();
t(h); // Treat it as a CanFight
u(h); // Treat it as a CanSwim
v(h); // Treat it as a CanFly
w(h); // Treat it as an ActionCharacter
}
} ///:~

</source>



== Multi Super Interfaces ==



<source lang="java">
public class MultiSuperInterfaces {
public interface Marker extends java.io.Serializable, java.rmi.Remote,
java.lang.Runnable {
}
public class Marked implements Marker {
public void run() {
// needed for Runnable
}
}
public static void main(String[] args) {
new MultiSuperInterfaces().print();
}
void print() {
Object o = new Marked();
if (o instanceof java.io.Serializable) {
System.out.println("Is Serializable");
}
if (o instanceof java.rmi.Remote) {
System.out.println("Is Remote");
}
if (o instanceof java.lang.Runnable) {
System.out.println("Is Runnable");
}
}
}

</source>



== This shows that a class implementing an interface need not ==



<source lang="java">

import java.io.*;
/** This shows that a class implementing an interface need not
* declare all the Throws that are declared in the interface.
*/
public class InterfaceWithoutAllThrows {
interface bar {
public void foo() throws IOException;
}
class baz implements bar {
public void foo() {
System.out.println("This is foo-lish");
}
}
public static void main(String[] argv) {
new InterfaceWithoutAllThrows().new baz().foo();
}
}

</source>



== Two ways that a class can implement multiple interfaces ==



<source lang="java">
// : c08:MultiInterfaces.java
// Two ways that a class can implement multiple interfaces.
// From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002
// www.BruceEckel.ru. See copyright notice in CopyRight.txt.
interface A {
}
interface B {
}
class X implements A, B {
}
class Y implements A {
B makeB() {
// Anonymous inner class:
return new B() {
};
}
}
public class MultiInterfaces {
static void takesA(A a) {
}
static void takesB(B b) {
}
public static void main(String[] args) {
X x = new X();
Y y = new Y();
takesA(x);
takesA(y);
takesB(x);
takesB(y.makeB());
}
} ///:~

</source>

← Предыдущая	Версия 06:47, 1 июня 2010
(нет различий)

Java/Language Basics/Interface and Abstract Class - История изменений

Admin: 1 версия

в 18:01, 31 мая 2010