为何Java让我如此沉迷

晴天学长

已于 2022-09-20 18:15:50 修改

阅读量406

点赞数 3

分类专栏： Java 文章标签： java 深度学习

于 2022-04-24 21:21:57 首次发布

本文链接：https://blog.csdn.net/weixin_56715699/article/details/124392262

版权

Java 专栏收录该内容

14 篇文章 0 订阅

订阅专栏

JavaSE

2022/4/24 星期天

1.Java的初步认识。
2.博客的重要性和创立。
3.Markdown语法的学习。
4.常用快捷键，例如：
1.Ctrl+shift+Esc 切出任务管理器。
2.Win+E我的电脑。

在这里插入图片描述

2022/4/25 星期一

Java的环境安装。
IDEA的安装。
破解了它！！很有成就感。
人生第一个Java代码（成功的一小步！）。

public class wodetian {
    public static void main(String[] args){
        System.out.println("Hello,world!");

}
`
5. 快捷键 1.psvm2.sout。
6. 怎么配置一个空环境的Java。
7. 单行注释// 多行注释/* */。
8. 标识符（关键字）。
在这里插入图片描述
9. String 是字符串类型

2022/4/26
1.eg：long float 后面分别要加个30L 50.1F。
2.boolean 只是ture 或 false。
3.在打印函数时，可以用 f == d 来判断。
4.类变量就是放在上面的常量，那个地方都可以用的到。eg：static(静态的)，不像局部变量，只能在局部用。
5.实例变量就是文件名.name(有点像结构体)。
6.常量 final。
7.变量的命名规范
在这里插入图片描述
8.！！！ctrl + D 复制当前到下一行！！！ctrl + z 回到上次操作。
9.++和-- 注意在前还是在后，是自加自减的作用，不赋值。
10.&& || 都是自右向左（注意短路现象）。
11.位运算（效率极高）
12. 包机制
定义包：package
引用包：import

2022/4/27
1.Scanner对象next（）和nextLine（）的区别。
2.输出字符时+号是连接符。
3.Scanner有两步。一个是建立扫描，第二个是扫到的什么数据赋值给一个已定义的常量。
4.无视类型的扫描数据（scanner.nextLine）。.
5.//println 输出完,会换行。
//print 输出完,不换行。
6.for快捷键 9.f（条件是9）。
7."\t"是空格。
8.增强for循环 for（int x：numbers）

2022/4/28
1.方法的创立和使用（类似于函数，来完成特定功能的代码片段）。
2.方法的重载。
3.可变参数 (…)。
4.递归函数：
推过去，再拉回来。

2022/4/29
1.Arrays类eg：
—Arrays.toString() 打印数组。
—Arrays.sort() 排序数组（升序）。
2.类（class）。
一个类里边只有属性和方法（一个功能）。
3.静态（static，和类一起加载的）和非静态（实例化这个类，通过new之后在存在）。
4.new 让一个类或类的方法实例化（创建对象）！！非常重要。
new 类名方法名（可以不加）。
思考（扫描器）：new Scanner（）；因为Scanner就是一个类了，也只有一个方法，所以没有那个点。
Scanner scanner = new Scanner();创造对象+类名加命名
意思就是new一个扫描器的方法给一个扫描器类型的扫描器(系统自己命名的，可以改)。

2022/4/30
1.值传递和引用传递（对象）:本质还是值传递！！。
2.this 调用本类的方法。
3.使用new关键字，本质是在调用构造器。
4.构造器的含义（最简洁的方法，只有修饰名+名字）。
pubic MyFrame（）{
}

2022/5/1
1.封装快捷键 Alt+Ins。（调用一个写好的方法，输入参数就可以了）
2.继承 extends 所有的类默认继承object。
3.super 重新构造用父类的方法。
4.重写（子类重写父类的方法，执行子类的方法）（用的是非静态）。
快捷键 ctrl+o。
//Student 能调用的方法都是自己的或者继承父类的！
//Person 父类型，可以指向子类，但是不能调用子类独有的方法。
5.指令 instanceof 判断两个类是不是父子关系。
6.抽象类（abstract），需要它的子类去写它的东西，这里不是重写，抽象类也可以有抽象方法，注意不能new这个抽象类，只能通过子类去实现它（约束）。------引入接口哈哈哈。
7.extends :单继承~ ，但接口可以多继承。
8.interface 接口接口只能定义且都需要实现类，并且需要全部重写接口的方法。
9.快速注释 Ctrl+Shift+/

2022/5/2
1.接口不能被实例化，接口中没有构造方法~
2.内部类可以访问外部类的私有属性，但是要注意静态和非静态是不一样的哈。
3.异常 try catch（从小到大）finally
快捷键 Ctrl+Alt+T
4.抛出异常方法内是 thow 方法外是thows

2022/5/3
一.GUI核心技术：Swing AWT
1.因为界面不美观。
2.需要jre环境！
为什么我们要学习？
1.可以写出自己心中想要的一些小工具
2.工作时候，也可能需要维护到swing界面，概率极小！
3.了解MVC架构，了解监听！
二.常用单词
请添加图片描述
三.
1.认识到封装的重要性
2.Frame的相关知识

2022/5/4
1.Panel（面板）
2.监听事件（窗口关闭），引入适配器

 frame.addWindowListener(new WindowAdapter() {
            //窗口点击关闭的时候需要做的事情
            @Override
            public void windowClosing(WindowEvent e) {
                //结束程序
                System.exit(0);
            }
        });

3.3种布局管理器
流式布局FlowLayout
东西南北中BorderLayout
表格布局TestGridLayout

2022/5/5
1.布局小练习

package com.kuang.lesson01;
import javax.swing.*;
import java.awt.*;
public class ExDemo {
    public static void main(String[] args) {
        //总 Frame
        Frame frame = new Frame();
        frame.setBounds(300,400,400,300);
        frame.setBackground(Color.BLACK);
        frame.setVisible(true);
        frame.setLayout(new GridLayout(2,1));
        //4个面板
        //上面的
        Panel p1 = new Panel(new BorderLayout());
        Panel p2 = new Panel(new GridLayout(2, 1));
        Panel p3 = new Panel(new BorderLayout());
        Panel p4 = new Panel(new GridLayout(2,2));
        p1.add(new Button("East-1"),BorderLayout.EAST);
        p1.add(new Button("West-1"),BorderLayout.WEST);
        p2.add(new Button("P2-1"));
        p2.add(new Button("P2-2"));
        p1.add(p2,BorderLayout.CENTER);
        //下面的
        p3.add(new Button("East-2"),BorderLayout.EAST);
        p3.add(new Button("West-2"),BorderLayout.WEST);
        //中间4个
        for (int i = 0; i < 4; i++) {
            p4.add(new Button("for-"+i));
        }
        p3.add(p4,BorderLayout.CENTER);
        frame.add(p1);
        frame.add(p3);
        frame.addWindowListener(new WindowAdapter() {
            //窗口点击关闭的时候需要做的事情
            @Override
            public void windowClosing(WindowEvent e) {
                //结束程序
                System.exit(0);
            }
        });
    }
}

总结：
1.Frame是一个顶级窗口
2.Panel无法单独显示，必须添加到某个容器。
3.布局管理器
1.流式
2.东西南北中
3.表格
4.大小，定位，背景颜色，可见性，监听！
5.按钮的监听事件
2022/5/7
1.写程序，最好写成一个主类（main），再去写其他的类，然后用new调用
2022/5/8
第一个计算器

package com.kuang.lesson02;

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class TestCalc {
    public static void main(String[] args) {
        new Calculator();
    }
}
//计算机类
class Calculator extends Frame {
    public Calculator(){
        //三个文本框
        setTitle("我的第一个计算器");
        TextField num1 = new TextField();
        TextField num2 = new TextField();
        TextField num3 = new TextField();
        //一个按钮
        Button button = new Button("=");
        button.addActionListener(new MyCalaculatorListener(num1,num2,num3));
        //1个标签
        Label label = new Label("+");
        //布局
        setLayout(new FlowLayout());
        add(num1);
        add(label);
        add(num2);
        add(button);
        add(num3);
        pack();
        setVisible(true);
    }
}
//监听器类
class MyCalaculatorListener implements ActionListener{
    //获取三个变量
    private TextField num1,num2,num3;
    public MyCalaculatorListener(TextField num1,TextField num2,TextField num3) {
        this.num1 = num1;
        this.num2 = num2;
        this.num3 = num3;
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        //1.或的加数和被加数
        int n1 = Integer.parseInt(num1.getText());
        int n2 = Integer.parseInt(num2.getText());

        //2.将这个值 + 法运算后，放到第三个框
        num3.setText("" + (n1 + n2));

        //3.清楚前两个框
        num1.setText("");
        num2.setText("");
    }
}

改进方法：1.面向对象在这里插入图片描述
2.内部类的方法去调用！！！
private
2022/5/9
第一个画图工具（鼠标监听，窗口画图工具）

package com.kuang.lesson03;

import com.sun.org.apache.xerces.internal.xinclude.XPointerSchema;

import java.awt.*;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.ArrayList;
import java.util.Iterator;

public class TestMouseListener {
    public static void main(String[] args) {
    new MyFrame("画图");
    }
}
class MyFrame extends Frame{
    //画画需要画笔，需要监听鼠标当前的位置，需要集合来存储这个点
    ArrayList  points;
    public MyFrame(String title)  {
        super(title);
        setBounds(200,200,400,300);
        //存鼠标点击的点
        points = new ArrayList<>();
        setVisible(true);
        //鼠标监听器，正对这个窗口
        this.addMouseListener(new MyMouseListener());
    }

    @Override
    public void paint(Graphics g) {
        //画画，监听鼠标的事件
        Iterator iterator = points.iterator();
        while(iterator.hasNext()){
            Point point = (Point) iterator.next();
            g.setColor(Color.BLUE);
            g.fillOval(point.x,point.y,10,10);
        }
    }
    //添加一个点到界面上
    public void addPaint(Point point){
        points.add(point);
    }
    private class MyMouseListener extends MouseAdapter {
        //鼠标按下 弹起 ，按住不放

        @Override
        public void mousePressed(MouseEvent e) {
            MyFrame frame = (MyFrame) e.getSource();
            //这个我们点击的时候，就会在界面上残剩一个点！画
            //这个点就是鼠标的点：
            frame.addPaint(new Point(e.getX(),e.getY()));
            //每次点击鼠标都需要重写画一偏
            frame.repaint();//刷新
        }
    }
}

思路很重要
在这里插入图片描述
2022/5/10
1.键盘监听

package com.kuang.lesson03;


import java.awt.*;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;

public class TestKeyListener {
    public static void main(String[] args) {
        new KeyFrame();
    }
}
class KeyFrame extends Frame{
    public KeyFrame(){
        setBounds(1,2,300,400);
        setVisible(true);
        this.addKeyListener(new KeyAdapter() {
            //键盘按下
            @Override
            public void keyPressed(KeyEvent e) {
                //获得键盘下的键是哪一个，当前的码
                int keyCode = e.getKeyCode();//不需要去记录这个数值，直接使用静态属性 VK_XXX
                System.out.println(keyCode);
                if (keyCode == KeyEvent.VK_UP){
                    System.out.println("你拉下了上键");
                }
            }
        });
    }
}

2.用swing写JFrame窗口

import javax.swing.*;
import java.awt.*;

public class JFrameDemo {
    public static void main(String[] args) {
        //init（）：初始化
        new MyJframe2().init();
    }
}

    class MyJframe2 extends JFrame {
        public void init() {
            //关闭窗口
            this.setBounds(10, 10, 200, 300);
            this.setVisible(true);
            JLabel label = new JLabel("徐洪勇真帅");
            this.add(label);
            //让文本标签居中，设置水平对齐
            label.setHorizontalAlignment(SwingConstants.CENTER);
            //获得一个容器
            Container container = this.getContentPane();
            container.setBackground(Color.yellow);
        }
}

2022/5/11
1.图像标签

import javax.swing.*;
import java.awt.*;
import java.net.URL;

public class ImageIconDemo extends JFrame {
    public ImageIconDemo(){
        //获取图片的地址
        JLabel label = new JLabel("ImageIcon");
        URL url = ImageIconDemo.class.getResource("捕获2.PNG");
        ImageIcon imageIcon = new ImageIcon(url);//命名不要冲突了
        label.setIcon(imageIcon);
        label.setHorizontalAlignment(SwingConstants.CENTER);
        Container container = getContentPane();
        container.add(label);
        setVisible(true);
        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        setBounds(200,100,200,200);
    }

    public static void main(String[] args) {
        new ImageIconDemo();
    }
}

2.文本域

import javax.swing.*;
import java.awt.*;

public class JScrollDemo extends JFrame {
    public JScrollDemo(){
        Container container = this.getContentPane();
        //文本域
        JTextArea textArea = new JTextArea(20,50);
        textArea.setText("欢迎学习狂神说Java");
        //Scroll面板
        JScrollPane scrollPane = new JScrollPane(textArea);
        container.add(scrollPane);
        this.setVisible(true);
        this.setBounds(100,100,300,350);
        this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    }
    public static void main(String[] args) {
        new JScrollDemo();
    }
}

2022/5/12

一 GUI结束！！！
实战项目：贪吃蛇
代码

```java
public class StartGame {
    public static void main(String[] args) {
        JFrame frame = new JFrame();
        frame.setBounds(10,20,900,720);
        frame.setResizable(false);//窗口大小不可变
        frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        //正常的游戏界面都应该在面上！
        frame.add(new GamePanel());
        frame.setVisible(true);
    }
}

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.util.Random;

public class GamePanel extends JPanel implements KeyListener, ActionListener {
    //定义蛇的数据结构
    int length;//蛇的长度
    int[] sankeX = new int[600];//蛇的坐标 25*25
    int[] sankeY = new int[500];//蛇的坐标 25*25
    String fx;
    //食物的坐标
    int foodx;
    int foody;
    Random random = new Random();
    int score;//成绩
    //游戏当前的状态： 开始 停止
    boolean isStart = false;//默认是停止
    boolean isFall = false; //默认是失败状态
    //定时器 以ms为单位 1000ms = 1s；
    Timer timer = new Timer(100,this);//100ms执行一次！

