Effective Java——（一）创建和销毁对象

原创 于 2025-02-28 18:18:53 发布 · 791 阅读 · 18 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
收录于
java

当前文章被收录于：

java
1 篇文章 0 人学习
订阅专栏 查看详情

作为一名Java开发人员，必须给大家推荐一部神书《Effective Java》，这本书告诉适合我们不同阶段的开发人员阅读，哪怕我现在工作多年，每次去看这本书，都能从中学到什么。

本篇文章就是给哪些不原看书，或者没有看过这本书的开发人员讲下这本书，本篇文章将结合实例和大家讲解，以便大家更容易理解

一、用静态工厂方法代替构造器优点：

优点

1、有名称

  1. 返回一个素数的BigInteger
方式一：new BigInteger(int bitLength, int certainty, Random rnd)
方式二：BigInteger.probablePrime(int bitLength, Random rnd)

这是jdk提供的一个工具方法，两个方法的实现的目的都是一样，但第二种方式却更能让大家理解，从命名上就知道这个方法的用处，具备更高的可读性。

  1. 创建一个对象
方式一：
new Class(String className, int stu);
new Class(int stu, String className);
方式二：
Class.createA(String className, int stu);
Class.createB(int stu, String className);

当我们要创建两个对象，参数都一样，但实现的目的不一样时，大多数人都可以通过参数顺序来实现，比如第一种方式。但在实际的开发中，我们并不提倡，这个方式可读性太差，必须要看具体的实现才能知道两者的区别。而如果是用第二种方式，我们通过名称就能知道我们想要的方法，而不必看对应的具体实现.。

2、不必在每次调用他们的时候都创建一个新对象

  • 不可变类可以使用预先构建好的实例
    如：Boolean.valueof(boolean)
    静态工厂中准备好常量，从而避免新建对象
  • 单例模式的getInstance

3、可以返回原返回类型的任何子类型的对象

public class Animal {
    protected  Animal(){
    }
    private static Animal dog;
    private static Animal snake;
    /**
     * 返回子类型  Dog
     * @return
     */
    public static Animal getAnimal_Dog(){
        if(dog == null){
            dog = new Dog();
        }
        return dog;
    }
    
	/**
     * 返回子类型 Snake
     */
    public static Animal getAnimal_Snake(){
        if(snake == null){
            snake = new Snake();
        }
        return snake;
    }

}

4、返回的对象的类可以随着每次调用而发生变化，取决于静态工厂方法的参数值

public static <E extends Enum<E>> EnumSet<E> noneOf(Class<E> elementType) {
        Enum<?>[] universe = getUniverse(elementType);
        if (universe == null)
            throw new ClassCastException(elementType + " not an enum");

        if (universe.length <= 64)
            return new RegularEnumSet<>(elementType, universe);
        else
            return new JumboEnumSet<>(elementType, universe);
    }

5、方法返回的对象所属的类型，在编写包含该静态工厂方法的类是可以不存在

  //四大组成之一：服务接口
  public interface LoginService {//这是一个登录服务
      public void login();
  }
  
  //四大组成之二：服务提供者接口
  public interface Provider {//登录服务的提供者。通俗点说就是：通过这个newLoginService()可以获得一个服务。
      public LoginService newLoginService();
  }
  
 /**
  * 这是一个服务管理器，里面包含了四大组成中的三和四
  * 解释：通过注册将 服务提供者 加入map，然后通过一个静态工厂方法 getService(String name) 返回不同的服务。
  */
 public class ServiceManager {
     private static final Map<String, Provider> providers = new HashMap<String, Provider>();//map，保存了注册的服务
  
     private ServiceManager() {
     }

     //四大组成之三：提供者注册API  (其实很简单，就是注册一下服务提供者)
     public static void registerProvider(String name, Provider provider) {
         providers.put(name, provider);
     }
  
     //四大组成之四：服务访问API   (客户端只需要传递一个name参数，系统会去匹配服务提供者，然后提供服务)  (静态工厂方法)
     public static LoginService getService(String name) {
         Provider provider = providers.get(name);
         if (provider == null) {
             throw new IllegalArgumentException("No provider registered with name=" + name);
       }
       return provider.newLoginService();
   }
}

