Effective Java 第2章 创建和销毁对象 精简总结 （1）

最新推荐文章于 2024-07-19 15:53:52 发布
最新推荐文章于 2024-07-19 15:53:52 发布
阅读量508 收藏
点赞数
分类专栏： Java 设计模式 技巧 文章标签： Effective 设计模式 代码技巧 总结
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/QiuFeihuMr/article/details/52003910
版权
Java 同时被 3 个专栏收录
3 篇文章 0 订阅
订阅专栏
设计模式
1 篇文章 0 订阅
订阅专栏
技巧
1 篇文章 0 订阅
订阅专栏
第一条 用静态工厂方法替代构造器

实例代码

     /**
     * Boolean 静态工厂方法
     */
    public static Boolean valueOf(boolean b) {
        return b ? Boolean.TRUE : Boolean.FALSE;
    }

    public static void main(String[] args) {
        //演示
        Boolean a = valueOf(1==1);
        System.out.println(a);
    }

结果：

true

讲解：
1.比构造方法，更易于使用，可以规范命名易于理解
当需要创建不同类型的对象时，可以写多个工厂方法

2.可以设置静态对象，不必每次都创建一个新的对象

3.可以返回任意子类创建的对象，例如Map接口，可以返回它的任意实现

4.在创建参数化类型对象的时候，可以是代码变得简洁
例如 

    /**
     * HashMap 静态工厂方法
     */
    public static <k,v> HashMap<k,v> newInstance(){
        return new HashMap<k,v>();
    }

    public static void main(String[] args) {
        //演示
        Map<String,String> map = newInstance();
        map.put("xiaomi","小米");
        System.out.print(map.get("xiaomi"));
    }

结果：

小米

建议命名：
如果是获取一个新的对象可以叫getNewInstance()
如果是获取一个单例对象可以叫getInstance();

实际应用案例：

import java.util.UUID;

/**
 * 学生类
 */
public class Student {

    private String id;
    private String name;
    private int age;
    private String className;
    private String school;

    //创建一个对象工厂方法
    public static Student getNewInstance(String name,int age){
        Student stu = new Student();
        stu.id = UUID.randomUUID().toString();
        stu.name = name;
        stu.age = age;
        return  stu;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getClassName() {
        return className;
    }

    public void setClassName(String className) {
        this.className = className;
    }

    public String getSchool() {
        return school;
    }

    public void setSchool(String school) {
        this.school = school;
    }


    //演示
    public static void main(String[] args) {
        Student xiaomi = Student.getNewInstance("小米",12);
        System.out.println(xiaomi.getName());
        System.out.println(xiaomi.getAge());
    }
}

结果：

小米
12
第二条 需要多个构造函数的时候，建议使用构建器

代码如下:

/**
 * 人类
 */
public class Person {

    private final String name;
    private final int age;
    private final String sex;

    //构造函数
    public Person(Builder builder){
        name = builder.name;
        age = builder.age;
        sex = builder.sex;
    }

    //类构建器
    public static class Builder {

        private String name;
        private int age;
        private String sex;


        public Builder(String name){
            this.name = name;
        }


        public Builder age(int age){
            this.age = age; return this;
        }

        public Builder sex(String sex){
            this.sex = sex; return this;
        }

        //创建对象返回
        public Person build(){
            return new Person(this);
        }


    }


    @Override
    public java.lang.String toString() {
        return "Person{" +
                "name=" + name +
                ", age=" + age +
                ", sex=" + sex +
                '}';
    }

}

测试代码：

    public static void main(String[] args) {
        Person hulin = new Person.Builder("胡林").age(12).sex("女").build();
        System.out.println(hulin.toString());
        Person xiaomi = new Person.Builder("小米").build();
        System.out.println(xiaomi.toString());
    }

运行结果：

Person{name=胡林, age=12, sex=女}
Person{name=小米, age=0, sex=null}

讲解：
先看结果，胡林和小米这两个对象，用以前思路的话，应该是创建两个构造函数，但是现在这种方法，就不需要啦！仔细观察代码，Builder这个构造器在编写的时候稍微复杂些，但是如果以后创建多个不同的对象，就规范精简很多啦！鱼和熊掌不可兼得嚒

第3条 用私有构造器或者枚举类型强化Singleton

类实现：

package com.qfh.object;

import java.util.Calendar;
import java.util.TimeZone;

/**
 * 单例模式(Singleton)
 */
public class HelloUtil {

    //在内存中只有一个实例,不可修改
    private static final HelloUtil INSTANCE = new HelloUtil();

    //私有化构造器
    private  HelloUtil(){}