    //利用构造器,调用的时候就被自动被初始化
    public GamePanel() {
        init();
        //获得焦点和键盘事件
        this.setFocusable(true);//获得焦点事件
        this.addKeyListener(this);//获得键盘监听事件
        timer.start();//游戏一开始定时器启动
    }
    //初始化方法
    public void init(){
        length = 3;
        sankeX[0] = 100;sankeY[0] = 100; //脑袋的坐标
        sankeX[1] = 75;sankeY[1] = 100;  //第一个身体的坐标
        sankeX[2] = 50;sankeY[2] = 100;  //第二个身体的坐标
        fx = "R" ;
        //把食物随机分布在界面上
        foodx = 25 +25*random.nextInt(34);
        foody = 75 +25*random.nextInt(24);
        score = 0;
    }
    //绘制面板，我们游戏中的所有东西，都是用这个画笔来画
    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);//清屏
        //绘制静态的面板
        this.setBackground(Color.white);
        Data.header.paintIcon(this,g,25,11);//头部广告栏画上去
        g.fillRect(25,75,850,600);//默认的游戏界面
        //画积分
        g.setColor(Color.WHITE);
        g.setFont(new Font("微软雅黑",Font.BOLD,18));
        g.drawString("长度"+length,750,35);
        g.drawString("分数"+score,750,55);
        //画食物
        Data.food.paintIcon(this,g,foodx,foody);
        //把小蛇画上去
        if(fx.equals("R"))  {
            Data.right.paintIcon(this,g,sankeX[0],sankeY[0]);//蛇头初始化向右,通过方向来判断
        }else  if(fx.equals("L")) {
            Data.left.paintIcon(this, g, sankeX[0], sankeY[0]);//蛇头初始化向右,通过方向来判断
        }else  if(fx.equals("U")) {
            Data.up.paintIcon(this, g, sankeX[0], sankeY[0]);//蛇头初始化向右,通过方向来判断
        }else  if(fx.equals("D")) {
            Data.down.paintIcon(this, g, sankeX[0], sankeY[0]);//蛇头初始化向右,通过方向来判断
        }
            for(int i =1 ;i < length ;i++ ) {
            Data.body.paintIcon(this,g,sankeX[i],sankeY[i]);//第二个身体的坐标
        }

