Java-设计模式
1. 设计模式
经验的总结
- 1.创建型 创建对象
- 2.结构型 对象的组成
- 3.行为型 对象的功能
创建型模式
单例模式:指的是在程序的运行过程中，内存只允许有一个对象存在
如何保障类在内存只有一个对象呢？
- 1、构造方法私有化
- 2、在类的内部成员变量位置上创建一个对象
- 3、提供公共的方法将唯一的对象返回出来获取
饿汉式:类一加载，对象就创建好了。
代码如下：
学生类：
public class Student {
private static Student student =new Student();
private Student(){
}
public static Student makeStudent(){
return student;
}
}
测试类
public class StudentDemo {
public static void main(String[] args) {
Student s1 = Student.makeStudent();
Student s2 = Student.makeStudent();
System.out.println(s1 == s2); //true
System.out.println(s1); //com.bigdat.java.day28.danlimoshi.Student@1b6d3586
System.out.println(s2); //com.bigdat.java.day28.danlimoshi.Student@1b6d3586
}
}
懒汉式：用的时候，再去创建对象
Teacher类
public class Teacher {
private static Teacher teacher = null;
private Teacher() {
}
//t1,t2,t3
// public static Teacher getTeacher() {
// synchronized (Teacher.class){
// if (teacher == null) {
// //t1,t2,t3
// teacher = new Teacher();
// }
//
// return teacher;
// }
// }
public synchronized static Teacher getTeacher() {
if (teacher == null) {
//t1,t2,t3
teacher = new Teacher();
}
return teacher;
}
}
测试类
public class TeacherDemo {
public static void main(String[] args) {
Teacher t1 = Teacher.makeTeacher();
Teacher t2 = Teacher.makeTeacher();
System.out.println(t1 == t2); //true
System.out.println(t1); // com.bigdat.java.day28.danlimoshi.Teacher@1b6d3586
System.out.println(t2); // com.bigdat.java.day28.danlimoshi.Teacher@1b6d3586
}
}
面试题：你知道java中的单例模式吗？开发中你喜欢用哪一种？
- 知道，有饿汉式和懒汉式，饿汉式是指类加载的时候，对象就创建好了，懒汉式指的是用的时候再去创建对象
但是，开发中使用饿汉式，因为懒汉式可能会有线程安全问题。
简单工厂模式
-https://blog.csdn.net/a745233700/article/details/120253639 ——百度搜索更详解释
- 简单工厂模式的核心是定义一个创建对象的接口，将对象的创建和本身的业务逻辑分离
简单工厂模式的优缺点
- 优点：简单工厂模式提供专门的工厂类用于创建对象，实现了对象创建和使用的职责分离，客户端不需知道所创建的具体产品类的类名以及创建过程，只需知道具体产品类所对应的参数即可，通过引入配置文件，可以在不修改任何客户端代码的情况下更换和增加新的具体产品类，在一定程度上提高了系统的灵活性。
- 缺点：在于不符合“开闭原则”，每次添加新产品就需要修改工厂类。在产品类型较多时，有可能造成工厂逻辑过于复杂，不利于系统的扩展维护，并且工厂类集中了所有产品创建逻辑，一旦不能正常工作，整个系统都要受到影响。
代码如下：
猫类
public class Cat extends Animal{
@Override
public void eat() {
System.out.println("猫吃鱼...");
}
}
狗类：
public class Dog extends Animal{
@Override
public void eat() {
System.out.println("狗吃肉...");
}
}
动物类：
public abstract class Animal {
public abstract void eat();
}
动物工厂类：
public class AnimalFactory {
//将构造方法私有化，让外界无法创建对象
private AnimalFactory(){}
//利用多态来创建对象
public static Animal createAnimal(String name){
if ("cat".equals(name)){
return new Cat();
}else if ("dog".equals(name)){
return new Dog();
}else{
System.out.println("动物工程暂不支持"+name+"类动物的培养！");
return null;
}
}
}
测试类：
public class AnimalDemo {
public static void main(String[] args) {
//一般创建对象的方法 创建一只猫和一只狗
// Animal cat = new Cat();
// cat.eat();
// Animal dog = new Dog();
// dog.eat();
//工厂方法来创建对象
Animal animal = AnimalFactory.createAnimal("dog");
Dog dog = (Dog)animal;
dog.eat();
Animal elephant = AnimalFactory.createAnimal("elephant");
elephant.eat();
}
}
工厂方法模式
- 工厂方法模式将工厂抽象化，并定义一个创建对象的接口。每增加新产品，只需增加该产品以及对应的具体实现工厂类，由具体工厂类决定要实例化的产品是哪个，将对象的创建与实例化延迟到子类，这样工厂的设计就符合“开闭原则”了，扩展时不必去修改原来的代码。在使用时，用于只需知道产品对应的具体工厂，关注具体的创建过程，甚至不需要知道具体产品类的类名，当我们选择哪个具体工厂时，就已经决定了实际创建的产品是哪个了。
猫类
public class Cat extends Animal{
@Override
public void eat() {
System.out.println("小猫吃鱼！！！");
}
}
狗类
public class Dog extends Animal{
@Override
public void eat() {
System.out.println("小狗吃肉！！！");
}
}
动物类
public abstract class Animal {
public abstract void eat();
}
工厂类
/*
抽象工厂
由具体的动物工厂来继承，然后造具体动物
*/
public abstract class Factory{
public abstract Animal createAnimal();
}
猫工厂类
public class CatFactory extends Factory{
@Override
public Animal createAnimal() {
return new Cat();
}
}
测试类
public class AnimalDemo {
public static void main(String[] args) {
CatFactory catFactory = new CatFactory();
Animal cat = catFactory.createAnimal();
cat.eat();
}
}
————————————————
版权声明：本文为CSDN博主「张维鹏」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/a745233700/article/details/120253639