缺点

1、类如果不含公有的或者受保护的构造器，就不能被子类化

  • 在使用静态工厂方法时，由于经常会处于保护目的，将构造器私有化，由于子类实例化时需要调用父类的构造器，所以私有的构造器会导致类无法被继承。处理的办法是，用复合（composition）取代继承，以实现类的正常拓展。

2、很难被发现

  • 因为静态工厂方法是自定义的，它们没有像构造器那样被明确规定如何实例化，因此程序员往往很难查明如何通过静态工厂方法实例化一个类，因此我们便需要遵守一些静态工厂方法的惯用名称。
  • from——类型转换方法，只有单个参数。返回该类型的一个相对应实例，例如：Date d=Date.from(instant)
  • of——聚合方法，有多个参数，返回该类型的一个实例，把它们合并起来，例如：Set＜Rank＞ facecards=Enumset.of(JACK， QUEEN， KING);
  • valueOf——比from和of更烦琐的一种替代方法，例如:BigInteger prime = BigInteger.valueOf(Integer.MAX_VALUE);
  • instance或者getInstance——返回的实例是通过方法的(如有)参数来描述的，但是不能说与参数具有同样的值，例如:Stackwalker luke -Stackwalker.getInstance(options);
  • ……

二、遇到多个构造器参数时要考虑使用构建器

传统方式：

  1. 构造器：
    new Class(“张三”,”李四”,”王五”,57);

  2. JavaBean方法：可能处于不一致的状态（多线程）
    Class class = new Class();
    class.setMathTeacher(“张三”);
    class.setChineseTeacher(“李四”);
    class.setEnglishTeacher(“王五”);
    class.setStudents(57);

示例：

public class NutritionFacts {
    private final Integer servingSize;
    private final Integer servings;
    private final Integer calories;
    private final Integer fatal;
    private final Integer sodium;
    private final Integer carbohydrate;

    public static class Builder {
        private final Integer servingSize;
        private final Integer servings;
        private Integer calories = 0;
        private Integer fatal = 0;
        private Integer sodium = 0;
        private Integer carbohydrate = 0;

        public Builder(Integer servingSize, Integer servings) {
            this.servingSize = servingSize;
            this.servings = servings;
        }
                public Builder calories(Integer value) {
            calories = value;
            return this;
        }

        public Builder fatal(Integer value) {
            fatal = value;
            return this;
        }

        public Builder sodium(Integer value) {
            sodium = value;
            return this;
        }

        public Builder carbohydrate(Integer value) {
            carbohydrate = value;
            return this;
        }
                public NutritionFacts build() {
            return new NutritionFacts(this);
        }
    }

    private NutritionFacts(Builder builder) {
        this.servingSize = builder.servingSize;
        this.servings = builder.servings;
        this.calories = builder.calories;
        this.fatal = builder.fatal;
        this.sodium = builder.sodium;
        this.carbohydrate = builder.carbohydrate;
    }
}

使用：
NutritionFacts facts = new NutritionFacts.Builder(17,25).calories(100).fatal(12).sodium(5).carbohydrate(30).build();

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

  • 传统方式：
方式一：
public class Singleton {
     private static Singleton instance = new Singleton();
     private Singleton (){}
     public static Singleton getInstance() {
         return instance;
     }
}

方式二：
public class Singleton {
     private static Singleton instance = null;
     static {
         instance = new Singleton();
     }
     private Singleton (){}
     public static Singleton getInstance() {
         return instance;
     }
}

方式三：
public class Singleton {
     private static Singleton instance;
     private Singleton (){}
     public static synchronized Singleton getInstance() {
         if (instance == null) {
             instance = new Singleton();
         }
         return instance;
     }
}