        //游戏状态
        if(isStart == false){
            g.setColor(Color.WHITE);
            g.setFont(new Font("微软雅黑",Font.BOLD,40));//设置字体
            g.drawString("按下空格开始游戏",300,300);
        }
        if(isFall){g.setColor(Color.RED);
            g.setFont(new Font("微软雅黑",Font.BOLD,40));//设置字体
            g.drawString("失败，按下空格重新开始",300,300);
        }
    }

    @Override
    public void keyTyped(KeyEvent e) {

    }
    //键盘监听事件
    @Override
    public void keyPressed(KeyEvent e) {
        int keyCode = e.getKeyCode();
        if (keyCode == KeyEvent.VK_SPACE) {//如果按下的是空格键
            if(isFall){
                //重新开始
                isFall = false;
                init();
            }else {
                isStart = !isStart;//取反
            }
        }
        //小蛇移动
        if(keyCode == KeyEvent.VK_UP){
            fx = "U";
        }else if(keyCode ==KeyEvent.VK_DOWN){
            fx = "D";
        }else if(keyCode ==KeyEvent.VK_LEFT){
            fx = "L";
        }else if(keyCode ==KeyEvent.VK_RIGHT){
            fx = "R";
        }
    }
    @Override
    public void keyReleased (KeyEvent e){ }
    //事件监听 --- 需要通过固定事件来刷新，1s=10次
    @Override
    public void actionPerformed(ActionEvent e) {
        if(isStart && isFall == false){//如果游戏是开始状态，就让小蛇动起来！
            //吃食物
            if(sankeX[0]==foodx && sankeY[0]==foody){
                length++;//长度+1
                //分数加10
                score = score +10;
                //再次随机食物
                foodx = 25 +25*random.nextInt(34);
                foody = 75 +25*random.nextInt(24);
            }
            //右移
            for (int i = length - 1; i > 0; i--) {//后一节移到前一节的位置
                sankeX[i] = sankeX[i-1];
                sankeY[i] = sankeY[i-1];
            }
            //走向
            if(fx.equals("R")){
                sankeX[0] = sankeX[0] +25;
                //边界判断
                if(sankeX[0]>850)sankeX[0] = 25;
            }
            if(fx.equals("L")){
                sankeX[0] = sankeX[0] -25;
                if(sankeX[0]<25)sankeX[0]=850;
            }
            if(fx.equals("U")){
                sankeY[0] = sankeY[0] -25;
                if (sankeY[0]<75)sankeY[0]=650;
            }
            if(fx.equals("D")){
                sankeY[0] = sankeY[0] +25;
                if(sankeY[0]>650)sankeY[0]=75;
            }
            //失败判断，撞到自己算失败
            for(int i = 1;i<length;i++){
                if (sankeX[0]==sankeX[i]&&sankeY[0]==sankeY[i]){
                    isFall = true;
                }
            }

            repaint();//重画页面
        }
        timer.start();//定时器开启！
    }
    }

