java知识查漏补缺

浏览数：14 / 时间：2015年06月08日

一、重写（override）和重载（overload）的区别

二者除了名字相似，其实没什么联系

范围不同：重写发生在同一个类的不同方法之间。重载发生在父类和子类自荐。

前提：

重写要求：方法名相同，参数列表不同，对于返回值类型不要求相同。

重载要求：方法名形同，参数列表也相同。重载是实现多态的关键，注意如果父类中的方法是private类型，那么子类中对应方法不算重载，而相当于是定义了一个新方法。

二、final的用法

修饰类：该类不能被继承

修饰方法：该方法不能被重写

修饰属性：该属性初始化后不能被修改

1，方法可以多态，Fields不能实现多态。

2，利用父类的引用调用子类的方法呈现子类的特征成为多态。

3，不能利用父类的引用去调用子类没有实现的方法，除非进行强制转换。

三、java实现的几种设计模式

3.1单例模式

作用：对于某些系统资源，比如可能只有一个窗口管理器等等，取消自由创建对象的系统开销。

单例类创建的注意点：

1）有一个该类的实例作为类属性。

2）构造函数为private类型

3）通过一个类方法获取类的唯一实例

package com.bobo.interview;

public class Singleton {

    private static Singleton instance;

    private Singleton() {

    }

    public Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }

     

}

单例模式

3.2不可变类

作用：利用java.lang.String等，并且绝对线程安全

创建的注意点：

1）使用private和final修饰类的field

2）提供代参数的构造器，用户根据传入参数来初始化类的field

3）仅仅提供getter，不能提供setter

4）如果有必要，重写类的equals和hashcode方法（根据关键的field来判断）

有些情况，还可以为不可变类增添缓存。

3.3简单工厂模式

作用：“面向接口”编程，降低耦合。

第一步：定义接口
package com.bobo.desing;

public interface Output {
    int MAX_CHCHE_LINE=50;
    void out();
 
}

第二部：定义接口的实现类
package com.bobo.desing;

public class Print1 implements Output{

    @Override
    public void out() {
        System.out.println("print2的out方法");
        
    }

     

}


package com.bobo.desing;

public class Print2 implements Output{

    @Override
    public void out() {
        System.out.println("print1的out方法");
        
    }

     

}


第三部：定义工厂类
package com.bobo.desing;

public class PrintFactory {
    public Output getOutput(){
        return new Print1();
    }
}


第四部：构建最终的实体类
package com.bobo.desing;

public class Computer {
    private Output op;

    public Computer(Output output) {
         this.op=output;
    }
    public void work(){
        op.out();
    }
    /**
     * @param args
     */
    public static void main(String[] args) {
        PrintFactory  factory=new PrintFactory();
        //这样如果需要为计算器更换打印机时，只需要factory返回不同的print对象即可，从而避免了硬耦合
        Computer co=new Computer(factory.getOutput());
        co.work();
    }

}

简单工厂设计模式

3.4命令模式

对于下列场景：某个方法需要完成某一个行为，但是这个行为的具体实现无法确定，必须等到执行该方法的时候才可以确定。也就是说，方法不仅仅需要根据传入的数据变换，而且方法的执行体也需要变化。

第一步：实现接口
package com.bobo.desing;

public interface Command {
    void process(int[] target);

}


第二部：实现了接口的相关类
package com.bobo.desing;

public class AddCommand implements Command {

    @Override
    public void process(int[] target) {
        int sum = 0;
        for (int var : target) {
            sum += var;
        }
        System.out.println(sum + "");
    }

}


package com.bobo.desing;

public class PrintCommand implements Command{

    @Override
    public void process(int[] target) {
        // TODO Auto-generated method stub
        for(int var:target){
            System.out.print(var+" ");
        }
        System.out.println();
    }

}


第三部：
package com.bobo.desing;

public class ProcessArray {

    public void process(int[] target, Command cmd) {
        // TODO Auto-generated method stub
        cmd.process(target);
    }

}


第四部：
package com.bobo.desing;

public class CommandTest {
    
    
    public static void main(String args){
        ProcessArray pa=new ProcessArray();
        int array[]={1,2,3,4};
        Command cmd=new AddCommand();
        Command cmd2=new PrintCommand();
        pa.process(array,cmd2);
    }

}