疯狂JAVA讲义---第六章（中）：面向对象二

这本书对java的每个知识点分析的比较细，虽说不用知道所有的知识点你也可以写代码，但写代码总是仿照他人的标准格式却不知道为什么。这样会使人觉得写代码是一种负担，还要背出那么多的语法，一旦你掌握了细节，写代码时你会觉得那些语法自然而然的就出来了，不用死记。

这章中间讲了抽象类和接口，抽象方法没有方法体，所以不用加花括号，接口的方法也一样，具体作用我在前几天写的blog《面向对象的重要概念》中已经讲的非常清楚了，这里就补充下书中的例子，eg（抽象类）

public abstract class SpeedMeter

{

    //转速

    private double turnRate;

    public SpeedMeter()

    {

    }

    //把返回车轮半径的方法定义成抽象方法

    public abstract double getRadius();

    public void setTurnRate(double turnRate)

    {

        this.turnRate = turnRate;

    }

    //定义计算速度的通用算法

    public double getSpeed()

    {

        //速度等于 车轮半径 * 2 * PI * 转速

        return java.lang.Math.PI * 2 * getRadius() * turnRate;

    }

}

public class CarSpeedMeter extends SpeedMeter

{

    public double getRadius()

    {

        return 0.28;

    }

    public static void main(String[] args) 

    {

        CarSpeedMeter csm = new CarSpeedMeter();

        csm.setTurnRate(15);

        System.out.println(csm.getSpeed());

    }

}

eg(接口)

interface interfaceA

{

    int PROP_A = 5;

    void testA();

}

interface interfaceB

{

    int PROP_B = 6;

    void testB();

}

interface interfaceC extends interfaceA, interfaceB

{

    int PROP_C = 7;

    void testC();

}

public class TestInterfaceExtends 

{

    public static void main(String[] args)

    {

        System.out.println(interfaceC.PROP_A);

        System.out.println(interfaceC.PROP_B);

        System.out.println(interfaceC.PROP_C);

    }

}

抽象类是一种模板式的设计，接口是一种规范。
面向接口编程实例,eg（工厂模式）

public class Computer

{

    private Output out;

    public Computer(Output out)

    {

        this.out = out;

    }

    //定义一个模拟获取字符串输入的方法

    public void keyIn(String msg)

    {

        out.getData(msg);

    }

    //定义一个模拟打印的方法

    public void print()

    {

        out.out();

    }

}

public class OutputFactory

{

    public Output getOutput()

    {

        //下面两行代码用于控制系统到底使用Output的哪个实现类。

        //return new Printer();

        return new BetterPrinter();

    }

    public static void main(String[] args) 

    {

        OutputFactory of = new OutputFactory();

        Computer c = new Computer(of.getOutput());

        c.keyIn("轻量级J2EE企业应用实战");

        c.keyIn("Struts2权威指南");

        c.print();

    }

}

public class BetterPrinter implements Output

{

    private String[] printData = new String[MAX_CACHE_LINE * 2];

    //用以记录当前需打印的作业数

    private int dataNum = 0;

    public void out()

    {

        //只要还有作业，继续打印

        while(dataNum > 0)

        {

            System.out.println("高速打印机正在打印：" + printData[0]);

            //把作业队列整体前移一位，并将剩下的作业数减1

            System.arraycopy(printData , 1, printData, 0, --dataNum);

        }

    }

    public void getData(String msg)

    {

        if (dataNum >= MAX_CACHE_LINE * 2)

        {

            System.out.println("输出队列已满，添加失败");

        }

        else

        {

            //把打印数据添加到队列里，已保存数据的数量加1。

            printData[dataNum++] = msg;

        }

    }

}

又学到一招，当内部类和外部类的属性或方法同名时可以用以下例子中的，外部类名.this来引用。eg,
public class DiscernVariable
{
    private String prop = "外部类属性";
    private class InClass
    {
        private String prop = "内部类属性";
        public void info()
        {
            String prop = "局部变量";
            //通过 外部类类名.this.varName 访问外部类实例属性
            System.out.println("外部类的属性值：" + DiscernVariable.this.prop);
            //通过 this.varName 访问外内部类实例的属性
            System.out.println("内部类的属性值：" + this.prop);
            //直接访问局部变量
            System.out.println("局部变量的属性值：" + prop);
        }
    }
    public void test()
    {
        InClass in = new InClass();
        in.info();
    }
    public static void main(String[] args) 
    {
        new DiscernVariable().test();
    }
}