构造器

//利用构造器,调用的时候就被自动被初始化,然后输入参数给形参，在加this.什么，就把参数复制给这个类中的this.什么了，避免了去监听什么键盘的事件。
public GamePanel() {
    init();
}

总结
步骤：1.定义
2.画上去
3.键盘监听
4.鼠标监听

2022/5/13

1.List集合
ArrayList 类（可变，无限大）实现了可变的数组，允许保存所有的元素，包括null，并可以根据索引位置对集合进行快速的随机访问。缺点就是向指定的索引位置插入对象或删除对象的速度较慢。
LinkedList类采用链表结构保存对象。这种结构的优点是便于向集合中插入对象或删除对象。缺点就是ArrayList的优点。
2.set集合（可以用于排序）p211.
3.Java IO 也称为IO流，IO = 流，它的核心就是对文件的操作，对于 字节 、字符类型的输入和输出流。

2022/5/14（网络编程开始！)

一.怎么连接别人的电脑（IP地址还有端口）

在这里插入图片描述
2022/5/15
TCP和UDP

2022/5/16
TCP步骤

服务器与客端的文件传送
客户端

建立Socket联系
创建一个输出流
读取文件
写出文件（在缓冲区中作为输出流写出）
关闭连接

服务器

创建一个Socket的服务器
监听客户端的连接
获取输入流
文件输出（在缓冲区中，作为输入流被写出）
关闭连接

