设计模式的概述及分类、创建型模式的分类
/*
设计模式：（设计模板，开发思想）
--经验的总结。
分为三大类型：
A:创建型 创建对象
B:结构型 对象的组成
C:行为型 对象的功能
今天重点说一下创建型
创建型模式：
1、单例模式（重点掌握）
饿汉式
懒汉式
2、简单工厂模式
3、工厂方法模式
*/
单例模式、饿汉式
public class Student {
//静态的只能访问静态的
private static Student s = new Student();
//构造方法私有化
private Student(){}
//静态方法--通过类名调用
public static Student getStudent(){
return s;
}
}
/*
单例模式：保证类在内存中始终只有一个对象
如何保证类在内存只有一个对象呢？
1、构造方法私有化（外界不能创建对象）
2、在类的成员变量的位置上创建一个对象
3、提供一个公共的方法给外界获取到该对象
通过观察发现，我们随着Student类的加载，对象就创建好了，（静态的）
通过观察发现，这个模式是单例模式中的饿汉式。
--无论你通不通过getStudent()方法创建Student类的对象，
我Student类中都有一个学生对象
*/
public class StudentDemo {
public static void main(String[] args) {
//通过getStudent()方法获取学生对象
Student s1 = Student.getStudent();
Student s2 = Student.getStudent();
//判断s1与s2是否相等
//如果相等说明只有一个对象
System.out.println(s1==s2);//true
System.out.println(s1);
System.out.println(s2);
}
}
懒汉式
public class Teacher {
//构造方法私有化
private Teacher() {
}
private static Teacher t = null;
// //假设现在有三个线程t1,t2,t3--可能会存在线程安全问题
// public static Teacher getTeacher() {
// //判断是否有对象
// if (t == null) {
// //假设将来t1进来了，但是还没有创建对象的时候
// //此时CPU的时间片被t2抢走了，t2也进来了。
// //t3同理
// t = new Teacher();
// }
// return t;
// }
// //加锁--同步代码块（静态的）
// public static Teacher getTeacher() {
// synchronized (Teacher.class){
// //判断是否有对象
// if (t == null) {
// //假设将来t1进来了，但是还没有创建对象的时候
// //此时CPU的时间片被t2抢走了，t2也进来了。
// //t3同理
// t = new Teacher();
// }
// return t;
// }
// }
//加锁--线程同步安全的方法
public synchronized static Teacher getTeacher() {
if (t == null) {
//t1,t2,t3
t = new Teacher();
}
return t;
}
}
/*
饿汉式：类一加载，就去创建对象
懒汉式：用的时候，再去创建对象
特点：
1、懒加载（延迟加载）
2、容易产生线程安全问题
1） 是否存在多线程环境 是
2） 是否存在共享数据 是
3） 是否存在多条语句操作共享数据 是
开发中用谁呢？饿汉式
面试的时候，说懒汉式，因为牵扯到线程安全的问题
*/
public class TeacherDemo {
public static void main(String[] args) {
Teacher t1 = Teacher.getTeacher();
Teacher t2 = Teacher.getTeacher();
//但是假如有多线程环境，懒汉式将来会容易产生线程安全问题
System.out.println(t1==t2);//true
System.out.println(t1);
System.out.println(t2);
}
}
简单工厂模式
//定义一个抽象的动物类
public abstract class Animal {
//抽象的吃的方法
public abstract void eat();
}
//定义一个狗继承动物类
public class Dog extends Animal {
@Override
public void eat() {
System.out.println("狗吃肉");
}
}
//定义一个猫继承动物类
public class Cat extends Animal {
@Override
public void eat() {
System.out.println("猫吃🐟");
}
}
public class AnimalFactory {
//将构造方法私有化让外部无法创建该类对象
private AnimalFactory(){}
// 定义一个静态的创建狗的对象的方法
// public static Dog createDog(){
// return new Dog();
// }
// 定义一个静态的创建猫的对象的方法
// public static Cat createCat(){
// return new Cat();
// }
//用多态改进，多态创建对象
public static Animal createAnimal(String name){
if("dog".equals(name)){
return new Dog();
}else if("cat".equals(name)){
return new Cat();
}else {
return null;
}
}
/*
简单工厂模式（静态工厂方法模式）
*/
public class AnimalDemo {
public static void main(String[] args) {
// 开发中一般来说测试类（客户端）是不创建对象的
// Dog dog = new Dog();
// dog.eat();
// Cat cat = new Cat();
// cat.eat();
// 现在有一个动物工厂去造一些动物
// 调用工厂中的静态创造狗的对象的方法创建狗的对象
// Dog dog = AnimalFactory.createDog();
// dog.eat();
// 同理，创建猫的对象
// Cat cat = AnimalFactory.createCat();
// cat.eat();
//假设工厂想造猪
//需要修改工厂类，添加创建猪的方法
//然后再调用，比较复杂
//通过多态改进后
Animal dog = AnimalFactory.createAnimal("dog");
if(dog!=null){
dog.eat();
}
Animal cat = AnimalFactory.createAnimal("cat");
cat.eat();
Animal pig = AnimalFactory.createAnimal("pig");
//NullPointerException-空指针异常
//pig.eat();
//加入判断，判断pig是否为null
if(pig!=null){
pig.eat();
}else {
System.out.println("该工厂目前还不生产猪");
}
}
}
工厂方法模式
//定义一个抽象的动物类
public abstract class Animal {
//抽象的吃的方法
public abstract void eat();
}
//定义一个狗继承动物类
public class Dog extends Animal {
@Override
public void eat() {
System.out.println("狗吃肉");
}
}
//定义一个猫继承动物类
public class Cat extends Animal {
@Override
public void eat() {
System.out.println("猫吃🐟");
}
}
//定义一个猪继承动物类
public class Pig extends Animal {
@Override
public void eat() {
System.out.println("猪吃康");
}
}
//定义一个工厂接口
public interface Factory {
//定义一个抽象的制造动物的方法
public abstract Animal createAnimal();
}
//定义一个造狗的工厂实现工厂接口
public class DogFactory implements Factory{
//重写抽象的制造动物的方法
@Override
public Animal createAnimal() {
return new Dog();
}
}
//定义一个造猫的工厂实现工厂接口
public class CatFactory implements Factory {
//重写抽象的制造动物的方法
@Override
public Animal createAnimal() {
return new Cat();
}
}
//定义一个造猪的工厂实现工厂接口
public class PigFactory implements Factory {
@Override
public Animal createAnimal() {
return new Pig();
}
}
/*
工厂方法模式
回想一下上一个简单工厂模式的时候，如果我想创造一个新的动物，得去修改工厂类
正常情况下，你没有权限修改工厂类，就不能在原来工厂基础上进行修改
但是我依旧想实现该功能怎么办呢？使用工厂方法模式开发
*/
public class AnimalDemo {
public static void main(String[] args) {
//我想要造一只狗
//创建实现了工厂接口的狗工厂的对象
DogFactory dogFactory = new DogFactory();
//调用重写抽象的制造动物的方法，返回Animal类的对象
//多态的形式
Animal animal = dogFactory.createAnimal(); //new Dog();
animal.eat();
//。。。
CatFactory catFactory = new CatFactory();
Animal animal1 = catFactory.createAnimal();
animal1.eat();
//。。。
PigFactory pigFactory = new PigFactory();
Animal animal2 = pigFactory.createAnimal();
animal2.eat();
}
}
