JAVA 10

POJO类  Entity类 ,所有的属性私有化,写公有的set get 方法, 在类中,不写业务逻辑, 必须实现序列化接口 , 必须有无参构造器
如果有需要,可以生成对应的构造器,重写toString equals hashcode 方法
对应数据库中的一张表
DTO类  Date Transform Object
数据在传输的过程中使用的模型类
VO类 View Object
专门针对于客户端显示的模型类 

全类名  例如: java.util.Date

如果在同一个场景下,出现两个相同的类名,其中一个要写成全类名

---

数据库(DB,Date Base)

数据库是所有软件体系中最核心的存在  DBA:数据库管理员

作用:存储数据,管理数据,

概念:数据仓库,软件,安装在操作系统

---

java高级部分:

1,泛型

2.枚举

3,多线程

4,集合

5,IO流

6,网络通信socket

7,反射和注解

---

泛型  Generic
什么是泛型?
广泛的,普通的类型,泛型能够帮助我们把[类型明确]的工作推迟到创建对象或者调用方法的时候
例如超级数组:定义类的时候,不需要考虑这个数组要存什么类型
创建这个超级数组对象的时候把里面要存的数据类型确定下来
1,泛型类
把泛型定义在类上,使用类时候把类型给确定  <>加上一个未知数,通常用T K V E等大写字母表示 Type key value
实际上用什么都可以,是个单词就行
2,泛型方法
定义泛型方法时首先定义泛型类型 ,定义在方法中间
有泛型声明<> 才是泛型方法, 使用泛型方法最好要结合返回值,
3,泛型接口

泛型的目的就是能够处理不同数据类型的数据
泛型类在继承的时候:
泛型的声明只能在当前类名后或者方法中间 ,继承对泛型没有遗传

//泛型类  T就是一个数据类型

//使用这个类的时候确定泛型类型
public class Ch1<T> {
    //声明了一个T类型的变量
    private T t;

//    Ch1<String> ch1=new Ch1();
//    jdk7以后  推荐使用  类型推断
//    Ch1<Integer> ch2=new Ch1<>();
    //jdk7以前 完整写法
//    Ch1<Double> ch3=new Ch1<Double>();


    //泛型方法:如果只关心某个方法,可以只定义泛型方法
    public <T> T show(T t){
//        throw new RuntimeException();
        //.......
        System.out.println(t);
        return t;
    }

    public static void main(String[] args) {
        new Ch1<String>().show("hhhhhhhh");
    }

}
class Father<T> {}

//在确定子类泛型的术后,父类的泛型和子类一样
//Class son<T> extends Father<T>{}
//当前子类不是泛型类,确定不了类型就是object
//Class son extends Father{}

泛型类中尽量不要使用泛型方法,泛型方法多数出现在非泛型类中
静态方法使用到泛型,声明必须写
静态结构属于类的,不属于某个对象
?(通配符):可以接收任何类型,
如果使用object 就不用泛型,泛型约束类的数据类型

类型参数化
类型擦除:
为了兼容性,使用原始类型(没有泛型)是可以的
保证代码的兼容性,将参数化类型的实例传递给设计用于原始类型的方法必须兼容
为了保持兼容性,有一种伪泛型,java在编译的时候,所有的泛型都会被擦掉
java的泛型语法是在编译期这个维度上实现的,正常来说,在生成的字节码文件中不包含泛型的类型信息的
在jvm中,由泛型附加的类型信息对jvm来说是看不到的,可以理解为泛型的本质就是让程序员编写代码时遵守的一个规则,
在确定了泛型之后,就统一操作同一类型的数据,如果放其他类型,编译不通过,

经验:开发中,能在业务上解决的问题,尽量不要在技术上解决
1,泛型不能是基本数据类型
2,数组原则上是可以当泛型的,但语法角度上不可以,<>里放的是类名,数组在编译之后才会生成一个类
($×××)可能是编译后的类名
方法的重载:
// 不是重载  原理:类型擦除
// public void show(superArray<String> s){}
// public void show(superArray<Double> s){}

