EffectiveJava笔记(一)-创建和销毁对象

创建和销毁对象

1. 考虑用静态方法代替构造器

例如

public static Boolean valueOf(boolean b){
    return b > Boolean.TRUE : Boolean.FALSE
}

优势

  • 有名称
  • 不必每次调用他们的的时候都创建一个新对象
  • 可以返回员返回类型的任何子类型的对象

缺点

  • 类如果不含共有的或者搜保护的构造器没,就不能被子类化
  • 他们于其他的静态方法实际上没有任何区别

2.遇到多个构造器参数时要考虑用构建器

JavaBeans

调用一个无参构造器来创建对象,然后调用 setter方法来设置每个必要的参数以及各每个相关的可选参数
缺点:

  • 因为被分到几个调用中,在构建过程中可能处于不一致的状态。
  • 阻止了把类做成不可变的可能,需求程序员付出额外的努力来确保它的线程安全

Builder模式(建造者模式)

如果类的构造器或者静态工厂中具有多个参数,设计这种类时,Builder模式是不错的选择。

// 例如
public class Course {
    private String courseName;
    private String coursePPT;
    private String courseVideo;
    private String courseArticle;

    /**
     * question & answer
     */
    private String courseQA;

    public Course(CourseBuilder courseBuilder) {
        this.courseName = courseBuilder.courseName;
        this.coursePPT = courseBuilder.coursePPT;
        this.courseVideo = courseBuilder.courseVideo;
        this.courseArticle = courseBuilder.courseArticle;
        this.courseQA = courseBuilder.courseQA;
    }

    @Override
    public String toString() {
        return "Course{" +
                "courseName='" + courseName + '\'' +
                ", coursePPT='" + coursePPT + '\'' +
                ", courseVideo='" + courseVideo + '\'' +
                ", courseArticle='" + courseArticle + '\'' +
                ", courseQA='" + courseQA + '\'' +
                '}';
    }

    public static class CourseBuilder {

        private String courseName;
        private String coursePPT;
        private String courseVideo;
        private String courseArticle;

        /**
         * question & answer
         */
        private String courseQA;

        public CourseBuilder buildCoureseName(String courseName) {
            this.courseName = courseName;
            return this;
        }

        public CourseBuilder buildCoursePPT(String coursePPT) {
            this.coursePPT = coursePPT;
            return this;
        }

        public CourseBuilder buildCourseVideo(String courseVideo) {
            this.courseVideo = courseVideo;
            return this;
        }

        public CourseBuilder buildCourseArticle(String courseArticle) {
            this.courseArticle = courseArticle;
            return this;
        }

        public CourseBuilder buildCourseQA(String courseQA) {
            this.courseQA = courseQA;
            return this;
        }

        public Course build() {
            return new Course(this);
        }

    }
}

// 测试
Course course = new Course.CourseBuilder()
.buildCoureseName("Java设计模式精讲")
.buildCoursePPT("Java设计模式PPT")
.buildCourseVideo("Java设计模式视频")
.build();
System.out.println(course);

3.用私有构造器或者枚举类型强化Singleton属性

Singleton是指仅仅被实例化一次的类。

注意:享有特权的客户端可以借助 AccessibleObject.setAccessible方法,通过反射机制调用私有构造器

4.通过私有构造器强化不可实例化的能力

企图通过将类做成抽象类来强制该类不可被实例化,是行不通的

5.避免创建不必要的对象

要优先使用基本类型而不是装箱基本类型,要当心无意思的自动装箱

6.消除过期的对象引用

/**
 * @author stone
 * @des 内存泄露示例
 * @date 2018/12/5/005 8:40
 **/
public class Stack {

    private Object[] element;
    private int size = 0;
    private static final int DEFAULT_INITIAL_CAPACITY = 16;

    public Stack() {

    }

    public void push(Object e) {
        ensureCapacity();
        element[size++] = e;
    }

    public Object pop() {
        if (size == 0) {
            throw new EmptyStackException();
        }
        // 注意下面这行代码会引起内存泄露
        // 如果一个栈是先增长,然后再收缩,那么,从栈中弹出来的对象将不会被当做垃圾回收,即使使用栈的程序不再引用这些对象,他们也不会被回收
        // 栈内部维护着这些对象的过期引用。过期引用:永远也不会再被解除的引用。
        // 本例中 凡是element数组中的活动部分之外的任何引用都是过期的。活动部分:element中下标小于size的那些元素
        // return element[--size];

        Object result = element[--size];
        // 解决方法如下 消除过期引用
        // Eliminate obsolete reference
        element[size] = null;
        return result;


    }

    /**
     * ensure space for at least one more element,roughly
     * doubling the capacity each time the array needs to grow
     */
    private void ensureCapacity() {
        if (element.length == size) {
            element = Arrays.copyOf(element, 2 * size + 1);
        }
    }
}

总结 : 过期的对象引用 可能会引起内存泄露
只要类是自己管理内存,程序员就应该警惕内存泄露的问题。

内存泄露常见来源

  • 只要类是自己管理内存,程序员就应该警惕内存泄露的问题。
  • 缓存
  • 监听器和其他回调

7.避免使用终结方法

终结方法(finalizer)通常是不可预测的,很危险的,也一般是不必要的。

Java语言规范不仅不保证终结方法会被及时地执行,而且根本就不保证它们会被执行。
不应该依赖终结方法来更新重要的持久状态。

System.gc System.runFinalization这两个方法确实增加了终结方法被执行的机会,但它们并不保证终结方法一定会被执行。

终结方法有一个非常严重的(Severe)性能损失。
用终结方法创建和销毁对象比正常要慢上百倍。

  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值