方式四：
public class Singleton {
     private static class SingletonHolder {
         private static final Singleton INSTANCE = new Singleton();
     }
     private Singleton (){}
     public static final Singleton getInstance() {
         return SingletonHolder.INSTANCE;
     }
}

方式五：使用反射机制修改实例对象
在这里插入图片描述
运行代码
在这里插入图片描述

  • 最佳方式：使用单元素的枚举类型
/** 使用单元素的枚举类型 */
public enum  Singleton2 {
    INSTANCE;
    public void whateverMethod() {}

    public static void main(String[] args) throws Exception{
        System.out.println(Singleton2.INSTANCE);
        System.out.println(Singleton2.INSTANCE);
        Field field = Singleton.class.getDeclaredField("INSTANCE");
        field.setAccessible(true);
        Constructor<?> constructor = Singleton.class.getDeclaredConstructor(String.class, int.class);
        constructor.setAccessible(true);
        Object instance = constructor.newInstance("", 0);
        field.set(Singleton.class, instance);
        System.out.println(Singleton2.INSTANCE);
        System.out.println(Singleton2.INSTANCE);
    }
}

运行代码
在这里插入图片描述
通过单元素的枚举类型，可以防止反射机制修改实例对象

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

/** 工具类 */
public class UtilityClass {
    private UtilityClass() {
        throw new AssertionError();
    }
}

五、优先考虑依赖注入来引用资源

六、避免创建不必要的对象

  • 示例1：
    反例：String s = new String(“obj”);
    正例：String s = “obj”;

  • 示例2：
    反例：
    在这里插入图片描述
    正例：
    在这里插入图片描述
    在这里插入图片描述

  • 示例3：自动装箱
    反例：
    在这里插入图片描述
    正例：
    在这里插入图片描述

七、消除过期的对象引用

在这里插入图片描述
在这里插入图片描述
注意：清空对象引用应是一种例外，而不是一种规范行为
内存泄露场景：
1、类自己管理内存
2、缓存
3、监听器和其他回调

八、避免使用终结方法和消除方法

  • 终结方法和清除方法通常是不可预测的，不能保证他们能够及时的被执行。
  • 可移植性较差
  • java 本身不保证终结和清除方法被执行
  • 如果异常出现在终结方法中，无法打印出异常（Stack Trace）
  • 会造成性能损失
  • 终结方法也存在安全问题

九、try-with-resource优先于try-finally

  • 以往方式：finally可能抛出异常，资源无法关闭
    在这里插入图片描述
  • 建议方式：类实现AutoCloseable，表示必须被关闭的资源
    在这里插入图片描述
    在这里插入图片描述

第一章的介绍到此为止，还是建议大家去看看，相信大家能有更多的理解，也能学到更多。

