Java编程思想接口笔记一

接口笔记一

抽象类

只有声明而没有方法体的不完整方法叫做抽象方法，含有抽象方法的类叫做抽象类。但是抽象类也可以没有抽象方法，这里使用抽象方法可能只是为了不允许创建这个类的实例对象。如果想要创建一个相应的对象，必须重新声明一个实体类，从抽象类继承并实现相应的抽象方法。或者以内部类的方式产生匿名对象。

public class Ex3 {    public static void main(String[] args) {        Sub sub = new Sub();        sub.print();    }}abstract class Base {    // 这里摘自http://docs.oracle.com/javase/specs/jls/se7/html/jls-12.html#jls-12.5    // Unlike C++, the Java programming language does not specify     // altered rules for method dispatch during the creation of a     // new class instance. If methods are invoked that are     // overridden in subclasses in the object being initialized,     // then these overriding methods are used, even before the new     // object is completely initialized.    public Base() {        print();    }    abstract void print();}class Sub extends Base {    int i = 7;    @Override    void print() {        System.out.println("i = " + i);    }}/*    output:    i = 0    i = 7    前面的0是在父类构造器里面调用子类print方法时候打印的，这时候    实例域全部都初始化默认值，所以打印为0*/

abstract class Dad {}class Son extends Dad {    protected void print() { System.out.println("Son"); }}abstract class SecondDad {    abstract protected void print();}class SecondSon extends SecondDad {    protected void print() { System.out.println("SecondSon"); }}public class Ex4 {    public static void testPrint(Dad d) {        // 没有print方法，需要向下转型        ((Son)d).print();    }    public static void secondTestPrint(SecondDad sd) {        // 实现了抽象类父类的接口，动态分配        sd.print();    }    public static void main(String[] args) {        Son s = new Son();        testPrint(s);        SecondSon ss = new SecondSon();        secondTestPrint(ss);                }}

接口

interface不仅仅是一个极端的抽象类，因为它允许通过创建一个能够被向上转型为多种基类的类型，来实现某种类似于多重继承的变种。

import java.util.Arrays;class Processor {    public String name() {        return getClass().getName();    }    Object process(Object input) {        return input;    }}class Upcase extends Processor {    @Override    String process(Object input) {        return ((String)input).toUpperCase();    }}class Splitter extends Processor {    @Override    Object process(Object input) {        return Arrays.toString(((String)input).split(" "));    }}public class Apply {    public static String name = "Disagreement with beliefs is by definition incorrect";    // 创建一个能够根据所传递的参数对象的不同而具有不同行为    // 的方法，被称为策略模式方法包括了将要执行的算法的固定    // 部分，而策略则包含了变化的部分。这里的策略是传递进去    // 的参数对象，包含了将要执行的代码。    public static void process(Processor p, Object s) {        System.out.println("Using Processor " + p.name());        System.out.println(p.process(s));    }    public static void main(String[] args) {        process(new Upcase(), name);        process(new Processor(), name);        process(new Splitter(), name);    }}

public class Ex11 {    public static void main(String[] args) {        Apply.process(new StringExAdapter(new StringExchange()), "hazhangfuyqol");    }}interface Processor {    String name() {}    Object process(Object input) {}}// 这里的类没有实现Processor，所以需要适配器进行转接class StringExchange {    public String name() {        return getClass().getName();    }    public static String process(String s) {        int length = s.length();        if (length <= 1) return s;        String[] strings = s.split("");        for (int i = 0; i < length - 1; i += 2) {            String tmp = strings[i];            strings[i] = strings[i + 1];            strings[i + 1] = tmp;        }        return String.join("", strings);    }}// 适配器，这里的Processor是一个接口// 这里实际上还应用到了代理模式class StringExAdapter implements Processor {    private StringExchange se;    public StringExAdapter(StringExchange se) {        this.se = se;    }    @Override    public String name() {        return se.name();    }    @Override    public Object process(Object o) {        return se.process((String)o);    }}/*    Using Processor interfaces.filter.StringExchange    ahhznafgyuoql*/