带你快速看完9.8分神作《Effective Java》—— 类和接口篇

电玩女神 2024-05-24 21:31 34阅读 0赞

> ? Java学习：[Java从入门到精通总结][Java]  
>   
> 
> 
> ? Spring系列推荐：[Spring源码解析][Spring]  
>   
> 
> 
> ? 最近更新：2022年1月7日  
>   
> 
> 
> ? 个人简介：通信工程本硕?、阿里新晋猿同学?。我的故事充满机遇、挑战与翻盘，欢迎关注作者来共饮一杯鸡汤  
>   
> 
> 
> ? 点赞 ? 收藏 ⭐留言 ? 都是我最大的动力！

突然发现中间的一期文章漏掉了，今天补发一下QAQ

### 15 使类和成员的可访问性最小化 ###

面向对象语言设计时的两大“法宝”就是封装和解耦。其中，封装可以隐藏组件所有的实现细节，把API与实现清晰隔离开，因此也就解除组成系统的各个组件之间的耦合关系。

**解耦还同时有另外的优点：**

1.  一旦完成了一个系统，并通过分析定位到哪些组件影响了系统的性能，这些组件就可以单独被优化
2.  提高了代码的重用性，因为组件之间并不会紧密相连，在其他环境里这些模块可能也有很大用途
3.  降低了构建大型系统的风险，因为系统即使不可用了，这些独立的组件也可能是可用的

> 这也是当今主流微服务的特色

--------------------

说了这么多，实现封装和解耦其实很简单，尽可能使每个类或成员不被外部访问即可。如果一个类只是在某一个类里被用到，则应该让这个类成为使用它的那个类的私有嵌套类。

但是里氏替换原则限制了我们降低方法可访问性的目标，即如果方法是覆盖父类中的方法，子类方法的访问级别就不能低于父类中的访问级别。这样可以确保任何可使用父类实例的地方也都可以使用子类的实例。

> 这条规则有条特殊的：如果是类实现接口，则所有被实现的方法必须是public的

public类的实例域绝不能是public的，因为public属性通常并不是线程安全的。如果有常量是需要暴露的，可以使用`public static final`来修饰这些属性。

对于数组这种数据结构，让类具有`public static final`数组属性是错误的，因为数组里面的内容还是可能会被修改的，下面就是一种错误的写法：

// wrong
    public static final Thing[] VALUES = {
       
        ......};

解决这个问题有两种写法：  
**方法一：**

private static final Thing[] PRIVATE_VALUES = {
       
        ......};
    public static final List<Thing> VALUES = Collections.unmodifiableList(Arrays.asList(PRIVATE_VALUES));

**方法二：**

private static final Thing[] PRIVATE_VALUES = {
       
        ......};
    public static final Thing[] values(){
       
        
    	return PRIVATE_VALUES.clone();
    }

### 16 在public类中使用访问方法而不是public属性 ###

有时候需要编写一些退化类，用来聚合一些属性，比如这样：

class Point {
       
        
    	public double x;
    	public double y;
    }

上面的写法违反了面向对象设计中封装的规定，应该被杜绝，而是使用下面这种setter的风格代替：

public class Point {
       
        
        private double x;
        private double y;
    
        public Point(double x, double y){
       
        
            this.x = x;
            this.y = y;
        }
    
        public double getX() {
       
        
            return x;
        }
    
        public double getY() {
       
        
            return y;
        }
    
        public void setX(double x) {
       
        
            this.x = x;
        }
    
        public void setY(double y) {
       
        
            this.y = y;
        }
    }

上面秉承了一个原则：如果类可以在它所在的包之外访问，就提供访问方法。才外还有另一个原则：如果类是default的或是private的嵌套类，可以直接暴露其属性

> Java平台类库里`java.awt.Point`和`java.awt.Dimension`类违反了这一条原则，这是个错误！

如果属性是final的，可以将其可见范围设为public并强加约束条件，就像下面一样加限制条件：

public class Time {
       
        
    
        private static final int HOURS_PER_DAY = 24;
        private static final int MINUTES_PER_HOUR = 60;
    
        public final int hour;
        public final int minute;
    
        public Time(int hour, int minute){
       
        
            if (hour < 0 || hour >= HOURS_PER_DAY)
                throw new IllegalArgumentException("Hour: " + hour);
            if (minute < 0 || minute >= MINUTES_PER_HOUR)
                throw new IllegalArgumentException("Minute: " + minute);
            this.hour = hour;
            this.minute = minute;
        }
    }

### 17 可变性最小化原则 ###

不可变类是指shilling不能被修改的类，比如：Sting、基本类型包装类、BigInteger、BigDecimal

之所以要使用不可变类，大致原因有：不可变的类更容易实现，且安全性更高，之后会有更详细的讨论。

不可变类的实现遵循下面四条原则：  
**1. 不提供任何setter方法**

**2. 保证类不会被继承**  
一般做法是将类声明为final的。还有一种做法是让类的构造函数是private或default的，然后使用静态工厂来代替公有的构造函数：

public class Complex {
       
        
        
        private final double re;
        private final double im;
        
        private Complex(double re, double im){
       
        
            this.re = re;
            this.im = im;
        }
        
        public static Complex valueOf(double re, double im){
       
        
            return new Complex(re, im);
        }
    }

**3. 所有的属性都是`private final`的**  
这条规定比实际使用里严格了一点，实际上为了提高性能，只要保证方法对对象的修改不会被外部可见即可。比如有一些不可变类也有不是final的属性，在第一次请求计算时会将一些昂贵计算开销的结果缓存在这些属性里。

**4. 确保对任何可变组件的互斥访问**  
这句话读起来比较拗口，实际上意思就是：不可变类里面如果有指向可变对象的字段，必须确保客户端不能获得这些字段。

--------------------

下面是一个不可变类的例子，该类定义了数学上面的复数：

public class Complex {
       
        
    
        private final double re;
        private final double im;
    
        public Complex(double re, double im){
       
        
            this.re = re;
            this.im = im;
        }
    
        public double realPart() {
       
        return re;}
        public double imaginaryPart() {
       
        return im;}
    
        public Complex plus(Complex c){
       
        
            return new Complex(re + c.re, im + c.im);
        }
        
        public Complex minus(Complex c){
       
        
            return new Complex(re - c.re, im - c.im)

[Java]: https://blog.csdn.net/HNU_Csee_wjw/article/details/108082426
[Spring]: https://blog.csdn.net/hnu_csee_wjw/category_10931055.html