Day 07-知识点汇总

public class A {

    //第一步：把类的构造器私有。
    private A(){}

    // 第二步：定义一个静态变量记住类的一个对象。
    private static  A a = new A();

    //第三步：定义一个静态方法，返回对象。
    public static A getInstance(){
        return a;
    }

}

public class Demo011 {

    public static void main(String[] args) {
        //单例模式对象是无法自己new的
        // A a0 = new A(); //报错，没有可以调用的构造器

        //获取A对象
        A a1 = A.getInstance();
        A a2 = A.getInstance();
        System.out.println(a1);
        System.out.println(a2);
        //结论：获取的单例对象内存地址一样，只有1个对象
    }
}

public class B {

    /*
    *  懒汉式单例模式开发步骤：
    *   第一步：把类的构造器私有。
        第二步：定义一个静态变量记住类的一个对象,不能初始化
        第三步：提供一个静态方法，在方法中判断并创建对象返回
    * */
    //第一步：把类的构造器私有。
    private B(){}

    // 第二步：定义一个静态变量记住类的一个对象,不能初始化
    private static B b;

    //第三步：提供一个静态方法，在方法中判断并创建对象返回
    //这个懒汉式不是最终代码，因为存在线程安全问题，等以后学习完多线程再优化
    public static B getInstance(){
        if(b==null){
            b = new B();
        }
        return b;
    }

}

public class Demo011 {

    public static void main(String[] args) {
        //单例模式对象是无法自己new的
        // A a0 = new A(); //报错，没有可以调用的构造器

        //获取A对象
        A a1 = A.getInstance();
        A a2 = A.getInstance();
        System.out.println(a1);
        System.out.println(a2);
        //结论：获取的单例对象内存地址一样，只有1个对象

        //获取B对象
        B b1 = B.getInstance();
        B b2 = B.getInstance();
        System.out.println(b1);
        System.out.println(b2);
    }
}

修饰符 enum 枚举类名{       
名称1 ,  名称2, ... ; 
       其他成员…
}

package com.itheima._02枚举;

/**
 * 枚举类: 一种特殊类。
 *  作用：用于输入限制一组有效的数据，可读性更好
 */
public enum Gender {

    //第一行(用的多)
    MAN,//原理 public static final Gender MAN =  new Gender()
    WOMAN("女");//原理 public static final Gender WOMAN = new Gender("女")

    //第二行开始（用的少）
    //成员变量
    private String value;
    public void setValue(String value) {
        this.value = value;
    }
    public String getValue() {
        return value;
    }

    //构造器
    // public Gender(){} 报错
    private Gender(){}
    Gender(String value){//修饰符没有写也是private
        this.value = value;
    }


    //定义枚举注意事项
    // 1.枚举类的第一句只能罗列一些名称，这些名称都是常量，并且每个常量会记住枚举类的一个对象。
    // 2.枚举类中，从第二句（行)开始，可以定义类的其他各种成员（成员变量、成员方法、构造器)。
    // 3.枚举都是最终类，不可以被继承，枚举类都是继承java.lang.Enum类的。
    // 4.举类的构造器都是私有的（写不写都只能是私有的），因此，枚举类对外不能创建对象。
    // 5.编译器为枚举类新增了几个静态方法，用于获取所有枚举对象或者某个枚举对象。
    //     public static 枚举类[] values();   返回所有枚举对象
    //     public static 枚举类 valueOf(java.lang.String); 返回单个枚举对象
}

package com.itheima._02枚举;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * @Description Student
 * @Author songyu
 * @Date 2026-02-06  11:08
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Student {

    private String name;
    private int age;
    // private String gender;//性别用字符串好不好？答：不好，输入任何值都可以，可能输入无效的数据
    private Gender gender;//使用枚举进行限制性别的输入，可读性（用的少）
}

package com.itheima._02枚举;

import java.util.Arrays;

/**
 * @Description Demo021
 * @Author songyu
 * @Date 2026-02-06  11:06
 */
public class Demo021 {

    public static void main(String[] args) {
        //创建对象
        Student s1 = new Student("播仔", 20, Gender.MAN);
        Student s2 = new Student("播妞", 19, Gender.WOMAN);

        //打印学生信息
        System.out.println("姓名："+s1.getName()+"，性别："+s1.getGender().getValue());//null
        System.out.println("姓名："+s2.getName()+"，性别："+s2.getGender().getValue());//女

        //解决上面的问题
        System.out.println("姓名："+s1.getName()+"，性别："+(s1.getGender()==Gender.MAN?"男":"女"));//null
        System.out.println("姓名："+s2.getName()+"，性别："+s2.getGender().getValue());//女

        //调用静态方法(用的少,了解即可)
        Gender[] values = Gender.values();//所有枚举对象
        System.out.println(Arrays.toString(values));//MAN,WOMAN
        Gender man = Gender.valueOf("MAN");
        System.out.println(man);//MAN

    }
}

public static void main(String[] args) {
        /*
        Arrays类中提供了一个sort方法对数组中的元素进行排序，默认是按照升序排序，如果需要自定义排序规则，则需要使用重载的方法： Arrays.sort(T[] t, Comparator<T> c)。
            参数1表示要排序的数组，参数二Comparator是一个接口，我们可以传递这个接口的匿名内部类对象，重写方法定
            义排序规则。
        关于比较规则：前面跟后面比，升序；后面跟前面比，降序。
            如果大于，返回任意正整数。
            如果小于，返回任意负整数。
            如果等于，返回0即可。
        *
        * */

        Integer[] arr = {10, 88, 52, 21, 76, 92, 28, 55, 39, 82};

        System.out.println("排序前："+Arrays.toString(arr));

        //升序排序
        Arrays.sort(arr, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1-o2;
            }
        });
        //arr里面的元素已经被升序移动元素位置了
        System.out.println("升序后："+Arrays.toString(arr));

        //降序
        Arrays.sort(arr, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2-o1;
            }
        });
        System.out.println("降序后："+Arrays.toString(arr));
    }