2022/5/17

1.UDP的认识
2.多线程的初步了解
3.URL
在这里插入图片描述
2022/5/18
多线程

2022/5/19
1.run（）和start（）的区别
最好不要调用run（）

//创建线程的方式一：继承Thread类，重写run（）方法，调用start开启线程
//总结：注意，线程开启不一定立即执行，由CPU调度执行
public class TestThread1 extends Thread{
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 200; i++) {
            System.out.println("我在看代码---"+i);

        }
    }

    public static void main(String[] args) {
          //main线程，主线程

        //创建一个线程对象
        TestThread1 testThread1 = new TestThread1();
        //调用start（）方法开启线程
        testThread1.start();
        for (int i = 0; i < 1000; i++) {
            System.out.println("我在学习多线程--"+i);
        }
    }
}

在这里插入图片描述
2.多个线程操作一个对象，可能会出现线程不安全，资源紊乱的情况。
3.静态的代理
Java之静态代理
2022/5/20
一.对象的类型
1.外部类
2.静态内部类（放在同一个类下面）
3.局部内部类（放在同一个方法里面）
4.匿名内部类（匿名就是没有名字，需要接口和父类实现，new的时候都值new接口或者父类就好了）
Java内部类和匿名内部类的用法
二.Java Lambda表达式
在这里插入图片描述
三.线程的礼让