    //暴露共有获取静态对象方法
    public static HelloUtil getInstance(){
        return INSTANCE;
    };

    /**
     * 判断时区,打印不同语言的世界你好
     */
    public void sayHello(){
        Calendar cal = Calendar.getInstance();
        TimeZone timeZone = cal.getTimeZone();
        if(timeZone.getDisplayName().indexOf("中国") >= 0){
            System.out.print("世界你好!");
        }else{
            System.out.print("Hello World!");
        }
    }

    /**
     * 测试
     * @param args
     */
    public static void main(String[] args) {
        HelloUtil.getInstance().sayHello();
    }

}

运行结果：

世界你好!

优点：
1.私有化构函数，保证不会被创建
2.实例是static 和final 类型的保证全局唯一性
3.线程安全
4.通过反射机制也无法创建新的实例

缺点：
1.无法抵御反序列化攻击

修改如下：

package com.qfh.object;

import java.io.Serializable;
import java.util.Calendar;
import java.util.TimeZone;

/**
 * 单例模式(Singleton)
 */
public class HelloUtil implements Serializable {

    private static final long serialVersionUID = 810160916916358307L;

    //在内存中只有一个实例,不可修改
    private static final HelloUtil INSTANCE = new HelloUtil();

    //私有化构造器
    private  HelloUtil(){}

    //暴露共有获取静态对象方法
    public static HelloUtil getInstance(){
        return INSTANCE;
    };

    /**
     * 判断时区,打印不同语言的世界你好
     */
    public void sayHello(){
        Calendar cal = Calendar.getInstance();
        TimeZone timeZone = cal.getTimeZone();
        if(timeZone.getDisplayName().indexOf("中国") >= 0){
            System.out.println("世界你好!");
        }else{
            System.out.println("Hello World!");
        }
    }

    /**
     * 防止单例对象在序列化后生成“多例”
     * @return
     */
    private Object readResolve(){
        return INSTANCE;
    }

}

使HelloUtil可序列化，并加入readResolve方法，在序列化的时候直接返回内存中的实例

测试代码：

