在讲设计模式之前，我们首先来说一下面向对象思想的设计原则，在实际的开发中，我们要想更深入的了解面向对象思想，就必须熟悉前人总结过的面向对象的思想的设计原则：
1.单一职责原则：“高内聚，低耦合”，也就是说，每个类应该只有一个职责，对外只能提供一种功能，而引起类变化的原因应该只有一个。在设计模式中，所有的设计模式都遵循这一原则。
2.开闭原则：核心思想：一个对象对扩展开放，对修改关闭，也就是说对类的改动是通过增加代码进行的，而不是修改现有代码。
3.里氏替换原则：在任何父类出现的地方都可以用它的子类来替代。其实就是说：同一个继承体系中的对象应该有共同的行为特征。
4.依赖注入原则：要依赖于抽象，不要依赖于具体实现。其实就是说：在应用程序中，所有的类如果使用或依赖于其他的类，则应该依赖这些其他类的抽象类，而不是这些其他类的具体类。为了实现这一原则，就要求我们在编程的时候针对抽象类或者接口编程，而不是针对具体实现编程。
5.接口分离原则：不应该强迫程序依赖它们不需要使用的方法。其实就是说：一个接口不需要提供太多的行为，一个接口应该只提供一种对外的功能，不应该把所有的操作都封装到一个接口中。
6.迪米特原则：一个对象应当对其他对象尽可能少的了解，其实就是说：降低各个对象之间的耦合，提高系统的可维护性。在模块之间应该只通过接口编程，而不理会模块的内部工作原理，它可以使各个模块耦合度降到最低，促进软件的复用。
简单工厂模式
简单工厂模式也叫静态工厂方法模式
设计一个工厂类:
工厂类提供一些静态方法,间接的去创建具体的对象
下来我们通过一个具体的例子来学习一下。
//提供了一个动物抽象类
public abstract class Animal {
//抽象功能
public abstract void 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 class AnimalFactory {
//无参构造私有:外界不能创建该类对象
private AnimalFactory() {
}
//提供一些静态功能,间接的创建具体对象
/*public static Cat createCat() {
return new Cat() ;
}
//狗类
public static Dog createDog() {
return new Dog() ;
}*/
//想办法用多态的形式解决:代码扩展性
public static Animal createAnimal(String type) {
if("cat".equals(type)) {
return new Cat() ;
}else if("dog".equals(type)) {
return new Dog() ;
}
return null;
}
}
public class AnimalDemo {
public static void main(String[] args) {
//养猫
Cat c = new Cat() ;
c.eat();
//养狗
Dog d = new Dog() ;
d.eat();
System.out.println("---------------------");
//优化改进之后,调用工厂类里面的方法
/*Cat cc = AnimalFactory.createCat() ;
cc.eat();
Dog dd = AnimalFactory.createDog() ;
dd.eat();*/
//改进:使用抽象类多态的形式改进工厂类
Animal a = AnimalFactory.createAnimal("cat") ;
a.eat();
a = AnimalFactory.createAnimal("dog") ;
a.eat();
a = AnimalFactory.createAnimal("pig") ;
//java.lang.NullPointerException
//对象进行非空判断
if(a!=null) {
a.eat();
}else {
System.out.println("抱歉,当前工厂类不提供该动物类的创建");
}
}
}
从代码中也可以发现，简单工厂模式的优缺点。
优点：
客户端不需要在负责对象的创建，从而明确了各个类的职责
缺点：
这个静态工厂类负责所有对象的创建，如果有新的对象增加，或者某些对象的创建方式不同，就需要不断的修改工厂类，不利于后期的维护（如代码中pig对象的增加，则必须增加pig类并修改AnimalFactory工厂类）工厂方法模式
工厂方法模式提供一个抽象类(抽象工厂)还需要提供一个接口(工厂接口),每一个具体的类都有对应的工厂类(实现工厂接口)
具体对象的创建工作由继承抽象工厂的具体类实现
//抽象类
public abstract class Animal {
public abstract void 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 interface Factory {
//该工厂接口的方法的返回值是抽象工厂类
public abstract Animal creatAnimal() ;
}
//猫的工厂类--->创建一只猫
public class CatFactory implements Factory {
@Override
public Animal creatAnimal() {
return new Cat() ;
}
}
public class DogFactory implements Factory {
@Override
public Animal creatAnimal() {
return new Dog();
}
}
public class AnimalDemo {
public static void main(String[] args) {
//创建Factory对象
//接口多态的形式
Factory f = new CatFactory() ;
Animal a = f.creatAnimal() ;
a.eat();
System.out.println("-------------------");
f = new DogFactory() ;
a = f.creatAnimal() ;
a.eat();
}
}
优点:
客户端不需要在负责对象的创建(不需显示创建具体对象)，从而明确了各个类的职责，
如果有新的对象增加，只需要增加一个具体的类和具体的工厂类即可，不影响已有的代码，后期维护容易，增强了系统的扩展性。
弊端:书写代码量大了!
单例模式
单例模式核心思想:某些类的对象在创建的时候 ,在系统内存始终只有一个对象!单例模式分类:
1)饿汉式 2)懒汉式(类似于多线程环境..)
两种分类在设计上几乎一样:
1)定义个类,将该类的无参构造方法私有化
2)在该类的成员位置创建该类对象 并且一定要私有化,防止外界更改这个对象
3)在该类中提供静态成员方法(返回值就是创建的那个对象),能被当前类直接调用,static修饰
饿汉式:
在加载那个类的时候,对象的创建工作就已经完成了!
//学生类
public class Student {
//无参构造私有化,目的为了防止用户创建对象的时候,会产生多个对象!
//为了不让直接通过构造方法创建该类对象
private Student() {}
//成员位置创建该类的实例
//静态方法只能访问静态变量
//加入私有修饰
private static Student s = new Student() ; //静态的类变量
//提供一个公共的成员方法
public static Student getStudent() {
return s ;
}
}
public class StudentDemo {
public static void main(String[] args) {
//创建学生对象
//在内存中有多个对象了
/*Student s1 = new Student() ;
Student s2 = new Student() ;
System.out.println(s1==s2);*/ //false
//修改当前那个类的成员
//Student.s=null ;
//直接更改了对象的值，所以学生类中应用private修饰
Student s1 = Student.getStudent() ;
Student s2 = Student.getStudent();
System.out.println(s1==s2);//true
System.out.println(s1);//org.westos_03.Student@70dea4e
System.out.println(s2);//org.westos_03.Student@70dea4e
}
}懒汉式:
符合单例模式核心思想
1)自定义一个类,将无参构造私有化
2)在成员位置声明变量
3)提供公共静态功能,在里面判断的创建该类对象,返回该类对象
如果是开发中,那么就使用饿汉式(饿汉式它不会出现问题的单例模式)
如果是面试中,那么使用懒汉式(因为他是可能出现问题的一种单例模式)
面试题:
你使用过单例模式吗?简单介绍一种单例模式,请用代码设计
面试官想问的是:使用设计单例的懒汉式,能否想到使用同步机制解决线程的安全问题..
懒汉式(延迟加载 -->懒加载)
可能会出现问题
---> 多线程的问题
--->校验多线程安全问题的标准
1)是否是多线程环境
2)是否有共享数据
3)是否有多条语句对共享数据进行操作 (使用同步机制进行操作)
public class Teacher {
//无参构造私有化
private Teacher() {
}
//在成员位置声明变量
//私有化,并且用static修饰来实现数据共享
private static Teacher t = null ;
//提供公共的静态功能
/*public static Teacher getTeacher() {
//如何创建该类对象,需要用的时候在创建
//t1,t2,t3
//在这里需要判断
synchronized (t) {
if(t==null) {
t = new Teacher() ;
}
return t ;
}
}*/
//静态的同步方法 (锁对象: 类名.class)
public synchronized static Teacher getTeacher() {
if(t==null) {
t = new Teacher() ;
}
return t ;
}
}
public class TeacherDemo {
public static void main(String[] args) {
//调用getTeacher()功能
Teacher t1 = Teacher.getTeacher() ;
Teacher t2 = Teacher.getTeacher() ;
System.out.println(t1==t2);
System.out.println(t1);//org.westos_04.Teacher@70dea4e
System.out.println(t1);
}
}
Runtime类
每个 Java 应用程序都有一个 Runtime 类实例，使应用程序能够与其运行的环境相连接。
public static Runtime getRuntime()返回与当前 Java 应用程序相关的运行时对象
public Process exec(String command) throws IOException在单独的进程中执行指定的字符串命令。
public class RunTimeDemo {
public static void main(String[] args) throws IOException {
//创建Runtime类的实例
Runtime r = Runtime.getRuntime() ;
//开启某一个进程
//r.exec("calc") ;//开启计算器进程
//r.exec("notepad") ;//开启notepad进程
r.exec("mspaint") ;//开启画图进程
}
}