标签
#java #开发语言
【Windows Server 2019】Active Directory Certificate Services 证书颁发机构的安装，配置和管理Ⅰ——AD CS的安装和配置
VMware, Windows, Linux, Cisco, Container, Kubernetes, Kali
07-25 4763
博文主要介绍了Windows Server 2019的证书颁发机构的安装和配置方法。
Effective Java第三版1
08-08
《Effective Java》第三版中文版目录 第一章 介绍 1 第二章 创建和销毁对象 4 1  考虑用静态工厂方法替换构造器 4 2  当遇到多个构造器参
带你快速看完9.8分神作《Effective Java》—— 并发篇（工作里的这些坑你都遇到过吗？）
如切如磋，如琢如磨
01-13 9998
???? Java学习：Java从入门到精通总结 ???? Spring系列推荐：Spring源码解析 ???? 最近更新：2021年12月16日 ???? 个人简介：通信工程本硕????、阿里新晋猿同学????。我的故事充满机遇、挑战与翻盘，欢迎关注作者来共饮一杯鸡汤 ???? 点赞 ???? 收藏 ⭐留言 ???? 都是我最大的动力！ 豆瓣评分9.8的图书《Effective Java》，是当今世界顶尖高手Josh Bloch的著作，在我之前的文章里我也提到过，编程就像练武，既需要外在的武功招
51单片机数字电子钟proteus仿真（数电课设，含时间显示、校准、整点报时、闹钟功能）
资料中包含proteus仿真文件及程序源码。包含功能：1)显示功能：可以显示时、分、秒（基于1602液晶显示屏）2)校时功能：可以分别对时分秒进行单独校时，使其校正到标准时间（其中可以进行加一和减一的操作）3)整点报时功能：到达整点蜂鸣器响进行报时4)闹钟功能：到达设定的闹钟时间时蜂鸣器响。（其中闹钟时间可以手动调整）
《Effective Java》真的是一本值得一直去钻研的好书
追求幸福，探索未知的博客
08-01 8609
文章目录《Effective Java》读书笔记第一章 引言第二章 创建和销毁对象1 考虑使用静态工厂方法替代构造方法**2 当构造方法参数过多时使用builder（建造者） 模式**3 使用私有构造方法或枚类实现Singleton 属性*4 使用私有构造方法执行非实例化*5 依赖注入优于硬连接资源（hardwiring resources）**6 避免创建不必要的对象*7 消除过期的对象引用*8 避免使用Finalizer 和Cleaner 机制**9 使用try-with-resources 语句替代t
一文简单理解《Effective Java》建议
weixin_40709965的博客
05-27 2608
​一种失败的接口就是所谓的常量接口这样的接口不包含任何方法;它只包含静态 final 属 性，每个输出一个常量。使用这些常量的类实现接口，以避免需要用类名限定常量名。​常量接口模式是对接口的糟糕使用。类在内部使用一些常量，完全属于实现细节。实现一个常量接口会导致这 个实现细节泄漏到类的导出 API 中。对类的用户来说，类实现一个常量接口是没有意义的。事实上，它甚至可能使他 们感到困惑。更糟糕的是，它代表了一个承诺：如果在将来的版本中修改了类，不再需要使用常量，那么它仍然必须 实现接口，以确保二进制兼容性。
Effective Java 经典学习（一）
冷血之心的博客
12-16 8591
  （尊重劳动成果，转载请注明出处：https://blog.csdn.net/qq_25827845/article/details/85016496冷血之心的博客） 系列文章： Effective Java经典学习（一） 目录 第二章：创建和销毁对象 （1）使用静态工厂方法代替构造器 （2）遇到多个构造器参数时要考虑用构建器 （3）用私有构造器或者枚举类型强化Singleton...
