25.设计模式和原则+枚举和注解

@一贤不穿小鞋

1.设计模式

• 前人经过项目经验的总结,得到的一套对特定问题的特定解决方案.(23种)
  

2.(了解)工厂模式：将程序中创建对象的工作交给工厂类的方法去完成.

• 优点:使用者再也不用管创建对象的工作,交给工厂类去创建对象.
• 缺点:整个项目全依赖工厂类.
• 案例:用反射实现工厂模式.

eg:/**
 * 工厂类
 * @author sx
 * @version 1.0 2020年11月9日
 */
public class ObjectFactory {
	/**
	 * 通过全限定类名得到类的实例对象
	 * @param className
	 * @return Object
	 */
	public static Object getObject(String className) {
		Object ob=null;
		try {
			//通过全限定类名得到类(反射)对象
			Class clzaa=Class.forName(className);
			ob=clzaa.newInstance();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return ob;
	}
}

3.单例模式:一个类只有一个对象.

• 优点:节省创建对象所消耗的系统资源.
• 实现方式:私有化构造方法,再声明一个私有的静态的当前这个类的对象的属性, 提供一个公有的静态的方法获得这个对象.

3.1:饿汉式单例模式:在声明类的对象属性时直接创建对象.

• 优点:相较于懒汉式单例模式,线程安全.
• 缺点:相较于懒汉式单例模式,耗内存.

eg:/**
 * 饿汉式单例模式
 * @author sx
 * @version 1.0 2020年11月9日
 */
public class King {
	public String kname;
	public String cloths;
	public Integer wifeCount;
	
	/**
	 * 私有构造方法
	 * @param kname
	 * @param cloths
	 * @param wifeCount
	 */
	private King(String kname, String cloths, Integer wifeCount) {
		super();
		this.kname = kname;
		this.cloths = cloths;
		this.wifeCount = wifeCount;
	}
	
	/**
	 * 声明一个私有静态的对象属性
	 */
	private static King k1=new King("小明", "黄袍子", 3000);
	
	/**
	 * 公有的静态的获得对象的方法
	 * @return
	 */
	public static King getKing() {//1,2
		return k1;
	}
}

3.2:懒汉式单例模式:在声明类的对象属性时,不创建对象,在公有的静态方法中创建对象.

• 优点:相较于饿汉式单例模式,省内存.
• 缺点:相较于懒汉式单例模式,线程不安全.想要安全用线程同步.

eg:/**
 * 懒汉式单例模式
 * @author sx
 * @version 1.0 2020年11月9日
 */
public class Boss {
	/**
	 * 私有构造方法
	 */
	private Boss() {
		
	}
	
	/**
	 * 私有的静态的对象属性
	 */
	private static Boss b2;
	
	/**
	 * 公有的静态的获得对象的方法
	 * @return Boss
	 */
	public synchronized static Boss getBoss() {
		if (b2==null) {//1,2,3
			b2=new Boss();
		}
		return b2;
	}
}

4.(扩展)设计原则

• 前人经过项目经验的总结,得到一套开发Java的规则.如果在写Java代码时遵循这些设计原则,就符合Java开发规则.也符合java提倡高内聚,低耦合.
• 内聚性:独立性.
• 耦合度:类与类之间依赖性.

4.1:单一职责原则

• 一个类只负责一种职责.
• 作用:降低类与类之间耦合度.

4.2:里氏替换原则

• 只要父类出现的地方，都可以用子类替换.
• 作用:提高程序的可扩展性和可维护性.

4.3:依赖倒置原则

• 能依赖于抽象的,就不依赖于具体的.
• 作用:提高程序的可扩展性和可维护性.

4.4:接口隔离原则

• 一个接口只被设计一种功能.
• 作用:提高程序灵活性.

4.5:迪米特法则

• 一个对象要对其他对象保持尽可能少的了解，即低耦合性.
• 作用:可以最大限度的保证代码的可复用性

4.6:开闭原则

• 对扩展开放
• 对修改关闭.

总结:
1.java8中方法引用.
2.Java8中Stream(重点)
3.java8中新日期(重点)
4.设计模式(重点)
5.设计原则(重点)

1.枚举类型:数据类型的值是固定.

1.1:枚举类型的作用

• 限定变量的取值.

1.2:枚举优点

• 方便,安全性好.

1.3:枚举类型特点

• 是一种引用数据类型,继承自java.lang.Enum,是终止类,它的值是静态常量.

1.4:声明枚举类型语法:

