Java19：JavaSE总结

本文主要是为了对照学过的知识点进行回顾，如果不能想起来的，就回顾总结知识点，进行巩固！

1.Java语言

1. 简单的DOS命令
2. 计算机语言发展
3. Java的诞生 1995年诞生

javaSE
javaME --> Android
javaEE //企业级开发

2006年Hadoop诞生

4. JDK 开发工具包
   配置环境变量

jdk的卸载
Path：jdk\bin; jre\bin; oracle…\javapath
JAVA_HOME

5. JRE 运行环境

2.HelloWorld

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

javac Hello.java 生成class
java Hello

1. 编译型语言和解释型语言
2. IDEA

3.基础语法

1. 注释

// 1.行内注释

/*
2.多行注释
*/

/**
  * 3.文档注释
  * /

2. 标识符 关键字

4.数据类型

4.1.基本数据类型

整数：

• byte 1字节
• short 2字节
• int （默认）4字节
• long 8字节

进制转换：0b 二进制；0x 十六进制；0八进制
浮点数：

• float 4字节
• double（默认）8字节
• BigDecimal（金融领域）

字符：

• 斜体样式char 2字节
• ascii 编码
• utf-8 编码
• Unicode 编码
  ‘\u0000’: \b: \n: \r: \t: ': ’ “:” \:\

布尔值：

• boolean 1位
  if(a) == if(a ==true)

4.2.引用数据类型

1. 类
2. 接口
3. 数组

5.类型转换

1. 自动类型转换 低转高
2. 强制类型转换 高转低(低)高

6.变量和常量

6.1 type varName [=value];

6.2.作用域

类变量
实例变量
局部变量

6.3.常量 final MAX_A= 10;

6.4.命名规范：

1.见名知意
2.驼峰命名
3.类，首字母大写，驼峰命名
4.常量：大写 + 下划线_
5. 不要使用拼音命名

7.运算符

1. 算术运算符
   +、-、*、/、 %、 ++、 –

2. 赋值运算符
   =

3. 关系运算符
   <、 >、 >=、 <=、 ==、 !=、 instanceof

4. 逻辑运算符
   && 、||、 ！

5. 位运算符
   & 、| 、 ~ 、 >>、 <<、 >>>

6. 条件运算符
   ? a : b ;

7. 扩展运算符
   +=、 -= 、*=、 /=

8. 包机制

域名倒写
防止命名冲突
package
import

9.JavaDoc 文档

9.1.JDK　帮助文档

9.2.JavaDoc

/**
* @author 作者
* @Version 版本
* @Since 最早支持的Java版本
* @param 参数
* @return 返回值
* @throws 异常
*/

public class Hello{
	/**
	* @author Mark
	* @Since 1.0
	* @param no
	* @throws null
	*/
	public static void main(String[] args) {
		System.out.print("hello");
	}
}

//生成文档命令：
javadoc -encoding UTF-8 -charset UTF-8 Hello.java

10.流程控制

1. Scanner 用户交互System.in

2. 顺序结构
程序默认的结构，自上而下地执行

3. 选择结构

1）if 单选择结构
2）if-else 双选择结构
3）if-else if -else 多选择结构
4）switch ：

1. jdk 支持了String类型
2. case 穿透
3. break
4. default

10.4. 循环结构

1. while：不可计数
   尽量避免死循环

2. do…while

先执行一次，再判断条件

3. for 循环：可计数

for(int i=0; i<100; i++)

4. 增强for循环

10.5. break & continue

break：跳出循环；
continue：终止本次循环，继续下次循环；
带标签continue（使用频率低）;
return：结束方法的运行。

11.方法

11.1.什么是方法

语句的结合

11.2 方法的定义

修饰符 返回值 方法名(参数名) {return 返回值;} 

11.3.方法的调用

类名.方法
对象.方法

11.4.方法的重载

名字相同，参数类型 或参数列表不同

11.5.命令行传参 给main方法传参

public class Hello{
	/**
	* @author Mark
	* @Since 1.0
	* @param no
	* @throws null
	*/
	public static void main(String[] args) {
		for(int i=0; i<args.length; i++) {
			System.out.print(args[i]);
		}
	}
}

javac Hello.java
java Hello zhong guo
zhong 
guo 

11.6.可变长参数

…
必须放在最后一个参数

11.7.递归 面试常问

自己调用自己，给自己一个出口

12.数组

12.1.数组的定义

new int[5];
{1,2,3,4,6}
必须是同一个类型

12.2.数组的使用

通过下标拿到值
ArrayIndexOutOfBounds 下标越界异常
增强for循环—进行遍历

12.3.二维数组 int[][]

12.4.Arrays工具类

Arrays.asList -变成数组
fori（遍历数组）
Arrays.sort -排序

