关于几种模式和jdk不同版本新特性的总结

设计模式

一、 装饰设计模式

interface Coder {
			public void code();
		}
		
		class Student implements Coder {
		
			@Override
			public void code() {
				System.out.println("javase");
				System.out.println("javaweb");
			}
			
		}
		
		class ItcastStudent implements Coder {
			private Student s;						//获取到被包装的类的引用
			public ItcastStudent(Student s) {		//通过构造函数创建对象的时候,传入被包装的对象
				this.s = s;
			}
			@Override
			public void code() {					//对其原有功能进行升级
				s.code();
				System.out.println("数据库");
				System.out.println("ssh");
				System.out.println("安卓");
				System.out.println(".....");
			}
			
		} 

二、单例设计模式

public static void main(String[] args) {
		/*Singleton s1 = Singleton.getS();
		Singleton s2 = Singleton.getS();
		
		System.out.println(s1==s2);*/
		
		Singleton s1 = Singleton.s;
		Singleton s2 = Singleton.s;
		
		System.out.println(s1==s2);
	}
	
}//
/*class Singleton{
	private Singleton(){}//私有构造方法，不让其他类创建本类对象
	
	private static Singleton s = new Singleton();//创建本类对象
	
	public static Singleton getS(){//对外提供公共访问方式，
		return s;//返回本类对象
	}
}*/
//懒汉式  单例的延迟加载
/*class Singleton{
	private Singleton(){}//私有构造方法 ，不让其他类创建本类对象
	
	private static Singleton s ;//声明本类对象
	
	public static Singleton getS(){//对外提供公共访问方式
		if(s==null){
		//线程1，线程2 有可能创建多个对象
			s=new Singleton();//判断什么时候用什么时候创建对象
		}
		return s;
	}
}*/
/*饿汉式和懒汉式的区别
 * 都是单线程时
 * 饿汉是空间换时间
 * 懒汉式是时间换空间
 * 都是多线程时
 * 饿汉式没有安全隐患
 * 懒汉式是可能出现安全隐患的，因为有可能创建多个对象*/
class Singleton{
	private Singleton(){}//私有构造方法
	public final static Singleton s = new Singleton();
}//创建本类公共的静态的final修饰的对象

三、简单工厂设计模式

          简单工厂模式概述
        又叫静态工厂方法模式，它定义一个具体的工厂类负责创建一些类的实例
  优点
 客户端不需要在负责对象的创建，从而明确了各个类的职责
  缺点
 这个静态工厂类负责所有对象的创建，如果有新的对象增加，或者某些对象的创建方式不同，就需要不断的修改工厂类，不利于后期的维护

public abstract class Animal {
	public abstract void eat() ;
}
private AnimalFactory(){}					//不让其他类创建本类对象
	public static Animal createAnimal(String name) {
		if(name.equals("dog")) {
			return new Dog();
		}else if(name.equals("cat")) {
			return new Cat();
		}else {
			return null;
		}
	}

public class Cat extends Animal {

	@Override
	public void eat() {
		System.out.println("猫吃鱼");
	}

}

public class Dog extends Animal {

	@Override
	public void eat() {
		System.out.println("狗吃肉");
	}

}

四、工厂方法设计模式

         工厂方法模式概述
               工厂方法模式中抽象工厂类负责定义创建对象的接口，具体对象的创建工作由继承抽象工厂的具体类实现。
         优点
               客户端不需要在负责对象的创建，从而明确了各个类的职责，如果有新的对象增加，只需要增加一个具体的类和具体的工厂类即可，不影响已有的代                    码，后期维护容易，增强了系统的扩展性
         缺点
              需要额外的编写代码，增加了工作量

<pre name="code" class="java">public interface Factory {
	public Animal createAnimal();
}

public class DogFactory implements Factory {

	@Override
	public Animal createAnimal() {

		return new Dog();
	}

}

<pre name="code" class="java">public abstract class Animal {
	public abstract void eat();
}

public class Dog extends Animal {

	@Override
	public void eat() {
		System.out.println("狗吃肉");
	}

}

public class Cat extends Animal {

	@Override
	public void eat() {
		System.out.println("猫吃鱼");
	}

}