四.join合并线程

五.线程的优先级

2022/5/21
一.线程同步

二.同步方法
锁的对象是变化的量，需要增删改的对象

三.Lock锁

在这里插入图片描述
2022/5/22
一. 注解和反射
一个类被加载了，就只有一个Class（镜子）。
二.Java集合、泛型和枚举
2022/5/23
1.Java的内存分析
2.类的加载

在这里插入图片描述
Javase 结束！！
晴天学长的知识点回顾篇！！
1.JAVA知识复盘001——面向对象?面向过程？面向对象的三大特点和五大基本原则是什么？

2.JAVA知识复盘002——构造方法能不能被重载，构造方法能不能被重写？
概述：构造方法存在于类中，给对象数据（属性）初始化；

特点：方法名与类名一样；无返回值无void;
3.子类在继承父类之后，创建子类对象的同时也会调用父类的构造方法
4.[Java中Scanner.useDelimiter( )方法使用] 分割符
相当于割肉，要的是前面割下来的那部分
5.Java Scanner类的常用方法及用法（很详细）
6.Java中Final修饰对象
（总结：final修饰的对象，内容可变，引用不可变。）
7.java多线程中sleep和wait的4个区别，你知道几个？
8.Java中构造方法与对象
9.抽象类、最终类(final修饰的类)和接口

抽象类不能够被实例化。
抽象类的子类需要实现父类中的所有的抽象方法，否则该子类也需声明为抽象类。
接口不可以实现接口。
接口与接口之间的关系为继承，既可以单继承，也可以多继承。