《Effective Java》对象的创建和销毁
qq_43350524的博客
11-11 516
《Effective Java》 第一章总结 - 对象的创建和销毁
Effective Java之创建和销毁对象
NEU_tt的博客
10-10 451
Effective Java这本书针对人群是对Java有一定的开发经验，至少对Java的整体结构是了解的，额，我属于比小白再高级点的，提前接触了这本书，有错误或者认识的不到位的欢迎指教，我也会随着时间的推移，不断地完善。 今天要总结的是Effective Java的第二章创建和销毁对象。 第一条：考虑使用静态工厂方法代替构造器 之前的博客有说过，关于创建一个类的实例的方法，最常见的即利用构造
笔记《Effective Java》01： 创建和销毁对象
最新发布
有一只柴犬的专栏
01-24 1837
《Effective Java》这本书可以说是程序员必读的书籍之一。这本书讲述了一些优雅的，高效的编程技巧。对一些方法或API的调用有独到的见解，还是值得一看的。刚好最近重拾这本书，看的是第三版，顺手整理了一下笔记，用于自己归纳总结使用。建议多读一下原文。今天整理第一章节：创建和销毁对象。
Effective Java(第三版) _ 创建和销毁对象
工作学习总结，技术分享
10-31 650
这本书，在刚从事开发的时候就被老师推荐阅读过，当时囫囵吞枣的看了一部分，不是特别的理解，也就搁置了，现在已经更新到第三版了，简单翻阅了一下，发现有些条例和现实开发中的场景呼应上了，开始意识到，确实应该好好的认真读一遍。应该会对自己有很大的帮助。通过这个专题，记录我的一些心得体会。
《Effective Java》学习笔记——第1部分 创建对象和销毁对象的最佳实践
weixin_37693760的博客
01-21 1136
Effective Java》共有多个章节，每个章节提供了若干条建议或最佳实践，整理了对应章节关键的实践内容，用于自己后续代码开发过程中，参考对照，自查代码习惯，从而提升输出的代码质量。
【总结】Effective java经验之谈，创建和销毁对象
01-16 188
转载请注明出处：http://blog.csdn.NET/supera_li/article/details/44940277 关于Effective Java 这本书，自己的一些总结性的思考。篇幅可能不按照目录来，因为自己喜欢先看哪一章就直接阅读了。不过能确定的是，每一章都会有总结。欢迎大家拍砖与补充。 Effective java系列 1.Effective java经验之...
Effective java 总结1 - 创建和销毁对象
ym & blog
07-19 566
静态工厂方法有名称不必每次调用的时候创建一个新的对象可以返回原返回类型的任何子类型对象返回对象的类可以根据方法的参数值变化方法返回对象所属的类，编写包含该静态工厂方法的类时可以不存在（服务提供者框架）...
effective java读书小记（一）创建和销毁对象
weixin_33767813的博客
08-01 231
序言 《effective java》可谓是java学习者心中的一本绝对不能不拜读的好书，她对于目标读者（有一点编程基础和开发经验）的人来说，由浅入深，言简意赅。每一章节都分为若干的条目，完全可以利用平时的零碎时间片来阅读和思考。仅仅是阅读了第二章，创建和销毁对象，从静态工厂、构造器等基础得不能再基础的知识，却使我有一种特别的感觉，就如同见到一位会使我怦然心动的女生，那种惊喜，是那么的美...
effective JAVA（一） 创建和销毁对象
qqbwww的专栏
10-21 182
摘自Effective Java中文版 第2章  创建和销毁对象 第1条：考虑用静态工厂方法代替构造函数：          静态工厂方法的好处： 1.具有名字。如果构造函数没有确切地描述被返回的对象，那么选用适当名字的静态工厂可以是一个类易于使用，并且相应的客户代码更易于阅读。          2.静态构造方法每次被调用的时候，不要求非得创建一个新的对象。          ...
effective java之创建与销毁对象
weixin_33704234的博客
10-31 126
2019独角兽企业重金招聘Python工程师标准>>> ...
Effective Java读书笔记（1）—— 创建和销毁对象
Aviato
04-16 274
很久以前买的一本《Effective Java》，最近开始读啦！从第二章开始看（第一章是引言），每一章都有若干条建议，翻了一下感觉对日常编码有很强的指导意义呀，勤劳的我决定写个读书笔记记录一下????。 第一条：考虑用静态工厂方法代替构造器 说到静态工厂方法，书里给的例子是包装类型，也就是平时常会用到的Integer.valueOf()，Integer.parseInt()想必也算，返回的都是Int...
Effective Java读书笔试之创建和销毁对象
简单生活,快乐工作
12-12 207
Effective Java读书笔试之创建和销毁对象     1.考虑用静态工厂方法代替构造函数      静态工厂方法的第一个好处是，与构造函数不同，静态工厂方法有名字，接口有更好的类型表达能力。      静态工厂方法的第二个好处是,与构造函数不同，它每次被调用的时候，不要求非得创建一个新的对象，特别是对于不变对象而言,可以在被调用时返回同一个对象的引用，重用对象. ...
[Effective Java] 创建和销毁对象篇
iBlue.tech
07-22 375
[Effective Java] 创建和销毁对象篇 1. 优先考虑用静态工厂方法代替构造器 优点： - 静态工厂方法相比于构造器，它们有名称 - 不需要每次在使用的时候创建一个对象 - 可以返回原返回类型的任何子类型的对象 - 在创建参数化是来的时候，代码更加简洁 缺点： - 不能被子类化（因为鼓励程序使用复合，而不是继承） - 与其他的静态方法实际上没有任何区别（想要查明如何实...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值