泛型_枚举_注解_单例

目录

文章目录

一、泛型

1.泛型类

2.泛型接口

二、枚举

三、单例模式

四、注解

---

 

一、泛型

作用：类型自动转换

1、泛型类

import lombok.Getter;
import lombok.Setter;

import java.util.ArrayList;
import java.util.List;

/**
 * MyClass<S,T>泛型类往往充当父类存在,充当工具类使用
 */
public class Demo {

    public static void main(String[] args) {

        MyClass<Boolean, Integer> myClass = new MyClass<>();
        myClass.setS(true);
        Boolean s1 = myClass.getS();
        System.out.println(s1);//true

        myClass.demo("hello world");//a:hello world

        List<CharSequence> list = new ArrayList<>();
        myClass.ha(list);
    }
}

@Getter
@Setter
//泛型类
class MyClass<S, T> {

    private S s;//private String str;
    private T t;

    //泛型方法
    public  <A> void demo(A a) {
        System.out.println("a:" + a);
    }

//    public static S s1; //S/T很少充当静态成员变量

    //静态方法-->工具类-->一般都是泛型方法
    public static <T> T demo1(T t){//第二个T指返回值类型
        System.out.println(t);
        return t;
    }

    //泛型的上下限
    //上限：一般体现在类中extends
    //下限：一般体现在方法中   ?只能是String以及String的父类或父接口
    public void ha(List<? super String> list){

    }
}

2、泛型接口

用户模块  crud
商品模块  crud
 .... 
UserDao.java
public interface BaseDao<T> {

    void add(T entity);

    void delete(int id);

    void update(T entity);

    T selectOne(int id);

    List<T> selectAll();

}  




public abstract class BaseDaoImpl<T> implements BaseDao<T>{
    @Override
    public void add(T entity) {

    }

    @Override
    public void delete(int id) {

    }

    @Override
    public void update(T entity) {

    }

    @Override
    public T selectOne(int id) {
        return null;
    }

    @Override
    public List<T> selectAll() {
        return null;
    }
}

二、枚举

public enum UserEnum {

    user1,
    user2(1,"张三");

    private Integer id;
    private String name;

    public Integer getId(){
        return id;
    }

    public String getName(){
        return name;
    }

    public static void a(){
    }

    UserEnum() {
        System.out.println("无参构造...");
    }

    UserEnum(Integer id, String name) {
        this.id = id;
        this.name = name;
    }

    public static void main(String[] args) {
        UserEnum user1 = UserEnum.user1;//有1个无参实例，默认走无参构造1次
        System.out.println(user1);//无参构造... user1
        System.out.println(UserEnum.user2.getName());//张三

    }
}

深入理解Java枚举类型(enum)

三、单例模式

单个实例，在一个进程（程序）里面有且只有一个对象，多进程里面，对象也必须是同一个对象
创建对象的方式：
new构造方法
clone
序列化流
反射

public class StudentTest {

    public static void main(String[] args) {
        Student student1 = Student.getInstance1();
        Student student2 = Student.getInstance1();
        System.out.println("student1:" + student1);//student1:Student@74a14482
        System.out.println("student2:" + student2);//student2:Student@74a14482

//        for (int j = 0; j < 3; j++) {
//            new Thread(() -> {
//                for (int i = 0; i < 10; i++) {
//                    System.out.println(Thread.currentThread().getName() + ": " + Student.getInstance1());
//                }
//            }).start();
//        }
        for (int j = 0; j < 3; j++) {
            new Thread(() -> {
                for (int i = 0; i < 10; i++) {
                    System.out.println(Thread.currentThread().getName() + ": " + Student.getInstance2());
                }
            }).start();
        }

    }
}

class Student {
    private Student() {
    }

    //饿汉模式：线程安全 弊端：没有体现懒加载的思想，直接new了
    //构造方法私有化，获得对象
    //提供静态变量，直接初始化
    private static Student student1 = new Student();

    //懒汉模式:单线程下操作没问题 多线程并发则不安全（内存不可见）
    //解决方式 加同步方法（不推荐）或同步代码块（sychronized） 效率慢
    //推荐同步代码块：DCL：双重检测锁 double check lock,存在隐患 指令重排（volatile）
    //创建对象：1、开辟内存空间 2、初始化成员变量 3、赋值
    private static Student student2;//null

    public static Student getInstance1() {
        return student1;
    }

    public static Student getInstance2() {
        //双重检测
        if (student2 == null) {//只有第一次进入时为空
            synchronized (Student.class) {
                //体现了懒加载
                if (student2 == null) {
                    student2 = new Student();
                }
            }
        }
        return student2;
    }
}

 克隆+序列化+反射    都会打破单例（序列化下使用readResolve可以保证单例模式）

序列化不走构造

public class Student implements Serializable, Cloneable {

    private static final long serialVersionUID = 2092414525597568198L;

    private Student() {
    }

    private volatile static Student student;//null

    public static Student getInstance() {
        if (student == null) {
            synchronized (Student.class) {
                if (student == null) {
                    student = new Student();
                }
            }
        }
        return student;
    }

    //克隆
    @SneakyThrows
    @Override
    public Student clone() {
//        return (Student) super.clone();//无法保证一个实例
        return this;//可以保证一个实例
    }


    //序列化
    public Object readResolve() {//可以保证单例模式
        return student;//返回的对象是本身
    }

}

java单例模式——详解JAVA单例模式及8种实现方式

四、注解

 项目开发方式:
   1.配置方式   配置文件  xml  properties   集成框架之间关系
       html--->controller--->service---->dao---->DB
               SpingMVC      Spring     mybatis   mysql    
      效率慢  可维护性较高 
       
   2.注解开发    
       效率快  解决问题时间  

语法:  @解释名 

 

jdk内置的注解:
@Deprecated
@SuppressWarnings("all")//压制所有警告
public class AnnoTest {


    private String name;

    @Override
    public String toString() {
        return "AnnoTest{" +
                "name='" + name + '\'' +
                '}';
    }

    @Deprecated     //表示过时方法
    public void a() {

    }

    public void b(@NonNull String name) {

        List list = new ArrayList();
        list.add(123);//警告
    }
    
    @SuppressWarnings    //压制C方法的警告
    public void c() {

        List list = new ArrayList();
        list.add(123);//警告
    }
}
   

元注解

@Target:    //标记注解可以在哪里被使用
@Retention     //标识注解的生命区间。源代码  class  整个运行期间
@Documented： javadoc    //在文档里面使用
@inherited      //继承  其它子类获得父类注解
@FunctionalInterface  修饰接口   面向函数式编程的表示，表示着接口只有一个方法

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface Override {
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Target {
    ElementType[] value();
}
 public enum ElementType {
    /** Class, interface (including annotation type), or enum declaration */
    TYPE,
    FIELD,
    METHOD,
    PARAMETER,
    CONSTRUCTOR,
    LOCAL_VARIABLE,
    ANNOTATION_TYPE,
    PACKAGE,
  
    TYPE_PARAMETER,
    TYPE_USE
} 
 

自定义注解