草莓味的小东西
草莓味的小东西

想学习JavaSE吗？八万字JavaSE资料送给你！

本文目录一图览

文章目录

  • 一、初始Java
    • 1. 了解Java
      • 1.1 Java——面向对象编程
      • 1.2 Java的某些名词
  • 二、相关准备
    • 1. JDK的安装
      • 1.1 JDK的下载
      • 1.2 JDK的安装
    • 2.Java环境配置
      • 2.1 有话说
      • 2.2 开始环境配置
    • 3第一个Java程序，hello world
      • 3.1 找一个容易记的目录
  • 三、Java编辑器介绍
    • 1.工具的选择
      • 1.1 IntelliJ IDEA
      • 1.2 Visual Studio Code（vs code）
      • 1.3EditPlus
    • 2.工具的安装
      • 2.1 InterlliJ IDEA的安装
      • 2.2 vs code的安装
  • 四、java 基本语法
    • 1. 标识符
    • 2.标识符命名规范
    • 3. 关键字与保留字
      • 3.1.关键字
      • 3.2 保留字
    • 4.分隔符
      • 4.1 分号
      • 4.2 大括号
    • 5.变量
    • 6.注释
      • 6.1 单行注释
      • 6.2 多行注释
      • 6.3 文档注释
  • 五、数据类型
    • 1.基本数据类型
      • 1.1 整型
      • 1.2字符型
      • 1.3浮点型
      • 1.4布尔类型
    • 2.引用数据类型
      • 2.1类
      • 2.2 接口
      • 2.3 数组
      • 2.4字符串类型
      • 2.5顺便说一下
  • 六、运算符
    • 1. 算术运算符
    • 3.关系运算符
    • 4. 位运算符
    • 5. 逻辑运算符
    • 6. 赋值运算符
  • 七、分支控制语句
    • 1. 循环控制语句
      • 1. 自我提问
      • 2. 回答问题
        • 1. 什么是循环控制语句？
        • 2. 他能干什么？
        • 3. 它有什么类型？
      • 3. 使用
        • 1.使用for循环实现1-100的累加
        • 2.使用while循环实现1-100的累加
        • 3.使用do…while实现1-100的累加
      • 4.嵌套循环
        • 1.嵌套循环代码展示
      • 课后小练习
    • 2. 条件控制语句
      • 1.最简单的if语句
      • 2.if…else…语句
      • 3.if…else if…else… 语句
      • 4.嵌套的条件控制语句
      • switch语句的格式
      • 话外语
      • 与switch语句再续前缘
      • 多一嘴
    • 彩蛋
    • 课后小练习
    • 课后小练习答案
      • 1. for循环实现九九乘法表
      • 2.质数
  • 八、功能类的使用
    • 1.Number类
      • 1.定义声明使用
    • 2.Mtah类
      • 1.基础用法
      • 2. 常用方法
    • 3.String相关类
      • 1. String类
        • 1.1定义
        • 1.2使用
      • 2.StringBuilder类
        • 2.1定义使用
      • 2.2常用方法：
      • 3.StringBuffer类
        • 3.1定义
        • 3.2使用
    • 4.Scanner类和Random类
      • 4.1Scanner 类
        • 1. 上手
      • 4.2Random类
        • 1.定义
        • 2.使用
  • 九、数组
    • 1.一维数组
      • 1.1 定义
      • 1.2添加元素
      • 1.3查找元素
    • 2.多维数组
      • 2.1定义多维数组
      • 2.2多维数组的下标取值
      • 2.3往多维数组添加元素
      • 2.4根据下标查找元素
    • 3.Arrays类操作数组
      • 3.1给数组赋值：通过 fill 方法。
      • 3.2数组排序：通过 sort 方法
      • 3.3比较数组：通过 equals 方法
    • 小练习
    • 小练习答案
  • 十、面向对象
    • 1.面向过程
    • 2.面向对象
    • 3.类
      • 3.1自定义类
        • 1. 无参构造方法
        • 2. 有参构造方法
      • 3.2类的属性
        • 1.成员变量
        • 2. 局部变量
        • 3. 类变量
        • 4. 私有属性
      • 3.3类的动作/方法
      • 3.4继承
      • 3.5重写与重载
        • 1. 重写
        • 2. 重载
      • 3.6封装
    • 4.接口
    • 5.抽象类
    • 6.枚举
  • 十一、异常与处理
    • 1.常见的异常类型
      • 1.1编译时错误
      • 1.2运行时错误
      • 1.3逻辑型错误
    • 2.Java中的Throwable
      • 2.1Error
      • 2.2Exception
      • 2.3运行时异常
      • 2.4非运行时异常
    • 3.异常处理
      • 3.1格式
      • 3.2简单使用
  • 十二、集合
    • 1.集合框架
      • 1.1set集合
      • 1.2list集合
      • 1.3map
    • 2.常用的集合
      • 2.1ArrayList定义
        • 1.增
        • 2. 增
        • 3. 删
        • 4. 改
        • 5. 查
      • 2.2LinkedList
        • 1. 增：
        • 2. 删
        • 3. 改
        • 4. 查
        • 5. 大小
      • 2.3HashSet
        • 1.常用方法
      • 2.4HashMap
        • 1.常用方法
  • 十三、泛型、反射、注解
    • 1.泛型
      • 1. 认识Java中的泛型使用
      • 2. 泛型特性
      • 3. 泛型使用
      • 4. 通配符
      • 5. 完事
    • 2.反射
      • 1.用处
      • 2.优缺点
      • 3.用法
      • 4.简单使用
        • 1. 定义一个类
        • 2. 使用反射
      • 使用对象获取类的构造方法
        • 3.获取成员变量
        • 4.获取成员方法
      • 总结
    • 3.注解
      • 1.常规注解
        • 1.代码中的注解
        • 2.创造注解
        • 3.使用注解
      • 2.元注解
        • 1. @Retention
        • 2. @Documented
        • 3. @Target
        • 4. @Inherited
      • 3.标准注解
        • 1. @Override
        • 2. @Deprecated
      • 4.注解的属性
  • 十四、Stream、IO、文件操作
    • 1.Stream流
      • 1.1从键盘获取数据
        • 1. 获取一个字符：
        • 2.获取多个字符
      • 1.2输出数据到控制台
    • 2.文件操作
      • 2.1相关包
      • 2.2创建文件，并写入
      • 2.3读取文件
  • 十五、多线程编程
    • 1.线程的工作过程
    • 2.Java线程拥有优先级
    • 3.创建多线程
      • 3.1.继承Thread类，重写run()方法
      • 3.2实现接口Runnable接口与run方法
      • 3.3实现Callable接口，实现call方法
    • 4.线程的生命周期
  • 十六、数据库与JDBC
    • 1.数据库
      • 1.1数据（Data）
      • 1.2数据库（Date Base）
        • 1.数据库的特点
        • 2.数据库的分类
      • 1.3数据库管理系统（DMBS）
    • 2.MySQL的安装与配置
      • 2.1启动与停止
      • 2.2环境配置
    • 3.MySQL基操
      • 连接MySQL
      • 数据库的操作
        • 1. 创建数据库
        • 2. 查看数据库信息
        • 3. 删除数据库
      • 数据表的操作
        • 1. 创建数据表
        • 2.添加数据
        • 3.查询数据
        • 4.删除数据
        • 5. 查询数据表
        • 6. 删除数据表
    • 4.JDBC
      • idea连接数据库
      • 代码连接
  • 十七、网络编程
    • 1.软件构成
    • 2.网络编程三要素
    • 3.通讯协议
      • 3.1TCP/IP协议
      • 3.2两种通讯协议
    • 4.IP地址
    • 5.端口号
    • 6.Java网络编程
      • 6.1服务端
        • 1. 使用之前，我们应该先导包，而考虑到后面会使用io包里的流和net包里的客户端，所以直接全导入
        • 2. 我们通过ServerSocket类的带端口参数的构造方法来实例化，创建一个服务端
        • 3. 获取客户端链接
        • 4. 使用getInputStream()方法接收数据
        • 5. 输出数据
        • 6. 使用getOutputStream()方法给客户端回应
        • 7. 关闭连接
      • 6.2客户端
        • 1. 导包
        • 2. 发起链接
        • 3. 给服务器端传数据
        • 4. 接收服务器端的响应
        • 5. 关闭链接
      • 效果展示
    • 6.Java网络编程
      • 6.1服务端
        • 1. 使用之前，我们应该先导包，而考虑到后面会使用io包里的流和net包里的客户端，所以直接全导入
        • 2. 我们通过ServerSocket类的带端口参数的构造方法来实例化，创建一个服务端
        • 3. 获取客户端链接
        • 4. 使用getInputStream()方法接收数据
        • 5. 输出数据
        • 6. 使用getOutputStream()方法给客户端回应
        • 7. 关闭连接
      • 6.2客户端
        • 1. 导包
        • 2. 发起链接
        • 3. 给服务器端传数据
        • 4. 接收服务器端的响应
        • 5. 关闭链接
      • 效果展示

立马开始学习

一、初始Java

1. 了解Java

1.1 Java——面向对象编程

想学一个语言，至少要了解他是干嘛的，是什么类型的，创始人是谁什么的等等等乱七八糟的，对写代码作用不大，但是作为一个程序员必须要知道的东西。

下面的篇幅，字比较多，但是还是认真的看看吧，如果实在不愿意，那么只看粗体字就行了
当然了，事先声明，由于我是个初学者，如果有哪里不对的地方，希望各路大佬指出来，防止我和看我文章的人误入歧途，谢谢
想学习JavaSE吗？八万字JavaSE资料送给你！_第1张图片

  1. 首先呢，我们必须知道的是这个：Java 是由 Sun Microsystems（简称为sun公司，现在已经被oracle收购） 公司于 1995 年 5 月推出的高级程序设计语言，是面向对象的编程语言，用途广泛，可以做的方向很多。

  2. 然后呢，我们还必须要知道我们所学的编程语言的优点是什么
    1. 一次写成，多次运行。 另一个名字是跨平台性。那么我们应该怎么理解呢，暂时打个哑谜，下面会介绍的，清耐心看下去哦！
    2. 简单易用。 是的没错，简单易用！为什么呢，这里的简单易用是相对于C语言来说的，因为Java含有类和对象的概念，可以规避某些重复的代码，减少代码量。
    3. 安全可靠。 Java通常用于网络环境中,为此,Java提供了安全机制以防恶意代码的攻击。Java程 序运行之前会利用字节确认器进行代码的安全检查,确保程序不会存在非法访问本地资源 和文件系统的可能,保证了程序在网络间传送的安全性。
    4. 多线程。 Java支持多线程，可以使程序并发进行，在硬件条件允许的情况下,这些线程可以直接分布到各个 CPU 上, 充分发挥硬件性能,大大提升了程序的运行速率；利用Java的多线程编程接口, 你可以方便地写出多线程的应用程序。Java语言提供的同步机制可保证各线程对共享数据的正确操作。

  3. Java 可运行于多个平台，如 Windows, Mac OS 及其他多种 UNIX 版本的系统，这是因为由Java虚拟机来完成的。

  4. Java的按照用途来分，有三个版本，分别是JavaSE（Java标准版）,JavaEE（Java企业版），JavaME（移动版）

上面的已经划过重点了，要考的想学习JavaSE吗？八万字JavaSE资料送给你！_第2张图片

那么到这里呢，你已经对Java有了一定的了解，但是呢随着你了解了一点，还是会产生更多的疑惑，那么随着我来慢慢学习吧，如果你还是不理解，那么
想学习JavaSE吗？八万字JavaSE资料送给你！_第3张图片

1.2 Java的某些名词

名词 解释
JavaSE 标准版，是为开发普通桌面和商务应用程序提供的解决方案
JavaEE 企业版,是为开发企业级应用程序提供 的解决方案
JavaME 微型版,是为开发电子消费产品和嵌入式设 备提供的解决方案
现在JavaME已经被Android代替
JDK Java开发工具包,Java的核心
含Java编译器、Java运行环境、Java打包工具、Java文档生成工具等
JRE Java运行环境
SDK 软件开发工具包，开发Android必须有这个
javac.exe Java编译器，将代码编译成字节码
java.exe Java解释器 ，将字节码解释成机器语言
javadoc 生成一个注释文档，和使用说明书一样作用
jvm Java虚拟机

二、相关准备

1. JDK的安装

1.1 JDK的下载

  • 你可以选择从官网下载——官网
  • 也可以选择从别人的百度云盘下载——jdk15.0.1 码：c3st

OK，相信现在大家就已经下载好了，那么我们就开始愉快的安装了

1.2 JDK的安装

  1. 这是下载好的样子，双击
    在这里插入图片描述

  2. 然后是这样子，点击下一步
    在这里插入图片描述

  3. 这里可以选择安装路径，不过推荐还是默认安装位置，下一步
    在这里插入图片描述

  4. 然后会看到文件下载，比如这样
    在这里插入图片描述然后下载完是这样，到这里就已经安装成功了
    在这里插入图片描述

不过，不要急，还没完，相信你们内心都是这样，哈哈

不过不要急嘛，慢慢来，以后写代码会有很多的，有好多的，急可是不行的

2.Java环境配置

2.1 有话说

其实如果使用全家桶系列的ide的话，这个环境配置是没有必要的，但是嘛，虽然没有必要，但还是要学的

2.2 开始环境配置

2.1 首先找到你安装jdk的目录，也就是这个地方
在这里插入图片描述
2.2 打开bin目录
在这里插入图片描述2.3 复制路径ctrl c
在这里插入图片描述
2.4 此电脑，右键，属性

在这里插入图片描述在这里插入图片描述2.5 高级系统配置
在这里插入图片描述2.6 环境变量

在这里插入图片描述2.7 新建系统变量
在这里插入图片描述
2.8 变量名为 CLASSPATH，变量值为 .;%JAVA_HOME%\lib;%JAVA_HOME%\lib\tools.jar 注意不要把**.**忘记
在这里插入图片描述2.9 变量值为 JAVA_HOME，变量值为 你刚刚复制的路径
在这里插入图片描述2.10 找到path，点进去，点击新建将“ %JAVA_HOME%\bin;%JAVA_HOME%\jre\bin;“填入
在这里插入图片描述

然后，就结束了，接下来让我们去试试是否成功安装了 Java

win+R 输入cmd
在这里插入图片描述然后输入javac，回车
，如果出现这种情况，就是成功了
在这里插入图片描述如果出现javac不是内部或外部命令，也不是可运行的程序
或批处理文件那么就是你上面哪一步出错了，建议在好好看看，加粗字体不能错

3第一个Java程序，hello world

3.1 找一个容易记的目录

我这边是在C盘新建了一个Java代码文件夹，点进去，新建一个文本文档

在这里插入图片描述点进去，新建一个文本文档
在这里插入图片描述命名为HelloWorld.txt，打开

在这里插入图片描述

把这个代码抄进去

public class HelloWorld{
     
    public static void main(String args[]){
     
        System.out.println("Hello World!");
    }
}

Ctrl+s 保存

在这里插入图片描述把文件名后缀改为.java
在这里插入图片描述

然后打开cmd命令行界面,输入cd \ 敲回车

在这里插入图片描述
然后cd java代码进入Java代码目录，输入javac HelloWorld.java
在这里插入图片描述
返回文件管理器，我们的Java代码界面可以看到多了一个HelloWorld.class的文件，这个是编译器将代码转为了字节码的格式，后面会详细说
在这里插入图片描述
然后回到cmd界面，输入java HelloWorld回车
在这里插入图片描述
然后就大功告成了，电脑返回给我们HelloWorld
在这里插入图片描述
我们的第一个Java程序就出来了，怎么样，有没有一种成功的快感

三、Java编辑器介绍

1.工具的选择

1.1 IntelliJ IDEA

这款IDE可以说是非常的优秀，主要还是看着十分的炫酷，是由JetBrains公司开发的，隶属于此家的工具（我所用到的）还有pycharm，是支持python开发的一款很强大的IDE。下面是相关截图,包含社区版和专业版，社区版是免费的
在这里插入图片描述
IntelliJ下载地址：
1.官网下载
2.百度云盘下载 码：8dvo

1.2 Visual Studio Code（vs code）

是一款免费开源的现代化轻量级代码编辑器，支持几乎所有主流的开发语言的语法高亮、智能代码补全、自定义热键、括号匹配、代码片段、代码对比 Diff、GIT 等特性，支持插件扩展，并针对网页开发和云端应用开发做了优化。软件跨平台支持 Win、Mac 以及 Linux

在这里插入图片描述
vs code 下载地址：
1.官网下载
2.百度云盘下载 码：aode

1.3EditPlus

EditPlus是一款由韩国 Sangil Kim出品的小巧但是功能强大的文本编辑器，小伙伴们可以使用EditPlus完成所有你想要的文本编辑功能。EditPlus也是一款非常好用的HTML编辑器，可支持C、C++、Perl、Java，EditPlus软件中有内建完整的HTML & CSS1 指令功能
(由于已经卸载，所以就不展示截图了。)

笔者初学Java的时候用的是IDE，后来到学校，老师是用EditPlus教的，再后来接触了VS code，现在学Android，Java只学基础语法就可以了，笔者推荐使用vs code，后面开发Android会用到AS Android Studio，是专业的Android原生开发工具，现在练习Java语法，使用vs code是够用的。当然，我们的代码演示都是以IDE来进行的，谁让我喜欢那个炫酷的界面呢

2.工具的安装

2.1 InterlliJ IDEA的安装

1.找到他并双击
在这里插入图片描述
2.next
在这里插入图片描述
3.这个地方可以更换安装地址，按照自己的需求和硬盘的大小安装
在这里插入图片描述
4.按照自己的需求勾选
在这里插入图片描述
5. 点击下载就行了

在这里插入图片描述
6.经过漫长的等待，终于是下载完成了，勾选这个
在这里插入图片描述
7.到这里社区版就安装好了，双击打开
在这里插入图片描述

8.这里没什么可说的
在这里插入图片描述
9.don‘t send
在这里插入图片描述

10. continue

11.选择样式，我更喜欢黑色的,下面选择安装一些插件（可以不选择，直接叉掉）
在这里插入图片描述
12.新建一个Java项目
在这里插入图片描述
13.选择jdk这个IDE一般会自动识别在哪里的
在这里插入图片描述
14.next两次
在这里插入图片描述