泛型的应用场景:
1,父类或者接口中,起到的是一个规范的作用,对里面的数据类型没有明确的要求
2,容器 (超级数组,链表,队列,栈) 指定装什么类型的数据
当类型无法确定时,使用泛型

---

 *  枚举类型
 *  应用场景：
 *  在某些情况下，一个类的对象的个数是有限的，
 *  如季节，春夏秋冬，比如24节气，星期。。。
 *  规定这个类的对象的个数。

* 大更新
 * JDK1.5更新了枚举类
 * 枚举类中：
 * 把需要用到的对象声明出来
 * 写对应的构造器
 * 可以有set，get方法

public enum SeasonEnum {

    SPRING(1,"春天"),
    SUMMER(2,"夏天"),
    AUTUMN(3,"秋天"),
    WINNER(4,"冬天");

    // public static final Season SPRING = new Season(1,"春天");

    private Integer value;
    private String name;

    SeasonEnum(Integer value, String name) {
        this.value = value;
        this.name = name;
    }

    public Integer getValue() {
        return value;
    }

    public void setValue(Integer value) {
        this.value = value;
    }

    public String getName() {
        return name;
    }

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

 * 枚举在switch中使用
 * JDK1.5之后
 *
 * 枚举类的命名规则：所有的枚举类要以Enum结尾。

    public static void main(String[] args) {
        SeasonEnum season = SeasonEnum.SPRING;

        switch (season) {
            case SPRING:

            case SUMMER:
            case AUTUMN:
            case WINNER:
        }
    }

枚举的静态导入
 *号代表导入枚举类的所有对象

import static com.jsoft.afternoon.SeasonEnum.*;

 public static void main(String[] args) {
        System.out.println(SPRING.getName());
    }

 * 单例模式
 * 使用枚举类实现单例模式。

* 单元素的枚举类型已经成为实现单例模式的最佳方案。

class Singleton {

    // 私有化构造器
    private Singleton() {}

    // 提供公有的获取实例的静态方法
    public static Singleton getInstance(){
        return SingletonHolder.INSTANT.instant;
    }

    // 声明一个枚举类（内部类）
    private enum SingletonHolder{

        INSTANT;

        private final Singleton instant;

        SingletonHolder() {
            instant = new Singleton();
        }
    }
}

public class Ch05 {

    public static void main(String[] args) {
        System.out.println(Singleton.getInstance() == Singleton.getInstance());
    }
}

 *  枚举的优势
 *  1.int类型不具备安全性。假如某个程序员在定义int时少写了个final，
 *      会存在被他人修改的风险。枚举类，它天然就是一个常量类
 *  2.使用int类型，语义不够明确。如果说在控制台打印输入1。
 *     枚举里面都是常量，静态
       推荐枚举的比较使用 ==

public interface SeasonConstant {

    Integer SPRING = 2;
    Integer SUMMER = 2;
    Integer AUTUMN = 3;
    Integer WINNER = 4;

}
 public static void main(String[] args) {
//        Integer seasonStr = 1;
//        if(seasonStr == SeasonConstant.SPRING) {
//            System.out.println(1);
//        }
        // 枚举里面都是常量，静态
        // 推荐枚举的比较使用 ==
        SeasonEnum spring = SeasonEnum.SPRING;
        String name = "春天";
        SeasonEnum1 spring1 = SeasonEnum1.SPRING;
//        if(name.equals(spring.getName())){
//            System.out.println("春天");
//        }
        if(spring1.equals(spring)) {
            System.out.println(123);
        }
    }

异常枚举

public enum ResultMessage {

    USERNAME_NOT_EXIST(101,"用户名不存在"),
    USERNAME_ALREADY_EXIST(102,"用户名已存在");

    private Integer code;
    private String message;