12.5.排序算法

【西部开源Java之数组与排序】

1. 冒泡排序
2. 选择排序
3. 插入排序
4. 快速排序
5. 归并排序
6. 希尔排序
7. 堆排序
8. 基数排序

13.面向对象

13.1.什么是面向对象？

13.2.类与对象

类是对象的抽象：模板Class
对象是类的具体

13.3.构造方法

构造的重载：
1. 默认的无参构造
2. 如果手动定义了有参构造，必须要手动再加一个无参构造；
3. 单例模式，需要构造器私有

13.4. new 对象

栈存放引用，堆存放具体的对象

13.5.封装

属性私有，get / set

13.6.继承

extends
Object
子类拥有父类的全部特征
方法重写
this
super
Java是单继承，只能继承一个父类

13.7.多态

父类的引用指向子类的对象

Person person = new Student();

instanceof 关键词，如果匹配，可以进行类型之间的转换

13.8.修饰符

public
protected
private
static
final
abstract

13.9.接口

interface
约束，只能定义方法名；
子类实现接口，必须重写其中的方法；
只有一个方法的接口叫做函数式接口，可以使用Lambda表达式简化；
接口比抽象类更抽象；
一个类可以实现多个接口；

13.10.内部类

局部内部类（方法里面）
静态内部类（方法外面，类里面）
匿名内部类（方法里面）

14.异常 Throwable

14.1. Exception异常

运行时异常
I/O
ClassNotFound
NullPoint
UnKownType
下标越界
…
检查性异常

14.2.Error错误

AWT 错误（前端的，频率低）
JVM 错误
StackOverFlow 栈溢出
OutOfMemory 内存溢出

14.3. 异常五个关键字

try{}
catch{} 先小（异常），后大（异常）
finally{}
throw 手动抛出异常，方法内使用；
throws 方法抛出异常，方法上使用

14.4.自定义异常

继承Exception 类即可
详细见Java09异常机制

// -------------Java高级-----------------------

15.常用类

15.1. Object类

hashcode()
toString()
clone()
getClass()
notify()
wait()
equals()

15.2. Math类-常见的数学运算

Math.runtime();//随机数
Math.PI();常量π

15.3. Rundom类-生成随机数-uuid

15.4. File类

创建文件：create new file
查看文件：find、madir、canRead、length、getPath
修改文件：
删除文件：delete

15.5. 包装类

自动装箱和拆箱？
Java是面向对象型语言，我们给八大基本类型。。对应的对象

15.6. Date类

Date
SimpeDateFormat （yyyy-MM-dd HH:mm:ss）
Calender 日期（建议使用）

15.7. String类-不可变性 final-操作量较少

String(char[], int, int);
String(byte[], int, int, Charset);
String(byte[], Charset);
String(StringBuffer);
String(StringBuilder);
length();
isEmpty();
charAt(); //String获取指定字符串
getBytes(String); //byte[]
indexOf(); // int 获取指定下标
concat(String); // String 包含某个字符串
replace(char, char); // String 替换某个字符串
replaceAll(String, String); // String 替换全部
toLowerCase(); //String 转小写
toUpperCase(); // String 转大写

public class demo1 {
    public static void main(String[] args) {
        String str1 = "a" + 1 + 2;//a12
        int str2 = 'a'+ 1 + 2;//整数:100
        String str3 =  1 + 2 + "a" ;//3a
        
		//Str1:a12---str2:100---str3:3a
        System.out.println("Str1:"+str1+"---str2:"+str2+"---str3:"+str3);
    }
}

15.8. StringBuffer-可变长 append()

多线程，操作量比较大，效率低，安全

15.9. StringBuilder -可变长

单线程，操作量比较大，效率高，不安全

16.集合框架

16.1.Collection-List

有序，可重复，
1）ArrayList（常用） 方法都实现了接口 Iterator（迭代器，推荐）

1. add
2. remove
3. contains 包含
4. size

2）LinkedList（常用）

1. getFirst();
2. getLast();
3. removeFirst();
4. addFirst();…

3）Vector（不常用）
4）Stack（栈，不常用）

16.2.Collection-Set

无序，不可重复
HashSet（常用）
TreeSet

16.3.Map

HashMap（常用，重点，面试高频）
jdk1.7:数组+链表
jdk1.8:hash表= 数组+链表+红黑树
红黑树？自平衡，提高效率
数组长度为什么是2的倍数？ 2的n次方就是1后面有n个0，而2的n次方-1，实际上就是n个1
加载因子=0.75？空间资源，时间资源
TreeMap

16.4.Collections工具类

16.5.泛型

<> ,约束，避免类型转换之间的问题

17.IO流

17.1.字节流

