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

设计模式

一、 装饰设计模式

interface Coder {public void code();}class Student implements Coder {@Overridepublic void code() {System.out.println("javase");System.out.println("javaweb");}}class ItcastStudent implements Coder {private Student s;//获取到被包装的类的引用public ItcastStudent(Student s) {//通过构造函数创建对象的时候,传入被包装的对象this.s = s;}@Overridepublic 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 {@Overridepublic void eat() {System.out.println("猫吃鱼");}}public class Dog extends Animal {@Overridepublic void eat() {System.out.println("狗吃肉");}}

四、工厂方法设计模式

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

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

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

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

public class Dog extends Animal {@Overridepublic void eat() {System.out.println("狗吃肉");}}

public class Cat extends Animal {@Overridepublic 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 {@Overridepublic 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。