public static void main(String[] args) {
		DogFactory df = new DogFactory();
		
		Animal a = df.createAnimal();
		a.eat();
	}

五、适配器设计模式

 什么是适配器
     在使用监听器的时候, 需要定义一个类事件监听器接口.
     通常接口中有多个方法, 而程序中不一定所有的都用到, 但又必须重写, 这很繁琐.
     适配器简化了这些操作, 我们定义监听器时只要继承适配器, 然后重写需要的方法即可.
 b.适配器原理
     适配器就是一个类, 实现了监听器接口, 所有抽象方法都重写了, 但是方法全是空的.类设为抽象 ，不让其他类创建本类对象调用本类方法，没有私有构造，为了让子类重写本类方法。
     目的就是为了简化程序员的操作, 定义监听器时继承适配器, 只重写需要的方法就可以了.

六、模板设计模式

public static void main(String[] args) {
		/*long start = System.currentTimeMillis();				//记录开始时间
		for(int i = 0; i < 100000; i++) {
			System.out.println("x");
		}
		long end = System.currentTimeMillis();					//记录结束时间
		
		System.out.println(end - start);*/
		
		Demo d = new Demo();
		System.out.println(d.getTime());
	}

}

abstract class GetTime {
	public final long getTime() {
		long start = System.currentTimeMillis();				//记录开始时间
		code();
		long end = System.currentTimeMillis();					//记录结束时间
		
		return end - start;
	}

	public abstract void code();
		
}

class Demo extends GetTime {

	@Override
	public void code() {
		int i = 0;
		while(i < 1000000) {
			System.out.println("x");
			i++;
		}
	}
}

JDK1.5新特性

 1,自动拆装箱

    Integer i = 100; 自动装箱

     i = i+1;    自动拆箱

 2,泛型

好处：

一是提高了安全性

二是省去了强制类型转换

不适用泛型

List li = new ArrayList();
li.put(new Integer(3));
Integer i = (Integer) li.get(0);

使用泛型
List<Integer> li = new ArrayList<Integer>();
li.put(new Integer(3));
Integer i = li.get(0);

 3,可变参数

就是可变的数组。例：int ...arr
 4,静态导入

import static java.lang.System.out;//导入java.lang包下的System类的静态方法out;
public class HelloWorld{
 public static void main(String[] args){
 out.print("Hello World!");//既是在这里不用再写成System.out.println("Hello World!")了，因为已经导入了这个静态方法out。
 }
}
import xxxx 和 import static xxxx的区别是前者一般导入的是类文件如import java.util.Scanner;后者一般是导入静态的方法，import static java.lang.System.out;

 5,增强for循环

public class DemoFor {
	public static void main(String[] args) {
		//demo1();
		ArrayList<Student> list = new ArrayList<>();
		list.add(new Student("李四",23));
		list.add(new Student("李桶",26));
		list.add(new Student("李盆",25));
		list.add(new Student("李完",28));
		
		
		for (Student s : list) {//增强for循环
			
			System.out.println(s.getName()+" ,"+ s.getAge());
		}
	}

	private static void demo1() {
		ArrayList<String> list = new ArrayList<>();
		list.add("a");
		list.add("b");
		list.add("c");
		list.add("d");
		
		for (String s: list) {//元素数据类型  变量名： 集合或数组
			System.out.println(s);
			
		}
	}
	
}

 6,互斥锁

           同步
   使用ReentrantLock类的lock()和unlock()方法进行同步
   通信
   使用ReentrantLock类的newCondition()方法可以获取Condition对象
   需要等待的时候使用Condition的await()方法, 唤醒的时候用signal()方法
   不同的线程使用不同的Condition, 这样就能区分唤醒的时候找哪个线程了
 7,枚举
是指将变量的值一一列出来,变量的值只限于列举出来的值的范围内。

JDK1.7新特性

        一、二进制字面量

  二、数字字面量可以出现下划线

  三、switch 语句可以用字符串

四、泛型简化,菱形泛型

 五、异常的多个catch合并

            每个异常用或|
 六、try-with-resources 语句

可以看到try语句多了个括号，而在括号里初始化了一个BufferedReader。

这种在try后面加个括号，再初始化对象的语法就叫try-with-resources。