工厂模式

工厂模式主要是为创建对象提供过渡接口，以便将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。
工厂模式可以分为三类：
1）简单工厂模式（Simple Factory）
2）工厂方法模式（Factory Method）
3）抽象工厂模式（Abstract Factory）

区别
工厂方法模式：
一个抽象产品类，可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类只能创建一个具体产品类的实例。
抽象工厂模式：
多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类可以创建多个具体产品类的实例。
区别：
工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。
工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。
两者皆可。

顶层父类：
public abstract class TwoClass {

    public abstract void Study();
}

老师类继承
public class Teacher extends TwoClass{

    @Override
    public void Study() {
        System.out.println("老师上课");
    }

}
学生类继承
public class Student extends TwoClass{

    @Override
    public void Study() {
        System.out.println("学生上课");
    }

}

工厂类：
public class ClassFactory {
    //无参构造
    public  ClassFactory(){

    }

    //形成老师类学生类
    public static Student CreatStudent(){
        return new Student();
    }
    public static Teacher Creatteacher(){
        return new Teacher();
    }

    //改进的形成类
    public static  TwoClass ClassCreat(String type){
        if("Student".equals(type )){
            return new Student();
        }else if("Teacher".equals(type)){
            return new Teacher();
        }else{
            return null;            
        }
    }

}

测试类：
public class TestDemo {

    public static void main(String[] args) {

        //提供了静态工厂类
        Teacher T1 = ClassFactory.Creatteacher();
        T1.Study();
        Student S1 = ClassFactory.CreatStudent();
        S1.Study();

        System.out.println("---------------");
        //改进的静态工厂类
        TwoClass S2 = ClassFactory.ClassCreat("Student");
        S2.Study();
        TwoClass T2 = ClassFactory.ClassCreat("Teacher");
        T2.Study();


    }

}
输出：
老师上课
学生上课
---------------
学生上课
老师上课

---

单例模式

单例模式: 在内存中始终只有一个对象
javaweb–Servlet(server applet) ,服务器端进行开发
饿汉式
特点:当前某一个一加载,就会创建一个对象
需要将该类的无参构造私有化
在成员变量创建该类的实例
需要提供公共的访问方法

懒汉式
特点:并不是加载某个类就直接创建对象,而是需要的时候在创建对象
1)懒加载(延迟加载)
2)线程的安全问题
a:是否是多线程环境
b:是否有共享数据
c:是否有多条语句对共享数据进行操作!
使用同步代码块进行解决

“`
老师类：饿汉式
public class Teacher {

//饿汉式，每创建一个变量就产生一个对象
//私有创建类
private Teacher() {
}

//在成员变量的位置创建该类的实例
    //静态只能访问静态,所以需要加上静态修饰
    //为了不让外界修改当前这个实例,所以加入private修饰
private static Teacher T = new Teacher() ;

//提供公共访问方法，返回值是该类实例对象
public static Teacher getTeacher(){
    return T;

}

学生类：懒汉式
public class Student {

private Student(){

}
//懒汉式，在需要对象的时候才产生对象
//在成员变量位置声明变量
    private static Student s= null ; //共享数据

///静态只能访问静态,所以需要加上静态修饰  , 私有类修饰，防止外界修改数据
public static Student getStudent(){

    if(s==null){
        s = new Student();
    }
    return s;
}

}

}“`