    ResultMessage(Integer code, String message) {
        this.code = code;
        this.message = message;
    }

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
}

/**
 * 多线程前置
 *
 * 我们要学习多线程，需要学习一些计算机组成的一些知识。
 * cpu8核以上和内存16G。
 *
 * 开一个虚拟机，开一个数据库，开git，开xshell，开idea，
 * 开Nginx，开redis，启动N多个微服务。
 *
 * 为了完成特定的任务，用某种编程语言写一个软件（程序）。
 * 程序要想运行就必须加载到内存中执行。
 *
 * 在执行程序的时候，实时的指令加载到cpu内存的指令寄存器中执行。
 * 执行过程中产生的数据要加载到数据寄存器中。ALU负责进行算术逻辑运算的操作。
 *
 * 系统总线（System Bus）：连接计算机系统的主要组件，用来降低成本和促进模块化。
 *      可以通过软件来控制硬件。
 *
 * 进程：
 *  一个正在执行中的程序就是一个进程，系统就会为这个进程发配独立的【运行资源】
 *  进程是程序的一次执行过程，它有自己的生命周期
 *  它会在启动程序时产生
 *      运行程序时存在
 *      关闭程序时消亡
 *
 * 比如：QQ，idea，腾讯会议，PDF
 *
 * 早期的计算机，单进程，同一时间只能执行一个进程。
 *  计算器。同一时间只能执行一段代码。
 *
 *  随着计算机的发展，CPU的计算能力大幅提升，
 *      按照时间线交替执行不同继承的方式。
 *      每个执行一点点时间，感官上觉得这么多的进程是同时在运行。
 *  如果一个进程有多个任务
 *
 *  打开浏览器，下载游戏（好几个小时，实况足球2022），另一个标签在看视频
 *  另一个标签在写博客，另一个标签在听音乐。。。
 *
 *  16核，4个任务
 *
 *  如果为每一个任务分配单独的进程去执行，进程间通信。CPU在调度。
 *  病毒，熊猫烧香。操作你的运行中的进程，修改了你的数据。
 *
 *  引入了线程。
 *   线程是由进程创建，是进程的一个实体，是具体干活的人
 *   一个进程有多个线程。线程不独立分配内存，而是共享进程的内存资源，
 *   线程可以共享cpu资源。
 *
 *   进程更强调的是【内存资源分配】，线程更强调的是【计算的资源的分配】
 *   因为有了线程的概念，一个进程的线程不能修改另一个线程的数据，线程之间是相互隔离 的，
 *   安全性更好。
 *
 *   我使用浏览器打开两个腾讯视频，他们同时播放视频，
 *   我一个浏览器也可以同时下载多个文件，
 *   同时播放两个视频，在多线程的作用下。
 *   下载，网络资源，IO问题。
 *
 *   我的电脑有2个核心，又有4个逻辑处理器。2核心4线程。
 *   8核心16线程啥意思？
 *
 *   理论上，一个核在一个时间点只能跑一个线程，但是cpu同一个时间能跑16线程
 *   1.物理cpu内核，每颗物理CPU可以有1个或多个物理内核，
 *      通常情况下物理CPU内核数都是固定，单核CPU就只有1个物理内核
 *   2.逻辑CPU内核，操作系统可以使用逻辑CPU来模拟真实CPU。
 *      在没有多核心CPU情况下，单核CPU只有一个核，可以把一个CPU当做多个
 *      CPU使用，逻辑CPU的个数就是作用的CPU物理内核数。英特尔研发的一种技术
 *      超线程，2002发布。和硬件有关，了解。
 *
 *   几个问题：
 *   1.我们的进程直接创建、调度线程。不能。
 *   2.QQ执行了一会，不执行，等其他线程执行完毕之后。
 *
 *   在上一次执行间歇期，会记录位置。
 *
 *   不同进程间的线程切换，耗费极大资源空间。
 *