    /**
     * 序列化克隆
     * @return
     * @throws Exception
     */
    public static HelloUtil deepCopy() throws Exception{
        ByteArrayOutputStream os = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(os);
        oos.writeObject(HelloUtil.getInstance());

        InputStream is = new ByteArrayInputStream(os.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(is);
        HelloUtil test = (HelloUtil) ois.readObject();
        return test;
    }

    public static void main(String[] args) {

        /**
         * 这样打印出的HelloUtil对象地址一致，
         * 说明依然是单例对象
         * 把readResolve方法注释掉再来一遍看看呢？
         */
        HelloUtil hello01 = HelloUtil.getInstance();
        HelloUtil hello02 = null;
        try {
            hello02 = deepCopy();
            hello02.sayHello();
        } catch (Exception e) {
            e.printStackTrace();
        }

        //如果两个对象的地址一样,说明依然是单例,没有创建新对象
        System.out.println("hello01:"+hello01);
        System.out.println("hello02:"+hello02);
        if(hello01 == hello02){
            System.out.println("是同一个实例对象");
        }else{
            System.out.println("不是同一个实例对象");
        }


    }

运行结果：

世界你好!
hello01:com.qfh.object.HelloUtil@4a5a12f5
hello02:com.qfh.object.HelloUtil@4a5a12f5
是同一个实例对象

对比实验：
注释掉readResolve方法：

    /**
     * 防止单例对象在序列化后生成“多例”
     * @return
     */
/*    private Object readResolve(){
        return INSTANCE;
    }*/

运行结果：

世界你好!
hello01:com.qfh.object.HelloUtil@61ae0436
hello02:com.qfh.object.HelloUtil@479747c9
不是同一个实例对象

但是以上方法不够精简，可以用枚举实现。
代码如下：

package com.qfh.object;

/**
 * 枚举类型的单例模式
 * 此方法好处有三点:
 * 1.线程安全
 * 2.不会因为反序列化而产生新实例
 * 3.防止反射攻击
 * 4.线程安全
 */
public enum GoodUtil {

    INSTANCE {

        @Override
        protected void sayGood() {
            System.out.println("棒棒哒!O(∩_∩)O哈哈~");
        }

    };

    /**
     * 此方法是内部继承的
     */
    protected abstract void sayGood();

}

测试代码：

    /**
     * 序列化克隆
     * @return
     * @throws Exception
     */
    public static GoodUtil deepCopy() throws Exception{
        ByteArrayOutputStream os = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(os);
        oos.writeObject(GoodUtil.INSTANCE);

        InputStream is = new ByteArrayInputStream(os.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(is);
        GoodUtil test = (GoodUtil) ois.readObject();
        return test;
    }

    public static void main(String[] args) {

        /**
         * 这样打印出的GoodUtil对象地址一致，
         * 说明依然是单例对象
         */
        GoodUtil hello01 = GoodUtil.INSTANCE;
        GoodUtil hello02 = null;
        try {
            hello02 = deepCopy();
            hello02.sayGood();
        } catch (Exception e) {
            e.printStackTrace();
        }

        //如果两个对象的地址一样,说明依然是单例,没有创建新对象
        System.out.println("hello01:"+hello01);
        System.out.println("hello02:"+hello02);
        if(hello01 == hello02){
            System.out.println("是同一个实例对象");
        }else{
            System.out.println("不是同一个实例对象");
        }


    }

运行结果：

棒棒哒!O(∩_∩)O哈哈~
hello01:INSTANCE
hello02:INSTANCE
是同一个实例对象
QiuFeihuMr
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Effective Java第三版1
08-08
### 第二章 创建和销毁对象 1. **考虑用静态工厂方法替换构造器**：静态工厂方法比构造器更灵活，它们可以返回已存在或新创建的对象，还可以有选择性地返回子类的实例，且名称可以更具描述性。 2. **构建器（建造者...
Effective-Java:Effective Java中文版第二版示例代码
07-09
《Effective Java》是Java开发领域的经典著作，由Joshua Bloch撰写，中文版第二版更是深受广大Java开发者喜爱。这本书提供了许多实用的编程实践和经验教训，帮助开发者编写出更高效、可维护的Java代码。这里我们将...
Effective Java（第三版） 学习笔记 - 第二章 创建和销毁对象 Rule1~4
weixin_44453385的博客
05-20 256
Effective Java（第三版） 学习笔记 - 第二章 创建和销毁对象 Rule1~4 本文主要介绍了对象创建和销毁相关的内容
EffectiveJava第二章内容总结
haiyanghan的博客
01-10 283
创建和销毁对象一. 用静态工厂方法代替构造器1. 静态方法对比构造器的优势1.1 他们有名字1.2 不用在每次调用的时候创建新对象1.3 可以返回原返回类型的任意子类型对象1.4 返回对象的类可以随着每次调用发生变化（取决于静态工厂方法的参数值）1.5 方法返回的对象所属的类，在编写包含该静态工厂方法时可以不存在2. 静态方法对比构造器的缺点2.1 类如果不含公有的或受保护的构造器，就不能被子类化2.2 程序员很难发现他们二. 遇到多个构造器参数时要考虑使用构建器1. JavaBeans模式2. Build
Singleton with constructor or enum-第二章创建和销毁对象-Effective Java学习笔记02
weixin_43596589的博客
01-13 150
学习笔记@Effective Java第二章创建和注销对象Item 3使单例属性具有私有构造函数或枚举类型优点第三个方法原文 文章内容来源于Joshua Bloch - Effective Java (3rd) - 2018.chm一书 第二章 创建和注销对象 Item 3使单例属性具有私有构造函数或枚举类型 Enforce the singleton property with a private constructor or an enum type 简单地，单例是只实例化一次的类。典型地，单例表示要么
Effective Java:创建和销毁对象
BoBoMEe
01-06 439
1. 静态工厂方法代替构造器简介 获取类的实例,除了提供公有的构造器外,还可以使用静态工厂方法 静态工厂方法 提供实例,不同于设计模式中的 工厂方法模式,简单示例: public static Boolean valueOf(boolean b) { return b ? Boolean.TRUE : Boolean.FALSE; }优势: 相对于构造器,静态工
读书笔记：《Effective Java 3rd》创建和销毁对象 01.用静态工厂方法代替构造方法
github_39353936的博客
02-12 246
文章目录概述优点1、有名称，可读性好2、不用重复创建一个对象3、可以返回原返回类型的任何子类型4、返回的对象可以随着每次调用时所传的参数值而改变5、在编写静态工厂方法的类时返回对象的类可以不存在服务提供者框架服务接口 UserService服务具体实现类 UserServiceImpl服务提供者接口 UserServiceProvider服务提供者具体实现类 UserServiceProvider...
(转载)effective java 第二版精简版
蓝色的博客
07-16 325
[size=small]第一章 前言 第二章 创建和销毁对象 1、 考虑用静态工厂方法代替构造器 创建对象方法：一是最常用的公有构造器，二是静态工厂方法。下面是一个Boolean的简单示例： public static Boolean valueOf(boolean b) { return (b ? Boolean.TRUE : Bo...
创建销毁对象(第一条：考虑静态工厂方法而非构造器)
FengvHaoDa的博客
04-09 192
第二章．创建销毁对象这一章主要关注创建和销毁对象：什么时候应该创建它们，该怎样创建它们，什么时候该避免创建它们，怎样避免创建它们。怎样保证他们在合适的情况下被销毁，怎么样来做一些发生在销毁对象之前的清理操作。 第一条：考虑静态工厂方法而非构造器对于一个类而言，允许客户端获取它的实例的传统方法是提供一个公共的构造方法。还有另一个方法应该成为每一个开发人员的开发技巧的一部分。这就是公共的静态工厂方法，...
《Effective C++》精简总结——1~17条款
To the beyond and infinity!
03-16 393
文章目录一、C++使用习惯1. C++的组成：4种次语言2. 最好以编译器替代预处理器3. 尽可能使用const4. 确定对象在使用前已被初始化二、构造/析构/赋值运算5. c++默认编写的自定义类型成员函数有哪些6. 一、C++使用习惯 1. C++的组成：4种次语言 可将C++语言视为4种次语言的联邦，这4种次语言分别为： C：C语言本身是面向过程的，高效，作为C++基础，包含区块、语句、预处理、内置类型、数组、指针等； Objected-Oriented C++（OOP:Objected-Ori
Effective Java读书笔记
逆水行舟，不进则退
01-23 881
第一章 引言 本文用来记录Effective Java学习过程中的各个知识点，受此时能力所限，有些点可能讲的不太清楚，或者理解有错误的地方，请多多指教！ 第二章 创建和销毁对象 第一条 用静态工厂方法代替构造器 可参考文章：https://blog.csdn.net/u014129886/article/details/89670049 总而言之，静态工厂方法和共有构造器各有各的用处，我们需要理解他们各自的长处，静态工厂经常更加合适。 此处的静态工厂方法与设计模式中的工厂模式不同，这里是一种构造
java effective 第二版中英文二份文件
01-17
以上只是《Effective Java》第二版部分关键知识点的概述，实际上，书籍中还包含更多关于类设计、方法设计、多线程、集合框架等方面的深入讨论和建议，是每个Java开发者不可或缺的参考书。通过阅读并实践书中的建议，...
(一)js前端开发中设计模式前篇之对象
峰会路转的博客
07-17 256
改进版与基础版要分开测试，不然会互相影响到。
模板方法原理与C++实现
Black.Spider的博客
07-15 309
定义一个操作中的算法骨架（稳定的），而将一些步骤的实现延迟到子类中（变化的）。模板方法使得子类可以复用一个算法的结构，而只改变（重写）这个算法的特定步骤。模板方法是一种非常实用且常见的设计模式，它使用简单的机制（虚函数）为应用程序框架提供了灵活的扩展点。模板方法中被模板方法调用的虚函数可以有具体实现，也可以没有任何实现（纯虚函数），但一般访问权限为protected，因为作为算法的一部分，它没有对外单独开放的必要。
(三)js前端开发中设计模式之工厂模式
峰会路转的博客
07-17 270
工厂模式是一种创建型设计模式，它可以帮助我们根据需求创建对象。
java设计模式：02-创建型设计模式-概览
Mr_Air_Boy的博客
07-17 358
创建型模式（Creational Patterns）主要用于处理对象创建的机制，旨在以适当的方式创建对象。这些模式的目的是将对象的创建过程与系统的其他部分分离，以提高系统的灵活性和可扩展性。通过使用创建型模式，可以使系统在创建对象时更加灵活，减少耦合，提高代码的可维护性。
Java 和 SpringBoot 中的设计模式 详解
最新发布
weixin_68074170的博客
07-19 641
假如有一结果api结果返回值的类Person，其在代码中频繁被使用。这两种使用方法的弊端有：（1）：当只需要部分参数的时候需要再定义个构造函数（比如失败的情况只需要code和message，结果肯定是空，因此不需要data），且一旦参数较多，则；（2）；Lombok插件的@Builder注解。
Linux C++ 056-设计模式之迭代器模式
Tianwx的博客
07-15 479
本节关键字：Linux、C++、设计模式、迭代器模式 相关库函数：
Effective Java读书分享：创建与销毁对象的最佳实践
第二部分主要探讨创建和销毁对象的策略。作者建议： - 使用静态工厂方法代替构造器。这样做的好处包括：提供更具描述性的方法名，可能实现对象缓存以提高性能，以及返回任何子类型的实例。然而，静态工厂方法也有其...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值