interface E extends A,B,C{
	
}

最终类不能被继承；最终方法不能被重写。

10.JAVA中private用法（用来封装）只可以被类本身访问和调用
要访问private成员变量，就是定义一对儿Getter/Setter方法。
11.[JAVA:List集合]
12.Java list集合转换Map集合（哈希表）.
2022/5/25
1.关键字super的作用是（）。
用来访问父类被隐藏的非私有成员变量
用来调用父类中被重写的方法
用来调用父类的构造函数
2.ArrayList和Vector实现了 Collection 接口。
3.java中foreach的用法（只用作打印遍历器吧，因为它没有用到数组下标）。
4.Java Iterator 详解（用于遍历数组）
5.Java集合——Set详解（Set是一个继承于Collection的接口，它是一个不允许重复元素的集合，实现类主要是HashSet、LinkedHashSet、TreeSet，而且都非线程安全）
6.Java 中什么叫线程安全，什么叫非线程安全？
线程安全就是在多线程下调用，不做任何同步处理，可以得到正确、可预期的结果。
非线程安全就是如果不同步，结果可能是错的，甚至程序发生死锁。
2022/5/26
1.Java中关于接口的定义以及接口的语法
2.Java抽象类与接口
（抽象类可以有普通方法，但是抽象方法没有代码体）
3.Java抽象类（怎么定义和使用）
4.Java中try-catch-finally用法
5.在java中==和equals()的区别
6.Float a = 1.0F;(定义float型变量时，如果不加F和f，系统会认为是double类型数据，进而出错。)
7.Java中length、length()、size()区别（size（）是针对集合的）
8.深入理解String、StringBuffer和StringBuilder
9.for循环可以没有条件
10.Java内部类详细介绍
2022/5/27
1.java中^怎么用运算符在Java中做什么？
2.java中的Set集合
3.Java中flush（）的使用
4.Java封装
5.Java封装/getter和setter（就是设置两个方法，一个用值传递把参数传进来用this去修改本类的值，一个return 返回那个私有属性）
6.Java中的向上转型和向下转型。
2022/5/28
1.源程序文件的扩展名是.java
一个源程序文件只能有一个public类，而且类名必须是文件名！！
一个源程序文件中可以有多个类
源程序文件名只能与其代码中的唯一一个public的类名相同
2.集合中那些是线程安全，那些不安全
Vector、HashTable、Properties是线程安全的；

ArrayList、LinkedList、HashSet、TreeSet、HashMap、TreeMap等都是线程不安全的。
值得注意的是：为了保证集合是线程安全的，相应的效率也比较低；线程不安全的集合效率相对会高一些。
3.Java中的修饰符
4.Java中的标识符
5.Java InputStream 知识
6.java线程的状态有几种
7.Java多线程学习（吐血超详细总结）（不管是继承Thread还是实现Runable接口，其实际还是运行Thread的start()方法来运行的）
2022/5/29
1.全局变量/属性可以加修饰符
局部变量不可以加修饰符
2022/5/30
1.在Java中，条件执行语句中，没有0和1，只有true和false。
2022/6/1
1.Java 中的每一个枚举都继承自 java.lang.Enum 类。当定义一个枚举类型时，每一个枚举类型成员都可以看作是 Enum 类的实例，这些枚举成员默认都被 final、public, static 修饰，当使用枚举类型成员时，直接使用枚举名称调用成员即可。
2.抽象类
3.在 swtich - case 语句中进去后，按顺序执行知最后或者遇到break，即使遇到default也是一样的还是会执行。
4.& gt; 和 & lt; 代表大于号> 和小于号<
5.下面哪些类实现或继承了 Collection 接口（）。
B、ArrayList(正确)
C、Vector(正确)
6.String与StringBuffer的区别（）。
A、String是不可变的对象，StringBuffer是可以再编辑的(正确)
B、字符串是常量，StringBuffer是变量(正确)
7.java replace和replaceAll