单例-设计模式

单个实例:
正常的类是可以创建无数个对象 。
但是某些应用场景中需要该类只能有一个对象,此时就需要将该类设计成单例 。

饿汉式单例模式

会在类加载时创建该类的实例,使用时直接用.

package com.zhiyou.singleton;

/**
 * @author QiuShiju
 * @date 2020/12/28
 * @desc
 */
public class Student {

    //1 构造方法要私有
    private Student(){}

    //3 设置属性
    private static Student student = new Student();

    //2 提供静态一个方法,获得该类的对象
    public static Student getInstance() {

        return student;
    }

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

public static void main(String[] args) {
    Student s1 = Student.getInstance( );
    Student s2 = Student.getInstance( );
    Student s3 = Student.getInstance( );
    // 得到的是同一个对象
    System.out.println(s1 );
    System.out.println(s2 );
    System.out.println(s3 );
}

`

懒汉式

在调用方法获得当前对象时,才会创建该对象.

package com.zhiyou.singleton;

/**
 * @author QiuShiju
 * @date 2020/12/28
 * @desc
 */
public class Student2 {
    // 3 定义属性
    private static Student2 student;

    // 1 构造方法私有
    private Student2() {}

    // 2 提供静态方法,获得当前类的对象
    public static Student2 getInstance() {
        if (student == null){
            student = new Student2();
        }
        return student;
    }




    private String name;

    public String getName() {
         return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

总结

饿汉式: 以空间换时间 , 开发中常用
懒汉式: 以时间换空间

枚举

没有枚举时

package com.zhiyou.enum_;

/**
 * @author QiuShiju
 * @date 2020/12/28
 * @desc
 */
public class Student {

    private int age;
    private String name;
    private Grade grade; // 成绩等级 A,B,C,D,E

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
          return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Grade getGrade() {
        return grade;
    }

    public void setGrade(Grade grade) throws Exception {
//        if(!grade.matches("[ABCDE]")){
//            throw new Exception("等级赋值不正确");
//        }
        this.grade = grade;
    }

    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", grade='" + grade + '\'' +
                '}';
    }
}

package com.zhiyou.enum_;

/**
 * @author QiuShiju
 * @date 2020/12/28
 * @desc 等级类
 */
public class Grade {

    private String name;
    // 1 私有构造方法
    private Grade() {}

    // 2 提供静态属性
    public static Grade A = new Grade("A");
    public static Grade B = new Grade("B");
    public static Grade C = new Grade("C");
    public static Grade D = new Grade("D");
    public static Grade E = new Grade("E");


    private Grade(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return name;
    }
}

package com.zhiyou.enum_;

/**
 * @author QiuShiju
 * @date 2020/12/28
 * @desc
 */
public class TestStudent {

    /**
     * 需求:
     *   给学生成绩赋值: 只能是A.B.C.D.E
     */
    public static void main(String[] args) throws Exception {
        Student s1 = new Student( );
        s1.setAge(18);
        s1.setName("张三");
        s1.setGrade(Grade.C);

        System.out.println(s1 );
    }
}

枚举

在JDK1.5后,出现了枚举类,简化了上面的操作
1)定义枚举类要用关键字enum

2)所有枚举类都是Enum的子类

3)枚举类的第一行上必须是枚举项，最后一个枚举项后的分号是可以省略的，但是如果枚举类有其他的东西，这个分号就不能省略。建议不要省略。
每个枚举项都是该枚举类的对象!

4)枚举每个都是静态常量,不允许其他修饰符修饰

5)枚举类可以有构造方法，但必须是private的，它默认的也是private的。
如果是空参构造，那么枚举项后可以省略（），也可以带上括号
如果是有参构造，那么枚举项后（）里面可以加参数;
如果枚举类中有且仅有一个构造方法,还是有参的,那么每个枚举项后都要加()传参数

6)枚举类可以有正常方法,且可以被调用执行
被枚举项调用执行

7)枚举类也可以有抽象方法，但是枚举项必须重写该方法

8)枚举类每个类都默认继承了Enum类,所以不能再继承其他类
但是可以实现接口,且重写其方法,并用枚举类的枚举项调用

9)枚举在switch语句中的使用

package com.zhiyou.enum_;

public enum GradeEnum {
    A(){
        @Override
        public void en2() {
            System.out.println("枚举项A重写en2方法" );
        }
    },B("B"){
        @Override
        public void en2() {

        }
    };

    private GradeEnum(){}

    private GradeEnum(String v){ }

    public void en1() {
        System.out.println("GradeEnum枚举类的方法执行了..." );
    }

    public abstract void en2();
}

练习: 成绩等级只能是A,B,C.D.E其中之一.(定义成枚举),但是输出结果时要求
枚举项A,输出90-100
枚举项B,输出80-89
枚举项C,输出70-79
枚举项D,输出60-69
枚举项E,输出0-59

public enum GradeEnum {
    A("90-100"),B("80-89"),C("70-79"),D("60-69"),E("不及格");

    private String value;

    private GradeEnum(String value){
        this.value = value;
    }

    @Override
    public String toString() {
        return value;
    }
}




public static void main(String[] args) throws Exception {
    Student s1 = new Student( );
    s1.setAge(18);
    s1.setName("张三");
    s1.setGrade(GradeEnum.C);

    System.out.println(s1 );

}

枚举类Enum的方法

int ordinal() 返回枚举常量的序数，注意从0开始
String name() 获得枚举常量的名称
String toString()
<T> T valueOf(String name) 返回指定名称的枚举常量
values() 返回所有枚举常量的数组集合

public class TestWeek {

    public static void main(String[] args) {
        Week one = Week.one;
        // 从0开始
        int i1 = one.ordinal( );
        System.out.println(i1 );

        System.out.println(Week.two.ordinal() );

        System.out.println(Week.three.ordinal() );
        System.out.println("-----" );
        System.out.println(Week.one.name() );
        System.out.println("-----" );
        Week one2 = Week.valueOf("one");
        System.out.println(one2 );
        System.out.println("-----" );
        // 从指定枚举类,获得指定枚举项
//        Week two = Enum.valueOf(Week.class, "four");
//        System.out.println(two );
        System.out.println("-----" );
        // 获得当前枚举类中所有枚举项,以数组返回
        Week[] values = Week.values( );
        for (Week week: values){
            System.out.println(week );
        }
    }
}

总结:

枚举类的主要作用 :
在方法的参数列表中定义参数类型为枚举类 , 那么在传参数时 , 参数值只能从枚举类的枚举项中选择 ! 不会再出现乱写的现象 。