JAVA知识笔记

基本介绍

特性与优势

面向对象
可移植性
高性能（即使编译）
分布式
动态性（反射机制）
多线程（多个任务同时执行）
安全性
健壮性
简单性

JAVA三大版本

javaSE：标准版本（桌面程序，控制台开发）
javaME：嵌入式开发（手机，小家电）
javaEE：E企业级开发（web端，服务器端）

JDK,JRE,JDK

jre是java基本的一个运行环境，jdk包含有jre的运行环境的同时还有一些开发工具。是开发工具包

java程序运行机制

编译型 -将编程语言编译成机器可运行的语言
解释型 -走一步解释一步，运行一段编译一段

java先将javac进行编译形成一个.class文件，再对class文件进行解释给操作系统平台

语法基础

注释

单行注释 (//)
多行注释 (/* xxxxx */)
文档注释 (/** *xx *xx */)

javaDoc

生成说明文档

@author
@Version
@Since
@param
@return
@throws

#生成程序帮助文档
javadoc -enconding UTF-8 charset UTF-8 文件名

标识符

标识符应该以字母(a-z)，美元符号($)，或者下划线(_)开始
字母大小写敏感
不可使用关键字来命名

数据类型

强类型语言

变量的使用要严格符合规定（符合数据类型定义），所有变量必须先定义后使用

安全性提高
运行速度下降

java数据类型分为两类

基本数据类型（8个）

数值类型

整数类型

byte 1个字节 -128-127

short 2个字节 -32768-32767

int 4个字节 -2147483648-2147483647

long 8个字节 -9223372036854775808-9223372036854775807 （数字后加L表示，50L）

浮点类型

float 4个字节（数字加F表示，50.1F）

double 8个字节

字符串类型

char 2个字节

boolean布尔类型：1个字节，只有true与false

引用类型

类

接口

数组

类型转换

低到高转换顺序

byte,short,char-->int-->long->float-->double

注意

布尔值不能转换
不想同的数据类型不能转换
高精度转低精度时，需要强制转换
转换可能会出现精度丢失或内存溢出等问题
低转高自动转换

什么是字节

位（bit）：是计算机 内部存储 的最小单位，11001100是一个八位二进制数字
字节（byte）：是计算机中 数据处理 的基本单位，习惯用大写B来表示。
1B （byte，字节）=8bit位
字符；是指计算机中使用的字母、数字、字和符号

java进制数表示

二进制 0b
十进制
八进制 0 (int i2=010 (8))
十六进制 0x （int i3=0x10 (16) )

数据类型拓展

浮点数不可以用于比较

浮点数是有限的数值，比较的结果离散的，会进行舍入操作，有舍入误差，数值接近但不等于

比较浮点数可以使用 BigDecimal

所有的字符本质还是数字

可以对字符 char类型进行int的强制转换，转换得出的结果对应Unicode编码中的编码

变量

定义

可以变化的量
java是一种强类型语言，每个变量都必须声明其类型
java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域

注意事项

每个变量都有类型，可为基本类型或应用类型
变量名为合法标志符
声明是一个完整的语句，以分号 ; 结束

常量

使用 final 来定义
初始化后值不能改变，值不会变动

变量名命名规则

变量，方法，类名：见名知意
类成员变量：首字母小写和驼峰原则：lastName
局部变量名：首字母小写和驼峰原则
常量：大写字母和下划线：MAX_VALUE
类名：首 字母大写 和驼峰
方法名：首字母小写和驼峰

变量作用域

类变量（static（静态）修饰）
实例变量（在类下，从属于对象）
局部变量（在方法内，在方法里有效，必须声明和初始化值）

变量默认值

基本数据类型默认值为0 或0.0
布尔值的默认值为false
除了基本数据类型，其余都是null

运算符

算术运算符
赋值运算符
关系运算符
逻辑运算符
位运算符
条件运算符
扩展运算符

自增符

i++:执行代码后，先赋值，后自增
++i:执行代码前，先自增，后赋值

幂运算

使用java工具 Math.pow(3,2) 3的2次方

逻辑运算&和&&区别

&逻辑运算，两个都为真才为真，&两边都会执行
&&短路运算，两个都为真才为真，前端为false，后端不执行

位运算

用二进制运算，效率高，常用于算法之中

