（一）、枚举类：
关键字：enum
语法：public enum 枚举类名{ 对象}
适用场景：当对象的个数固定，且有限。
例子：
public enum Sex{
MAlE,
FEMALE;
public void test(){};//枚举中定义方法，MALE，FEMALE对象都有这个方法
private string cnName;
Sex(String cnName){this.cnName=cnName}；//构造方法，不能定义成public，对象有限。
}
测试类中：获取枚举类的序号：Sex.MALE.ordinal()。
把枚举对象转为字符串：Sex.MALE.name();
把字符串转为枚举对象Sex.valueof();
虚拟机中的枚举对象只会有一份，可以用==来比较，定义几个对象就有几个。
获取枚举中的所有对象：Sex.values();返回值Sex[]数组。
枚举类中也可以有方法，构造方法，属性，但是构造方法不能是公共的，枚举类型也不能继承。
代码实现：
public enum Sex {
//枚举类，对象固定且有限
MALE("男"),
FEMALE("女");
//构造方法不能加public
//因为对象数是固定的有限个
private String chName;
Sex(String chName){
this.chName=chName;
}
public String getChName() {
return chName;
}
//枚举类中可以定义方法，
public void test(){
System.out.println("我是枚举类中的test方法");
}
}
public class SexTestEnum {
public static void main(String[] args) {
int i1= Sex.MALE.ordinal();//返回此枚举常量的序号
int i2=Sex.FEMALE.ordinal();
System.out.println(i1);
System.out.println(i2);
Sex.MALE.test();//调用方法
Sex.FEMALE.test();
System.out.println(Sex.MALE.name());//把枚举对象转为字符串
System.out.println(Sex.FEMALE.toString());//把枚举对象转为字符串
System.out.println(Sex.MALE.getChName());
Sex sex = Sex.valueOf(Sex.MALE.name());//把字符串转为枚举对象
System.out.println(sex);
Sex[] sexs= Sex.values();//获取枚举类型中的所有对象
for(Sex sex1:sexs){
System.out.println(sex1);
}
}
}（二）、设计模式((Design pattern)重要)
定义：就是编程中的一些套路；目的让我们的代码实现特定的目的，结构上更加优秀。
GOF(group of Four)—总结出了23种设计模式；
1.单例模式(singleton)
(1).定义：虚拟机中这个类只有一个实例（一个对象）；
(2).饿汉式单例模式：（一开始就创建好了）
第一步：让构造方法私有，别人没办法创建此类对象；
第二步：自己创建这个实例对象；//定义成私有的，静态的
第三步：定义静态方法，获取唯一实例；
代码如下：
//设计模式之饿汉单例模式
public class Singleton1 {
//第一步：让构造方法私有
private void Singleton1(){}
//第二步：自己创建这个类的实例对象
private static final Singleton1 st1=new Singleton1();
//第三步：定义静态方法，获取唯一实例
public static Singleton1 getInstance(){
return st1;
}
}
测试类：
public class Singleton1Test {
public static void main(String[] args) {
Singleton1 st1= Singleton1.getInstance();
Singleton1 st2=Singleton1.getInstance();
System.out.println(st1==st2);//true证明只有一个对象
}
}(2).懒汉式单例模式：（用到实例对象时才创建，不像饿汉式那样随着类的加载就创建）
第一步：构造方法私有；
第二步：只声明有实例对象，不创建；
第三步：在获取实例方法中创建对象；注意要进行判断对象是不是刚开始的null，
第一次才创建对象，后面就不创建了，注意在方法上也要加上锁synchronized，保证在多线程下单例的安全。
注：静态方法上的synchronized锁住类对象，普通方法锁住this对象；
//设计模式之懒汉单例模式
public class Singleton2 {
//第一步私有化构造函数
private Singleton2(){}
//第二步只声明实例对象，不实现
private static Singleton2 ST;
//第三步定义获取实例方法，并实现实例对象创建
//在多线程时 为了保证安全，需加锁Syncthronize
public synchronized static Singleton2 getInstance(){
//进行判断，只有第一次时才创建对象
if(ST==null){
ST=new Singleton2();
}
return ST;
}
}(3).用枚举类实现单例 (属于饿汉式单例);
//枚举类型创建单例模式
public enum Singleton3 {
ST;
}
(4).懒汉式单例改进：
在（2）中的懒汉式模式中，在多线程中，每次调用方法都要加锁，锁很浪费资源，所以现在有了一个改进方法，采用静态内部类， 在多线程中第一次枷锁，第二次及以后不加锁；
第一步：私有化构造；
第二步：用静态内部类创建唯一实例；（类只加载一次，所以只创建了一次对象）
第三步：获取唯一实例；
代码如下：
//懒汉式单例模式的改进，采用静态内部类
public class Singleton4 {
//第一步私有化构造
private Singleton4(){}
//第二步用静态内部类创建唯一实例
static class Inner{
static Singleton4 ST=new Singleton4();
}
//第三步获取实例
public static Singleton4 getInstance(){
return Inner.ST;
}
}2.享元模式 flyweight
(1).提倡重用已有的对象，而不是创建新的对象；
Integer的享元范围：-128到127；
后面学习连接池时也会用到享元模式：对数据库连接对象进行重用。
public class Flyweight {
public static void main(String[] args) {
//Integer类的源码就是享元模式，享元范围是-128到127
System.out.println(Integer.valueOf(1)==Integer.valueOf(1));//true
System.out.println(Integer.valueOf(127)==Integer.valueOf(127));//true
System.out.println(Integer.valueOf(200)==Integer.valueOf(200));//false
}
}3.原型模式prototype
(1).根据已有对象来创建新的对象，克隆；
(2).要求：需要实现一个接口：Cloneable，并且需要重写其父类Object中的c lone()方法。
代码如下：
public class Prototype implements Cloneable{
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
private String name;
private int age;
private Date birthday;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
}
测试类：
public class PrototypeTest1 {
public static void main(String[] args) throws CloneNotSupportedException {
copy();//浅拷贝
}
private static void copy() throws CloneNotSupportedException {
Prototype pt = new Prototype();
pt.setName("小明");
pt.setAge(18);
pt.setBirthday(new Date());
System.out.println(pt.getName());
System.out.println(pt.getAge());
System.out.println(pt.getBirthday());
System.out.println("==================");
//克隆的另一个对象
Prototype pt2= ( Prototype )pt.clone();
System.out.println(pt==pt2);//false
pt2.setName("小红");
System.out.println("新克隆用户的名字:"+pt2.getName());
System.out.println("小明的名字:"+pt.getName());
pt2.getBirthday().setDate(15);
//新克隆用户的生日改变了，随之也把小明的生日改变了
//克隆对于引用数据类型仅仅复制的是地址，内容没有复制，
// 同一个地址中，内容改变了，其他引用此地址的对象的内容随之改变。
System.out.println("新克隆用户的生日："+pt2.getBirthday());
System.out.println("小明的生日："+pt.getBirthday());
}
}(3).使用场景：当对象属性非常多时，希望新的对象的大部分属性是从原对象复制过来的。
(4)常遇到的问题：浅拷贝与深拷贝
刚才的Cloneable是浅拷贝，也就是说对象的属性仅仅是复制了地址，没有把内容
复制一份。当更改克隆出来的引用数据类型对象时，也会把原来对象的值也给改变（基本类型用浅拷贝可以完全拷贝，引用数据类型要用深拷贝）。
深拷贝是指所有的内容都得是全新的，深拷贝可以用反序列化来完成。
代码如下：
//深拷贝，采用反序列化流，需要实现Serializable接口
public class Prototype2 implements Cloneable,Serializable {
@Override
protected Object clone() {
// return super.clone();不再直接使用父类的克隆方法了
//定义了一个字节数组流
ByteArrayOutputStream bos=new ByteArrayOutputStream();
try {
//定义一个序列化流
ObjectOutputStream os=new ObjectOutputStream(bos);
os.writeObject(this);//把当前对象写入字节数组流
//取出字节数组
byte[] bytes=bos.toByteArray();
//反序列化为对象
ByteArrayInputStream bis=new ByteArrayInputStream(bytes);
ObjectInputStream ois=new ObjectInputStream(bis);
return ois.readObject();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
return null;
}
private String name;
private int age;
private Date birthday;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
}测试类同浅拷贝一样，只是输出结果中新克隆用户的生日改变了，小明的生日将不再改变了。
4.建造器模式：（Builder）
问题：person
String sex ; string name; Integer weight;
目的：让创建对象的过程更为灵活；适用于一步一步创建更为复杂的某些属性。
代码如下：
public class Person {
private String name;
private String sex;
private Integer weight;
private Integer height;
public Person(String name,String sex,Integer weight,Integer height){
this.name=name;
this.sex=sex;
this.weight=weight;
this.height=height;
}
//建造器
public static class PersonBuilder{
private String name;
private String sex;
private Integer weight;
private Integer height;
//返回值是构造器本身
public PersonBuilder name(String name){
this.name=name;
return this;
}
public PersonBuilder sex(String sex){
this.sex=sex;
return this;
}
public PersonBuilder weight(Integer weight){
this.weight=weight;
return this;
}
public PersonBuilder height(Integer height){
this.height=height;
return this;
}
//定义一个方法，搜集信息，返回类型为Person类
public Person build(){
return new Person(name,sex,weight,height);
}
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", sex='" + sex + '\'' +
", weight=" + weight +
", height=" + height +
'}';
}
}
测试类：
public class PersonTest {
public static void main(String[] args) {
//可以打点连调是因为返回的类型就是PersonBuilder类，
//这就是建造器中的方法为什么要返回PersonBulider类型的原因。
Person p1=new Person.PersonBuilder()
.name("小明")
.sex("男")
.weight(60).build();
System.out.println(p1);
Person p2=new Person.PersonBuilder()
.name("小红")
.height(160)
.build();
System.out.println(p2);
}
}5.迭代器模式（iterator）
（1）.定义：以一种一致的方式对集合内的元素进行遍历，而不在乎集合的数据结构。
(2)for(Object o:list)的底层就是迭代器模式。
6.策略模式（strategy）
(1)Java集合或者数组的排序算法；
基本数据类型：双基点的快速排序；
对象类型：TimSort(早期的JDK使用归并排序)；
规模小：插入排序；
(2)排序的算法是固定的，排序的规则能否固定-------不能。
把排序的规则抽出来， 形成比较器接口（Comparator），不同比较器的实现称之为策略。
(3)Open close 开闭原则；
算法不能更改-----体现的是close原则；
比较器可以改------体现的是open原则；
代码如下：
public class StrategyStudent {
public static void main(String[] args) {
Student s1=new Student("Zhangsan",12);
Student s2=new Student("Lisi",19);
Student s3=new Student("Bob",10);
Student s4=new Student("Wangming",21);
Student s5=new Student("Tommy",16);
Student s6=new Student("Tommy",19);
List<Student> list=new ArrayList<>();
list.add(s1);
list.add(s2);
list.add(s3);
list.add(s4);
list.add(s5);
list.add(s6);
//按年龄从小到大顺序输出
Collections.sort(list, ( o1, o2) -> {return o1.getAge()-o2.getAge(); });
System.out.println(list);
//按年龄从大到小顺序输出
Collections.sort(list, new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
return -o1.getAge()-o2.getAge();
}
});
System.out.println(list);
//按姓名字母的字典顺序输出
Collections.sort(list, new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
return o1.getName().compareTo(o2.getName());
}
});
System.out.println(list);
//先按名字再按年龄排
Collections.sort(list,(o1,o2)->{
int b=o1.getName().compareTo(o2.getName());
if(b==0){
return o1.getAge()-o2.getAge();
}else{
return b;
}
});
System.out.println(list);
}
}
Student类如下：
public class Student {
private String name;
private int age;
public Student(String name,int age){
this.name=name;
this.age=age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