在这里插入图片描述
15. 这里面填写项目的名字，然后点完成
在这里插入图片描述
16.然后是这样1 2 3 按步骤走
在这里插入图片描述
17.创建一个包，com.项目名.作者名.名字，必须全部小写在这里插入图片描述
18.按照步骤走,
在这里插入图片描述
19.创建一个Java类，首字母大写，其他单词首字母也大写
在这里插入图片描述

20.输入main，回车
在这里插入图片描述
在这里插入图片描述
21.写一个HelloWorld小程序（上一篇教过，应该都没忘吧）
在这里插入图片描述
22.右键，或者ctrl+shift+f10运行,
在这里插入图片描述
23.运行结果
在这里插入图片描述
24.大功告成，完结撒花

2.2 vs code的安装

1.找到你下载的安装包双击
在这里插入图片描述
2.同意，下一步
在这里插入图片描述3.该选择的选择，然后下一步
在这里插入图片描述4.毋庸置疑，当然点击安装
在这里插入图片描述
5.安装完成
在这里插入图片描述
6.打开，点击这里
在这里插入图片描述
7.找到这个，点下载，我这里是禁用（因为我已经安装过一次）
在这里插入图片描述
9.创建一个新文件
在这里插入图片描述
10.调试为Java代码
在这里插入图片描述11.把之前写的HelloWorld粘贴进去保存为HelloWorld.java文件
在这里插入图片描述12.f5运行
会出现Hello World

四、java 基本语法

每个编程语言都有各自的基本语法，代码风格等，你既然学这门编程，不仅仅需要知道怎么使用，还要知道怎么使用好

1. 标识符

标识符就是变量、常量、方法、枚举、类、接口等 由程序员指定的名字。构成标识符的字母均有一定的规范

2.标识符命名规范

  1. 区分大小写：HelloWorld和helloworld是两个不同的标识符
  2. 关键字不能作为标识符
  3. 一般使用驼峰命名法
  4. 变量名首字母小写，其他单词首字母大写
  5. 方法名与变量名相似，驼峰命名法
  6. 包名全部小写，必须有唯一性，中间可以使用.分开
  7. 类名首字母大写，其他单词首字母大写
  8. 接口名首字母大写，其他单词首字母大写
  9. 文件名：采用大驼峰法，首字母大写，其他单词首字母大写
  10. 常量名全部大写

这么说可能有点难以理解，我就写段代码示例吧

package com.util.text; //包名，可以用.隔开，全部小写
 public class HelloWorld{
       //HelloWorld为类名
 	public static void main(String[] args){
      //main为方法名
 		int girlFriend = 1; //变量
 		int GirlFriend = 2; //另一个变量
 		final int PI = 3.14; //常量名
 		String 9io = "ds";  //这种命名方法是错误的,复制代码的时候，记得把这一行注释掉
 		String $io,_io = "s","aa"; //正确命名不过一般不用$做第一个
 		System.out.println(girlFriend + $io + GirlFriend + PI + _io);
 		//输出的会是1 s 2 3.14 aa
 	}
 }

3. 关键字与保留字

3.1.关键字

关键字是由Java本身定义的单词，具有一定其他作用，比如class是定义类的关键字，int是声明整型变量的关键字，下面放一张关键字的图片
想学习JavaSE吗？八万字JavaSE资料送给你！_第4张图片
具体都是什么作用，这个，我暂时也没有研究完全，哈哈

3.2 保留字

保留字是Java语言中既不能当作标识符使用，也不是关键字，也不能在程序中使用，也就是不能在程序里面出现的单词
1. goto：在其他语言中叫做“无限跳转”语句，在 Java语言中不再使用goto语句，因为“无限跳
转”语句会破坏程序结构。在Java语言中goto的替换语句可以通过break、continue和return实现“有限跳转”。
2. const：在其他语言中是声明常量关键字，在
Java语言中声明常量使用public static final 方式声明

4.分隔符

在Java源代码中，有一些字符被用作分隔，称为分隔符。分隔符主要有：分号（;）、左右大括号（{}）

4.1 分号

Java中只使用英文符号，使用半角分号作为每行表达式语句的结束

System.out.println(""); //用半角分号作为这行表达式语句的结束

4.2 大括号

Java中使用大括号分割不同的代码块，比如不同类，不同方法，不同的控制语句

public class TheTect{
     
	public static void main(String[] args){
     
		//代码块
		int a = 10;
		if(a == 10){
     
				    System.out.println("000");
				}
			}
}

第一个大括号是分割类，第二个大括号是分割方法，第三个大括号是分割条件控制语句

5.变量

变量应该先声明在定义，再使用，变量名命名规范上面有
我们应该先声明她的类型
按照这个格式去做 类型 变量名 = 值; 不要忘记以半角分号结尾

假如我们想定义一个名为helloWorld的字符串"Hello World!",我们需要这样做

String helloWorld = "Hello World!";
//定义一个常量 需要使用final关键字
final int S = 10;

6.注释

Java中含有三种注释格式

6.1 单行注释

使用 // 去注释

//这是单行注释

6.2 多行注释

使用
/*

xxxxxx

*/

注释xxxxxx

/**
这里是
多行注释
*/

6.3 文档注释

使用

/**

* 作者：xxx

* 日期：20210329

*/ 注释
可以使用javadoc生成注释文档

/**
* author: Smly
* data: 2021/3/29
* /

五、数据类型

1.基本数据类型

几乎与数学相同，先在脑子里搜刮一下关于数的数学知识

1.1 整型

  1. int类型

  2. short类型

  3. long类型

  4. byte类型
    想学习JavaSE吗？八万字JavaSE资料送给你！_第5张图片
int a = 1;
long b = 1;
byte c = 1;
short d = 1;
System.out.println("int类型："+ a +"\n" +"long类型："+ b +"\n" +"byte类型："+ c +"\n" +"short类型："+ d);
/* 输出以下结果：
int类型：1
long类型：1
byte类型：1
short类型：1
*/

1.2字符型

表示单个字符,定义时必须使用英文单引号\' ' 
```java

char a = ‘a’;
```

1.3浮点型

  1. 单精度浮点数float类型

  2. 双精度浮点数double类型
    想学习JavaSE吗？八万字JavaSE资料送给你！_第6张图片
float a = 1.0f;
double a = 1.0;

1.4布尔类型

在Java语言中声明布尔类型的关键字是boolean，它只有两个值：true和false

  1. false

  2. true

boolean isOK = true;
boolean noOK = false;

2.引用数据类型

除了基本类型以外的都是引用数据类型

2.1类

我觉得这个不用详细说，以后会有专门的章节细细讲到

2.2 接口

类似于抽象类，以后会在面向对象的知识点细细讲解

2.3 数组

数组就是一个存储多个数据的东西

//定义一个长度为10的整型数组
int[] a = new int[10];
//定义一个字符型数组
char[] ch = {
     'a', 'b', 'c','d'};
//两种定义数组的方法，一种是定义长度，一种是直接定义

2.4字符串类型

String a = "asd";

2.5顺便说一下

Java中变量定义时，先根据指定的类型分配一个内存地址，再将值放入其中
Java编译器将程序员写的Java源代码编译成字节码，然后通过Java解释器，转成二进制代码的格式交给计算机识别

六、运算符

想必各位都对这个并不陌生，什么+ - * / 的，大家都在数学中见过，但是还是有些不一样的地方的，那么跟着我来认识一下我们在Java中经常会见到的以后的熟人吧

运算符也有挺多类别，如常见的算术运算符，赋值运算符，逻辑运算符等，Java中有六种运算符：算术运算符，关系运算符，位运算符，赋值运算符，逻辑运算符，其他运算符

1. 算术运算符

顾名思义，是用来进行运算的，有+，-，*，/，++，–，%

+ 的作用是进行加法运算，这个应该上过小学的人都知道，那么来看看Java中是如何使用的吧

public class Te0{
     
	public static void main(String[] args){
     
		System.out.println("1 + 1 =  " +(1+1));
	}
}
//输出的结果是 ： 1 + 1 =  2
//2是运算结果，1+1=是字符串，不进行运算

- 的作用是进行减法运算，下面看代码演示

public class Te1{
     
	public static void main(String[] args){
     
		System.out.println("1 - 1 =  " +(1-1));
	}
}
//输出的结果是 ： 1 - 1 =  0，0是运算结果，1 - 1 = 是字符串，不进行运算

* 进行乘法运算，下面看代码演示

public class Te2{
     
	public static void main(String[] args){
     
		System.out.println("2 * 3 =  " +(2*3));
	}
}
//输出的结果是 ：2 * 3 =  6，6是运算结果，2 * 3 =  是字符串，不进行运算

/ 进行除法运算 5/4的结果默认是 1

public class Te3{
     
	public static void main(String[] args){
     
		System.out.println("5 / 4 =  "+(5/4));
	}
}
//输出的结果是 ：5 / 4 =  1，1是运算结果，5 / 4 =  是字符串，不进行运算

之所以5/4的结果是1，是因为，这些数字是默认为整型的运算结果自然也是整型
% 是取余运算符，意思就是，拿到余数

public class Te4{
     
	public static void main(String[] args){
     
		System.out.println("3 % 2 =  "+(3%2));
	}
}
//输出的结果是 ：3 % 2 =  1，1是运算结果，3 % 2 =  是字符串，不进行运算

++ 自增运算符，自己给自己加1 --(两个减号)，自减运算符，单目运算符，只能适用于变量

public class Te5{
     
    public static void main(String[] args){
     
        int a = 1;  //想使用单目，必须有变量
        a++; //等效于a=a+1，但是输出的话，输出的是后面的a，而不是前面的
        System.out.println(a);
        //结果是2
        /*
        可能还是很不理解，那么久来看看这个例子吧
        现在你叫张三，我给你个代号是a
        a++就是，我对你说：张三，以后你叫李四，我先喊你的名字，然后告诉你，你名字被我改成李四了
        ++a就是，我直接在你档案改了你的名字，所以我喊你，应该喊李四，而不是张三
        a--，--a同理
         */
    }
}

3.关系运算符

顾名思义，就是计算你们两个的关系的，关系运算符有：== 、!=、>、<、<=、>= 这里的都是英文符号，需要注意的是，关系运算符都是二目运算符，返回的都是布尔类型的数据true/false

  1. ==和数学中的=一样用法，比如，你看到别人这样写：1 = 2，你就下意识的知道，这是错的，同理，你在Java中写出1 == 2，计算机也是知道这是错的，他会告诉你：false
  2. != 不等于，和数学中的 ≠ \neq ​=是一样的，比如你看到1 ≠ \neq ​= 2，你会说，这是对的，同样的，你给电脑看1!=2，电脑也会告诉你，这是对的，true。
  3. 下面的大于小于，大于等于，小于等于，都和数学组的一样，想必上过小学的人，都不会理解不了吧——笑

4. 位运算符

位运算符主要针对的是二进制数据，并只适用于int ，short ，byte，long，char五种类型。
位运算符有，&、|、<<、>>、<<<、^、~

  1. ＆ 如果相对应位都是1，则结果为1，否则为0
  2. | 如果相对应位都是 0，则结果为 0，否则为 1
  3. ^ 如果相对应位值相同，则结果为0，否则为1
  4. 〜 按位取反运算符翻转操作数的每一位，即0变成1，1变成0
  5. << 按位左移运算符。左操作数按位左移右操作数指定的位数
  6. >> 按位右移运算符。左操作数按位右移右操作数指定的位数
  7. >>> 按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充
    这个计算是要有二进制来使用，我是没怎么用过。。所以理解的不够深入，尽请谅解

5. 逻辑运算符

既然有运算符，那么怎么能没有与或非呢，三种运算符：&&、 ||、 ！

  1. &&，这个就是与，也就是和逻辑，两个都必须满足，举个例子：我有女朋友和你有女朋友，那么，皆大欢喜。只要我没有女朋友或者你没有女朋友，就不说皆大欢喜，如果我俩都有，那就是皆大欢喜
  2. ||，这个是或，通用上面的例子，不过这次是只要我们俩其中一个有女朋友就是皆大欢喜
  3. !，这个是非，通用上面的例子，这次是我们俩都没有女朋友，就皆大欢喜（？怎么哪里怪怪的）

6. 赋值运算符

估计很多人都疑惑，为什么==是数学中的=，那么Java中的=是什么意思的呢？当当当当，就是这个赋值运算符了。当然，赋值运算符也是挺多的，不止一个=：=、+=、-=、*=、/=、(%)、<<=、>>=、&=、|=、^=，这里需要注意的是，这些赋值运算符都是双目运算符

  1. = 定义变量的时候，就要用这个，看下面的代码
    int a = 1;
    这句话的意思就是，将1的值给a，类型是int。这句话被执行后，a会在内存中分配一块整型的内存，然后将1的值，放入其中，举个例子，你是张三，我是李四，我们有一个秘密行动，你的代号是_007，我的代号是_008，那么用代码写出来就是：
    String _007 = "张三";
    String _008 = "李四";
  2. += 加等，顾名思义，写个例子就明白了：
    int a = 1;
    a += 1;//这个的意思就是a = a+1
  3. 剩下的也是如此，就不一一赘述了。。。

七、分支控制语句

包含循环控制语句和条件控制语句

1. 循环控制语句

1. 自我提问

今天学到了个新知识，在学习一个东西前，先提出自己的一些问题，然后在学习，可能效率会高一点，那么就来提出一些问题吧

  1. 什么是循环控制语句？
  2. 他能干什么？
  3. 它有什么类型？

2. 回答问题

1. 什么是循环控制语句？

循环控制语句在于循环，能够让你在进行重复的操作时省时省力

2. 他能干什么？

举个例子：让你从1数到100，你数出来，会花费不短的时间，但是你让计算机数的话，计算机很快就能给你数出来，甚至可以说是瞬间

这个例子可能不太恰当，那么就来一个更加容易理解，也是学循环控制语句被玩烂的东西：1累加到100。让你手动算的话，要花费很多时间（不要跟我说什么你会数学，也能很快算出来，咱这边先不考虑，只是举个例子），但是让程序去用循环控制语句算的话就很快，也是瞬间。

3. 它有什么类型？

  1. for循环，由关键字for开头的

for(初始化;表达式;更新){
     
	代码块
}

  1. while循环，由while关键字开头的

while(表达式){
     
	代码块
}

  1. do…while循环，由do开头，中间由while衔接的

do{
     
	代码块
	}while(表达式);

3. 使用

通过例子，帮助理解

1.使用for循环实现1-100的累加

public class 循环 {
     
    public static void main(String[] args) {
     
        int num = 0;  //声明一个用来接收累加结果的变量
        for (int i = 0;i<=100;i++){
     
            num = num + i;
        }
        System.out.println(num);
    }
}

for循环直接在for后面跟初始体(int i = 0)，限制条件(i<=100)和更新体(i++)，中间需要用半角分号隔开，这是不可更改的
这个代码的意思是：初始化i是0，限制i的最大值是100，每次进行将num+i的值赋值给num循环后，让i+1。循环100次。结果是5050。

2.使用while循环实现1-100的累加

public class 循环 {
     
    public static void main(String[] args) {
     
        int num = 0;
        int i = 0;
        while (i<=100){
     
            num = num + i;
            i+=1;
        }
        System.out.println(num);

    }
}

while循环里面的初始体需要在循环外面定义，更新体在循环内部，限制条件在while后面的括号里。

3.使用do…while实现1-100的累加

public class 循环 {
     
    public static void main(String[] args) {
     
        int num = 0;
        int i = 0;
        do {
     
            num = num + i;
            i+=1;
        }while (i<=100);
        System.out.println(num);

    }
}

do…while循环，先执行do后面的代码块，再进行更新体的更新

4.嵌套循环

循环我们已经知道了，那么嵌套循环是什么？
嵌套循环就是循环里面还有循环，用前段时间的网络用语就是循环套娃，当然，嵌套循环在生活中也是非常的常见的，比如：你要围着操场跑三圈，，每一圈都要跑多少步。跑三圈就是一个大点的循环，那么你跑一圈要多少步就是多少个小循环。那么代码表示大概就是这样：

  1. 跑的第一圈
    • 迈左脚
    • 迈右脚
    • …
  2. 跑的第两圈
    • 迈左脚
    • 迈右脚
    • …
  3. 跑的第三圈
    • 迈左脚
    • 迈右脚
    • …

1.嵌套循环代码展示

用代码将：跑三圈 ，每圈4步 表现出来

public class ForExample{
     
	public static void main(String[] args){
     
		        for (int i = 1;i<=3;i++){
     
		        	System.out.println("第"+i+"圈");
		            int j = 1;
		            while (j<=4){
     
		                System.out.println("迈左脚");
		                System.out.println("迈右脚");
			            j++;
            }
        }
		}
}

这个是for里面嵌套了一个while循环，外部循环一次，内部循环四次；意思就是按顺序循环，外面第一次循环，然后进入内部进行执行，进入内部又碰到循环，在里面需要把内部循环循环完成才能进行外部循环的第二次循环。这个代码循行的结果是：

/*
第1圈
迈左脚
迈右脚
(循环四次)
第2圈
迈左脚
迈右脚
(循环四次)
第3圈
迈左脚
迈右脚
(循环四次)
*/
//不展示那么多，免得说占字数

如果把这个理解了，那么可以尝试一下各种循环互相嵌套。

课后小练习

分别使用三个循环进行99乘法表的实现

2. 条件控制语句

条件控制语句用人的话来说就是，如果…就…
这么一听的话，是不是就觉得很简单了，那么去看看他怎么在代码中显示吧，不过在此之前，我们先去复习一下循环控制语句的小练习吧。

1.最简单的if语句

我们会在这里说明最简单的if语句，帮助理解if语句。

if(条件){
代码块
}
为什么说最简单呢，因为她只有一个if，没有别的了，意思就是，如果这个条件正确，就执行下面的代码块。如果错误，就跳过，条件的值必须是布尔值。比如：如果我十八岁了，我就可以去网吧上网。如果就是Java代码中的if，我是否十八岁是括号里面的条件，就可以去网吧上网是代码块。

int age = 18;
if (age>=18){
     
	System.out.println("可以去网吧上网");
}

是不是很简单，这个时候，我们可以这样做：

String text = "理解";
String me;
if (me == text){
     
	System.out.println("就这");
}

看懂的掌声，啪啪啪啪啪~~

2.if…else…语句

这次我们的if有了个跟班，名字叫做else，大家应该都学过英语，都知道是什么意思吧。没错，其他。

