JAVA知识总结：单例模式和多态

Posted 2020-11-23 envythink

好吧，今天一定要把面向对象的最后一个特性：多态，给说完。不过我们先来聊一聊设计模式，因为它很重要。

设计模式

官方的解释是，设计模式是：一套被反复使用，多数人知晓的，经过分类编目，代码设计经验的总结。说人话就是：软件开发人员在软件开发过程中面临的一般问题的解决方案。

常见的设计模式可以参看这张图片：

我们可以对其按照作用来进行分类:：
关注对象创建过程的：创建型模式；
类和对象组合：结构型模式；
对象之间的通信过程：行为型模式；

单例模式

单例模式: 一个类有且仅有一个实例,并且自行实例化向整个系统提供，它的目的就是使得类的一个对象成为该类系统中的唯一实例。

要点：

1. 某个类只能有一个实例;；
2. 必须自行创建实例；
3. 必须自行向整个系统提供这个实例；

实现：
1、只提供私有的构造方法；
2、只含有一个该类的静态私有对象；
3、提供一个静态的公有方法用于创建、获取静态私有对象。

对于1的理解：private是访问限制能力最强的修饰符，只能在当前类内被使用。也就是说经过private修饰，该类的对象在类外无法通过new关键字直接实例化，这样可以做到限制类实例化产生；

对于2的理解：1可以实现有且仅有一个实例，static修饰的静态成员可以满足该类有且仅有一个，所有的对象都共享这一个静态成员；

对于3的理解：类似于封装，必须向外部系统提供唯一的公有访问方法。

在java中实现单例模式有2种方式：饿汉式和懒汉式。

饿汉式：在类中私有对象创建的过程中立刻进行实例化操作（言外之意，不管你用不用，我先把这个给做了）如此看来确实挺饿的；

懒汉式:：对象创建时并不立刻进行实例化操作，而是在静态公有方法中进行实例化操作（言外之意，你不需要我就不做）如此看来确实挺懒的。

饿汉式

饿汉式：在类中私有对象创建的过程中立刻进行实例化操作（言外之意，不管你用不用，我先把这个给做了）：

package SingleExample;
// 饿汉式：创建对象实例的时候直接初始化；（空间换时间）

public class SingletonOne {

    //1、创建类中私有的构造方法
    private SingletonOne() {
        
    };
    
    //2、创建该类型的私有静态实例
    private static SingletonOne instance = new SingletonOne();
    
    //3、创建公有的静态方法，返回静态实例对象
    public static SingletonOne getinstance() {
        return instance;
    };
}

测试代码：

package SingleExample;

public class SingleOneTest {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        SingletonOne one =SingletonOne.getinstance();
        
        SingletonOne two =SingletonOne.getinstance();
        
        System.out.println(one==two);   //输出结果为true
    } 
}

懒汉式

懒汉式:：对象创建时并不立刻进行实例化操作，而是在静态公有方法中进行实例化操作（言外之意，你不需要我就不做）：

package SingleExample;
//懒汉式：创建对象实例的时候并不初始化；（时间换空间）

public class SingletonTwo {
    // 1、创建类中私有的构造方法
    private SingletonTwo() {

    };

    // 2、创建静态的该类实例对象
    private static SingletonTwo instance = null;

    // 3、创建公有的静态方法，提供实例对象
    public static SingletonTwo getinstance() {
        if (instance == null) {
            instance = new SingletonTwo();
        }
        return instance;
    };
}

相应的测试代码为：

package SingleExample;

public class SingleTwoTest {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        SingletonTwo one = SingletonTwo.getinstance();

        SingletonTwo two = SingletonTwo.getinstance();

        System.out.println(one == two);   //输出结果为true
    }

}

单例模式两种实现总结

饿汉式在类加载时就创建实例，第一次加载速度快；
懒汉式在第一次使用时才进行实例化，第一次加载速度慢；

饿汉式：空间换时间
懒汉式：时间换空间

饿汉式，类在加载时进行了对象的实例化创建，即使多个进程进行并发操作，访问的实例也是唯一的，饿汉式线程安全。

懒汉式，第一次使用才会实例化，多个线程并发操作时，由于时间片的切换，可能导致线程风险。

但是懒汉式的线程危险是可以规避的，通过关键字Synchronized实现线程的锁定，也可以通过静态内部类和枚举保证操作时的线程唯一。

单例模式优缺点及使用场景

单例模式的优点：
1、在内存中只有一个对象,节省内存空间；
2、避免频繁的创建销毁对象, 提高性能；
3、避免对共享资源的多重占用。

