Java基础5——设计模式

简单工厂模式

//创建型模式：简单工厂模式
public abstract class Animal{
    public abstract void eat();
}
public class Dog extends Animal{
    public void eat(){
        System.out.println("狗吃肉");
    }
}
public class Cat extends Animal{
    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 type){
        if("dog".equals(type)){
            return new Dog();
        }else if("cat".equals(type)){
            return new Cat();
        }else{
            return null;
        }
    }
}
public class AnimalDemo{
    public static void main(String[] args){
        Dog d=new Dog();
        d.eat();
        Cat c=new Cat();
        c.eat();
        System.out.println("-----------");
        //通过工厂来造
        //Dog dd = AnimalFactory.createDog();
        //Cat cc = AnimalFactory.createCat();
        //dd.eat();
        //cc.eat();
        Animal a = AnimalFactory.createAnimal("dog");
        a.eat();//调用的是狗的
        Animal b = AnimalFactory.createAnimal("cat");
        b.eat();//调用的是猫的
    }
}

简单工厂模式使得客户端不需要再负责对象的创建，从而明确了各个类的职责
但是这个静态工厂类负责所有对象的创建，如果有新的对象增加，或者某些对象的创建方式不同，就需要不断的修改工厂类，不利于后期维护

工厂方法模式

public interface Factory{
    public abstract Animal createAnimal();
}

public class DogFactory implements Factory{
    public Animal createAnimal(){
        return new Dog();
    }
}

public class CatFactory implements Factory{
    public Animal createAnimal(){
        return new Cat();
    }
}

public class AnimalDemo{
    public static void main(String[] args){
        Factory f=new DogFactory();
        Animal a=f.createAnimal();
        a.eat();
        
        f=new CatFactory();
        a=f.createAnimal();
        a.eat();
    }
}

工厂方法模式改变了简单工厂模式的弊端，但是工厂方法模式写起来比较繁琐

还有一种工厂方式叫抽象工厂方式，可以解决工厂方法模式的弊端 

单例模式——饿汉式

特点：对象在内存中只有一份

如何保证类在内存中只有一个对象
1 把构造方法私有
2 在成员位置自己创建一个对象
3 通过一个公共的方法访问

public class Student{
    private Student(){
        
    }
    //静态方法只能访问静态资源
    //外界也不能直接改变Student类里面的成员s，所以需要加上private
    private static Student s=new Student();
    
    //构造函数已经私有化了，所以外界只能通过静态的方式来访问getStudent方法
    public static Student getStudent(){
        return s;
    }
}
public class StudentDemo{
    public static void main(String[] args){
        Student s1=Student.getStudent();
        Student s2=Student.getStudent();
        System.out.println(s1==s2);
    }
}

单例模式——懒汉式

public class Teacher{
    private Teacher{
        
    }
    private static Teacher t=null;
    
    public static Teacher getTeacher(){
        if(t==null){
            t=new Teacher();
        }
        return t;
    }
}
public class TeacherDemo{
    public static void main(String[] args){
        Teacher t1=Teacher.getStudent();
        Teacher t2=Teacher.getStudent();
        System.out.println(t1==t2);
    }
}

总之，单例模式的思想就是保证只有一个对象，饿汉式是不会出问题的单例模式，所以开发的时候经常用，而懒汉式是会出问题的，所以面试时经常问

懒汉式有延迟加载的特点

懒汉式可能会带来线程安全问题，如果执行环境是多线程，我们有共享数据t， 也有多条语句操作t，如果在t1执行if(t==null)的时候t2也进来了就会创建两个对象所以比较保险的做法是给getTeacher方法加上synchronized关键字

而饿汉式里面对象初始化就是一个原子性的操作，所以不会出现线程安全问题

Runtime类的概述和应用

public class RuntimeDemo{
    public static void main(String[] args) throws IOException{
        //每个Java应用程序都有一个Runtime类实例，使应用程序能够与其运行的环境相连接，可以通过getRuntime方法获取当前运行时
        Runtime r=Runtime.getRuntime();
        //exec方法可以执行dos指令
        r.exec("calc");
    }
}

//在Runtime类源码内部，可以发现以下源码
class Runtime{
    private RunTime(){}
    private static Runtime currentRuntime=new Runtime();
    public static Runtime getRuntime(){
        return currentRuntime;
    }
}