我们if…else…的格式是这样的：

if (条件表达式){
     
	代码块;
}else{
     
	代码块;
}

上面已经说过，条件的值是布尔类型的，只有两个值，true和false，那这个的意思就是，如果条件是true，那么就执行if下面的代码块，如果是false就执行else下面的代码块。
明天是周末，假如我们计划：如果明天不下雨，那么我就出去跑步，如果下雨，就在家里读书。那么用代码写出来，应该不是很难吧

String weather = "不下雨";
if (weather == "不下雨"){
     
	System.out.println("出去跑步");
	}else{
     
	System.out.println("在家读书");
}

3.if…else if…else… 语句

上面哪一种是只考虑了两种情况，但是有时候往往两种情况是不适用于我们的实际运用的，比如说成绩，60以下是不及格，60-80是及格，80-100是优秀，这就有了三种情况，用if…else…就不行了，而我们的if…else if…else 语句应运而生。
语句格式：

if(表达式){
     
	代码块;
}else if(表达式){
     
}else{
     
	代码块;
}

下面我们就对这个成绩进行划分

int score = 80;
if (score<60&&score>=0){
     
    System.out.println("不及格");
}else if (score>=60&&score<80){
     
    System.out.println("及格");
}else {
     
    System.out.println("优秀");
	}
}

当然，还能有更多的情况，更多的情况就是更多的else if

4.嵌套的条件控制语句

条件控制语句，我觉得就是限制住某个条件才能执行，而嵌套的if就是在限制了一个条件后，再进行一次限制。
比如我们上面的划分成绩的例子中，我么后在对60-80的同学进行限制的时候，是用了我们说过的逻辑运算符，与，这个我们也可以使用嵌套来做。
下面看看用代码显示吧。

int score = 81;
if (score>=60){
     
    if (score<80){
     
        System.out.println("及格");
    	}
	}
}

当然这个只是最简单的，我们就用嵌套把3中的第一个限制条件也改了吧

int score = 1;
if (score<60){
     
    if (score>=0){
     
        System.out.println("不及格");
    }
}else if (score<80){
     
    if(score>=60){
     
        System.out.println("及格");
    }
}else {
     
    System.out.println("优秀");
}

switch语句的格式

学习语法嘛，要先看怎么用的，也就是，格式

switch(表达式){
     
    case 值 ://语句
       break; //可选
    case 值 ://语句
       break; //可选
    //你可以有任意数量的case语句
    default : //语句 //可选
}

嚯，这一看，不得了：这是什么玩意啊？

不慌，我们先看看怎么用的，就用猜拳游戏当例子吧

import java.util.Random;
//导入Random包，用于取随机数
import java.util.Scanner;
//导入Scanner包，用于从键盘获取数据
public class 猜拳 {
     
    public static void main(String[] args) {
     
        Scanner sc = new Scanner(System.in);  //只有sc是自定义的，别的地方都是固定语法
        Random ra = new Random();  //固定语法
        System.out.println("请输入你猜拳的数！规则如下：");
        System.out.println("0——————石头");
        System.out.println("1——————剪刀");
        System.out.println("2——————布");
        int a = sc.nextInt();  //用a从键盘接受一个整形类型的数据
        int pc = ra.nextInt(2);  //用pc变量接受一个从0 1 2 中随机取的数
        String guiZe = null;  //初始化变量
        String pc1 = null;   //初始化变量
        switch (a){
     
            case 0: guiZe = "石头";
                break;
            case 1: guiZe = "剪刀";
                break;
            case 2: guiZe = "布";
                break;
        }
        switch (pc){
     
            case 0: pc1 = "石头";
                break;
            case 1: pc1 = "剪刀";
                break;
            case 2: pc1 = "布";
                break;
        }
        if (pc == a){
     
            System.out.println("平局！");
            System.out.println("你出的是："+guiZe);
            System.out.println("电脑出的是："+pc1);
        }else if (pc >= a){
     
            System.out.println("你输了！");
            System.out.println("你出的是："+guiZe);
            System.out.println("电脑出的是："+pc1);
        }else {
     
            System.out.println("你赢了！");
            System.out.println("你出的是："+guiZe);
            System.out.println("电脑出的是："+pc1);
        }
    }
}

好，以上就是代码了，一眼看过去不会还是这样的感觉吧？（woc，这是什么鬼？）这都学到这里了，是时候该自己看代码了。——无良作者，什么时候学过Scanner和Random的，明明没有，掀桌 凸(艹皿艹 )

话外语

Random包，用于取随机数

Random ra = new Random();
ra.nextInt(2);

Scanner包，用于从键盘获取数据
用法：

Scanner sc = new Scanner(System.in);
sc.next类型();类型首字母必须大写

与switch语句再续前缘

好，话外语已经说完了，继续我们的switch，既然代码那么长，就是看switch的部分吧

switch (a){
     
    case 0: guiZe = "石头";
        break;
    case 1: guiZe = "剪刀";
        break;
    case 2: guiZe = "布";
        break;
    default: guiZe = "不符合规则";
}
switch (pc){
     
    case 0: pc1 = "石头";
        break;
    case 1: pc1 = "剪刀";
        break;
    case 2: pc1 = "布";
        break;
}

这个看着蛮复杂的，其实也算是个条件控制语句，我们先看第一个，其实只看第一个也就行了，开整，冲
如果a的值和case后面的值相等了，那么就执行冒号后面的代码，而如果没有相等的，就执行default后面的代码。好，我觉得我说的很详细了，就不多说了！
我觉得在这里插入图片描述

多一嘴

好吧，还是有必要多说几句的
表达式的值可以是：byte、short、int 、char、String，且case标签必须是字符串常量或字面量
好了，这次是真的没了！

彩蛋

本来是不想说的，但是看很多人都没发现，还是说一下，文中的猜拳小游戏有些逻辑上的错误哦，由于懒（确实是懒，不是理由哈哈），错误是什么我就不说了，自己找吧，就当锻炼一下自己，当程序员，找错是必不可少的技能，冲冲冲

课后小练习

判断一个数（由自己定义）是否是质数

什么是质数：只能被1和他本身整除的数就是质数。 例如：2、3、5、7、11、13…

课后小练习答案

1. for循环实现九九乘法表

首先先分析分析怎么做到，我们知道，循环是连续执行的，那么怎么让程序将九九乘法表展示给我们呢？我们先回顾一下九九乘法表长什么样子
在这里插入图片描述

回想一下我们的循环，再结合这张图，我们能想到什么呢？第一行，只有一个，第二行，两个，第三行，三个…
我们可以用嵌套循环，外部循环表示纵的，内部循环表示横的，第一次循环，只输出1*1=1，只循环一次，第二行循环2次。。。做为限制条件，横的有9行，外部循环就以9为限制条件，那内部循环用什么呢，用纵列和行数的关系做为限制条件，就行了，代码如下

public class Te0 {
     

    public static void main(String[] args) {
     
        for (int i = 1;i<=9;i++){
     
            for (int j = 1;j<=i;j++){
     
                System.out.print(j+"*"+i+"="+(i*j)+" ");
                //这个地方注意要用print，这个函数的意思是输出完不换行
                //后面加空格是不让每个都连在一起
            }
            System.out.println(" ");
            //这句的作用是，每次循环结束后，换行
        }
    }
}

结果：

1*1=1  
1*2=2 2*2=4  
1*3=3 2*3=6 3*3=9  
1*4=4 2*4=8 3*4=12 4*4=16  
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25  
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36  
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49  
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64  
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81

2.质数

先回顾一下题目：

判断一个数（由自己定义）是否是质数

什么是质数：只能被1和他本身整除的数就是质数。 例如：2、3、5、7、11、13…

想必对大家来说这个是很简单的吧！

import java.util.Scanner;
public class Test {
     
    public static void main(String[] args) {
     
        boolean isPrime = true;
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个正整数");
        int num = sc.nextInt();
        if (num > 0) {
     
            int k = (int) Math.sqrt(num);//k为num的正平方根，取整数 
            // 考虑平方根是为了减少重复量，开平方后面的数不处理
            /*
            素数是因子为1和本身， 如果数c不是素数，则还有其他因子，其中的因子
            假如为a,b.其中必有一个大于sqrt(c) ， 一个小于sqrt(c) 
            所以m必有一个小于或等于其平方根的因数，那么验证素数时就只需要验证到其平方根就可以了
            */
            for (int i = 2; i <= k; i++) {
     
                if (num % i == 0) {
     
                    isPrime = false; //不是素数
                    break;
                }
            }
        }
        if (isPrime) {
     
            System.out.println(num + "是素数");
        } else {
     
            System.out.println(num + "不是素数");
        }
    }
}

就不多做赘述了

八、功能类的使用

Java中有一些比较常用的类可以使用，今天就去学习一下# 关于数学的类Number类和Math类，一个是将内置数据类型装箱成对象，一个是进行数学中的相关运算

1.Number类

虽然Java语法中有着基本数据类型，但是有的时候我们在使用中，往往需要将数据作为对象来使用，所以Java中将数字的int、short、long、float、double、byte这几种内置数据类型都封装进类中，分别是Integer、Short、Long、Float、Double、Byte而他们都是Number类的子类，继承自Number类。
并且由于这些类都用了final修饰词修饰，所以是无法被继承，重写的。(继承这个后面会讲，大概意思就是父类有的，子类也有，父类没有的，子类也可以有)。
而关于基本数据类型的包装类，还有两个，一个是Character类，另一个是Booleam类。Number类在java.lang包中，包括它的子类也在java.lang中。这种由编译器特别支持的包装称为装箱，所以当内置数据类型被当作对象使用的时候，编译器会把内置类型装箱为包装类。
相似的，编译器也可以把一个对象拆箱为内置类型。

1.定义声明使用

使用方法上和内置还是数据类型没什么区别都是先写类型名/类名+空格+变量名+赋值运算符+值+半角分号，以Integer为例：

public class Te0{
     	
    public static void main(String[] args){
     
        Integer a = 10;          
        b= a + 10;        
        System.out.println(b);	
    }
}

运行结果

20

别的类也是同样的用法

2.Mtah类

Java 的 Math 包含了用于执行基本数学运算的属性和方法，如初等指数、对数、平方根和三角函数等运算，由于Math类是静态类（static），所以其中的方法可以直接调用，同样的Math类也不需要导入可以直接使用。
我爱数学，大爱数学

1.基础用法

既然是用于数学运算的类，那么就不得不提一下两个量，一个是 π \pi π （圆周率3.1415926…），一个是e （自然常数）。
在Math类中，也有这两个量，使用final修饰，表示不可变的常量
π \pi π 在Java的Math中是Math.PI
e 在Java的Math中是Math.E。

public class Te1{
     	
    public static void main(String[] args){
     
        System.out.println(Math.PI+" "+Math.E);	
    }
}

输出结果：

3.141592653589793 2.718281828459045

2. 常用方法

话不多说，咱就直接上干货！（干货？！真的是干货吗？作者竟然能写干货，稀奇）

  1. abs() 求绝对值
    Math.abs(-10); //结果：10
  2. ceil() 向上取整
    Math.ceil(5.2); //结果：6.0 直接让个位+1
  3. floor() 向下取整
    Math.floor(5.7); //结果：5.0 直接让个位-1
  4. max() 最大值
    Math.max(5, 6.2); //结果：6.2 比较两个数的大小，返回大的
  5. pow() a的b次幂
    Math.pow(2, 3); //结果：8.0 返回2**3的结果，结果为double类型
  6. random() 随机数
    Math.random(); //结果：一个0-1的随机数，注意里面没有参数
  7. round() 四舍五入
    Math.ronud(11.1); //结果：11
  8. sqrt() 求平方根
    Math.sqrt(2); //结果：1.4142135623730951
  9. sin() cos() tan() asin() acos() atan() 三角函数和反三角函数

简单的将方法叭叭后，就要动手练练？或者说是看一下运行结果？对，来了。