System.out.print(2<<3);
//结果位8
/*
<< *2
>> /2

0000 0000 0
0000 0001 1
0000 0010 2
0000 0100 4
0000 1000 8
0001 0000 16
*/

String + 号拼接问题

int a=10;
int b=20;
System.out.println(""+a+b);
//结果位1020，""先将a和b转换位字符串，再拼接
System.out.println(a+b+"");
//结果为30，先将a+b运算，再转换为字符串拼接

三元运算符号

/*
x ? y : z
如果x为真，结果为y,否则为z
*/

流程结构

顺序结构

java基本的结构就是顺序结构，按照顺序一句一句执行
从上到下顺序进行，任何一个算法都离不开的基本结构

选择结构

if选择

if单选结构
if双选结构
if多选结构
嵌套的if结构
switch多选择结构

switch选择

jdk支持了Stirng类型
缺少break，出现case穿透现象
default

循环结构

while
do....while
for

for循环

for循环语句是支持迭代的一种通用结构，是最有效，最灵活的循环结构
for循环执行的次数在执行前就确定的。

//for循环多个参数定义
for(int i=0;j=array.length-1,i<array.length;i++,j--){
    //循环体
}

九九乘法表

for(int j=1;j<=9;j++){
    for(int i=1;i<=j;i++){
        //"\t"table空格
        System.out.print(j+"*"+i+"="+(j*i)+"\t");
    }
    System.out.println();
}

break和continue

break在任何循环语句的主体部分，均可用break控制循环的流程
break用于强制退出循环，不执行循环中剩余的语句
continue语句用在循环语句体中，用于终止某次循环过程，接着进行下次循环的判定
continue通过 outer标签 跳转到外层指定层级的循环
~~goto~~关键字是java的一个保留字，但并未在语言中正式使用，但能使用break和continue看到相应的影子

方法

定义

java方法是语句的集合，用特定的代码片段完成特定功能。

方法是解决一类问题的步骤的有序组合
方法包含于类或对象中
方法在程序中被创建，在其他地方被引用

设计原则

方法本意是功能块，是实现某个功能的语句块和集合，设计时最好保持方法的原子性，就是一个方法只完成一个功能 ,利于后期扩展。

方法组成

方法包含一个方法头和一个方法体

修饰符：可选，告诉编译器如何调用该方法，定义该方法的访问类型
返回值类型：放回值的类型，没有放回值则用void
方法名：方法的实际名字，方法名和参数表共同构成方法签名
参数类型：可选，参数是一个占位符号，当方法被调用时，传递值给参数。可分为 形式参数 :在方法被调用时用于接收外界输入数据。实参: 调用方法时实际传给方法的数据
方法体：方法体包含具体的语句，定义该方法的功能。