单例模式的缺点:
1、扩展比较困难；
2、如果实例化后的对象长期不利用,系统将默认为垃圾进行回收,造成对象状态丢失。

使用场景:
1、创建对象时占用资源过多,但同时又需要用到该类对象；
2、对系统内资源要求统一读写,如读写配置信息；
3、当多个实例存在可能引起程序逻辑错误,如号码生成器；

每一种设计模式都是针对场景，针对某种具体问题的，具体场景应当进行具体分析，选用合适的设计模式。

多态

终于开始进入多态的世界了，在这里你将全面了解多态的特点及使用。

多态你可以理解为不同类的对象对同一消息做出不同的响应。

一般而言，多态分为编译时多态和运行时多态这两种。

编译时多态：也称设计时多态，它是通过方法重载来实现的，编译器在编译状态可以进行不同行为的区分。

而运行时多态，则必须要求程序运行时，动态决定调用哪个方法。

我们通常在Java中的多态指的就是运行时多态。

实现多态的必要条件: 满足继承和重写；父类引用指向子类对象

向上转型

所谓的向上转型也指隐式转型（自动转型）。说通俗一点就是父类引用指向子类实例，它可以调用子类重写父类的方法以及父类派生的方法，但是无法调用子类特有方法。

举个例子，假如Dog这个类继承了我们Animal这个类，我们不仅可以这样：

Dog dog =new Dog();
Animal animal =new Animal();

你还可以这样：

Animal dog2 =new Dog();

这就是将一个子类对象转型为一个父类对象，这个很好理解，对吧。

接下来我们来说一下，向下转型，顾名思义就是和向上转型相反的操作了，是的，你很聪明。

向下转型

向下转型也称强制类型转换。它是子类引用指向父类实例，我们在之前就用过了，还记得我们在重写Object类的equals方法时，就将父类Object强制转换，然后才调用子类特有的方法。

向下转型并不是可以随便转换的，需要满足一定的转换条件。我们可以通过instanceof这个运算符来判断是否能进行强制类型转换。

通过上面的图片，我们可以很清楚的知道instanceof的作用就是判断左边对象是否是右边这个类的实例，如果是就返true，否则就返回false。

因此，我们在进行向下转型的时候，可以用instanceof来判断一个对象是否满足某个类的实例特征。满足，我们才进行类型转换，否则强制转换会报错。

总结一下：
向上转型: 父类引用指向子类对象。即小变大。

向下转型: 子类引用指向父类对象。即大变小。

需要注意的是：父类中static修饰的方法允许被子类使用，但是不允许被子类重写，所以向上转型之后，只能调用到父类原有的静态方法。如果此时要用子类中的，只能通过向下转型来实现。

抽象类

某个父类只是知道其子类应该包含怎样的方法，但无法准确知道这些子类如何实现这些方法，这样我们的抽象类就派上用场了。

抽象类可以避免子类设计的随意性，还可以避免父类无意义的实例化。

你只需知道，修饰抽象类要用abstract这个关键词，抽象类不可以直接被实例化。

抽象方法

我们前面说过，父类只是规定子类拥有该项能力，但在父类中具体实现它是没有任何意义的，因此该方法应设置为抽象方法。

public abstract void test();

你记住，抽象方法是不允许有方法体的，也就是不能有花括号。而且此时子类必须实现父类的抽象方法，如果你不实现，那么这个类就必须被设置为抽象类（不设置就会报错），然后由继承它的类去具体实现相应的方法。简单来说就是一句话：抽象方法中不允许包含方法体，子类需要重写父类的抽象方法。

一般抽象类适用于这种情况：1、父类中的实现没有意义；2、提醒子类必须要去自己实现自己的这个方法。

通常子类变多了之后，你新建一个类只要继承了抽象的父类，IDE会自动提醒你实现父类中的抽象方法的，你不实现就会报错。

抽象类和抽象方法的使用

你可以使用abstract关键词来定义抽象类，抽象类不能被直接实例化，你可以通过向上转型完成对象实例，只能被继承。

abstract关键词定义抽象方法 ，你不需要具体实现也不能具体实现，也就是花括号不能有。

需要注意的是：抽象类可以没有抽象方法，但包含抽象方法的类一定是抽象类。

我们前面说过，当一个类继承抽象类，必须实现类中的抽象方法。如果不重写，则必须将该子类也变为抽象类，由其子类来实现，否则会报错。

注意：static final private 不可以和abstract同时出现（因为抽象方法是要在子类中进行重写的，而private只能在当前类被访问，final方法不允许被子类重写，static静态不允许被子类重写。）