System.out.println(Math.sin(Math.PI/2));  //结果：1.0 求正弦值
System.out.println(Math.cos(Math.PI/2));  //结果：6.123233995736766E-17  求余弦值
System.out.println(Math.tan(Math.PI/2));  //结果：1.633123935319537E16  求正切值
System.out.println(Math.asin(0.5);  //结果：0.5235987755982989  求sin的反函数值
System.out.println(Math.acos(0.5));  //结果：1.0471975511965979  求cos的反函数值
System.out.println(Math.atan(0.5));  //结果：0.4636476090008061  求tan的反函数值

3.String相关类

总共这几种：String 、StringBuffe、 StringBuilder三种String是无法修改的，当对字符串进行修改的时候，需要使用 StringBuffer 和 StringBuilder 类。
StringBuilder和StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）。
由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类

1. String类

1.1定义

  1. 直接定义法
    String str = "Hello World!";
  2. 创建对象法
    String str1 = new String("Hello World!");
    两个方法区别是什么呢？第一种如果字符串内容相同的话，那么两个变量就会指向同一个字符串，可以理解为一个人有多个名字（网名）；第二种内容相同的话，把他们用equals()方法比较的话，就会返回false，因为他们是两个实例化对象，可以理解为：世界上有两个人名字相同，但是不是一个人

1.2使用

  1. 字符串拼接

    1. 使用+号拼接
      System.out.println("Hello"+" "+"World"+"!"); //结果：Hello World！

    2. 使用concat方法

    System.out.println("Hello ".concat("World!")); //结果：Hello World！

  2. 字符串格式化

    就是通过某种符号，将字符串格式化输出，可以这么理解：如果我要使用的字符串有可变量，比如说我跑步的时候，每跑一圈都要喊一句：跑了x圈。那么我们就可以使用字符串格式化。
    —— 有人会说，之前用的时候，不是用的+号吗？
    —— 确实，可以使用+号，不过如果有多个量的话，+会不会显得有一点繁琐了呢？
    所以我们学过以后就可以用格式化字符串的方法了，既显得逼格高，又好用，岂不美哉？

System.out.printf("He%slo Wo%sld! ", "l","r"); 
//第一种方法结果是：Hello World %s表示占位符，可以表示任何类型的
//同样的占位符还有%d ，表示数字的
System.out.println(String.format("He%slo Wo%sld! ", "l","r")); 
//第二种方法结果是：Hello World!

  1. 字符串比较

System.out.println("a".equals("b")); //结果是：false

  1. 字符串按照元素找下标

System.out.println("appdata".indexOf("t")); //结果是：5 如果没有找到，则返回-1

  1. 字符串长度

System.out.println("appdata".length()); 
//结果是：7 返回字符串的长度

2.StringBuilder类

与String不同的是，StringBuilder类的对象是可变的，意思是什么呢，就是我们可以直接在原对象上进行操作，而不会生成一个新的对象。

2.1定义使用

StringBuilder是一个类，所以通过new关键词来实例化对象

StringBuilder s1 = new String("hello world"); //直接写字符串，进行初始化
StringBuilder s2 = new StringBuilder(5);  //定义一个长度，不进行初始化
System.out.println(s1+" "+s2);
s1.append("12345");
s1.append("666");
System.out.println(s1+" "+s2);
/*
输出结果为：
1234512345666 12345 
*/

2.2常用方法：

  1. 字符串.append\(\); 一个参数在原字符串后面加新的内容，上面第一四步就是在空字符串上加12345

StringBuilder s1 = new StringBuilder("hello world");
s1.append("!");
System.out.println(s1);  
//结果：hello world!

  1. 字符串.insert\(\); 两个参数

StringBuilder s1 = new StringBuilder("hello world");
s1.insert(10,"!");
System.out.println(s1);  
//结果：hello world!

第一个参数为字符串下标，第二个为内容，将内容添加到下标前面
3. 字符串.delete() 两个参数;两个参数都是下标，第一个是起始下标，第二个是终止下标，将两个下标之间的内容删除。

StringBuilder s1 = new StringBuilder("hello world!");
s1.delete(0, 4);
System.out.println(s1);
//结果是： world!

3.StringBuffer类

StringBuffer类和StringBuilder类一样，对象都是可变对象。

3.1定义

StringBuffer s1 = new StringBuffer ("123");
// 实例化对象为s1，并初始化为123
StringBuffer s1 = new StringBuffer ();
//实例化对象为s1，并不进行初始化

3.2使用

StringBuffer s1 = new StringBuffer ("123");
s1.append("1")
System.out.println(s1);  //追加1，输出：1231
s1.replace("1", "2")
System.out.println(s1);  //将1替换成2，输出：2232
s1.insert(3, "2")
System.out.println(s1);  //在下标为3的后面插入2，输出：22322
s1.delete(1, 2)
System.out.println(s1);  /删除从下标为1到下标为2的值，输出222

就这么多了，不过开头我也说了，这都是基操，所以，就这样吧。

4.Scanner类和Random类

一个是控制输入的类，一个是随机数类

4.1Scanner 类

从键盘获取数据，位于java.util包下，使用需要先导入

1. 上手

  1. 先导入

import Java.util.Scanner;

  1. 再实例化

Scanner scan = new Scanner (System.in);
//为Scanner类实例化一个名为scan的类，用于接收从键盘获取的数据

  1. 使用

int a = scan.nextInt();
//声明整型变量a，将从键盘获取的数据存入a中，输入的时候必须为整数，否则报错
float b = scan.nextFloat();
//声明单精度浮点数变量b，将从键盘获取的数据存入b中，输入的时候必须为单精度浮点数，否则报错
char c = scan.nextChar();
//声明字符型变量c，将从键盘获取的数据存入c中，输入的时候必须为字符型，否则报错
String d = scan.next();
//声明字符串d，将从键盘获取的数据存入d中，输入的时候必须为字符串，否则报错
System.out.println(a+" "+b+" "+c+" "d);
//可以像使用普通变量一样去通过变量名调用他们

好了，没了，我会的就这么多了，学识短浅

4.2Random类

随机数类，简单实用，真的超级简单的用法

1.定义

Random rd = new Random ();
//第一种方法：实例化一个Random类对象
Random rd2 = new Random (10);
//第二种方法：根据种子值实例化一个对象

2.使用

System.out.println(rd.nextInt()); //生成一个随机整型数
System.out.println(rd.nextDouble()); //生成一个0-1的双精度浮点数
//…还有别的，用法是next+首字母大写的基本数据类型名字，和Scanner接收数据的用法差不多
System.out.println(rd.nextInt(5)); //生成一个0-5之间的随机整数
System.out.println(rd.nextDouble()*5); //生成一个0-5的小数

差不多这就够用啊，就这样咯

九、数组

什么是数组？在Java中，数组就是存储多个相同数据的集合，他们的内存地址是相邻的，所以可以通过数组取值。

这么说，是不是有点不好理解，那么这样呢？

我有一颗白菜，手拿着就能回家，那如果是十几颗呢？

我就可以用麻袋！麻袋！装进去，带回家！是的你要存的数据就是白菜，而这个数组就是你要用的麻袋~~~~~

麻袋中的白菜怎么拿出来我需要用的呢？

下标，Java中的下标是以0开始的，什么是下标，就是你从0开始查，查到某个你要的数据，查到几，下标就是几，就相当于，我在装白菜的时候，说“这是第0个白菜，这是第1个白菜…”，而他们也能听懂（别管他们能不能听懂，我说能就能，哈哈~~），等我需要哪一颗白菜的时候，喊一声，他就自己跳出来了

白菜可以是任意类型的，但是麻袋要和白菜必须是同样的类型

1.一维数组

1.1 定义

两种方法

  1. 直接定义法：直接把白菜装进麻袋a里

int[] a = {
     1,2,3,4,5,6,7};

  1. 实例化对象定义，初始化大小：不知道有什么白菜，先拿一个知道大小的麻袋a，然后再往里面装白菜

int[] a = new int[10];

1.2添加元素

多种数据，多种数据，多种数据，重要的事情说三遍
多种，怎么办？一个一个往里面装~~
怎么一个一个装？这种重复的事情，当然交给循环来干了！
比如说我要把1-66装进去

int[] a = new int[66];
for(int i = 0;i<a.length;i++){
     
	a[i] = i+1;  //这就是我告诉白菜，你是第i个白菜
}

1.3查找元素

我要把名字叫做5的白菜从麻袋里面拿出来，怎么做？

想必你们也都看到了这个a[i]，这个就是对麻袋a中叫做i的白菜进行操作~

代码接着上面的

System.out.println(a[5]);  
//结果是6，为啥是6，因为我们的白菜是从1开始往里面装的，而名字是从0开始取的

如果想全部取出，也可以用循环选手哦！

2.多维数组

如果我的白菜，有的老，有的嫩，我想分开装，怎么办?

我告诉你，你这没必要用多个麻袋装，你可以在麻袋里在放几个麻袋啊。

这叫做：多维数组（麻袋里面的白菜，换成了麻袋，然后麻袋里面的麻袋里面装白菜）

2.1定义多维数组

定义一个里面含有三个麻袋的麻袋，每个麻袋可以装4个白菜

int[][] a = new int[3][4];

2.2多维数组的下标取值

先打开这个a[]大麻袋，再打开里面的a[0][]小麻袋，然后才能往里面放白菜

小麻袋也有名字，也是下标，我们要往麻袋里面的第一个小麻袋的第一个位置放一个名字叫做1的白菜，这样做：

a[0][0] = 1;

2.3往多维数组添加元素

先往第一个小麻袋放，在往第二个小麻袋放…

for (int i = 0;i<a.length;i++){
     
            for (int j = 0;j<a[0].length;j++){
     
                a[i][j] = j;
	}
}

2.4根据下标查找元素

将我们的数组输出就行了

System.out.println(Arrays.toString(a[0]));
System.out.println(Arrays.toString(a[1]));
System.out.println(Arrays.toString(a[2]));

结果是：

[0, 1, 2, 3]
[0, 1, 2, 3]
[0, 1, 2, 3]

3.Arrays类操作数组

我们可以使用Arrays类操作我们的麻袋

3.1给数组赋值：通过 fill 方法。

将指定的 int 类型白菜分配给指定 int 型麻袋指定范围中的每个元素

int[][] a = new int[3][4];
Arrays.fill(a[0], 5);
Arrays.fill(a[1], 5);
Arrays.fill(a[2], 5);
System.out.println(Arrays.toString(a[0]));
System.out.println(Arrays.toString(a[1]));
System.out.println(Arrays.toString(a[2]));
/*
输出结果:
[5, 5, 5, 5]
[5, 5, 5, 5]
[5, 5, 5, 5]
*/

3.2数组排序：通过 sort 方法

按升序排序，从小到大

int[][] a = new int[3][4];
//随便给几个值
a[0][2] = 5;
a[1][3] = 3;
a[2][0] = 4;
System.out.println(Arrays.toString(a[0]));
System.out.println(Arrays.toString(a[1]));
System.out.println(Arrays.toString(a[2]));
/*
排序前：
[0, 0, 5, 0]
[0, 0, 0, 3]
[4, 0, 0, 0]
*/
Arrays.sort(a[0]);
Arrays.sort(a[1]);
Arrays.sort(a[2]);
System.out.println(Arrays.toString(a[0]));
System.out.println(Arrays.toString(a[1]));
System.out.println(Arrays.toString(a[2]));
/*
排序后：
[0, 0, 0, 5]
[0, 0, 0, 3]
[0, 0, 0, 4]
*/

3.3比较数组：通过 equals 方法

比较数组中元素值是否相等。
不相等返回false

int[][] a = new int[3][4];
int[][] b = new int[3][4];
System.out.println(Arrays.deepEquals(a, b));
//结果：false

小练习

定义两个数组，一个用于存放学生学号，一个用于存放学生姓名，使用循环同时打印学号与姓名

小练习答案

很简单的一个题，想想怎么做。
定义就不说了，很简单的，如何将他们两个同时显示，其实也很简单，就看脑子转不转的过来圈。

public class Hello{
     
  public static void main(String[] args){
     
    // 先定义两个数组
    int[] ids = new int[]{
     1001, 1002, 1003, 1004, 1005};
    String[] names = new String[]{
     "张三", "李四", "王二", "麻子", "张武"}；
    for (int i=0;i<ids.length;i++){
     
      System.out.println("姓名是："+names[i]+"学号是："+ids[i]);
    }
  }
}

十、面向对象

编程语言有面向对象（Java，Python）和面向过程（C语言）之分，面向对象需要一些抽象的思维才行。

面向过程和面向对象有什么区别呢？

面向过程注重亲力亲为，意思也就是自己去干这件事；而面向对象更倾向于找个人给自己做事。

就拿那个老生常谈的例子来说吧——洗衣服：

1.面向过程

面向过程的洗衣服是每次洗衣服都需要：

  1. 把衣服拿到洗衣机旁边
  2. 放进去
  3. 等待
  4. 捞出来

等下一次洗衣服，你还得重复这些操作

2.面向对象

而面向对象则是：

  1. 创造一个机器人

  2. 教他如何洗衣服

    1. 把衣服拿到洗衣机旁边
    2. 放进去
    3. 等待
    4. 捞出来

  3. 让他去干活

等下一次需要洗衣服，就让机器人去干，我们只需要歇着就行了

而面向对象绕不开的就是类和对象了，接着往下看吧

3.类

那么什么是类呢？类，分门别类的类，类别的类，人“类”就是我们现实生活中的一个类，而每一个人就是一个对象。

对象就是特殊个体，类就是一般个体，可能还是不那么好理解，我就再详细点

“我认识一个叫做丸子的女孩”——这句话中，丸子就是对象，代表一个真正的人，具体的人；而女孩就是类，代表一个抽象的东西，一个笼盖所有女孩的类别。

3.1自定义类

把具有相同特征的一些东西/事物分门别类，我们自己造一个名字

好，我们现在造一个火柴盒妹子类，用比较艺术化的话来说就是：只具其形，不具其神！

class Girl{
     
    
}

好了，这就是我们的女孩类，是不是感觉啥都没有，不对不对，Java类中有一个默认的东西，叫做构造方法，构造方法，构造方法，重要的事情说三遍！
构造方法：实例化对象时，自动调用，默认会存在一个无参数的构造方法

1. 无参构造方法

默认构造方法，只用于创建实例化对象，无法接受参数

public class Ec4_19 {
     
    public static void main(String[] args) {
     
        Girl girl = new Girl();
        System.out.println(girl);  //Girl@4517d9a3，返回的是内存地址
    }
}
class Girl{
     

}

2. 有参构造方法

Java类中可以创建多个构造函数，但是参数和返回类型不能相同，这种情况叫做重载，意思就是你可以创建很多个构造函数

public class Ec4_19 {
     
    public static void main(String[] args) {
     
        Girl girl = new Girl();
        Girl girl1 = new Girl("Jecy");
    }
}
class Girl{
     
    Girl(String name){
     
        System.out.println("有参构造函数"+"  "+name);
    }
    Girl(){
     
        System.out.println("无参构造函数");
    }
}
/*
输出结果为：
无参构造函数
有参构造函数  Jecy
*/

应该已经了解构造函数了吧，啊，这个实在想不出来什么骚话来形容~~

3.2类的属性

类中有属性，分为成员变量，局部变量和类变量
在我们创建的女孩类中，属性就是女孩们的诸如身材，相貌等的东西，当然，像什么年龄名字的，也是必须有的，不过不同的属性有不同的作用，所以属性也分上面三种

1.成员变量

在类中，方法外定义，在实例化对象时创建，并可以被实例化对象拿去用(赋值，修改)，不多说，看代码

public class Ec4_19 {
     
    public static void main(String[] args) {
     
        Girl girl = new Girl(); //实例化对象
        girl.age = 10;  //调用 设置成员变量值
        girl.name = "Jeccy";  //调用 设置成员变量值
        System.out.printf("%s今年%d岁了",girl.name, girl.age);
    }
}
class Girl{
     
    public int age;
    public String name;
}
/*
输出结果为：
Jeccy今年10岁了
*/

2. 局部变量

在方法中定义，作用于在定义的方法中，也就是说只在该方法中能够使用，比如在构造方法中的变量，就无法通过实例化的对象调用

public class Ec4_19 {
     
    public static void main(String[] args) {
     
        Girl girl = new Girl(10,"Jeccy");  //用有参构造方法实例化对象
        System.out.printf("%s今年%d岁了",girl.name, girl.age);
    }
}
class Girl{
     
    public int age;  //成员变量
    public String name;  //成员变量
    Girl(int a, String n){
     
        age = a;  //局部变量，无法通过实例化对象直接调用
        name = n;  //局部变量
    }
}
/*
输出结果为：
Jeccy今年10岁了
*/

3. 类变量

需要通过static修饰符修饰，可以直接通过类名调用

public class Ec4_19 {
     
    public static void main(String[] args) {
     
        Girl.name = "西施";
        Girl.age = 10;
        System.out.printf("%s今年%d岁了",Girl.name, Girl.age);
    }
}
class Girl{
     
    public static int age;
    public static String name;
}
/*
运行结果：
西施今年10岁了
*/

4. 私有属性

无法被外界访问的属性，就是私有属性，就像女孩们有些东西不会被别人知道一样（比如三围之类的啦）

public class Ec4_19 {
     
    public static void main(String[] args) {
     
        Girl.name = "西施";
        Girl.age = 10;
        System.out.printf("%s今年%d岁了",Girl.name, Girl.age);
    }
}
class Girl{
     
    private static int age;
    private static String name;
}
/*
这样写，就算是定义的静态方法，但是因为是私有的，也无法被访问
运行会报错
*/

3.3类的动作/方法

行为就是方法，一般来说，Java类的规范写法是为每个属性设置一个setXxx方法，一个getXxx方法，并且将每个属性设为私有方法
就像这样：这是一般的规范写法

public class Ec4_19 {
     
    public static void main(String[] args) {
     
        Girl girl = new Girl();
        girl.setAge(10);
        girl.setName("Jerry");
        System.out.printf("%s今年%d岁了", girl.getName(), girl.getAge());
    }
}
class Girl{
     
    private int age;
    private String name;
    void setName(String name){
     
        this.name = name;
    }
    String getName(){
     
        return name;
    }
    void setAge(int age){
     
        this.age = age;
    }
    int getAge(){
     
        return age;
    }

}

当然，也有别的普通的方法，比如妹子会撒娇，会打游戏之类的

public class Ec4_19 {
     
    public static void main(String[] args) {
     
        Girl girl = new Girl();
        girl.setAge(10);
        girl.setName("Jerry");
        girl.playGame();
        System.out.println("");
        girl.coqutry();
        System.out.printf("%s今年%d岁了", girl.getName(), girl.getAge());
    }
}
class Girl{
     
    private int age;
    private String name;
    void setName(String name){
     
        this.name = name;
    }
    String getName(){
     
        return name;
    }
    void setAge(int age){
     
        this.age = age;
    }
    int getAge(){
     
        return age;
    }
    void playGame(){
     
        System.out.printf("%s打游戏很厉害", name);
    }
    void coqutry(){
     
        System.out.println("哥哥不要这样啦，人家害怕啦~~~");
    }

}
/*
运行结果：
Jerry打游戏很厉害
哥哥不要这样啦，人家害怕啦~~~
Jerry今年10岁了
*/

3.4继承

继承就是我们的孩子，有我们造的妹子的特性，比如说：孩子长得像他妈妈啦，性格像她妈妈啦之类的

虽然在Java中，被继承的类叫做父类，但是我们也是可以这么理解的~

后面我就叫做母类了，emmm原谅我，我只是觉得这样更好听一点

当然，Java中，类的继承只支持单继承

public class Ex4_22 {
     
    public static void main(String[] args) {
     
        Child ch = new Child();
        ch.setAge(10);
        int age = ch.getAge();
        System.out.println("孩子的年龄是："+age);
        System.out.println("孩子会撒娇");
        ch.coqutry();
    }
}
class Child extends Girl{
     
    /*
    孩子继承了妈妈的特性
    */
}
/*
运行结果：
孩子的年龄是：10
孩子会撒娇
哥哥不要这样啦，人家害怕啦~~~
*/

3.5重写与重载

1. 重写

就是我们的孩子虽然已经继承了妈妈的东西，但是有些东西总不能是完全一样的

这个时候就要重写操作，可以将母类的东西改变，延伸

当然，我们的重写必须是跟母类的形参和返回值是相同的、、、

public class Ex4_22 {
     
    public static void main(String[] args) {
     
        Child ch = new Child();
        ch.setAge(10);
        int age = ch.getAge();
        System.out.println("孩子的年龄是："+age);
        System.out.println("孩子会撒娇");
        ch.coqutry();
    }
}
class Child extends Girl{
     
    public void coqutry(){
     
        System.out.println("粑粑，我好爱你哦~~~");
    }
}
/*
运行结果：
孩子的年龄是：10
孩子会撒娇
粑粑，我好爱你哦~~~
*/

2. 重载

重载是构造方法的重载，之前说过就不说了

3.6封装

还记不记得我之前说过的规范

一般将属性设置为private，私有类型，无法被外界的访问

而对于这样的属性，我们一般需要对每个属性设置两个方法，
一个是getXxx()， 一个是setXxx()，用于对属性初始化和调用
这个过程就是封装

class Girl{
     
    private int age;  //这个是年龄属性
    private String name;  //这个是姓名属性
    public void setName(String name){
     
        /*
        设置名字
        参数：name 名字
         */
        this.name = name;
    }
    String getName(){
     
        /*
        获取名字
         */
        return name;
    }
    public void setAge(int age){
     
        /*
        设置年龄
         */
        this.age = age;
    }
    public int getAge(){
     
        /*
          获取年龄
         */
        return age;
    }
}

4.接口

接口使用interface关键词来定义

interface Text{
     
    //定义一个接口
}

接口是抽象方法的结合，被类继承
接口支持多继承（可以继承爸爸妈妈爷爷奶奶很多人的特性）

接口没有构造方法，因此无法进行实例化对象操作，只有在被类继承后，才可以继承用到接口中的方法

接口被类继承需要用到implements关键词

public class Ex4_22 {
     
    public static void main(String[] args) {
     
        Text_1 te1 = new Text_1();
        te1.eat();
    }
}

interface Text_0 {
     
    int a = 0;
    public void eat();
}
class Text_1 implements Text_0 {
     
    public void eat(){
     
        System.out.println("00");
    }

}
//运行结果：00

5.抽象类

抽象类并没有那么多属性可以去描绘一个完整的个体

public abstract class Ex4_22{
     
    //定义一个抽象类
}

抽象类的方法也是抽象的，就是不具体的，就比如

我会说话，但是你只知道我会说话，而不知道我会说什么话，而这个会说话的方法就是抽象方法。

public abstract void print();//抽象方法，没有方法体，有abstract关键字做修饰

和接口不同的是，抽象类虽然无法实例化对象，但是抽象类是个类，有构造方法
所以抽象类一般在设计程序的时候就要考虑是否定义

而抽象类被继承后，继承抽象类的类需要将抽象类的抽象方法重写，使其具体化

public class Ex4_22 {
     
    public static void main(String[] args) {
     
        Text te = new Text();
        te.print();
    }
}
abstract class Ex4_2 {
     
    //定义一个抽象类
    public abstract void print();//抽象方法，没有方法体，有abstract关键字做修饰
}
class Text extends Ex4_2{
     
    public void print(){
     
        System.out.println("Hello");
    }
}
//运行结果：Hello

6.枚举

Java 枚举是一个特殊的类，一般表示一组常量

比如妹子的性别等

使用enum定义

enum Gender{
     
    MAN, WOMAN;
}
 
public class Test{
     
    // 执行输出结果
    public static void main(String[] args){
     
        Gender c1 = Gender.MAN;
        System.out.println(c1);
    }
}
//运行结果：MAN

可以使用switch语句来使用

enum Gender{
     
    MAN, WOMAN;
}
public class Ex4_22 {
     
  public static void main(String[] args) {
     
    Color myVar = Gender.MAN;

    switch(myVar) {
     
      case :
        System.out.println("男性");
        break;
      case WOMAN:
         System.out.println("女性");
        break;
    }
  }
}
//运行结果：男性

枚举可以在类内部定义

十一、异常与处理

在Java开发中，经常会遇到错误，这个时候就要学到异常处理，当然，学异常处理之前，我们应该先学学异常是什么~

异常就是我们在写代码的时候，爆红啦，高亮啦什么的，还有运行的时候碰到的各种报错啦

我们经常会因为各种各样的报错而头疼——哦！天呐！又报错了！

但是我们应该想想好的，我们编程水平不也随着解决各种各样的报错而提高了吗？

当然我们也可以通过某些方式来避免这种异常，当然这是我们在解决了许许多多的报错后的事啦，也就是现在！是的没错就是现在!O(∩_∩)O哈哈~

一般分为三个类型：编译时错误 、运行时错误 、逻辑型错误

1.常见的异常类型

1.1编译时错误

就是在写代码的时候，出现了语法上的错误，比如在定义变量的时候

int i = 1

在这里，我们就犯了个编译时的错误，少打了一个作为每句表达式结束的英文分号

1.2运行时错误

就是语法上没有出现错误，但是编译的时候会出现错误，比如

double[] a =  {
     1.0, 2.0};
System.out.println(a[3]);

在这里，虽然不会爆红，但是却会在运行的时候出现错误

Index 3 out of bounds for length 2

意思是索引超出范围，我们的数组只有两个长度，却查找第四个元素，很明显是不对的

1.3逻辑型错误

就是我们的代码不符合逻辑

int a = 1;
int b = 0;
System.out.println(a/b);

就会出现错误

/ by zero

2.Java中的Throwable

可分为Error和Exception两种，Throwable是Error和Exception的共同父类

2.1Error

Error为错误，是程序无法进行处理的

一般遇到错误，不应该使用异常处理try…catch…

而是修改源代码，进行改良

Error有三个子类：

  • VirtualMachineError（虚拟机错误）
  • OutOfMenmoryReeor（内存溢出）
  • ThreadDeath（线程死锁）

目前我只见过内存溢出错误，通常是因为某些原因，程序出现死循环导致的

2.2Exception

Exxception可以通过代码来避免，分成运行时异常和非运行时异常

运行时异常：RuntimeException

非运行时异常：IOException、SQLException、、

2.3运行时异常

码代码的时候，编辑器不会给你提示，但是会出现错误

  1. NullPointerException（空指针异常）
    比如在定义了一个方法并使用的时候，传递的参数为空
public class Ex4_26 {
     
    public static void main(String[] args) {
     
        Integer a = null;
        Integer b = 1;
        System.out.println(jiSuan(a,b));
    }
    public static Integer jiSuan(Integer a, Integer b){
     
        Integer c = a + b;
        return c;
    }
}

报错了：
在这里插入图片描述

  1. ArrayIndexOfBoundsException（数组下标越界异常）
    我觉得我不用多说，看中文名字应该就知道这是个啥了，不过我还是大发慈悲的决定上代码
public class Ex4_26 {
     
    public static void main(String[] args) {
     
        int[] a = new int[10];
        System.out.println(a[10]);
    }
}

会报错：
在这里插入图片描述

  1. ArithmeticException（算术异常）
    这个上面也有例子，被除数为0 的情况，就不多做赘述了
  2. ClassCastException（类型转换异常）

如果出现运行时异常，通常是程序员的问题，因为这些都是可以通过逻辑上的处理而避免

2.4非运行时异常

IOException（IO异常）、SQLException（SQL异常）

3.异常处理

我们的程序遇到这种异常通常会直接结束，并会返回报错信息给你
如果我们想要让我们的程序继续运行，我们就需要通过代码对这些异常进行处理

3.1格式

try {
     
	可能会遇到异常的代码块
}catch (){
     
	遇到异常之后，会做的事情
}finally {
     
	不管会不会出现异常都会进行的操作
}

3.2简单使用

public class Ex4_26 {
     
    public static void main(String[] args) {
     
        String[] a = new String[10];
        try {
     
            System.out.println(a[10]);
        }catch (ArrayIndexOutOfBoundsException e){
     
        	System.out.println(e);
            System.out.println("下标越界啦！");
        }finally {
     
            System.out.println("不管下标是否越界都会执行");
        }
    }
}

可以清晰地看到，我们的数组长度只有10，而下标是从0开始的，所以我们查看下标为10的元素的时候，就会出现数组下标越界异常，因此那行代码就是错的，不会被执行，会执行下面的代码

十二、集合

知道常见的集合

会集合的简单操作

特点： 存储空间可变

存储多个数据时，经常会遇到长度不固定的情况，此时，就无法使用数组进行存储，此时就需要用到集合

1.集合框架

分为Collection和map

collection是集合，以每个元素分开储存在同一个集合

map是键值对的形式（什么是键值对？一个名字对应一个人就像这样：“z”: 1这样，"z"是键，1是值，合在一起就叫键值对）储存

1.1set集合

set集合的元素是无序的

优点：删除和插入效率高，元素是无序的，不会引起其他元素的变化

缺点：查找效率低

举个例子方便理解：

set集合相当于是一个乱糟糟的大厅

你想在里面找某个人（查找元素），比较麻烦

但是你进去出来却不会引起什么变化

1.2list集合

list集合是有序的，和数组类似，只不过list集合的长度是动态的

优点：查找效率高

缺点：插入删除操作效率低，会引起元素位置的变化

举个例子方便理解：

list集合就相当于一个标注着名字的会议室

你要找某个人，很轻松就可以找到

但是你要是想在里面加个座位给新来的领导，就会很麻烦

1.3map

map使用键值对的形式储存数据，不算集合，但是在Java中却是整合在集合中的

2.常用的集合

ArrarList，LinkedList，HashSet，HashMap

2.1ArrayList定义

当然，由于集合在java.util 包中，因此在使用之前应该先导包
import java.util.ArrayList;

ArrayList<类型> 变量名 = new ArrayList<>();

这里的类型只能是引用数据类型，如果想储存基本数据类型，可以装箱

常见方法，当然少不了增删改查

1.增

ArrayList.add("元素"); //在ArrayList最后面追加元素

ArrayList<String> b = new ArrayList<>();
for (int i = 0; i<10; i++){
     
	b.add(Integer.toString(i));
}
System.out.println(b);

在这里插入图片描述

2. 增

ArraysList.add(5, "在下标为5的位置追加引号中的内容");

ArrayList<String> b = new ArrayList<>();
for (int i = 0; i<10; i++){
     
	b.add(Integer.toString(i));

}
b.add(5,"sja");
System.out.println(b);

在这里插入图片描述

3. 删

ArrayList.remove(下标); //删除下标元素


ArrayList<Integer> b = new ArrayList<>();
b.add(1);
b.add(2);
b.add(3);
b.add(4);
b.add(5);
b.remove(3);
System.out.println(b);

运行结果：
在这里插入图片描述

4. 改

ArrayList.set(下标); //通过下标修改元素

ArrayList<String> b = new ArrayList<>();
for (int i = 0; i < 10; i++) {
     
b.add(Integer.toString(i));
}
b.set(3, String.valueOf(10));
System.out.println(b);

运行结果：
在这里插入图片描述

5. 查

ArrayList.get(下标); //通过下标访问元素

ArrayList<String> b = new ArrayList<>();
for (int i = 0; i < 10; i++) {
     
b.add(Integer.toString(i));
	}
String a = b.get(3);
System.out.println(a);
}