		public enum 类型名{
			值1,值2,值3...;
			//声明普通方法
			访问修饰符 返回值类型 方法名(形参列表){
				方法体;
				[return 结果;]
			}
			//声明静态方法
			访问修饰符 static 返回值类型 方法名(形参列表){
				方法体;
				[return 结果;]
			}
		}

1.5:使用枚举类型的语法:

1.5.1:用枚举类型作为变量的数据类型

• 枚举类型名 变量名=枚举类型名.值1;

1.5.2:调用枚举类型的普通方法

• 变量名.普通方法名(实参列表);

1.5.3:调用枚举类型的静态方法

• 变量名.静态方法名(实参列表);
• 枚举类型名.静态方法名(实参列表);

eg:/**
 * 自定义枚举类型
 * @author sx
 * @version 1.0 2020年11月10日
 */
public enum MySex {
	男,女,woman,man;

	/**
	 * 普通实例方法
	 */
	public void show1() {
		System.out.println("这是一个普通方法");
	}
	/**
	 * 静态方法
	 */
	public static void show2() {
		System.out.println("这是一个静态方法");
	}
}

/**
 * 学生类
 * @author sx
 * @version 1.0 2020年11月10日
 */
public class Student {
	public String sname;
	//用枚举类型作为属性的数据类型,属性的取值范围就固定
	public MySex ssex;
	@Override
	public String toString() {
		return "Student [sname=" + sname + ", ssex=" + ssex + "]";
	}
}

public static void main(String[] args) {
		//创建学生对象
		Student stu1=new Student();
		//用对象调用属性并赋值
		stu1.sname="张三";
		stu1.ssex=MySex.男;
		
		//用枚举类型的属性去调用实例方法和静态方法
		stu1.ssex.show1();
		stu1.ssex.show2();
		
		//用枚举类型来调用静态方法
		MySex.show2();

		System.out.println(stu1);
	}

2.注解:是代码里的特殊标记,程序可以读取注解,一般用于替代配置文件.

2.1:常见注解:

• @Override 表示该方法是重写方法
  
• @FunctionalInterface 表示该接口是函数式接口
• @Deprecated 表示该类或该方法或该属性过时,不再推荐使用.
  
• @SuppressWarnings(“unchecked”) 表示压制警告.不检查方法的警告，忽略类型的警告。
  

2.2:定义注解:@interface关键字,注解中只能包含属性.

2.3:注解属性类型:String类型,基本数据类型,Class类型,枚举类型,注解类型,以上类型的一维数组.

2.4:元注解:用来描述注解的注解.

• @Retention用于指定注解可以保留域
• @Target指定注解用于修饰类的那个成员

eg:/**
 * 自定义注解
 * @author sx
 * @version 1.0 2020年11月10日
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(value= {ElementType.FIELD,ElementType.METHOD})
public @interface MyAnnotation {
	public String mname() default "唐三";
	public int mage() default 20;
}
	
		/**
 * 老师类
 * @author sx
 * @version 1.0 2020年11月10日
 */
public class Teacher {
	@MyAnnotation
	public String tname;
	
	@MyAnnotation(mname="小舞",mage=18)
	public void show1() {
		
	}
}

		public static void main(String[] args) throws Exception {
		//获得类的反射(类)对象
		Class<Teacher> clazz=(Class<Teacher>) Class.forName("com.qf.day26.demo4.Teacher");
		
		//获得属性的反射对象
		Field tnameField=clazz.getDeclaredField("tname");
		//通过属性的反射对象获得属性上注解对象
		MyAnnotation m1= tnameField.getAnnotation(MyAnnotation.class);
		System.out.println(m1);
		//通过注解对象调用属性
		System.out.println(m1.mname()+","+m1.mage());
		
		
		//获得方法的反射对象
		Method show1Method=clazz.getDeclaredMethod("show1");
		//通过方法的反射对象获得方法上的注解对象
		MyAnnotation m2=show1Method.getAnnotation(MyAnnotation.class);
		System.out.println(m2);
		//通过注解对象调用属性
		System.out.println(m2.mname()+","+m2.mage());
	}