输入：OutputStream
输出：InputStream

17.2.字符流

字符流 有中文时推荐使用

Reader
Writer

17.3.节点流

1）CharArray数组

1. CharArrayReader
2. CharArrayWriter
3. CharArrayInputStream
4. CharArrayOutputStream

2）String

1. StringReader
2. StringWriter

3）pipe（管道流）

1. PipedInputStream
2. PipedOutputStream

4）File（文件流）

17.4.处理流

1）序列化

1. Serializable
2. transient（透明的，不需要序列化时使用）

2）反序列化

3）buffer（四个）

1. bufferInputStream
2. bufferOutputStream
3. bufferReater
4. bufferWriter

4）date（两个）

1. DateInputStream
2. DateOutputStream

5）转换流（两个，常用）

1. InputStreamReader
2. OutputStreamWriter

6）Object（四个）

7）Filter（四个）

8）print（两个）

1. PrintWriter
2. PrintStream

18.多线程

18.1.进程和线程

18.2.run(),start();

18.3.线程的创建方式

Runnable（start0，本地方法：Java无权调用，交给底层的c处理）
private native void start0(); // 本地方法，Java无权调用
Thread （继承Runnable）
函数式接口，可以被Lambda表达式 表示
Callable（可以有返回值）

18.4.静态代理

new Thread(Runnable).start();

18.5.Lambda表达式-函数式编程

避免内部类定义过多

new Thread(()->{
System.out.print();
}).start();

手动推导Lambda表达式

18.6.线程的状态

新建状态
就绪
运行
阻塞
死亡

18.7.线程的常用的方法

start
sleep （计时器）
join
yield
isLive
setPriority / getPriority–优先级
interrupt()
stop();（不推荐使用）

18.8.线程同步–锁

问题：多个对象操作 同一个资源，涉及并发问题
解决：队列 + 锁

Synchronized：
1. 同步方法，弊端：锁的内容太多了
2. 同步代码块（ ！常用）

锁的原理：第一个进程进来拿到锁，后面就要排队了，直到这个人释放锁，后面拿到锁才能进去;

死锁：两个人都抱着对方的锁

死锁的四个条件：

1. 互斥
2. 请求与保持
3. 不剥夺条件
4. 循环等待条件

Lock（ 优先级高） ReentrantLock

1. lock()
2. unlock()
3. trylock()

锁的优先级：Lock > 同步代码块 > 同步方法

18.9.线程通信

通信的方法（2种）：

1. 缓冲区：消息队列
2. 标志位（红绿灯）

线程通信 用到的方法：

wait(); // 线程等待
notify(); // 随机唤醒一个线程
notifyAll(); // 唤醒全部线程

18.10.线程池

由于创建线程需要消耗大量资源，就有了线程池。

//池化技术（线程池、数据库连接池。。。）
Executors.newFixedThreadPool();

线程池七大参数：

1. corePoolSize 线程池大小
2. maximumPoolSize 最大连接数
3. keepAliveTime 超时时间
4. unit 超时时间单位
5. workQueue 阻塞队列
6. threadFactory 线程创建的工厂
7. handler （线程满时 ）拒绝策略

19.网络编程

IP、端口
Socket编程
TCP编程：三次握手，四次挥手；面向连接。
UDP编程：无连接，package（包）
URL：IP + 端口
聊天通信
文件上传、下载

初识Tomcat

20.GUI（可选）

20.1.AWT

1）Frame
2）监听事件：

1. 鼠标
2. 键盘
3. 窗口
4. 动作事件

20.2.Swing

文本框
标签
按钮
文本域
面板
布局方式
关闭窗口
列表

20.3.贪吃蛇

Timer 定时器
键盘监听
游戏帧的概念

21.注解和反射

21.1.注解

元注解
内置注解
自定义注解
反射读取注解

21.2.反射

Class类 newInstance();
类加载机制
Method invoke(); 存在重载，需要写参数的类型
Field set(); 需要写参数的类型
Construct newInstance(); 获取的时候，需要传递参数的 Class类型

破坏私有关键字：setAccessible(true);
性能分析：正常 new > 检测关闭的反射 > 默认的反射
反射获得注解，泛型…（不重要）

21.3.单例模式的探究

21.4.Stream

21.5.ForkJoin 效率对比

22.思考：

1.线程的5种状态，以及线程常用的方法
2.通过反射如何创建对象，执行对象的方法，修改对象的字段，如果是私有的该怎么办？
3.面向对象的概念的理解（生活示例）
4.native，volatile关键字作用！各举一个Java中的例子

23.聊天室

代码实现：多线程聊天室
1.GUI
2.多线程
3.集合
4.网络编程
5.IO流
6.Timer定时
7.监听
8.Java基础