运行结果：
在这里插入图片描述

2.2LinkedList

链表是一种线性表，但是却不是按线性的顺序储存数据，而是每个节点里存到下一节点的地址（这个是不是不太好理解，下面详讲）

例子理解：
就相当于你去操场跳广播体操，每个人一小块地方，需要在指定时间內按照之前的顺序站好，你如果把那些小 块块都一个个排序好序号，然后再找，固然可以（这是数组的方法），但是也多多少少有点费事，而这个链表 就是让你记得站在你旁边的人的位置，而去找自己的位置

链表有单向链表和双向链表

单向链表：每个元素只记后面元素的位置，而不管其他

双向链表：不仅仅后面，还有前面

LinkedList和ArrayList相差不大，但是LinkedList的增删效率高，改查效率低

增删改查

1. 增：

LinkedList.add();   //往链表后面添加元素
LinkedList.addFirst();  //往链表开头添加元素
LinkedList.addLast();   //往链表末尾添加元素

//实操理解
LinkedList<String> te1 = new LinkedList<>();
te1.add("I");
te1.add("am");
te1.add("Smly");
System.out.println(te1);

运行结果：

在这里插入图片描述

//接上面的代码
te1.addFirst("hello");
te1.addLast("bye");
System.out.println(te1);

运行结果：

在这里插入图片描述

2. 删

LinkedList.remove();
LinkedList.removeFirst();
LinkedList.removeLast();

不多做赘述

3. 改

LinkedList.set(下标, 元素);  //将该下标对应的元素修改

4. 查

LinkedList.get();
LinkedList.getFirst();
LinkedList.getLast();

5. 大小

LinkedList.size();   //返回链表大小

2.3HashSet

HashSet是set集合，元素是无序的，并且不允许有相同的元素出现

1.常用方法

HashSet.add();   //增
HashSet.remove();  //删
HashSet.size();  //大小
HashSet.contains();  //判断元素是否存在

代码展示:

HashSet<String> ha1 = new HashSet<>();
ha1.add("Hello");
ha1.add("world");
ha1.add("!");
ha1.add("。");
System.out.println(ha1);
Boolean cunZai = ha1.contains("a");
int dax = ha1.size();
System.out.println(cunZai+" "+dax);
ha1.remove("。");
System.out.println(ha1);

结果：
在这里插入图片描述

2.4HashMap

是map，键值对形式存储数据，可以自由规定键值对的类型
现在讲解使用键字符串，值整型来演示

1.常用方法

HashMap.put(键,值);  //增
HashMap.remove(键);  //删
HashMap.get(键);   //查
HashMap.size();   //大小
HashMap.clear();  //全部删除

代码示例：

HashMap<String,Integer> hama = new HashMap<>();
hama.put("Jerry", 13);
hama.put("Jack", 16);
hama.put("Tom", 18);
hama.put("TextClear", 11111);
System.out.println(hama);
hama.remove("TextClear");
System.out.println(hama);
int age = hama.get("Tom");
int size = hama.size();
System.out.println(age+" "+size);
hama.clear();
System.out.println(hama);

结果展示：
在这里插入图片描述

十三、泛型、反射、注解

1.泛型

当我第一次听到这个东西的时候，我是这样想的：

泛型？什么东西，听起来感觉挺高大上的，我能学会吗？我能理解吗？我会不会栽在这里？

是啊，听起来就蛮牛，蛮高大上的嘛，但是你需要仔细理解，啊不对，说得简单点，你就把这俩字拆开来解读不就完事了吗？

泛型：

泛：广泛

型：类型

对，其实就是这样，是不是瞬间感觉在这里插入图片描述

好嘛，这才哪跟哪啊，你要是这样想，就对了！哈哈，不要觉的他好难好难的

理解最重要，我一向反对死记硬背的学习，所以我也不抄别人的看着好高大上的解释，除了让人望而生畏之外，对理解并没有什么卵用。

像他们说的什么参数化类型，那玩意真的能让很多人理解吗？

并不能，至少在我看到这个的时候，是无法很清晰的理解到的，既然我做不到，那么根据某定理（想不起来名字了），那么肯定也有人和我一样，无法很明白的，很清晰的理解这个东西。

那我就按照我的理解来说了

1. 认识Java中的泛型使用

那么我们先来看看这个代码

ArrayList<String> b = new ArrayList<>();

之前说过，哪个小小的尖括号里面是放类型的，可以是任意的引用类型

何为引用类型：字符串，数组，接口，类。。。

那么我需要整型的怎么办，之前也说过，装箱，装箱为Integer这种类型的就可以了

好，言归正传，这个代码我们很熟悉，创建一个ArrayList集合对象嘛，形式我们也很熟悉，类的实例化对象嘛。

但是你有没有发现，这个格式貌似和我们自己定义的类的实例化对象的格式不太一样？

那么再来看看我们之前创建的Girl类的实例化

Girl girl = new Girl();

大致一看，还是差不多的：

类名 自定义名字 = new 类名;

但是仔细一看就不一样了，尖括号，对，我们创建的Girl中没有尖括号。

那么这个尖括号是干嘛的呢？联想我们的这个博客，你是不是若有所思？难不成，这就是泛型？

对啊，这就是泛型啊，这就是Java中的具体使用，用来广泛特指别的类型

说到这里，有没有一种恍然大悟的感觉

在这里插入图片描述

2. 泛型特性

泛型类型在逻辑上看成是多个不同的类型，实际上都是相同的基本类型

3. 泛型使用

相信经过上面的解释，你已经对泛型有所理解，那么来看看我们怎么使用泛型吧

先来看看如何定义一个泛型类

class 类名<泛型类型（一般使用T,K,V,N，也可以使用别的）>{
     
    public 泛型类型 变量名;  //初始化一个泛型类型的变量
    public 泛型类型 方法名(泛型类型 变量名){
     
        代码块;
    }
}

应该，很清晰吧，都是之前学过的东西了

那么来看看怎么使用的吧！

这次测试还是我们的妹子类

由于英文不好，主类名就用拼音了，见谅见谅

public class Fanxing {
     
    public static void main(String[] args) {
     
        Gril5_3<String> text = new Gril5_3<>("测试成功");
        text.setT("hello");
        String a = text.getT();
        System.out.println(a);
    }
}
class Gril5_3<T>{
     
    private T t;
    public Gril5_3(T t){
     
        this.t = t;
        System.out.printf("测试泛型ddd  %s",t);
        System.out.println();
    }
    void setT(T t){
     
        this.t = t;
    }
    T getT(){
     
        return t;
    }
}

应该没什么问题吧，set和get用于封装，使用泛型类型替代了原来的类型，定义属性的时候也使用泛型类型替代

运行结果：

在这里插入图片描述

好好好，好啊，我们成功了！

那么需要注意的是，我们在实例化前，我们的类型T可以是任意类型的，意思就是，你定义是什么类型，他就是什么类型的。

4. 通配符

通配符，就是字面意思，可以通用的符号

不得不赞一句，见名知意的感觉是真的好，以后我们写代码的类啦，接口啦，方法啦，一定要记得这样命名，见名知意！！！

一般用于集合中传递数据时

  1. 当使用泛型类或者泛型接口，泛型的类型你自己都不确定的时候，可以通过通配符表示。一旦程序当中使用泛型的通配符后，只能使用Object类中的共性的方法，集合中元素本身方法无法使用
    此时只能接收数据，不能往集合当中存储数据
  2. 通配符的高级使用—受限泛型（泛型的上限和下限）
    上限：格式: 类型名称 对象名称 意义：只能接受该类型及其子类
    下限：格式：类型名称 对象名称 意义：只能接受该类型及其父类

示例说明