/* 修饰符 返回值类型 方法名(参数类型，参数名){
	方法体
	return 返回值;
}

方法的调用

静态方法：static修饰的方法，可直接通过类名来调用
非静态方法：需要实列化（new）类来调用方法
形参和实参：形参参数的名，实参传递的数据，两者类型需要相同
值传递和应用传递
this关键字

方法的重载

重载：在一个类中，相同的函数名，但形参不同的函数

重载的规则

方法名称必须相同
参数列表必须不同（个数，类型，参数排列顺序等）
方法的返回类型可以相同也可以不相同
仅仅返回类型不同，不可以重载方法

可变参数

JDK 1.5开始，java支持传递同类型的可变参数给一个方法
在方法声明中，在指定参数类型后加一个省略号(...)
一个方法只可以有一个可变参数，必须在方法的最后一个参数。

public void test1(int...a){
  }

命令行传参数

通过命令行给main方法传递参数

public static void main(String [] args){    for(int i=0;i<args.length;i++){        System.out.println(args[i])    }}

命令行传参

#先编译#javac 文件名javac hello.java#java 文件 参数java hello hello1 world

递归

定义

方法自身调用自己
递归的能力在于在有限的语句来定义对象的无限集合。

递归结构

递归头：什么时候不调用自身方法，若没有将会死循环
递归体：什么时候需要调用自身方法

数组

定义

数组是相同类型数据的有序集合
按照一定先后次序排列组合而成
每一个数组称作一个数组元素，每个数组元素可以通过小标来访问它们
通过索引进行访问，即下标一般从“0”开始

java简单内存分析

java内存

堆

存放new对象和数组

可以被所有的线程共享，不会存放别的对象引用

栈

存放基本变量类型（会包含这个基本类型的具体数值）

引用对象的变量（会存放这个引用在堆里面的具体地址）

方法区

可以被所有的线程共享

包含所有的class和static变量

数组的特征

数组长度是确定的，一旦被创建，大小不可以改变。
其元素的数据类型必须相同，不允许有混合类型
数组元素可以是任何数据类型，包括基本数据类型和引用数据类型
数组变量属于引用类型，数组也可以看成是对象，数组中的元素相当于其中的成员变量
数组本身就是对象，java中对象是在堆中，因此数组本身是在堆中

多维数组

多维数组就是数组的元素中还是数组。

//二维数组int[][] arr = new int[11][11];int [][] array={{2,3},{4,5}};

Arrays类

数组的工具类，java.util.Arrays
Arrays类中的方法都是static修饰的静态方法，使用是可以直接使用类名调用

具有以下功能

给数组赋值:通过fill方法
对数组排序:通过sort方法，升序
比较数组:通过equals方法比较数组中的元素是否相等
查找数组元素:通过binarySearch方法能对排序好的数组进行二分查找法的操作

排序方法

八大排序方法

内部排序

插入排序

直接插入排序

希尔排序

选择排序

简单选择排序

堆排序

交换排序

冒泡排序

快速排序

归并排序

基数排序

外部排序

冒泡排序

比较数组中两个相邻元素的大小，如果第一个元素比，第二个元素大，则交换他们的位置
每一次比较，都会产生出一个最大，或者最小的数字
下一轮可以减少一次排序
依次循环比较
嵌套循环，时间复杂度为O(n^2)

//临时变量int temp=0//外层循环，判断需要循环多少次for(int i=0;i<array.length-1;i++){    //标志位    boolean flag=false;    //内层比较大小,比较完的可以不用再进行比较    for(int j=0;j<array.length-1-i;j++){        if(array[j]>array[j+1]){            temp=array[j];            array[j]=array[j+1];            array[j+1]=temp;            flag=true;        }      }    if(flag==false){        break;    }}return array;

稀疏数组

当一个数组中大部份元素的值相时，可以使用稀疏数组保存，节省空间
记录数组一共有几行几列，有多少个不同的值
把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模

//创建一个二维数组 11*11 记录棋盘棋子信息 0:没有棋子 1：黑棋 2:白棋        int [][] array1=new int[11][11];        array1[1][2]=1;        array1[2][3]=2;        //输出原始数组        System.out.println("原始数组");        for (int[] ints:array1){            for (int anInt:ints){                System.out.print(anInt+"\t");            }            System.out.println();        }        System.out.println("=========");        //转换位稀疏数组保存        //获取有效值的个数        int sum=0;        for (int i=0;i<11;i++){            for (int j=0;j<11;j++){                if (array1[i][j]!=0){                    sum++;                }            }        }        System.out.println("稀疏数组");        System.out.println("有效值的个数"+sum);        //创建一个稀疏数组        int[][] array2=new int[sum+1][3];        array2[0][0]=11;        array2[0][1]=11;        array2[0][2]=sum;        //遍历二维数组，将非零的值，存放稀疏数组中        int count=0;        for (int i = 0; i < array1.length; i++) {            for (int j=0;j<array1[i].length;j++){                if (array1[i][j]!=0){                    count++;                    array2[count][0]=i;                    array2[count][1]=j;                    array2[count][2]=array1[i][j];                }            }        }        //输出        for (int i = 0; i < array2.length; i++) {            System.out.println(array2[i][0]+"\t"                    +array2[i][1]+"\t"                    +array2[i][2]+"\t");        }        //还原稀疏        //读取稀疏数组        int[][] array3=new int[array2[0][0]][array2[0][1]];        //给其中的元素还原它的值        for (int i = 1; i < array2.length; i++) {            array3[array2[i][0]][array2[i][1]]=array2[i][2];        }        System.out.println("=========");        //打印        System.out.println("输出还原数组");        for (int[] ints:array3){            for (int anInt:ints){                System.out.print(anInt+"\t");            }            System.out.println();        }    }

面向对象编程

面向过程思想

步骤清晰，
面对过程适合处理一些简单问题

面向对象思想

物以类聚，分类的思维模式，思考问题首先需要那些分类，然后对这些分类进行单独思考，最后，对某个分类下的细节进行面向过程的思考。
适合处理复杂问题，需要多人协作处理问题

对于复杂的事物，从宏观上把握、合理分析，需要使用面向对象的思路分析整个系统。但是具体到微观操作，仍然需要面向过程的思路去处理。

什么是面向对象

面向对象编程（Object-Oriented Programming，oop）
面向对象的本质是：以类的方式组织代码，以对象的方式组织（封装）数据
抽象：把对象中所共有的东西抽取出来，形成大家所共有的东西
从认识的角度考虑是，先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象
从代码运行考虑是现有类后有对象。类是对象的模板

三大特性

封装：把数据包装起来，定义私有属性，通过set，get暴露出来给方法调用
继承：子类继承父类所有的属性
多态：同一个事物，会有多种形态，同一个对象有不同的表现形式

类与对象的关系

类是一种抽象的数据类型，它是对某一事物整体描述/定义，但是不能代表某一个具体的事物。
类是抽象的，只有在实例化（new）的时候，才成为对象
类实例化后，返回一个自己的对象
student对象就是一个student类的具体实例

创建与实例化对象

使用new关键字创建的时候，除了分配内存空间外，还会给创建好的对象进行默认的初始化，以及对类的构造器的调用

构造器

类中的构造器也称为构造方法，是进行创建对象的时候必须调用的。有以下特点

必须和类的名字相同
必须没有返回类型，也不能写void
定义有参构造器时，需要显示定义无参构造器

封装

程序设计追求”高内聚，低耦合“。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。

封装（数据的隐藏）

通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问。
属性私有化，get/set表示

继承

继承的本质是对某一批类的抽象
extends的意思是 ”扩展“ 的意思，子类是父类的扩展
JAVA中只有单继承，没有多继承
继承是类和类之间的一种关系。除此外类和类之间还有依赖关系、组合、聚合。
子类和父类之间，应该是”is a“关系

instanceof

判断是否为继承关系，返回true和false

super与this关键字

super关键字的作用是调用父类中的构造器，且在代码的首行
this关键字是调用类自身的构造器，且在代码的首行
super和this不能同时调用构造方法

方法的重写

重写是方法的重写，和属性无关
静态方法不能被重写
重写发生在继承当中，子类重写父类中的方法
方法名相同，参数列表相同
修饰符范围可以扩大，但不能缩小：Public>Protected>Default>Private
抛出的异常：范围可以缩小，但不能扩大；ClassNotFoundEXception -->Exception(大)

多态

同一方法可以根据发送对象的不同而采用多种不同的行为方式。

一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多

多态的存在条件

有继承关系
子类重写父类的方法
父类引用指向子类的对象

多态注意事项

多态是方法的多态，属性没有多态
父类和子类，继承关系，方法需要重写
父类引用指向子类 Father f1=new Son();

理解

多态是同一个行为具有多个不同表现形式或形态的能力。

多态性是对象多种表现形式的体现。

现实中，比如我们按下 F1 键这个动作：

如果当前在 Flash 界面下弹出的就是 AS 3 的帮助文档；

如果当前在 Word 下弹出的就是 Word 帮助；

在 Windows 下弹出的就是 Windows 帮助和支持。

同一个事件发生在不同的对象上会产生不同的结果。

多态的优点

消除类型之间的耦合关系
可替换性
可扩充性
接口性
灵活性
简化性

多态存在的三个必要条件

继承
重写
父类引用指向子类对象：Parent p = new Child();

类型转换

父类需要调用子类的方法需要进行强制类型转换

由父类转换成子类，由高转低，需要强制类型转换

由子类转成父类，由低转高，不需要强类型转换，会丢失精度，失去子类的方法

抽象类

abstract修饰符可以用来修饰类或者修饰方法，如果方法即为抽象方法，修饰类，即为抽象类
抽象类中可以没有抽象方法，但是有抽象方法的类必须为抽象类
抽象类，不能实例化（new）来创建，它是通过子类来继承的
抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的。
子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类。

特点

不能实例化（new）抽象类，只能继承，靠子类去实现它：约束
抽象类中可以写普通方法
抽象方法必须在抽象类中

接口

接口就是规范，定义的是一组规则，体现了现实世界中，“如果你是...则必须能...”的思想，如果你是汽车，则必须能跑，如果你是好人，必须做好事等。
接口的本质是契约，就像法律一样，我们必须遵守
OOP的精髓，是对对象的抽象，能体现这一点的就是接口。
接口的关键字是interface

作用

约束
定义一些方法，让不同的人实现
可以实现多个，必须重写接口中的方法

内部类

内部类就是在一个类中定义一个类，比如在A类中定义了一个B类，那么B类相对A类来说就是内部类，反之为外部类。

可获取外部内中的私有属性和私有方法

可以分为：

成员内部类
静态内部类
局部内部类：方法里定义类
匿名内部类

异常

定义

异常指，程序运行中出现不期而至的各种状况，如找不到文件、网络连接失败、非法参数等
异常发生在程序运行期间，它影响正常的程序执行流程

异常体系

java把异常当作对象来处理，并定义一个基类java.lang.Throwable作为异常的超类
在javaAPI中定义了许多异常类，主要分为 错误ERROR和 异常Exception

ERROR

Error类对象由java虚拟机生成并抛出，大多数错误与代码编写者所执行的操作无关。
java虚拟机运行错误，当JVM不再有继续执行操作所需的内存资源时，将出现 OutOfMemoryError 。这些异常发生时，java虚拟机，一般会选择线终止
虚拟机试图执行应用时，如类定义错误、链接错误。这些错误是不可查的，因为它们在应用程序控制和处理能力之外，而且绝大多数是程序运行时不允许出现的状况。
StackOverFlow ：栈溢出
OutOfMemory：内存溢出

Exception

在Exception分支中有一个重要子类，RuntimeException（运行时异常）

运行时异常

一般是指我们开发中，编译运行程序后，遇到在控制台所发生的异常，一般有：

ArrayIndexOutOfBoundsException（数组下标越界）
NullPointerException（空指针异常）
ArithmeticException （算术异常）
MissingResourceException （丢失资源）
ClassNotFoundException （找不到类）

这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度避免这类异常

非运行时异常（一般异常）

checked exceptions，非运行时异常（编译异常）：是RuntimeException以外的异常，类型上都属于Exception类及其子类。从程序语法角度讲是必须进行处理的异常，如果不处理，程序就不能编译通过。如IOException、SQLException等以及用户自定义的Exception异常，一般情况下不自定义检查异常。通俗的话说就是在写代码时出现红线，需要try catch或者throws时出现的异常。

运行和非运行的区别

异常表示程序运行过程中可能出现的非正常状态，运行时异常表示虚拟机的通常操作中可能遇到的异常，是一种常见运行错误。java编译器要求方法必须声明抛出可能发生的非运行时异常，但是并不要求必须声明抛出未被捕获的运行时异常。

Error和Exception区别

Error通常是灾难性的致命的错误，是程序无法控制和处理的，当出现这些异常时，java虚拟机（JVM）一般会选择终止线程；Exception通常情况下是可以被程序处理的，并且在程序中应尽可能的去处理这些异常。

处理机制

抛出异常：throw、throws
捕获异常：try、catch、finally
常用关键字：try、catch、finally、finally、throw、throws

自定义异常

步骤

创建自定义异常类，继承Exception类
在方法中通过throw关键字抛出异常对象
如果在当前抛出异常的方法中处理异常，可以使用trycatch语句捕获并处理；否则在方法声明处通过throws指明抛出给方法调用者的异常，继续执行下一步
在出现异常方法的调用者中捕获并处理异常

常用类

Object类

hashcode（）
toString（）
clone（）
getClass（）
notify（）
wait（）
equals（）

Math类

常见数学运算

Random类

生成随机数

File类

创建文件
查看文件
修改文件
删除文件

包装类

自动装箱和拆箱

Date类

Date
SimpleDateFormat（yyy-MM-dd:HH:mm:ss）

String

字符串内容不可以改变 final，操作量少

StringBuffer

字符长内容可以改变 append（）
多线程，数据量较大时,效率低，安全

StringBuilder

字符串内容可以改变
单线程，数据量较大，效率高，不安全

集合框架

Collection

List（有序可重复）

ArrayList（数组）

add（）

remove（）

contains（）

size（）

LinkedList （链表）

getFirst（）

getLast（）

removeFirst（）

addFirst（）

Vector（迭代器）

Stack（栈）

Set（无序不可重复）

HashSet

TreeSet

Map

HashMap

TreeMap

IO流

字节流

输出：OutputStream
输入：InputStream

字符流

Reader
Wirter

节点流

CharArrayReader，Writer，inputStream，outputStream
StringReader，Writer
pipe（管道流）PipedOutputStream

处理流

buffer

bufferInputStream

bufferOutputStream

bufferReader

bufferwirter

data

DataInputStream

DataOutPUtStream

转换流

InputstreamReader

OutputStreamWriter

filter （四个）

object (四个)

print

PrintWirter

printStream

序列化反序列化 Serializable transient（透明）

多线程

进程和线程
run（），start（）

线程创建的方式

Thread start0，本地方法，java无权调用，交给底层的C处理 private native void start0（）；
Runnable 函数式接口 lambda
Callable 可以有返回值

静态代理

new Thread（Runnable）.start（）

Lambda表达式

函数式编程
避免内部类定义过多

线程状态

新建状态：生成线程对象，并没有调用start（）方法
就绪状态：线程调用start（）方法后，进入就绪状态，线程位于可运行线程池中，等待被调度
运行状态：线程获得cpu使用权，执行代码块
阻塞：因某种原因放弃了cpu的使用权，让出了cpu，暂时停止运行。直到线程进入到就绪状态，后被调度再次运行
- 等待阻塞：运行(running)的线程执行o.wait()方法，JVM会把该线程放入等待队列(waitting queue)中。
- 同步阻塞：运行(running)的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池(lock pool)中。
- 其他阻塞：运行(running)的线程执行Thread.sleep(long ms)或t.join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入可运行(runnable)状态。
死亡：线程执行run（）方法结束，或因异常退出run（）方法，线程运行状体结束。

线程常用方法

sleep
join
yield
isLive
start
setPriority
interrupt

线程同步

多个对象操作同一个资源，并发
队列+锁

Synchronized

同步方法弊端：锁太多
同步代码块（常用）
第一个线程进来拿到锁，后面就要排队，直到这个人释放锁，后面拿到锁才能进去
死锁互斥，请求保持，不剥夺条件，循环等待条件

Lock（优先级高）

ReentrantLock lock，trylock，unlock

线程通信

缓冲区：消息队列
标志位：红绿灯
wait（）
notifyAll（）唤醒

线程池

池化技术
池的大小
最大连接数目
保持时间

网络编程

ip
端口
Socket编程
TCP 三次握手，四次挥手，面想连接
UDP 无连接，Packet
URL
Tomcat
聊天通信
文件上传

注解和放射

注解

元注解
内置注解
自定义注解
放射注解

反射

Class newInstance（）
类加载机制
Method invoke，存在重载，也需要写参数的类型
Field set
Construct
破坏私有关键字
性能分析
放射获得注释，泛型

原文地址：https://www.cnblogs.com/ybigbear/p/15022977.html

JAVA知识笔记

JAVA知识笔记

基本介绍

特性与优势

JAVA三大版本

JDK,JRE,JDK

java程序运行机制

语法基础

注释

标识符

数据类型

类型转换

什么是字节

java进制数表示

数据类型拓展

变量

变量作用域

变量默认值

运算符

自增符

幂运算

逻辑运算&和&&区别

位运算

String + 号拼接问题

三元运算符号

流程结构

顺序结构

选择结构

循环结构

方法

方法的调用

方法的重载

可变参数

命令行传参数

递归

数组

java简单内存分析

数组的特征

多维数组

Arrays类

排序方法

稀疏数组

面向对象编程

什么是面向对象

类与对象的关系

构造器

封装

继承

super与this关键字

方法的重写

多态

多态的优点

多态存在的三个必要条件

类型转换

抽象类

接口

内部类

异常

分类

异常体系

ERROR

Exception

运行时异常

非运行时异常（一般异常）

运行和非运行的区别

Error和Exception区别

处理机制

自定义异常

常用类

集合框架

IO流

多线程

线程创建的方式

线程状态

线程常用方法

线程同步

线程通信

线程池

网络编程

注解和放射