面向对象6-常用设计模式以及Lambda表达式

面向对象6

本章目标

1. 了解什么是设计模式

   • 单例
   • 工厂
   • 代理

2. Java8特性Lambda表达式的使用

3. 枚举

什么是设计模式

设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思维方式

1.单例模式

采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象的实例方法

过程

/** 1.构造方法私有化* 

2.声明一个当前对象			2.1. 直接实例化 2.2. 方法中实例化

3.声明一个静态方法返回 返回值就是类的类型** */

实现单例模式需要满足的三个条件

1. 单例类只能有一个实例
2. 单例类必须自己创建自己的唯一实例
3. 单例类必须给所有其他对象提供这一实例

懒汉式与和饿汉式

1. 饿汉式

   public class Ehs{
   
   private static final Ehs ehs = new Ehs();//声明一个对象
   
   private Ehs(){
   //构造方法私有化
   }
   public static Ehs getEhs(){
   	return ehs;
   }
      
      public static void main(String []args){
        Ehs ehs1 = getEhs();
        Ehs ehs2 = getEhs();
         System.out.println(ehs==ehs2);
         //输出为true
      }
      
   }
   

   2.懒汉式

   public class Lhs{
   	private static Lhs s1 = null;
   	
   	private Lhs(){
   	//构造方法私有化之后，在class之外的其他类中将无法直接创建对象实例；因为无法访问私有构造方法
   	}
   	
   	//Q2 外界能访问该对象，且每次都是同一个对象---书写一个方法的返回值就是当前类类型
   	public static Lhs getLhs(){
   	if(s1=null){
   			s1 = new Lhs();
   		}
   		return s1;
   	//此时s1如果不是null说明已经被实例化了，如果此时仍然对其new对象则会产生第二个对象，故返回原s1
   	}
   	
   	public static void main(String []args){
   		Lhs ss = getLhs();
   		Lhs ss2 = getLhs();
   		ss=ss2;//true
   	
   	}
   }
   

   区别

   1. 饿汉式当类加载完毕时，就已经完成了对象的初始化。保证在get方法使用时，就已经存在单例
   2. 懒汉式即当采用get方法后才开始进行单例的初始化
   3. 资源利用效率上：懒汉式>饿汉式 速度：懒汉式<饿汉式
   4. 懒汉式存在线程不安全，可以使用多线程修复

单例模式应用实例

1. 网站计数器
2. 多线程的线程池设计
3. 应用程序的日志应用
4. Spring框架中的bean默认为单例模式

2.工厂模式

Factory Pattern 是Java中最常见的设计模式之一，属于创建型模式，提供了一种创建对象的最佳方式

通过一个共同的接口来指向新创建的对象

意图：让子类自己决定实例化哪一个工厂类

例如：Cat和Dog都实现了Pet的eat方法，但是Cat执行吃fish，Dog吃bone

public interface Pet{
 void eat();
}

public dog implements Pet{
public void eat(){
	System.out.prinlnt("Bone");
						}
}

public cat implements Pet{
pbulic void eat(){
	System.out.println("Fish");
}
}


public class Master{
	public static Pet returnPet(String name){
	if(name.equals("dog")){
	return new dog();
	}
	else if(name.equals(cat")){
	return new cat();
	}
	return pet;
	}
}


public class Test{
public static void main(String []args){
	Pet pp = Master.returnPet("dog");
	pp.eat();

}
}

工厂模式与前几节的内容基本一致，不再详细展开说

3.代理模式

为其他对象提供一个代理控制这个对象的访问

object接口

public interface Object {
    void action();
}

object实现类

public class ObjectImpl implements Object {
    @Override
    public void action() {
        System.out.println("O==============================");
        System.out.println("ObjectImpl.action");
        System.out.println("O==============================");
    }
}

object代理类

public class ProxyObject implements Object {
    Object obj;
    
    public ProxyObject(){
        System.out.println("ProxyObject代理类");
        obj=new ObjectImpl();
    }
    
    @Override
    public void action() {
        System.out.println("ProxyObject.Act");
        obj.action();//important,唯一的实现类
        System.out.println("ProxyObject.End");
    }
}

测试类

public class Test {
    public static void main(String[] args) {
        Object oo = new ProxyObject();
        oo.action();
    }
}

代理模式优缺点

1. 优点
   • 职责清晰
   • 高拓展性
   • 智能化
2. 缺点
   • 速度可能变慢
   • 部分代理模式实现起来十分复杂

Java8 Lambda表达式

允许将函数作为参数写入方法中

package javalearning.Practice.Lambda;

/**
 * @author chenxu
 * @date 2020/11/2 - 14:15
 */
public class Lbd {


    public static void main(String[] args) {
        Lbd lbd = new Lbd();
        Math011 hhh =(int a,int b)->a+b;
        System.out.println(lbd.opreate(5,5,hhh));
    }
    
    public  int opreate(int a,int b,Math011 math01){
        return math01.operation(a,b);
    }
}

interface Math011{
    public abstract int operation(int a,int b);
}

Lambda例子2

package javalearning.kkb7oob7.LambdaDemo;

/**
 * @author chenxu
 * @date 2020/11/1 - 0:31
 */
public class GreetDemo {
    public static void main(String[] args) {

        GreetService gs = message -> System.out.println("GreetDemo.main"+message);
        gs.Greeting("1113333111111");
    }

    interface GreetService{
        void Greeting(String string);
    }
}

枚举

enum不可以继承另外一个类，也不能被另外一个类所继承；

代码案例1

package javalearning.kkb7oob7.EnumDemo;

/**
 * @author chenxu
 * @date 2020/10/31 - 17:28
 */
public class Demo1 {
    enum Week{
        Monday,Tuesday,Wednesday
    }

    public static void main(String[] args) {
        Week day1 = Week.Monday;
        Week day2 = Week.Tuesday;
        System.out.println(day1.toString());
        System.out.println(day1.name());
        System.out.println(day1.ordinal());
        System.out.println(day1.getDeclaringClass());
    }
    
}
输出结果为：
Monday
Monday
0
class javalearning.kkb7oob7.EnumDemo.Demo1$Week

Demo2

 	package javalearning.kkb7oob7.EnumDemo;

/**
 * @author chenxu
 * @date 2020/10/31 - 17:41
 */
public class Traffci {
    enum Light{red,yellow,green
    }

    public static void main(String[] args) {
        Light red = Light.red;


        System.out.println( showLight(red));
        System.out.println( showLight(Light.green));

    }
    
    public static String showLight(Light light){
        String string = "Traffci is broken ";
        switch (light){
            case red:
                string="red";
                break;
            case green:
                string="greed";
                break;
            case yellow:
                string="yellow";
                break;
            default:break;
        }
        return string;
    }
    
}
OUT:
red
greed

Demo3

package javalearning.kkb7oob7.EnumDemo;

/**
 * @author chenxu
 * @date 2020/11/1 - 0:36
 */
public class DemoExam {
    enum Score{
        A,B,C,D,E,F
    }
    public static void main(String[] args) {
        Score one = Score.A;
        Score two = Score.B;
        ReturnMarks(one);
    }
    public static void ReturnMarks(Score string){
        switch (string){
            case A:
                System.out.println("100");
                break;
            case B:
                System.out.println("90");
                break;
            case C:
                System.out.println("DemoExam.ReturnMarks");
                break;
            default:
                System.out.println("------------------");
        }
    }
    
}
out:100