public static void main(String[] args) {
     
    Collection<Integer> list01 = new ArrayList<Integer>();
    Collection<String>  list02 = new ArrayList<Integer>();
    Collection<Number>  list03 = new ArrayList<Integer>();
    Collection<Object>  list04 = new ArrayList<Integer>();
}
// 定义方法  用于接收任意的数据类型
public static void getElement(Collection<?> coll) {
     //.....}
 // 定义方法 用于接收数字类型 Number类型或者Number的子类Integer等
pubic static void getElement(Collection<? extends Number> coll){
     //...}    
// 定义方法  用于接收Number类型及其父类的类型
public static void getElement(Collection<? super Number> coll) {
     //....}

5. 完事

泛型就说这么多，相信大家对泛型也有了自己的认识，想去深挖的话，还是别来看我的博客

建议找大佬的博客钻研钻研一起进步一起学习！

2.反射

什么是反射？就是Java中可以通过反射，将类的各个组成成分映射成一个个的对象。

好，这是我查看别人的解释。

那么现在就来说说我对反射的理解。

反射：

就是在你只知道一个类名，而且无法查看类的源码（也就是说你对这个类的理解只局限于你知道类名）的时候，可以通过反射来将类中的各个成分调出来，成为一个个对象，可以通过反射了解这个类的成分。如果你不知道类里面都有哪些成分的话，那说明你的基础还不够扎实，推荐你去看看我的类三部曲。

那么这么说还是有点不太容易理解吧。

那就举个例子：

我是一个黑客，有个人叫张三（类），他惹了我，我知道了他的名字（类名），我通过技术手段（反射）人肉到了他的个人消息（各个组成成分）。

这就是反射！

在这里插入图片描述

1.用处

反射可以将加载到JVM中的类的信息加载出来，供我们使用。

反射在框架架构中经常使用，而在日常开发中，并不经常使用。

那么为什么我们还需要学习反射呢？因为我们需要去看别人的框架源码来深入学习，而如果我们对反射不理解的话，就不能理解别人的源码。

2.优缺点

优点

  • 增加程序的灵活性，避免将固有的逻辑程序写死到代码里
  • 代码简洁，可读性强，可提高代码的复用率

缺点

  • 相较直接调用在量大的情景下反射性能下降
  • 存在一些内部暴露和安全隐患

3.用法

使用反射技术，就不得不提一下Class类，下面我们先看看别人对Class类的说法：

Class 类的实例表示正在运行的 Java 应用程序中的类和接口。也就是Java虚拟机中有N多的实例每个类都有该Class对象。（包括基本数据类型）
Class 没有公共构造方法。Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的defineClass 方法自动构造的。也就是这不需要我们自己去处理创建，JVM已经帮我们创建好了。

——摘自Java基础之—反射（非常重要）

换句话说，我们所用到的所有类，都是Class类的一个实例化对象。是不是感觉有点难，没事，其实之前我听过一个底层大佬的一句话，感觉受益很多：

每个类都是更抽象的类的对象罢了

而我们现阶段不需要了解那么多，只需要使用Class类中的方法就可以了

4.简单使用

好了，巴拉巴拉的说了这么多，也该上代码了

1. 定义一个类

class Girl_5_5{
     
    String name;
    Integer age;
    Integer ID;
    public void describe(String name, Integer age, Integer id){
     
        this.ID = id;
        this.name = name;
        this.age = age;
        System.out.printf("我是%s，我的证明是%d，我今年%d岁了", name, id, age);
    }
}

2. 使用反射

我们需要获取Class对象获取Class对象的三种方式

  1. Object类（自定义类的默认父类）的getClass();方法

  2. 类自带的class属性 类名.classs;

  3. 通过Class类的静态方法：forName（String className）(常用)

public class Fanshe {
     
    public static void main(String[] args) {
     
        Girl_5_5 girl = new Girl_5_5();  //实例化一个对象
        //第一种方法，使用所自定义类中的默认父类Object的class方法
        Class<? extends Girl_5_5> girlClass = girl.getClass();
        //第二种方法 访问静态属性class获取
        Class<Girl_5_5> girlClass1 = Girl_5_5.class;
        //第三种方法
        try {
     
            Class<?> girlClass2 = Class.forName("com.util.text.基础语法.反射.Girl_5_5");
            System.out.println(girlClass+"\n"+girlClass1+"\n"+girlClass2);
        } catch (ClassNotFoundException e) {
     
            e.printStackTrace();
        }

    }
}
class Girl_5_5{
     
    String name;
    Integer age;
    long ID;
    public void describe(String name, Integer age, long id){
     
        this.ID = id;
        this.name = name;
        this.age = age;
        System.out.printf("我是%s，我的证明是%d，我今年%d岁了", name, id, age);
    }
}

运行结果：

在这里插入图片描述

这都是我们的Girl_5_5类对象，我们将这个类，通过反射实例化成了一个Class类的对象，可以通过这个对象调用Class的方法，通过Class的方法可以获得Girl_5_5的构造方法，成员变量等，并将其化为一个一个的对象。

使用对象获取类的构造方法

所有构造方法：girlClass2.getDeclaredConstructors();

所有公有构造方法：girlClass2.getConstructors()；

所有公有无参构造方法：girlClass2.getConstructor(null); 这个参数也可以不放

import java.lang.reflect.Constructor;
import java.util.Arrays;

public class Fanshe {
     
    public static void main(String[] args) throws Exception {
     
        Girl_5_5 girl = new Girl_5_5();  //实例化一个对象
        //第一种方法，使用所自定义类中的默认父类Object的class方法
        Class<? extends Girl_5_5> girlClass = girl.getClass();
        //第二种方法 访问静态属性class获取
        Class<Girl_5_5> girlClass1 = Girl_5_5.class;
        //第三种方法 通过forName方法获取
        try {
     
            Class<?> girlClass2 = Class.forName("com.util.text.基础语法.反射.Girl_5_5");
            //输出三种方法
            System.out.println(girlClass+"\n"+girlClass1+"\n"+girlClass2);
            //所有构造方法
            String allConstructors = Arrays.toString(girlClass2.getDeclaredConstructors());
            //所有共有构造方法
            String publicConstructors = Arrays.toString(girlClass2.getConstructors());
            //共有无参构造方法
            String nullConstructors = Arrays.toString(new Constructor[]{
     girlClass2.getConstructor(null)});
            //输出看看
            System.out.println(allConstructors+"\n"+publicConstructors+"\n"+nullConstructors);
        } catch (ClassNotFoundException e) {
     
            e.printStackTrace();
        }


    }
}
class Girl_5_5{
     
    String name;
    Integer age;
    long ID;
    public void describe(String name, Integer age, long id){
     
        this.ID = id;
        this.name = name;
        this.age = age;
        System.out.printf("我是%s，我的证明是%d，我今年%d岁了", name, id, age);
    }

    /**
     * 共有有参构造方法
     * @param name：提供一个形参
     */

    public Girl_5_5(String name){
     
        System.out.println(name+"hello");
    }

    /**
     * 共有无参构造方法
     */
    public Girl_5_5(){
     

    }

    /**
     * 私有有参构造方法
     * @param age：提供形参
     */
    private Girl_5_5(Integer age){
     

    }
}

运行结果：

在这里插入图片描述

3.获取成员变量

获取所有：girlClass.getDeclaredFields();

获取所有公有：girlClass.getFields();

具体我就不一一举例子了

4.获取成员方法

获取所有：girlClass.getDeclaredMethods();

获取所有公有：girlClass.getMethods();

总结

反射就是能在你只知道类名的时候，获取调用类的各种组成成分。

3.注解

好嘛，好嘛，又到了伤脑筋的时候啦！

讲真的，之前Java这三大高级特性，我一听名字就感觉到了一股杀气！哇，泛型，反射，注解，这都是什么高级词汇，一听就很难学！
后来学了后发现，嗯，没感觉错，确实是很难学！哈哈哈（笑啥笑，难学还挺开心）

今天我们的主角是注解。好家伙，注解。啥东西啊，看着就没思路。
不要慌，问题不大

我们先看看比较官方的解释：Java 注解用于为 Java 代码提供元数据。作为元数据，注解不直接影响你的代码执行，但也有一些类型的注解实际上可以用于这一目的。

看看官方解释，再结合字面意思，咦，貌似有点内个意思了哈。

上面清晰的写着，注解不直接影响你的代码执行，意味着什么，意味着我们从字面理解的意思，是差不多对的。
好，总结一下，注解就是：声明我们的代码中的方法，属性，类，接口等作用的，而且和注释不同的一个东西。

而且而且，貌似你可以这么理解，我给你一个注解，像不像我给你扣了一个大帽子。

比如说你初学Java，进了一个Java群，你刚好会了一个新知识，这时候有一个比较活跃的群友问了这个问题，你洋洋洒洒的说了出来，顿时这个人就给你套了个大佬的帽子，因为他是活跃群友，所有你一冒头他就喊你是大佬，这样你在别人眼里也就是大佬了。

而注解就相当于是我给代码套了个帽子，让别的程序员一下就能看出来他是干嘛的 。

1.常规注解

1.代码中的注解

Java代码中的注解就是这种形式的

在代码上面有个 ： @Xxxx 的东西

应该见过，也可能没见过，不过就是这个东西，这是用法

2.创造注解

那么怎么创造一个注解呢

其实特别简单，格式如下：

@Interface Xxx{}

没了，就这么简单

那么我们就动动小手 创建一个我们能的注解吧

//定义一个 什么都没有的 注解
@interface Isthis{
      }

这就定义好我们自己的注解了

3.使用注解

上面我们已经定义了一个注解，那么怎么使用呢

只需要将我们自己定义的注解（名词）放在我们需要注解（动词）的代码上面，就像这样

//定义一个 什么都没有的 注解
@interface Isthis{
      }

//使用你的注解
@Isthis
class Good{
      }

我们定义了一个空的注解，也定义了一个空的类，并将我们的注解用在了我们的类上面

当然，这样很不直观，那么我们就实例化一个对象来看看

public class Ex5_8 {
     
    public static void main(String[] args) {
     

        Good a = new Good();
        System.out.println(a);
    }
}

运行结果为：

在这里插入图片描述

然后再将注解去掉看看

public class Ex5_8 {
     
    public static void main(String[] args) {
     

        Good a = new Good();
        System.out.println(a);
    }
}

class Good{
      }

运行结果为：

在这里插入图片描述

是一样的，说明注释对我们的代码没有影响

2.元注解

什么是元注解？能给注解进行注解的注解。

哈哈哈，是不是有点套。没事，这样看：

元注解是能给注解（我们之前定义的）进行注解（注释解释）的注解（名词，注解）。

这就很清晰了吧。

我们的元注解有以下几种，下面我将带领大家看看。

在这里插入图片描述

1. @Retention

Retention的意思是保留。根据见名知意的理解，其实这个元注解的作用其实就是注解的保留时间，也就是这个注解能保留到什么时候。

注解也有方法，我们来看看这个保留注解的方法

  1. SOURCE

被这个属性注解的注解，只在源代码中能看到，起作用

用法是这样：

@Retention(RetentionPolicy.SOURCE)
@Interface Text{
     }
  1. CLASS

被这个属性注解的注解，在class文件中也可以看见，但是不会被我们的Java虚拟机加载

用法：

@Retention(RetentionPolicy.CLASS)
@interface Text{
      }
  1. RUNTIME

会被Java虚拟机加载

@Retention(RetentionPolicy.RUNTIME)
@interface Text{
      }

2. @Documented

中文意思是：备有证明文件的。好吧，这个意思就不是那么清晰了

这个元注解的作用是将我们的注解加载到javadoc中，这个javadoc是我们的Java程序中所有的文档注释(/** */)产生的注视文档。

而这个元注解就是可以让我们的注解也进入这个文档。

3. @Target

中文意思是：目标。

作用是：告诉注解，你该用到哪里，就是说被这个注解的注解可以注解什么类型的数据

大白话：我告诉你，你只能给类进行注解，那你就只能给类注解，放别的地方就会报错。

具体使用如下：

  1. 可以给注解进行注解，是不是想到了元注解，没错，可以看看元注解的源码，都被这个注解过

@Target(ElementType.ANNOTATION_TYPE)
@interface Text{
      }

  1. 可以让注解给构造方法注解

@Target(ElementType.CONSTRUCTOR)
@interface Text{
      }

  1. 可以让注解给属性进行注解

@Target(ElementType.FIELD)
@interface Text{
      }

  1. 可以让注解给局部变量进行注解

@Target(ElementType.LOCAL_VARIABLE)
@interface Text{
      }

  1. 可以让注解给方法进行注解

@Target(ElementType.METHOD)
@interface Text{
      }

  1. 可以让注解给包进行注解

@Target(ElementType.PACKAGE)
@interface Text{
      }

  1. 可以让注解给方法变量进行注解

@Target(ElementType.PARAMETER)
@interface Text{
      }

4. @Inherited

中文意思：继承

被此元注解 注解（动词） 的注解（名词），如果注解了一个类A，类A被类B继承，那么，类B同样继承类A的注解。

@Inherited
@interface Text{
      }

@Text
class Good{
      }

class Good_son extends Good{
     }

这里的Good_son类虽然看起来没有被注解，但是因为Inherited元注解的存在，他也继承了Good的注解@Text.

3.标准注解

标准注解就是直接作用在别的数据上的
什么是数据？变量，方法，类，接口，枚举。。。

1. @Override

中文意思：重写

保证Override重写声明的正确性。

是不是很眼熟，没错就是了类里面的重写父类方法，这个注解的作用就是用在子类需要重写的时候。

如果父类没有你要重写的方法，就会出错误。这里我们故意出错看看错误

class Good{
      
    void say(){
     }
    void speak(){
     }
}

class Good_son extends Good{
     
    @Override
    void say(){
     }
    @Override
    void spea(){
     }
}

idea的方便之处，会爆红：

在这里插入图片描述

会提示错误，并给出解决方法

在这里插入图片描述

意思就是，你的父类没这个方法，下面的上移就是讲这个方法在父类实现。

改正确，就不会爆红：

在这里插入图片描述

2. @Deprecated

中文意思：不宜用

就是这个方法已经不适合使用了

public class Ex5_8 {
     
    public static void main(String[] args) {
     

        Good a = new Good();
        a.say();

    }
}


class Good{
     
    @Deprecated
    void say(){
     }
    void speak(){
     }
}

这样看代码，不太直观，还是放idea的截图吧

say方法被@Deprecated注解，在实例化调用的时候，就会有删除线，意思就是，这个方法已经不适合使用了。

4.注解的属性

注解也有属性，和类一样。

用法是这样

@interface Text{
     
    int id();
    String value();
}
@Text(id=1, value="s")
class Good{
     
    void say(){
     }
    void speak(){
     }
}

定义注解属性的时候，类型 属性名();

属性可以有默认值，默认值需要用default关键字传递

类型 属性名 default 值

@interface Text{
     
    int id() default 0;
    String value();
}
@Text(id=1, value="s")
class Good{
     
    void say(){
     }
    void speak(){
     }
}

十四、Stream、IO、文件操作

关于本篇，引用一个群大佬的话：

stream是管道，文件是数据载体，IO（InPut（输入）、OutPut（输出））是数据的流动的方向

1.Stream流

Java流是对于字节和字符来说的，所以是字节流，字符流。

什么是流，大家看一个词，水流，什么是水流大家都知道，那么换成字节流，字符流不过是同样的意思罢了。
什么是字节流？单个字节或者字符，而单个字节或者字符很明显构不成流，得是多个字节或者字符。

那么这么解释，应该是不会再感觉到困惑啦。

下面看看实操吧。

1.1从键盘获取数据

咦，突然有种莫名的熟悉感。这不是Scanner吗！

不不不，今天我们讲的是另一个：InPutSteamReader

看着好长啊，我们这次先不去管它是什么，我们先看看他能干什么：获取键盘数据

1. 获取一个字符：

import java.io.*;

public class Ex5_9io {
     
    public static void main(String[] args) throws IOException{
     
        BufferedReader a = new BufferedReader(new InputStreamReader(System.in));
        //获取单个字符
        char c;
        c = (char) a.read();  //使用c来接收字符
        System.out.println(c);   //输出
    }
}

运行结果：

在这里插入图片描述

玩点花的：

import java.io.*;

public class Ex5_9io {
     
    public static void main(String[] args) throws IOException{
     
        BufferedReader a = new BufferedReader(new InputStreamReader(System.in));
        //获取单个字符
        ArrayList<Character> c = new ArrayList<>();
        for (int i = 0;i<10;i++){
     
            c.add((char) a.read());
        }
        System.out.println(c);
    }
}

都是之前学过的东西，如果你看不懂，说明基础大的不太牢固哦

运行结果：

在这里插入图片描述

嘿嘿

在这里插入图片描述

可以看到，虽然我们输入了一句话，但是我们的Java却一个字符一个字符的存入了集合c中

2.获取多个字符

也就是获取字符串

import java.io.*;

public class Ex5_9io {
     
    public static void main(String[] args) throws IOException {
     
        BufferedReader a = new BufferedReader(new InputStreamReader(System.in));
        String str;
        str = a.readLine();
        System.out.println(str);
    }
}

运行试试

在这里插入图片描述

嗯，效果还可以，那就玩点花里胡哨的：

import java.io.*;

public class Ex5_9io {
     
    public static void main(String[] args) throws IOException {
     
        BufferedReader a = new BufferedReader(new InputStreamReader(System.in));
        //获取字符串
        ArrayList<String> str = new ArrayList<>();
        while (true){
     
            String st = a.readLine();
            if (st.equals("quit")){
     
                break;
            }
            str.add(st);
        }
        System.out.println(str);
    }
}

我们尝试输出一堆字符串并保存在集合中。

运行结果：在这里插入图片描述

1.2输出数据到控制台

这还有什么可好说的？

  1. System.out.print\(\); 不换行输出

  2. System.out.println\(\); 换行输出

  3. System.out.write\(\); 输出低八位字节

  4. System.out.printf\(\) 格式化输出（这个之前好像没说过）

System.out.println(0);  //输出一个，并换行
System.out.print(1+" "); //输出一个 后面跟个空格，不换行
System.out.write('a');//输出一个字符a 不换行
System.out.println(); //加个这个，换行，美观一点
System.out.printf("这是一个数字 %d 这是一个字符串 %s ",1,"hello"); //格式化输出

运行结果：
在这里插入图片描述

2.文件操作

关于对文件的操作，要说的话，有很多很多，就直接实战看例子吧

2.1相关包

首先呢，我们先导包

import java.io.*;

可以看到，我们的文件操作的包位于java.io包中。

2.2创建文件，并写入

写入文件的相关操作位于io包中的OutputStream类中。想对文件进行操作，我们需要先利用OutputStream类的构造方法创建一个文件对象，然后根据文件对象的方法对文件进行操作。

OutputStream fwrite = new FileOutputStream("C:/java/text.txt");  //创建文件对象
for (int i = 0;i<10;i++){
     
//循环向里面存数据
fwrite.write(i);
}
fwrite.close();  //关闭文件

2.3读取文件

读取文件的相关操作位于io包中的InputStream类中，我们若想对文件进行操作，就和写入文件是一样的，先创建对象，再使用相关操作方法。

利用InputStream读取文件：

InputStream fread = new FileInputStream("C:/java/text.txt");  //创建文件对象
byte[] fb = fread.readAllBytes();  //创建数组接收数据
fread.close();  //关闭文件
for (byte b : fb) {
     
//循环读取
System.out.println(b);
}

全部代码：

import java.io.*;

public class Ex5_9io {
     
    public static void main(String[] args) throws IOException {
     
        OutputStream fwrite = new FileOutputStream("C:/java/text.txt");
        for (int i = 0;i<10;i++){
     
            fwrite.write( i);
        }
        fwrite.close();
        InputStream fread = new FileInputStream("C:/java/text.txt");
        byte[] fb = fread.readAllBytes();
        fread.close();
        for (byte b : fb) {
     
            System.out.println(b);
        }

    }
}

十五、多线程编程

何为多线程，通俗的讲就是让你的代码同时干好几件事。

而我们的一个代码文件或者一个项目就是一个进程，而如果我们想提高效率，我们可以多开几个文件进行多进程，也可以在进程中创建多线程（多写几个方法），但是多进程比较耗费资源，所以一般推荐多线程，在代码里，让代码做几个文件做的事。

多线程编程可以让我们的代码拥有更高效率。

1.线程的工作过程

犹如上图

使用多线程需要先创建一个或者多个线程

然后让线程调用CPU资源，开始运行

然后运行完毕等待所有线程运行完毕

然后删除资源，结束线程

2.Java线程拥有优先级

优先级就是系统确定线程的调度顺序，但是不执行顺序，因为多线程的执行是具有无序性的。

调度顺序只是系统分配资源的顺序，不分配资源就无法执行。

3.创建多线程

如何在Java代码中创建多线程，Java内置了用于多线程的库。

3.1.继承Thread类，重写run()方法

我们需要写一个类A来继承Thread类，并重写run()方法。

run()方法里面放我们需要进行多线程的代码。

然后再在主类中实例化类A的对象，并且调用strat方法。

public  class TheadText  {
     
    public static void main(String[] args) {
     
        //实例化StartThread，并调用start方法使线程动起来
        StartThread t1 = new StartThread("一  ");
        t1.start();
        StartThread t2 = new StartThread("二  ");
        t2.start();
        StartThread t3 = new StartThread("三  ");
        t3.start();
        StartThread t4 = new StartThread("四  ");
        t4.start();
    }
}

/**
 * 1.继承Thread类并重写run方法
 */
 class StartThread extends Thread{
     

     String name;
     StartThread(String name){
     
         this.name = name;
     }
    @Override
    public void run() {
     

       System.out.println(name+1);
       System.out.println(name+2);
       System.out.println(name+3);
       System.out.println(name+4);
       System.out.println(name+5);
     }
 }

运行结果（还可以体现线程的无序性）：

3.2实现接口Runnable接口与run方法

使用Runnable接口避免了单继承的局限性，线程类只是实现了 Runnable 接口，还可以继承其他类

public  class TheadText  {
     
    public static void main(String[] args) {
     
		StartRunnable startRunnable1 = new StartRunnable("  一  ");
        Thread te1 = new Thread(startRunnable1);
        te1.start();
        StartRunnable startRunnable2 = new StartRunnable("  二  ");
        Thread te2 = new Thread(startRunnable2);
        te2.start();
        StartRunnable startRunnable3 = new StartRunnable("  三  ");
        Thread te3 = new Thread(startRunnable3);
        te3.start();
        StartRunnable startRunnable4 = new StartRunnable("  四  ");
        Thread te4 = new Thread(startRunnable4);
        te4.start();
	}
}
/**
 * 2. 实现Runnable接口，实现run方法
 */
 class StartRunnable implements Runnable{
     
     String name;
//     重载一下方法，利于区分
     StartRunnable(String name){
     
         this.name = name;
     }
     @Override
     public void run() {
     
         System.out.println(name+1);
         System.out.println(name+2);
         System.out.println(name+3);
         System.out.println(name+4);
         System.out.println(name+5);
     }

 }

运行结果：

在这里插入图片描述

3.3实现Callable接口，实现call方法

这个我研究了挺大一会儿。

实现这个接口后，还需要实现call方法

然后通过FutureTask类来对我们实例化对象进行封装

最后还要实例化Thread类进行start操作开启我们的线程

代码演示：

public  class TheadText  {
     
    public static void main(String[] args) {
     
        //先实例化
        StartCallable a = new StartCallable();
        //然后调用FutureTask类
        FutureTask<String> te1 = new FutureTask<>(a);
        //设置我们的name属性
        a.name = "  一  ";
        //开启我们的线程一
        new Thread(te1).start();
        StartCallable b = new StartCallable();
        FutureTask<String> te2 = new FutureTask<>(b);
        b.name = "  二  ";
        new Thread(te2).start();
        StartCallable c = new StartCallable();
        FutureTask<String> te3 = new FutureTask<>(c);
        c.name = "  三  ";
        new Thread(te3).start();
        StartCallable d = new StartCallable();
        FutureTask<String> te4 = new FutureTask<>(d);
        d.name = "  四  ";
        new Thread(te4).start();

    }
}
/**
 * 实现Callable接口，实现call方法
 */
 class StartCallable implements Callable<String>{
     
     String name ;
     public String call() throws Exception{
     
         System.out.println(name+1);
         System.out.println(name+2);
         System.out.println(name+3);
         System.out.println(name+4);
         return name;
     }
 }

运行结果：

在这里插入图片描述

4.线程的生命周期

线程在我们创建后（出生）等待CPU的资源分配，然后开始工作，在工作完我们分配的工作后，就会（死亡）消失

十六、数据库与JDBC

1.数据库

数据，数据库，数据库管理系统等

1.1数据（Data）

数据是描述事物的符号，比如音频，视频，文档，图片等可以转化为计算机可以是别的标识，转成二进制存入计算机。

1.2数据库（Date Base）

从字面理解，数据库就是存储数据的仓库。具体来说就是长期存放在计算机硬件上的，有组织，可共享的数据集合。

1.数据库的特点

  • 有组织的
  • 可共享的
  • 较高的数据独立性
  • 易扩展性

2.数据库的分类

根据数据模型的不同，数据库通常被分为层次数据库（IBM的IMS）、网状数据库（DBTG）、关系数据库（DB2、MySQL等）。
还有另一种，关系型数据库和非关系型数据库（MongoDB）。

1.3数据库管理系统（DMBS）

数据库需要多个元素，共同组合成数据系统才能发挥作用。

数据库管理系统是一种操纵和管理数据库的大型软件，用于建立，使用，维护数据库。
用户通过DMBS访问数据库中的数据，数据库管理员通过DMBS维护数据库。
数据库管理系统由 用户，硬件，软件，数据库共同组成，

像我们平时所说的数据库就是数据库系统，包括数据库，软件，硬件，用户的。

而我们市面上主流的关系型数据库有：

  • SQL server （运行与Windows ）
  • Sybase（支持Windows NT、Unix/Linux）
  • DB2（主要运行于Unix）
  • Oracle（应用广泛，功能强大）
  • MySQL（比较流行，体积小，速度快，开源）

2.MySQL的安装与配置

8.0.18.0版本下载——点击链接下载 MySQL8.0.18.0

下载好之后双击安装，默认选第一个，然后一直点击next，唯一需要注意的是，设置密码的时候需要注意，不要忘掉，忘了就只能卸载重装再设置了。

在这里插入图片描述

然后别的就一直next就行了。

安装好之后，我们可以在开始菜单里面找到我们安装的MySQL

在这里插入图片描述

然后会出现这个界面

在这里插入图片描述

然后输入密码，就能够成功的进入我们的数据库

在这里插入图片描述

然后我们就可以输入命令来操作数据库了，我现在掩饰一个查看版本的命令

select version();

在这里插入图片描述

当前状态：status;

在这里插入图片描述

2.1启动与停止

  1. 启动 cmd 输入 net start mysql80
  2. 停止 cmd 输入 net stop mysql80

2.2环境配置

计算机->右键->属性->高级系统配置->环境变量->在path里面把C:\Program Files\MySQL\MySQL Server 8.0\bin加进去

这个路径是按安装路径，默认都是这个路径，，但是你也可以在安装的时候更改，这里就按照默认的

配置好之后，我们就可以通过dos命令来链接MySQL了

mysql \-h localhost \-u root \-p

然后再输入密码，就可以连接到我们的数据库

在这里插入图片描述

当然，我们仍然可以通过开始菜单里面链接操作

一般推荐使用dos命令链接，操作

3.MySQL基操

增删改查，这些都是必须会的，如果不会，那后果可是很严重！

连接MySQL

想要操作数据库，我们需要先连接数据库

首先打开cmd

然后输入

mysql -h localhost -u root -p

显示这个就是成功了

在这里插入图片描述

数据库的操作

上一篇已经说过，MySQL中由许多数据库组成，我们现在说的就是对数据库的操作

1. 创建数据库

通过如下指令创建一个数据库

create database name1;

回车后会显示如下内容，表示创建成功

在这里插入图片描述

  • 常见错误：

    • 没有连接数据库直接输入语句，出现以下错误

      在这里插入图片描述

    • 最后的;输入成中文，会这样

      在这里插入图片描述

2. 查看数据库信息

show databases; # 查看所有数据库
show create database name1;  # 查看数据库  name1

回车显示：

在这里插入图片描述

3. 删除数据库

drop database name1;

在这里插入图片描述

使用show databases验证是否成功

在这里插入图片描述

可以看到我们的name1数据库已经没了，而看到这个text5_23没，这个就是我们用来演示下一个操作的数据库。

数据表的操作

想要操作数据表，首先你要告诉MySQL你要操作哪个数据库中的数据表

use text5_23;

会看到：

在这里插入图片描述

这就代表着已经成功的进入了我们的目标数据库

1. 创建数据表

创建一个数据表用来存储我们班人的姓名和学号

看这个命令前，最好先看一下MySQL的数据类型——MySQL 数据类型 | 菜鸟教程)

create table 20network(
studyid smallint not null,
studyname char(10) not null
);

not null是不能为空

敲回车会显示这样

在这里插入图片描述

就是已经成功的创建了一个数据表

2.添加数据

  • 往数据表中插入一个学号为1001，名字为 布小禅的数据

    insert into 20network(
studyid,studyname)
values(
1001, "布小禅"
);

    在这里插入图片描述

3.查询数据

select * from 20network;  # 查询表内的所有数据
select studyid from 20network;  # 查询表内的学号
select studyname from 20network;  # 查询姓名

 结果：

在这里插入图片描述

4.删除数据

delete from 20network;  # 删除表内所有数据
delete from 20network where studyid=1001;  # 删除学号=1001的数据

 不要轻易尝试，恢复数据不容易，但是练手可以随意

​

5. 查询数据表

show tables;  # 查看当前数据库所有数据表
show create table 20network;  # 查看20network表

结果：

在这里插入图片描述

6. 删除数据表

删除需要慎用，最好不要做个删库跑路的人（手动狗头）

drop table 20network;

在这里插入图片描述

查一下是否删除成功
在这里插入图片描述

欧克成功了

4.JDBC

jdbc是Java连接数据库的工具，需要下载jar包——MySQL8.0版本以上的jar包

在Java项目中，肯定是需要使用数据库的，因此这也是一门极其重要的课程！

idea连接数据库

首先

把我们下载的jar包导入我们的项目

1.在这里插入图片描述

在这里插入图片描述

然后：

在这里插入图片描述

接着：

在这里插入图片描述

成功：

在这里插入图片描述

我们可以在idea中查看我们的数据表

ax

也可以在idea中创建数据表，添加数据

在这里插入图片描述

代码连接

这些只是方便我们操作数据库，那么就看看怎么用代码连接和操作把


import java.sql.*;
public class TextMySQLConnect {
     
    public static void main(String[] args) throws SQLException, ClassNotFoundException {
     
        //通过反射设置驱动
        Class.forName("com.mysql.cj.jdbc.Driver");
        // 数据库uurl前面复制刚刚连接数据库的时候的url，后面接着复制
        String url = "jdbc:mysql://localhost:3306/***(这里填你MySQL里面的数据库名字)?useSSL=false&allowPublicKeyRetrieval=true&serverTimezone=UTC";
        //  账号
        String user = "root";
        // 密码
        String password = "这里填写你自己的MySQL密码";
        // 连接数据库
        Connection coon = DriverManager.getConnection(url, user, password);
        // 执行查询
        Statement stmt = coon.createStatement();
        // sql语句
        String sql = "select * from 20network";
        // 执行sql语句
        ResultSet rs = stmt.executeQuery(sql);
        // 查询数据表的内容，可以通过rs.get数据类型（首字母大写）("数据名");
        // 比如查询学号

        // 返回布尔值，成功操作返回为true
        if (rs.next()){
     
            int id = rs.getInt("studyid");
            System.out.println("True");
            System.out.println("学号为："+id);
        }

        // 关闭
        rs.close();
        stmt.close();
        coon.close();
        System.out.println("GoodBye");
    }
}

运行结果：

在这里插入图片描述

在Java中的sql语句不需要加**;** 并executeQuery方法无法对数据表进行操作

十七、网络编程

网络编程是编写运行在网络中不同设备中的程序。例如（QQ，微信等）。

通过网络编程，人们可以实现网络中不同设备的通讯。

1.软件构成

软件的构成有两种方式

  • C/S结构
  • B/S结构

C/S结构是client（客户端）/server（服务器）结构，常见的有QQ，微信等桌面客户端

B/S结构是browser（浏览器）/server（服务器）结构，常见的是百度，哔哩哔哩，CSDN等各大网站

2.网络编程三要素

通讯协议，IP地址，端口号

3.通讯协议

网络之间的通讯需要遵循一定的网络通讯协议。

通讯协议就是让网络中的每台计算机都使用一样的规则，这样才能互相通讯。

协议就像我们平时说的语言

在中国（局域网）说汉语（中国的通讯协议就是汉语）

但是到了国际上，我说汉语，你说日语，当然无法交流

因此就需要一个统一的语言，也就是英语（协议）来规定

3.1TCP/IP协议

而提起通讯协议，就不得不说TCP/IP协议，它是网络中使用最多，最广泛的协议，当然，它并不是单单指TCP协议和IP协议，它是由：FTP、SMTP、TCP、UDP、IP等协议构成，之所以称为TCP/IP

协议是因为它们两个最具代表性。

3.2两种通讯协议

一为UDP协议，一为TCP协议

  • UDP：UDP （英语：User Datagram Protocol，用户数据报协议），位于 OSI 模型的传输层。一个无连接的协议。提供了应用程序之间要发送数据的数据报。由于UDP缺乏可靠性且属于无连接协议，所以应用程序通常必须容许一些丢失、错误或重复的数据包。

  • TCP：TCP（英语：Transmission Control Protocol，传输控制协议） 是一种面向连接的、可靠的、基于字节流的传输层通信协议，TCP 层是位于 IP 层之上，应用层之下的中间层。TCP 保障了两个应用程序之间的可靠通信。通常用于互联网协议，被称 TCP / IP。

说白了UDP就是用于视频通话，打电话，看直播的时候，而TCP则是用在传输文件的时候。因为UDP并不安全，它在传输数据时会丢失一些数据包，而在你视频电话时，遇到这种情况时，无非就是卡了一下罢了，并不会太影响，而UDP的速率比TCP 的速率要快；不过TCP 的安全性更高，它通常在传输文件时使用，它并不会丢失数据包，但是速率上较之UDP慢。

TCP之所以会慢是因为TCP每次都需要经过三次握手，即客户端向服务端发送请求；服务端回应请求；客户端确认请求这三个过程。

4.IP地址

IP地址是计算机的唯一标识，用于被别的计算机识别，然后连接，通讯。

就相当于我们用的身份证，代表着我们的身份。

当然因为他叫地址，我们也可以理解为我们每个人的地址，而这个理解相对于身份证号来说，对端口号的；接更为方便一些。

而IP地址分为IPv4和IPv6

IPv4有四个字节，但是却是使用十进制来表示的a.b.c.d每个大小取值的范围是0~255，范围大致为2**32（每个字节有8个二进制构成）也就是4294967296个，而这个值对于地球上的计算机来说，是有些不够用的，因此就出现了IPv6

IPv6有六个字节，取值范围远大于IPv4，足足有281474976710656个，号称可以给地球上的每个沙子配上ip，IPv6的出现，解决了IPv4地址不够用的问题

5.端口号

我们计算机上每个软件工作时，操作系统都会给软件分配一个端口号，因为计算机只有一个IP地址，而计算机上有许许多多的软件，当我们用一个软件通讯时，虽然可以通过IP地址找到目标计算机，但是却无法找到目标计算机上对应的软件，此时就需要端口号了，这个端口号就是我们的软件能够找到目标计算机的软件的凭证。

端口号由两个字节组成，取值范围是0~65536，不过1024之前的端口我们无法使用，因为操作系统已经将其分配给了系统软件，而端口号是无法相同的。

利用地址来理解，你就会发现端口号只不过就是这样罢了：

IP地址是计算机的小区地址，而端口号是门牌号，我给你的小区送了一封信，如果没有门牌号的话，物流就无法知道这封信到底是寄给谁的。

6.Java网络编程

Java网络编程是使用Java代码编写运行在网络中的多台设备的程序

Java网络编程被封装在java.net包中

而表示客户端的类是java.net.Socket类

表示服务端的类是java.net.ServerSocket类

而我们需要创建一个服务端和一个客户端，然后进行数据的传输

6.1服务端

我们创建一个服务端，需要以下步骤

  1. 创建服务器
  2. 指定服务器端口
  3. 获取客户端链接
  4. 接收数据
  5. 回应客户端
  6. 关闭链接

表示服务端的类是java.net.ServerSocket类

1. 使用之前，我们应该先导包，而考虑到后面会使用io包里的流和net包里的客户端，所以直接全导入

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

2. 我们通过ServerSocket类的带端口参数的构造方法来实例化，创建一个服务端

ServerSocket server = new ServerSocket(8888); //1.创建一个服务器对象，绑定端口位8888

3. 获取客户端链接

Socket socket = server.accept(); //2.获取链接

4. 使用getInputStream()方法接收数据

InputStream is = socket.getInputStream();
byte[] bytes = new byte[1024];
int len = is.read(bytes);

5. 输出数据

System.out.println(new String(bytes,0,len));

6. 使用getOutputStream()方法给客户端回应

OutputStream os = lj.getOutputStream();
String name = "服务器：";
String nr = String.format("%s你好啊，客户端！", name);
os.write(nr.getBytes());

7. 关闭连接

server.close();
lj.close();

服务端完整代码：

package Java进阶.netBc;

import java.io.*;
import java.net.*;

/**
 * 1.创建一个服务器对象，绑定端口
 * 2.获取链接
 * 3.获取数据
 * 4.回应数据
 * 5.释放资源
 */
public class TCPServer {
     
    public static void main(String[] args) throws IOException {
     
        ServerSocket server = new ServerSocket(8888); //1.创建一个服务器对象，绑定端口
        Socket lj = server.accept(); //2.获取链接
        InputStream is = lj.getInputStream(); //3.获取数据
        byte[] bytes = new byte[1024];
        int len = is.read(bytes);
        System.out.println(new String(bytes,0,len));
        OutputStream os = lj.getOutputStream();
        String name = "服务器：";
        String nr = String.format("%s你好啊，客户端！", name);
        os.write(nr.getBytes());
        server.close();
        lj.close();
    }
}

6.2客户端

我们在客户端上需要：

  1. 向服务端发起链接
  2. 然后把数据传给服务端
  3. 接收来自服务端的回应
  4. 关闭链接

而表示客户端的类是java.net.Socket类

1. 导包

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

2. 发起链接

Socket socket = new Socket("127.0.0.1", 8888);

3. 给服务器端传数据

OutputStream os = socket.getOutputStream();
String nr = String.format("%s你好，服务器",name);
os.write(nr.getBytes());

4. 接收服务器端的响应

InputStream is = socket.getInputStream();
byte[] bytes = new byte[1024];
int len = is.read(bytes);
System.out.println(new String(bytes,0,len));

5. 关闭链接

socket.close();

全部代码

package Java进阶.netBc;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

/**
 * 1.创建Socket对象
 * 2.传数据
 * 3.接收响应
 * 4.关闭
 */
public class TCPClint {
     
    public static void main(String[] args) throws IOException {
     
        String name = "客户端：";
        Socket socket = new Socket("127.0.0.1", 8888);
        OutputStream os = socket.getOutputStream();
        String nr = String.format("%s你好，服务器",name);
        os.write(nr.getBytes());
        InputStream is = socket.getInputStream();
        byte[] bytes = new byte[1024];
        int len = is.read(bytes);
        System.out.println(new String(bytes,0,len));
        socket.close();
    }
}

效果展示

注意需要先让服务器运行起来，再运行客户端

客户端：

想学习JavaSE吗？八万字JavaSE资料送给你！_第7张图片

服务器端：

想学习JavaSE吗？八万字JavaSE资料送给你！_第8张图片

粉丝福利：

添加左侧好友领取海量Java资料

解，你就会发现端口号只不过就是这样罢了：

IP地址是计算机的小区地址，而端口号是门牌号，我给你的小区送了一封信，如果没有门牌号的话，物流就无法知道这封信到底是寄给谁的。

6.Java网络编程

Java网络编程是使用Java代码编写运行在网络中的多台设备的程序

Java网络编程被封装在java.net包中

而表示客户端的类是java.net.Socket类

表示服务端的类是java.net.ServerSocket类

而我们需要创建一个服务端和一个客户端，然后进行数据的传输

6.1服务端

我们创建一个服务端，需要以下步骤

  1. 创建服务器
  2. 指定服务器端口
  3. 获取客户端链接
  4. 接收数据
  5. 回应客户端
  6. 关闭链接

表示服务端的类是java.net.ServerSocket类

1. 使用之前，我们应该先导包，而考虑到后面会使用io包里的流和net包里的客户端，所以直接全导入

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

2. 我们通过ServerSocket类的带端口参数的构造方法来实例化，创建一个服务端

ServerSocket server = new ServerSocket(8888); //1.创建一个服务器对象，绑定端口位8888

3. 获取客户端链接

Socket socket = server.accept(); //2.获取链接

4. 使用getInputStream()方法接收数据

InputStream is = socket.getInputStream();
byte[] bytes = new byte[1024];
int len = is.read(bytes);

5. 输出数据

System.out.println(new String(bytes,0,len));

6. 使用getOutputStream()方法给客户端回应

OutputStream os = lj.getOutputStream();
String name = "服务器：";
String nr = String.format("%s你好啊，客户端！", name);
os.write(nr.getBytes());

7. 关闭连接

server.close();
lj.close();

服务端完整代码：

package Java进阶.netBc;

import java.io.*;
import java.net.*;

/**
 * 1.创建一个服务器对象，绑定端口
 * 2.获取链接
 * 3.获取数据
 * 4.回应数据
 * 5.释放资源
 */
public class TCPServer {
     
    public static void main(String[] args) throws IOException {
     
        ServerSocket server = new ServerSocket(8888); //1.创建一个服务器对象，绑定端口
        Socket lj = server.accept(); //2.获取链接
        InputStream is = lj.getInputStream(); //3.获取数据
        byte[] bytes = new byte[1024];
        int len = is.read(bytes);
        System.out.println(new String(bytes,0,len));
        OutputStream os = lj.getOutputStream();
        String name = "服务器：";
        String nr = String.format("%s你好啊，客户端！", name);
        os.write(nr.getBytes());
        server.close();
        lj.close();
    }
}

6.2客户端

我们在客户端上需要：

  1. 向服务端发起链接
  2. 然后把数据传给服务端
  3. 接收来自服务端的回应
  4. 关闭链接

而表示客户端的类是java.net.Socket类

1. 导包

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

2. 发起链接

Socket socket = new Socket("127.0.0.1", 8888);

3. 给服务器端传数据

OutputStream os = socket.getOutputStream();
String nr = String.format("%s你好，服务器",name);
os.write(nr.getBytes());

4. 接收服务器端的响应

InputStream is = socket.getInputStream();
byte[] bytes = new byte[1024];
int len = is.read(bytes);
System.out.println(new String(bytes,0,len));

5. 关闭链接

socket.close();

全部代码

package Java进阶.netBc;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

/**
 * 1.创建Socket对象
 * 2.传数据
 * 3.接收响应
 * 4.关闭
 */
public class TCPClint {
     
    public static void main(String[] args) throws IOException {
     
        String name = "客户端：";
        Socket socket = new Socket("127.0.0.1", 8888);
        OutputStream os = socket.getOutputStream();
        String nr = String.format("%s你好，服务器",name);
        os.write(nr.getBytes());
        InputStream is = socket.getInputStream();
        byte[] bytes = new byte[1024];
        int len = is.read(bytes);
        System.out.println(new String(bytes,0,len));
        socket.close();
    }
}

效果展示

注意需要先让服务器运行起来，再运行客户端

客户端：

想学习JavaSE吗？八万字JavaSE资料送给你！_第9张图片

服务器端：

想学习JavaSE吗？八万字JavaSE资料送给你！_第10张图片

你可能感兴趣的:(Java,vscode,java)

  • Long类型前后端数据不一致 igotyback 前端
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
  • LocalDateTime 转 String igotyback java开发语言
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计 网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team 若博豆 java算法华为javascript
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业javascripthtmlcss旅游风景
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动 二挡起步 web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
  • node.js学习 小猿L node.jsnode.js学习vim
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
  • Java 重写(Override)与重载(Overload) 叨唧唧的
    Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
  • 简单了解 JVM 记得开心一点啊 jvm
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
  • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven Energet!c 开发语言
    1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
  • 「豆包Marscode体验官」 | 云端 IDE 启动 & Rust 体验 张风捷特烈 iderust开发语言后端
    theme:cyanosis我正在参加「豆包MarsCode初体验」征文活动MarsCode可以看作一个运行在服务端的远程VSCode开发环境。对于我这种想要学习体验某些语言，但不想在电脑里装环境的人来说非常友好。本文就来介绍一下在MarsCode里，我的体验rust开发体验。一、MarsCode是什么它的本质是:提供代码助手和云端IDE服务的web网站，可通过下面的链接访问https://www
  • Java企业面试题3 马龙强_ java
    1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
  • JVM、JRE和 JDK：理解Java开发的三大核心组件 Y雨何时停T Javajava
    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
  • Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选javakafka
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
  • 白骑士的Java教学基础篇 2.5 控制流语句 白骑士所长 Java教学java开发语言
    欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
  • python语法——三目运算符 HappyRocking pythonpython三目运算符
    在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
  • ArrayList 源码解析 程序猿进阶 Java基础ArrayListListjava面试性能优化架构设计idea
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
  • Java爬虫框架（一）--架构设计 狼图腾-狼之传说 java框架java任务html解析器存储电子商务
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
  • Java：爬虫框架 dingcho Javajava爬虫
    一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
  • python怎么将png转为tif_png转tif weixin_39977276
    发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
  • JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy） 跳房子的前端 前端面试javascript开发语言ecmascript
    在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
  • JAVA·一个简单的登录窗口 MortalTom java开发语言学习
    文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
  • ESP32-C3入门教程 网络篇⑩——基于esp_https_ota和MQTT实现开机主动升级和被动触发升级的OTA功能 小康师兄 ESP32-C3入门教程https服务器esp32OTAMQTT
    文章目录一、前言二、软件流程三、部分源码四、运行演示一、前言本文基于VSCodeIDE进行编程、编译、下载、运行等操作基础入门章节请查阅：ESP32-C3入门教程基础篇①——基于VSCode构建HelloWorld教程目录大纲请查阅：ESP32-C3入门教程——导读ESP32-C3入门教程网络篇⑨——基于esp_https_ota实现史上最简单的ESP32OTA远程固件升级功能二、软件流程
  • WebMagic：强大的Java爬虫框架解析与实战 Aaron_945 Javajava爬虫开发语言
    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
  • 博客网站制作教程 2401_85194651 javamaven
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
  • 00. 这里整理了最全的爬虫框架（Java + Python） 有一只柴犬 爬虫系列爬虫javapython
    目录1、前言2、什么是网络爬虫3、常见的爬虫框架3.1、java框架3.1.1、WebMagic3.1.2、Jsoup3.1.3、HttpClient3.1.4、Crawler4j3.1.5、HtmlUnit3.1.6、Selenium3.2、Python框架3.2.1、Scrapy3.2.2、BeautifulSoup+Requests3.2.3、Selenium3.2.4、PyQuery3.2
  • JAVA学习笔记之23种设计模式学习 victorfreedom Java技术设计模式androidjava常用设计模式
    博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
  • JavaScript `Map` 和 `WeakMap`详细解释 跳房子的前端 JavaScript原生方法javascript前端开发语言
    在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
  • 计算机毕业设计PHP仓储综合管理系统（源码+程序+VUE+lw+部署） java毕设程序源码王哥 php课程设计vue.js
    该项目含有源码、文档、程序、数据库、配套开发软件、软件安装教程。欢迎交流项目运行环境配置：phpStudy+Vscode+Mysql5.7+HBuilderX+Navicat11+Vue+Express。项目技术：原生PHP++Vue等等组成，B/S模式+Vscode管理+前后端分离等等。环境需要1.运行环境：最好是小皮phpstudy最新版，我们在这个版本上开发的。其他版本理论上也可以。2.开发
  • java线程Thread和Runnable区别和联系 zx_code javajvmthread多线程Runnable
    我们都晓得java实现线程2种方式，一个是继承Thread，另一个是实现Runnable。 模拟窗口买票，第一例子继承thread，代码如下 package thread; public class ThreadTest { public static void main(String[] args) { Thread1 t1 = new Thread1(
  • 【转】JSON与XML的区别比较 丁_新 jsonxml
    1.定义介绍 (1).XML定义 扩展标记语言 (Extensible Markup Language, XML) ，用于标记电子文件使其具有结构性的标记语言，可以用来标记数据、定义数据类型，是一种允许用户对自己的标记语言进行定义的源语言。 XML使用DTD(document type definition)文档类型定义来组织数据;格式统一，跨平台和语言，早已成为业界公认的标准。 XML是标
  • c++ 实现五种基础的排序算法 CrazyMizzz C++c算法
    #include<iostream> using namespace std; //辅助函数，交换两数之值 template<class T> void mySwap(T &x, T &y){ T temp = x; x = y; y = temp; } const int size = 10; //一、用直接插入排
  • 我的软件 麦田的设计者 我的软件音乐类娱乐放松
         这是我写的一款app软件，耗时三个月，是一个根据央视节目开门大吉改变的，提供音调，猜歌曲名。1、手机拥有者在android手机市场下载本APP，同意权限，安装到手机上。2、游客初次进入时会有引导页面提醒用户注册。（同时软件自动播放背景音乐）。3、用户登录到主页后，会有五个模块。a、点击不胫而走，用户得到开门大吉首页部分新闻，点击进入有新闻详情。b、
  • linux awk命令详解 被触发 linux awk
    awk是行处理器: 相比较屏幕处理的优点，在处理庞大文件时不会出现内存溢出或是处理缓慢的问题，通常用来格式化文本信息 awk处理过程: 依次对每一行进行处理，然后输出 awk命令形式: awk [-F|-f|-v] ‘BEGIN{} //{command1; command2} END{}’ file [-F|-f|-v]大参数，-F指定分隔符，-f调用脚本，-v定义变量 var=val
  • 各种语言比较 _wy_ 编程语言
                        Java Ruby PHP 擅长领域                  
  • oracle 中数据类型为clob的编辑 知了ing oracle clob
    public void updateKpiStatus(String kpiStatus,String taskId){ Connection dbc=null; Statement stmt=null; PreparedStatement ps=null; try { dbc = new DBConn().getNewConnection(); //stmt = db
  • 分布式服务框架 Zookeeper -- 管理分布式环境中的数据 矮蛋蛋 zookeeper
    原文地址： http://www.ibm.com/developerworks/cn/opensource/os-cn-zookeeper/ 安装和配置详解 本文介绍的 Zookeeper 是以 3.2.2 这个稳定版本为基础，最新的版本可以通过官网 http://hadoop.apache.org/zookeeper/来获取，Zookeeper 的安装非常简单，下面将从单机模式和集群模式两
  • tomcat数据源 alafqq tomcat
    数据库 JNDI(Java Naming and Directory Interface，Java命名和目录接口)是一组在Java应用中访问命名和目录服务的API。 没有使用JNDI时我用要这样连接数据库： 03.  Class.forName("com.mysql.jdbc.Driver");  04.  conn
  • 遍历的方法 百合不是茶 遍历
                                                          遍历 在java的泛
  • linux查看硬件信息的命令 bijian1013 linux
    linux查看硬件信息的命令 一.查看CPU： cat /proc/cpuinfo   二.查看内存： free   三.查看硬盘： df   linux下查看硬件信息 1、lspci 列出所有PCI 设备； lspci - list all PCI devices:列出机器中的PCI设备（声卡、显卡、Modem、网卡、USB、主板集成设备也能
  • java常见的ClassNotFoundException bijian1013 java
    1.java.lang.ClassNotFoundException: org.apache.commons.logging.LogFactory   添加包common-logging.jar2.java.lang.ClassNotFoundException: javax.transaction.Synchronization    
  • 【Gson五】日期对象的序列化和反序列化 bit1129 反序列化
    对日期类型的数据进行序列化和反序列化时，需要考虑如下问题：   1. 序列化时，Date对象序列化的字符串日期格式如何 2. 反序列化时，把日期字符串序列化为Date对象，也需要考虑日期格式问题 3. Date A -> str -> Date B,A和B对象是否equals   默认序列化和反序列化     import com
  • 【Spark八十六】Spark Streaming之DStream vs. InputDStream bit1129 Stream
      1. DStream的类说明文档：   /** * A Discretized Stream (DStream), the basic abstraction in Spark Streaming, is a continuous * sequence of RDDs (of the same type) representing a continuous st
  • 通过nginx获取header信息 ronin47 nginx header
    1. 提取整个的Cookies内容到一个变量，然后可以在需要时引用，比如记录到日志里面， if ( $http_cookie ~* "(.*)$") {         set $all_cookie $1; }     变量$all_cookie就获得了cookie的值，可以用于运算了
  • java-65.输入数字n，按顺序输出从1最大的n位10进制数。比如输入3，则输出1、2、3一直到最大的3位数即999 bylijinnan java
    参考了网上的http://blog.csdn.net/peasking_dd/article/details/6342984 写了个java版的： public class Print_1_To_NDigit { /** * Q65.输入数字n，按顺序输出从1最大的n位10进制数。比如输入3，则输出1、2、3一直到最大的3位数即999 * 1.使用字符串
  • Netty源码学习-ReplayingDecoder bylijinnan javanetty
    ReplayingDecoder是FrameDecoder的子类，不熟悉FrameDecoder的，可以先看看 http://bylijinnan.iteye.com/blog/1982618 API说，ReplayingDecoder简化了操作，比如： FrameDecoder在decode时，需要判断数据是否接收完全： public class IntegerH
  • js特殊字符过滤 cngolon js特殊字符js特殊字符过滤
    1.js中用正则表达式 过滤特殊字符, 校验所有输入域是否含有特殊符号function stripscript(s) {    var pattern = new RegExp("[`~!@#$^&*()=|{}':;',\\[\\].<>/?~！@#￥……&*（）&mdash;—|{}【】‘；：”“'。，、？]"
  • hibernate使用sql查询 ctrain Hibernate
    import java.util.Iterator; import java.util.List; import java.util.Map; import org.hibernate.Hibernate; import org.hibernate.SQLQuery; import org.hibernate.Session; import org.hibernate.Transa
  • linux shell脚本中切换用户执行命令方法 daizj linuxshell命令切换用户
    经常在写shell脚本时，会碰到要以另外一个用户来执行相关命令，其方法简单记下：   1、执行单个命令：su - user -c "command" 如：下面命令是以test用户在/data目录下创建test123目录 [root@slave19 /data]# su - test -c "mkdir /data/test123" 
  • 好的代码里只要一个 return 语句 dcj3sjt126com return
    别再这样写了：public boolean foo() {    if (true) {         return true;     } else {          return false;    
  • Android动画效果学习 dcj3sjt126com android
    1、透明动画效果 方法一：代码实现 public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { View rootView = inflater.inflate(R.layout.fragment_main, container, fals
  • linux复习笔记之bash shell (4)管道命令 eksliang linux管道命令汇总linux管道命令linux常用管道命令
    转载请出自出处： http://eksliang.iteye.com/blog/2105461     bash命令执行的完毕以后，通常这个命令都会有返回结果，怎么对这个返回的结果做一些操作呢？那就得用管道命令‘|’。     上面那段话，简单说了下管道命令的作用，那什么事管道命令呢？     答：非常的经典的一句话，记住了，何为管
  • Android系统中自定义按键的短按、双击、长按事件 gqdy365 android
    在项目中碰到这样的问题： 由于系统中的按键在底层做了重新定义或者新增了按键，此时需要在APP层对按键事件（keyevent）做分解处理，模拟Android系统做法，把keyevent分解成： 1、单击事件：就是普通key的单击； 2、双击事件：500ms内同一按键单击两次； 3、长按事件：同一按键长按超过1000ms（系统中长按事件为500ms）； 4、组合按键：两个以上按键同时按住；
  • asp.net获取站点根目录下子目录的名称 hvt .netC#asp.nethovertreeWeb Forms
    使用Visual Studio建立一个.aspx文件(Web Forms)，例如hovertree.aspx,在页面上加入一个ListBox代码如下： <asp:ListBox runat="server" ID="lbKeleyiFolder" />   那么在页面上显示根目录子文件夹的代码如下： string[] m_sub
  • Eclipse程序员要掌握的常用快捷键 justjavac javaeclipse快捷键ide
      判断一个人的编程水平，就看他用键盘多，还是鼠标多。用键盘一是为了输入代码（当然了，也包括注释），再有就是熟练使用快捷键。   曾有人在豆瓣评 《卓有成效的程序员》：“人有多大懒，才有多大闲”。之前我整理了一个 程序员图书列表，目的也就是通过读书，让程序员变懒。  写道 程序员作为特殊的群体，有的人可以这么懒，懒到事情都交给机器去做，而有的人又可
  • c++编程随记 lx.asymmetric C++笔记
     为了字体更好看，改变了格式……   &&运算符：   #include<iostream> using namespace std; int main(){      int a=-1,b=4,k;      k=(++a<0)&&!(b--
  • linux标准IO缓冲机制研究 音频数据 linux
    一、什么是缓存I/O(Buffered I/O)缓存I/O又被称作标准I/O,大多数文件系统默认I/O操作都是缓存I/O。在Linux的缓存I/O机制中，操作系统会将I/O的数据缓存在文件系统的页缓存(page cache)中，也就是说，数据会先被拷贝到操作系统内核的缓冲区中，然后才会从操作系统内核的缓冲区拷贝到应用程序的地址空间。1.缓存I/O有以下优点:A.缓存I/O使用了操作系统内核缓冲区，
  • 随想 生活 暗黑小菠萝 生活
    其实账户之前就申请了，但是决定要自己更新一些东西看也是最近。从毕业到现在已经一年了。没有进步是假的，但是有多大的进步可能只有我自己知道。   毕业的时候班里12个女生，真正最后做到软件开发的只要两个包括我，PS：我不是说测试不好。当时因为考研完全放弃找工作，考研失败，我想这只是我的借口。那个时候才想到为什么大学的时候不能好好的学习技术，增强自己的实战能力，以至于后来找工作比较费劲。我
  • 我认为POJO是一个错误的概念 windshome javaPOJO编程J2EE设计
                  这篇内容其实没有经过太多的深思熟虑，只是个人一时的感觉。从个人风格上来讲，我倾向简单质朴的设计开发理念；从方法论上，我更加倾向自顶向下的设计；从做事情的目标上来看，我追求质量优先，更愿意使用较为保守和稳妥的理念和方法。    &
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他