thinking in java 第七章笔记及思考：探险复用类

　　还是以本书的第一句话开头：复用代码是java众多引人注目的功能之一，但是想成为极具革命性的语言，仅仅能够复制代码并对之加以改变是不够的，他还必须能够做更多的事情。
　　我们先自己考虑，代码怎么复用？继承、代码重构。

　　文章提到两个方法：
　　在新的类中产生关于现有类的对象(继承)
　　按照现有类的类型来创建新类(组合)
　　
一、组合
1.将一个对象（一组对象）的引用（一组引用）放在另一个新类中，例如：
　　

public class Member{
    List<Student> studentsList = new ArrayList<>();
}

class Student{
    ...
}

2.之前做过一个项目，有8个类都是组合的关系，因此最大的一个类与8个类有关，我们使用的数据库是mongoDB。原因：i.创建数据库简单，根本不需要考虑结构，因此对于敏捷开发来说更适应。ii.在数据库中存储的是对象，可以很直观的看出其结构而不需要像数据库还需要连表查询。

public class Member{
    List<Student> studentsList = new ArrayList<>();
}

class Student{
    List<Stu> stuList = new ArrayList<>();
    List<Stude> studeList = new ArrayList<>();
}

class Stu{
}

class Stude{
}

二、继承
　　这里其实没有什么好说的，挑挑一些非基础或者有意思的知识谈谈。　
this和super：
　　有没有人经常混淆this、super是否放在第一行？到底哪个应该放在第一行？这里会给出讲解，让你再也不会疑惑他们的用法。
　　this：引用，指向自身对象的引用。可以通过this来调用自身类的方法，如果是普通方法，不需要放在第一行；如果是调用构造方法，必须放在第一行。
　　super：引用，指向基类对象的引用。可以通过super来调用基类的方法，如果是普通方法，不需要放在第一行；如果是调用构造方法，必须放在第一行。

三、代理
　　这是继承与组合之间的中庸之道。
　　说到这里我们的说说一个方法：Arrays.asList()。这个是集合和数组之间的中庸之道。
1.Arrays.asList()
　　他的代码如下：

 /**
     * Returns a fixed-size list backed by the specified array.  (Changes to
     * the returned list "write through" to the array.)  This method acts
     * as bridge between array-based and collection-based APIs, in
     * combination with {@link Collection#toArray}.  The returned list is
     * serializable and implements {@link RandomAccess}.
     *
     * <p>This method also provides a convenient way to create a fixed-size
     * list initialized to contain several elements:
     * <pre>
     *     List&lt;String&gt; stooges = Arrays.asList("Larry", "Moe", "Curly");
     * </pre>
     *
     * @param <T> the class of the objects in the array
     * @param a the array by which the list will be backed
     * @return a list view of the specified array
     */
    @SafeVarargs
    @SuppressWarnings("varargs")
    public static <T> List<T> asList(T... a) {
        return new ArrayList<>(a);
    }

　　我们可以看到他返回的是一个固定size的List。我们跟进到ArrayList里边，这个在Arrays类里边的静态内部类生成的是一个固定size的list。源代码如下：

    /**
     * @serial include
     */
    private static class ArrayList<E> extends AbstractList<E>
        implements RandomAccess, java.io.Serializable
    {
        private static final long serialVersionUID = -2764017481108945198L;
        private final E[] a;

        ArrayList(E[] array) {
            a = Objects.requireNonNull(array);
        }
        /*...*/
    }

　　可以看出他生成的是固定size 的List。继续说组合。

2.代理
　　可以用代理选择只提供在成员对象中的方法的某个子集。如下：

Class Student{
    public static void getName(String name){
        sysout("name : " + name)
    }

    public static void getHobby(String hobby){
        Sysout("hobby : " + hobby);
    }
    /*...*/
}

class StuProxy{
    private Student student = new Student();
    public void getName(){
        student .getName();
    }
}

public class Test{
    main(){//手打，简写多担待
        StuProxy StuProxy = new StuProxy ();
        StuProxy.getName("naem");
    }
}

　　其实这个还是为了安全问题，只把一个对象的少数方法暴露给另一个对象。看别人很多封装的类就是这样用的。

四、结合使用组合和继承
　　之前我做的一个项目里边确实有结合使用组合跟继承。因为有8个类相互复用，但是对于不同的场景需要不同的类，会创建不同场景的8个类，分四种场景。为了代码复用就创建一个公共的Comment类，其他类用来继承这个类。可以看出节省了很多的代码。可以看出组合继承对代码复用特别有用。

五、final关键字
1.final数据
　　final数据说明数据是常量。
　　一个永不改变的编译时常量
　　一个在运行时被初始化的值，而你不希望被改变。
　　一个即是static 和final的域占据一段不能改变的存储空间
2.final参数
　　我是没有见过final参数啊，但是final参数不允许在方法内修改其指向的对象。参数是引用，final的引用无法再指向新的对象。

3.final 方法
　　把方法锁定，任何方法都对他无法修改，覆盖。效率高。
　　缺点：无法被复用
　　
4.final 类
　　不打算被继承。

thinking in java 第七章笔记及思考：探险 复用类

猜你喜欢

thinking in java 第七章笔记及思考：探险复用类