导图社区 JAVASE基础知识
- 71
- 6
- 3
- 举报
JAVASE基础知识
Java SE（Java Standard Edition，Java 标准版）是Java技术的核心和基础，是Java ME和Java EE编程的基础 。
编辑于2021-01-09 17:44:46- JAVASE基础知识
Java SE（Java Standard Edition，Java 标准版）是Java技术的核心和基础，是Java ME和Java EE编程的基础 。
- JAVASE_反射机制
Java反射机制主要提供了以下功能： 1.在运行时判断任意一个对象所属的类。 2.在运行时构造任意一个类的对象。 3.在运行时判断任意一个类所具有的成员变量和方法。 4.在运行时调用任意一个对象的方法。
- JAVASE_多线程
程序：一段静态的代码 进程：正在运行的一个程序 线程：进程可进一步细化为线程，是一个程序内部的一条执行路径 说明：线程作为调度和执行的单位，每个线程都拥有独立的运行栈和程序计数器，线程切换开销小。多个线程共享同一个进程中的结构：方法区、堆。
JAVASE基础知识
社区模板帮助中心，点此进入>>
- JAVASE基础知识
Java SE（Java Standard Edition，Java 标准版）是Java技术的核心和基础，是Java ME和Java EE编程的基础 。
- JAVASE_反射机制
Java反射机制主要提供了以下功能： 1.在运行时判断任意一个对象所属的类。 2.在运行时构造任意一个类的对象。 3.在运行时判断任意一个类所具有的成员变量和方法。 4.在运行时调用任意一个对象的方法。
- JAVASE_多线程
程序：一段静态的代码 进程：正在运行的一个程序 线程：进程可进一步细化为线程，是一个程序内部的一条执行路径 说明：线程作为调度和执行的单位，每个线程都拥有独立的运行栈和程序计数器，线程切换开销小。多个线程共享同一个进程中的结构：方法区、堆。
- 相似推荐
- 大纲
JAVASE
1.java简介
环境安装
什么是API？
应用程序编程接口（里封装了好多函数）
src
src里边存的是源文件（.java），就是人能看懂的文件，都是程序员写好的源代码
bin
bin里边存的是字节码文件（.class），就是编译后的文件，让机器看的
两个文件夹里的文件名是对应的。
计算机语言的历史
一 机器语言0100000110101010
二 汇编语言
三
面向过程 C 、Fortran、COBOL、PASCAL、ADA
面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。
面向对象 Java、Python、c#.net、c++
就是将实物抽象的表现为一个个对象，通过对象间的相互作用，从而模拟现实实物之间的相互关系。
核心优势
跨平台：在任何出操作系统下都能运行
JAVA版本结构
JavaSE: Java Standard Edition
JavaEE：Java Enterprise Edition
JavaME:Java Micro Edition
记事本编写java代码
JDK>JRE>JVM
JDK Java Development Kit(Java开发包工具)
JRE Java Runtime Environment(Java运行时的环境)
JVM Java Virtual Machine（Java虚拟机）
JVM是一种规范。
关系图
编码规范
见名知意
不允许使用中文
不允许使用拼音
不允许使用中英混合
不允许使用_$开头或结尾
命名规则
类名 首字母大写，驼峰式
包名 所有全小写
方法名、变量名、参数名 首字母小写
常量名 全大写，如果有多个单词，使用_分隔
缩进 使用四个空格缩进，或者直接使用编辑工具中的tab
二元运算符和三元运算符左右两边必须要有缩进
子主题 2
2.变量（variable）
变量包括
局部变量
类的属性，或者叫值域
Admin admin = new Admin();
方法里的局部变量（方法中的变量都是局部变量）
局部变量使用前必须初始化
方法的参数（参数列表中）
其实第三种变量和第二种本质上是一样的，都是方法中的局部变量。只不过作为参数，肯定是被初始化过的，传入的值就是初始值，所以不需要初始化。
成员变量
实体类下定义的属性
变量的声明
变量与常量
子主题 变量： 数据类型 变量名 = 变量值； 可以用=来改变变量的值； 例： int a = 32； a=10； a的值最后为10； 常量： final 数据类型 常量名 = 常量值； 不可以改变常量的值，否则会报错； 例 final int a=33； 不可以用=来改变，改变就会报错；
进制
10进制：int a = 33；生活中常用的进制； 8进制： int b = 033；以0开头的进制； 16进制：int c = 0x33；以0x开头的进制；
进制间的转换
Integer.toBinaryString()
十进制
Integer.toOctalString()
八进制
Integer.toHexString()
十六
Integer.MAX_VALUE
Integer.MIN_VALUE
Scanner
Scanner sc = new Scanner(System.in) systrem.out.println("请输入人数：") int a = sc.nextInt();
例题
数据类型
基本数据类型
整型：byte short int lone
byte -2^7~2^7-1 short -2^15~2^15-1 int -2^31~2^31-1 lone -2^63~2^63-1
占1字节 2字节 4字节 8字节
1Byte=8bit
long 类型赋值时必须加上L后缀；如：long a=333333333L；
浮点型
float double
float（32位） double（64位
单精度浮点数7位有效数字。 双精度数15位有效数字。
在 32 位机器上用 4 个字节来存储的；而双精度double是用 8 个字节来存储的，这是他们最本质的区别。
float 占4个字节 赋值时后缀加f；例：float a=1.4f； double 占8个字节
字符型chat
无符号16位整数 [0,65535]
转译字符\->'\u4e00' '\n' '\t'
补充
转义字符： \’ 单引号字符 \” 双引号字符 \\ 反斜杠字符 \t 垂直字表符，将光标移到下一个字标符的位子 \r 回车 \n 换行 \b 退格 \f 换页
char 占一个字节；创建字符需要用单引号扩起来’’ 例：char a=‘5’
根据编码方式不同，中文字符所占子节不同
Java语言中，中文字符所占的字节数取决于字符的编码方式，一般情况下，采用ISO8859-1编码方式时，一个中文字符与一个英文字符一样只占1个字节；采用GB2312或GBK编码方式时，一个中文字符占2个字节；而采用UTF-8编码方式时，一个中文字符会占3个字节。
包装类character
布尔型boolean
true
flase
引用数据类型
类class
接口interface
数组（Array）
枚举类型（Enum）
数据类型转换
隐式数据类型转换
小类型->大类型（什么也不用操作）
数据的转换： 自动转换顺序图： byte—>short—>int (char)—>long —>float—>double 注意在char的取值范围情况下 与int时兼容的
显示数据类型
大类型->小类型（需要在数据类型前写（long））
显示转换： （类型名）要转换的值 例：int a=100； byte b=（byte）a；
大类型转化为小类型必须写（） int a = (int) 10L
常用工具类 java
lang包（提供了Java中的基础类）
java.lang.String
length()
获取字符长度
获取字符串的长度： public int length (); 使用：例：String a=“123456789”； int b=a.length(); 结果：b的值是10； 注意：字符串的长度包括空格；
charAt(int index)
获取指定字符
获取指定的字符的方法： public char charAt (in index); //方法 使用：例:String name=“diao”; char a=name.charAt(3); 结果为a=‘o’；charAt();括号中的为要获取的索引位子；
indexOf(int ch)
获取第一次出现的索引
获取第一次出现的索引： pubic int indexOf (String str); 使用：例： String a = “abcabcabc”; int b=a.indexOf(“a”); 结果：b=0；因为这获取的是第一次出现的位置，a在第一位就出现了，也就为0位； 扩展：指定位置获取第一次出现的索引； public int indexOf(String str ,int fromlndex); 使用：例： String a= “abcabcabc”; int b=a.indexOf(a,4); 结果：b=6;获取a，4前面的a都不算a；
lastIndexOf
获取去倒数第一次出现的索引
获取倒数第一次出现的索引： public int lastIndexOf(String str); 使用例：String a=“abcabcabc”; int b=a.lastIndexOf(“b”); 结果：b=7;因为从后往前找； 扩展：指定位置： public int lastIndexOf(String str,int a); 使用：例： String a=“abcabcabc”; int b=a.lastIndexOf(“b”,6); 结果：b=4;因为从索引6开始往前找，跳过了前面的b；
comparTo(String)
先比字符数组中的每个字符的Unicode value
再比长度
例题
java中的compareto方法，返回参与比较的前后两个字符串的asc码的差值，看下面一组代码 String a="a",b="b"; System.out.println(a.compareto.b); 则输出-1； 若a="a",b="a"则输出0； 若a="b",b="a"则输出1； 单个字符这样比较，若字符串比较长呢？？ 若a="ab",b="b",则输出-1； 若a="abcdef",b="b"则输出-1； 也就是说，如果两个字符串首字母不同，则该方法返回首字母的asc码的差值； 如果首字母相同呢？？ 若a="ab",b="a",输出1； //长度的差值 若a="abcdef",b="a"输出5； 若a="abcdef",b="abc"输出3； 若a="abcdef",b="ace"输出-1； 即参与比较的两个字符串如果首字符相同，则比较下一个字符，直到有不同的为止，返回该不同的字符的asc码差值，如果两个字符串不一样长，可以参与比较的字符又完全一样，则返回两个字符串的长度差值
startWith(str)
判断字符串句首内容是否相同
判断字符串句首内容： public boolean startsWith(String prefix ); 使用例： String a = "abcabcabc"; boolean b = a.startsWith("abc"); System.out.println(b); 结果：b=true;自然是一样的；
endWith(str)
判断字符串结尾内容
判断字符串结尾内容： public boolean endsWith(String suffix); 使用例： String a = "abcabcabc"; boolean b = a.endsWith(".java"); System.out.println(b); 结果：b=false;结果错误，字符串结尾并不相同；
substring(int)
截取字符串
substring(beginlnlndex,endlndex)
截取字符串（范围）
截取字符串： 从指定位置截取： public String substring(int beginIndec); 使用：例： String a = "abcabcabc"; String b = a.substring(3); System.out.println(b); 结果:b=“abcabc”;从索引3截取（统一是从0下标开始数，第三位应该是0.1.2.3，以上都是如此计算；）； 扩展：截取指定范围： public String substring(int beginIndec,int endlndex ); 使用：例： String a = "340404199305040430"; String b = a.substring(6, 14); System.out.println(b); 结果：b=“19930504”;从索引6截取，到索引14之前的位置；
replace(char old,char new)
将旧字符串替换成新字符串
将旧字符串替换成新字符串： public String replace(CharSequence target,CharSequence replacement ); 使用例： String a = "abcabcabc"; String b = a.replace("a", "d"); System.out.println(b); 结果：b=“dbcdbcdbc”;将所有的a替换成了b；
replace(String old,String new)
toCharArray() 字符串转数组
valueOf(数) 数转字符串
trim（） 去收尾空格
去除首尾空白内容：
去除首尾空白内容： public String trim(); 使用：例： String a = " 222 "; String b = a.trim(); System.out.println(b); 结果：b=“222”:空格已经被去除； 去除所有的空白内容；
toUpperCase() 转大写
大小写例题
字符串大小写转换： 大写转换： public String toUpperCare(); 小写转换： public String toLowerCare(); 使用例： String a = "aaaBBB"; String a1 = a.toLowerCase(); String a2 = a.toUpperCase(); System.out.println(a1); System.out.println(a2); 结果：a1=“aaabbb”;a2=“AAABBB ”;
toLowerCare()转小写
split(str) 用str进行分割 会返回一个char[]
字符串分割： public String[] split(String regex); 使用例： String a = "abcabcabcabc"; String[] a1 = a.split("c"); for (String tme : a1) { System.out.println(tme); } 结果：ab，ab，ab，ab，输出了4个字符串
扩展：限制分割次数分割: public String[] split (String regex ,int limit ); 使用例： String a = "111.222.333.4.0"; String[] a2 = a.split("\\.", 3); for (String tme : a2) { System.out.println(tme); } 结果：111，222， 333.4.0三个字符串；
字符串拼接
字符串的拼接： 字符串用+号拼接； 例；String a=“abc”;String b=“123”; String c=a+b; c=“abc123”; c 的值是由a和b拼接在一起得出的；也可以用+=； 例： String a=“123”; a+=“456”; 结果：a=“123456”;
java.lang.System
.out.print()
不换行输出
.out.println()
换行输出
System.in
System.out：对应的是标准输出设备，控制台。 System.in：对应的是标准输入设备，键盘。
System.arraycopy(src,srcPosition,dest,destPosition,length)
数组拷贝
原数组，原数组开始的位置，目标数组，目标数组开始的位置，复制的长度
java.lang.Math
random()
随机数[0,1）
cell()
不小于
传回不小于x的最小整数值。，向上取整
floor()_
不大于
sqrt()
正平方根
abs()
绝对值
pow()
次幂
Math.pow() 返回第一个参数的第二个参数次幂的值
min()/max()
最大最小
Math.max() 返回两个 double 值中较大的一个
sin()/cos()/tan()
正弦余弦正切
Math.PI
π
toRadians(deg)
角度
toDegrees（rad）
弧度
Math类的所有执行方法都是静态方法，可以直接使用类名.方法名调用
补充
java.lang.Math类中包含E和PI两个静态常量，以及进行科学计算的类(static)方法，可以直接通过类名调用。 public static final Double E = 2.7182818284590452354 public static final Double PI = 3.14159265358979323846 public static long abs(double x)：传回 x 的绝对值。X也可int long float public static long sin(double x): 传回x径度的正弦函数值 public static long cos(double x)：传回x径度的余弦函数值 public static long tan(double x): 传回x径度的正切函数值 public static long asin(double x)：传回x值的反正弦函数值。 public static long acos(double x)：传回x值的反余弦函数值。 public static long atan(double x)：传回x值的反正切函数值。 public static long atan2(double x, double y)：传回极坐标（polar）的θ值 public static long floor(double x)：传回不大于x的最大整数值 ，向下取整 public static long ceil(double x)：传回不小于x的最小整数值。，向上取整 public static long exp(double x)：传回相当于e^x public static long log(double x)：传回x的自然对数函数值 public static long max(double x,double y)：传回x、y较大数 public static long min(double x,double y)：传回x、y较小数 public static long pow(double x,double y)：传回x的y次幂值 public static long sqrt(double x): 传回x开平方值 public static long rint(double x):传回最接近x的整数值 public static long round(double x):传回x的四舍五入值 public static long toDegrees(double angrad):传回将angrad径度转换成角度 public static long toRadians(double angdeg): 传回将angdeg角度转换成径度 public static long random():传回随机数值,产生一个0-1之间的随机数(不包括0和1)NumberFormat类：(public abstract class NumberFormat extends Format) 用java.text.NumberFormat类对输出的数字结果进行必要的格式化。 使用该类如下方法类实例化一个NumberFormat对象： public static final NumberFormat getInstance() 然后用该对象调用如下方法可以格式化数字number(返回字符串对象)： public final String format(double number) NumberFormat类有如下常用方法： public void setMaximumFractionDigits(int newValue)//设置数的小数部分所允许的最大位数。 public void setMaximumIntegerDigits(int newValue)//设置数的整数部分所允许的最大位数。 public void setMinimumFractionDigits(int newValue)//设置数的小数部分所允许的最小位数。 public void setMinimumIntegerDigits(int newValue)//设置数的整数部分所允许的最小位数。
round()
四舍五入
.cbrt()
立方根
util
java.util.Arrays
toString(int[] arr)
以特定格式输出数组
可实现基本数组转字符串
sort(int[] arr)
对数组排序
copyof(arr,newlength)
数组的拷贝
java.util.Date
new Date()
系统当前时间
new Date(lone)
指定时间
getTime()
返回1970-01-01 00:00:00到当前的毫秒数
java.util.Random
nextlnt()±21E
nextInt(bound) [0,bound-1]
math（包）
BigDecimal（提供了大数字，超过十六位有效位，用于高精度运算）
add(BigDecimal)加
subtract（BigDecimal）减
mulply(BigDecimal)乘
divide（BigDecimal）除
text
java.text.SimpleDateFormat
new SimpleDateFormat("yyy-MM-dd HH:mm:ss.SSS")
sdf.fomat(Date) 将日期对象转化为String
sdf.parse(String) 将String对象转化为日期对象
3.Java中的方法
方法的语法 **
（修饰词）[关键字]（返回值类型）（方法名）(参数列表){ //方法体 }
return 关键字 *
如果有返回值定义（也就是返回值类型不是 void）就必须有 return 语句, 返回和返回值类型兼容的数据。如上图所示，返回值类型为 int，所以 return 的值 a + b 必须是int 类型的。
局部变量（local variable） *
方法的参数和方法内部的变量，都是局部变量，这些变量作用域只在方法内部，在一个方法中定义的变量只能在本方法中使用。
形参和实参 *
实参: 方法调用时候实际传递的参数变量（实际的值，相当于赋值）。
形参: 方法的参数定义,是临时变量（是个空壳子，相当于声明变量而没有赋值）。
什么方法的重载及条件
名字相同，口味不同
两同三不同，同一个类同一个方法名，参数列表中参数的顺序，个数，类型
主函数调本类方法，直接写方法名就行了，调方法得到该方法的返回值
static静态方法可以不创建对象
无返回值类型值类型省略return；无返回值类型不能用任何数据类型接收 ，调方法时直接调用
运算符
算数运算符
%
自增或自减
举例： int a = 0; int b = ++a;// a先递增，结果a=1, b=1 int x = 0; int y = x++;// x先代入表达式计算，再递增，结果y=0, x=1
逻辑运算符
&&
||
！
位运算符
&
int类型时，"&" 按位与，计算时将 十进制 转为 二进制 再进行计算，同位置为1，则结果为1，其余情况皆为0
|
按位或，计算时将 十进制 转为 二进制 再进行计算，同位置为0的结果为0，其余情况皆为1
~
二进制下所有为0的数换位1，为1的都换位0
面试题：&&和&的区别
实际开发中使用&&效率最高
区别
java中&叫做按位与，&&叫做短路与，它们的区别是： & 既是位运算符又是逻辑运算符，&的两侧可以是int，也可以是boolean表达式，当&两侧是int时，要先把运算符两侧的数转化为二进制数再进行运算，而短路与（&&）的两侧要求必须是布尔表达式。举例如下： 12&5 的值是多少？答：12转成二进制数是1100（前四位省略了），5转成二进制数是0101，则运算后的结果为0100即4 这是两侧为数值时； 若 int i = 2，j = 4；则（++i=2）&（j++=4）的结果为false，其过程是这样的：先判断++i=2是否成立，这里当然是不成立了（3 == 2），但是程序还会继续判断下一个表达式是否成立，j++=4 ，该表达式是成立的，但是&运算符要求运算符两侧的值都为真，结果才为真，所以（++i=2）&（j++=4）的结果为 false 注意 ：&为真的条件是两侧表达式都为真，但是即使我们判断出左侧表达式的值为false，程序也还是要继续执行去判断右侧的表达式值的真假
运算符补充
单目运算符（只有一个操作）
逻辑非运算符【!】、按位取反运算符【~】、自增自减运算符【++ --】、负号运算符【-】、类型转换运算符【(类型)】、指针运算符和取地址运算符【*和&】、长度运算符【sizeof】这些是单目运算符
双目运算符
，+，-，*，/，=，== 等等
三目运算符
返回值=判断公式？结果1：结果2； 判断公式的值必须为布尔值，当判断公式的值为ture时运算符返回值为结果1； 当判断公式的值为false时，运算符返回值为结果2；
运算符优先级
运算符优先级： 单目运算优先级高于双目运算符； （）优先级最高，然后依次是算数运算符，位运算符，关系运算符，逻辑运算符 ，赋值运算符；
if条件语句
第一种
if(布尔表达式){ 语句； }
第二种
if(布尔表达式){ 语句; }else{ 语句； }
第三种
if(布尔表达式){ 语句； }else if(布尔表达式){ 语句； }else if(布尔表达式){ 语句； }else{ 语句； }
流程控制
单分枝结构
多分支结构
switch....case结构
有break穿透问题，在开发过程中需要每个case都有一个break
循环控制
while
while(布尔表达式){ 语句 }
当布尔表达式的结果为真时，则不停的循环语句，当布尔表达式为假时，终止循环，进行下一条语句； 注意： 1.表达式不允许为空； 2.表达式不应该是常数； 3.循环体中应该有改变表达式值得语句，否则会变成死循环；
do{}while
do{ 语句； }while(布尔表达式);
先执行语句，然后在判断是否循环； 注意：{}while()；后面的这个分号千万别忘了写；
两者区别：while是先判断后执行do while相反
for循环
for循环嵌套（外层控制行，内层控制列）
for(初始化表达式1；布尔表达式2；表达式3){ 语句 }
例题：九九乘法表
foreach语句：
for（type x：obj）{ 语句 }
type数据类型，x数据名 ；obj一个可以被遍历的集合，例如数组； 遍历：我们可以理解为，对数据或集合中的所有元素，逐一访问，依次读取一遍；
break
break：终止当前循环； 当循环嵌套时，只终止内循环，而不终止外循环；
continue
跳过本次循环，执行下一次循环；
异同点例题
1、二者的相同点：都可以用在循环语句中，break还可用在switch中。 例如：int i=0; int a=2; for(i=0;i<10;i++){ if(i==a){ ① break; ②continue； } system.out.print("apple"); }
2、不同点： break可以跳出当前的循环中，即结束本次循环（本次循环已经终止） continue：只能终止本次循环，还需进行下一轮的循环（本次循环还会继续） 例如：上面的例子中如果是①，那么循环语句执执行了3次，输出2次apple；如果是②，循环一共执行了10次，输出10次apple。
4.java的数组
数组的初始化
静态初始化
{1,2,3,4}
int[ ] arr3 ={1,2,3};
动态初始化
new int[10]
int[ ] arr =new int[4]; int arr1[ ] = new int[4]; int[ ] arr2 = new int[ ]{1,2,3};
动静结合（用的较少）
new int[ ]{1,2,3}
数组的输出
Arrays.toString(arr)
char[]可以直接输出，但是没有格式（char类型数组）
数组元素的访问
arr[i]
System.out.println(arr[1]);
得到数组的第二个元素
数组的长度
arr.length
System.out.println(arr.length);
数组的遍历
foreach遍历
for（类型 名：要遍历的数组或容器对象）
for循环
for(int i=0;i<arr.length;i++){ sysout}
多维数组
数组元素是数组的数组
在动态初始化时，new int[4][]
数组的复制和数组的赋值的区别
数组的copy->JavaAPI
例题
数组的扩展
例题
数组的排序Arrays.sort(arr)
例题
1, 2, 11, 25, 56, 58, 66,
数组的补充
一维数组
数组元素类型 数组名字[]； 数组元素类型 []数组名字；
初始化
子主题 1
二维数组
语法： 数组元素类型 数组名字[][]; 数组元素类型[][] 数组名字；
初始化
子主题 1
数组的length属性：
数组的遍历（遍历数组就是获取数组中的每个元素）
一维数组
for循环
foreach遍历
二维数组
for循环遍历
子主题 3
5.排序算法
选择排序
i是第一次比(从哪开始比，比多少次)，j是下一次比（从哪开始比，第一个数还是第二个数）
首先第一个跟其他每一个数比，较小的放前面
冒泡排序
相邻的两个比较，较大的往右放
插入排序
快速排序
堆排序
希尔排序
归并排序
基数排序
二分查找
递归
6.面向对象
概念OOP
子主题 1
面向对象（Object Oriented），是指面向客观事物之间的关系。人类日常的思维方式是面向对象的，自然界事物之间的关系是对象和对象之间的关系。
对象
1.对象的创建
java语言中使用一个new操作符调用构造方法就可以创建一个对象
子主题 1
当用户new操作创建一个对象后，可以使用“对象.类成员”（对象.类成员，对象.类方法）来获取对象的属性和行为。对象的属性和行为在类中是通过类成员变量和成员方法的形式来表示的，所以当对象实例化以后，也就获得了相应的属性和行为；
2.对象的引用
在Java语言中尽管一切都可以看做对象，但真正的操作标识符实质上是一个引用；
3对象的使用
构造方法（构造器）Constructor
使用new关键字，调用构造方法（只要使用new关键字地址一定不同）
测试类
结果
在编程时，一定要写上无参的构造方法（jvm中，如果不写，会调用默认的无参构造方法）
OOA 声明一个类时，要考虑该类有什么样的属性行为
this关键字
子主题 1
this 是对当前对象的引用，是运行期间当前对象本身。 可以使用 this 明确的访问当前对象的属性或者方法，类似于"我" this() 可调用本类的其他构造器, 可以使用构造器的重用简化代码的实现 this() 必须写在构造器的第一行！
三大特征
继承extends
子类继承父类，会继承父类中除父类构造方法以外的所有属性和行为
方法的重写
1.要有继承，父子类之间
2.方法名，参数列表完全相同
3.方法体不同
4.注意要区别于方法的重载
为什么要重写方法:
1.当父类中的方法无法满足子类需求的时候,需要方法重写
2.当子类具有特有的功能的时候,就需要方法重写
封装 encapulation
访问权限修饰符
外界只调用其方法而不知道里面怎么实现
属性私有，设置public 方法操作
多态polymorphysim
赋值多态
Foo foo（父类） =new Koo()（子类）
传参多态
构成多态
必须要有继承
必须要有方法的重写
父类的引用指向子类的对象
public void aa(Foo foo){}
传进来的是一个父类，实际传进来的可能是父类本身也可能是父类所对应的子类
父类 引用 = 指向 子类对象
输出 汪汪汪。。。
备注：没有返回值的输出不用sysout 直接animal.nose();(这是错的，哈哈哈)
Garbage Collection
垃圾回收机制：自动销毁内存中不用的对象和变量
System.gc()
系统自动调用，无需手动
finalize()
gc中的方法，不建议使用，面试会问
子主题 1
java没有覆盖这么一说，如果你在A类(子类)里，想写和B类(父类)同名的方法(finalize()),java叫方法重写,这时，父类此方法自动隐藏，也就是说，你在main方法中，实例化子类对象 调用该方法时，永远执行的是子类中的finalize()方法 另外，父类中的此方法不是允许使用了，如果 想调用父类中的这个方法，可以使用super.finalize()实现
Object类
重写toString()
系统重写
自定义重写
拥有自己的格式
toString方法会返回一个“以文本方式表示”此对象的字符串。结果应是一个简明但易于读懂的信息表达式。建议所有子类都重写此方法。
重写equals（）
==的用法
基本数据类型
比较两个数据类型的题
引用类型
引用对象的地址
equals()的用法
引用类型
不重写Object的equals（）比较的是地址
重写 比较的是自定义的比较规则（默认下，比较的是每个成员变量的值）
hashCode（）
重写equals时必须重写hashCode()
super关键字
直接父类的引用
final关键字
final修饰的类不能被继承
修饰的方法不能被子类重写
修饰的变量不能被二次赋值
static关键字
修饰的属性为类属性，修饰的方法为类方法， 从属于类，类加载时直接加载； 而成员变量和成员方法在new对象时才能创建
执行顺序
父类static代码块
子类static代码块
父类普通代码块
父类构造方法
子类普通代码块
子类构造方法
在项目开发中，为了让项目运行的更流畅，资源文件一般使用static修饰
JavaBean的开发规范（实体类，entity,pojo,vo）
所有成员变量必须使用private修饰，不能直接赋值（），通过构造方法进行初始化
如果数据类型是基本数据类型是基本数据类型，则使用对应的引用类型（包装类）
包装类是对象,拥有方法和字段.而基本类型不是.另外一个区别是,包装类是引用传递 而基本类型是值传递
需要提供一个对外public修的方法来获取（get）和修改（set）成员变量
例题
想获取id（或修改id）需有一个对外开方的public修饰的方法
测试类中
无参构造方法必须写
重写equals()时必须重写hashcode
equals()判断对象的内容而非地址
在往HashSet集合放置元素时，会根据其hashCode来判断两个元素是否一样，如果是一样，这后者覆盖前者。而hashCode默认是比较其地址值。于是，对于两个new 出来的“21岁的张三”，其地址值不一样，所以HashSet才将两个均加入其中。
需要重写toString()
使对象可读
需要实现可序列化接口（Serializable）
永久的保存对象，实现对对象的持久化操作
abstract
类
抽象类：不能new对象（可使用多态）
抽象类中，不一定有抽象方法（语法没问题，但设计不合理）
有抽象方法的类必须定义成为抽象类
方法
抽象方法：没有方法体，子类必须重写
interface
接口：比抽象类更抽象的抽象类
接口中的方法默认都是public、abstract类型的。
为了解决Java中不能多继承的缺陷
class extends class
class implenments interface
interface extends interface
接口必须被实现，接口只定义和 规范行为
补充
接口中定义的变量是常量，设计角度一律不用
面试题：接口和抽象类的区别
抽象类 由class 只能单继承
接口 interface修饰 多实现
内存机制
堆内存，栈内存（栈区放创建的引用变量，堆区放new的对象）
过程
先在栈区创建一个引用变量s1,对应堆内存中的new的一个对象，在堆区创建一个地址，这个地址把所有成员变量的值设成初始值，然后在堆的方法区开辟一个空间放所有的方法，赋值时会在堆的方法区的常量池生成相应地址。 创建s2引用变量时，在堆区创建一个不同的地址，也指向堆中的方法区。方法被调用后，方法中的局部变量都会被jvm里gc(垃圾回收机制自动销毁) 注：碰到方法的return时直接被销毁 栈区：先进后出，先进后销毁。 方法区常量池引用变量公用
String，StringBuild,StringBuffer的区别
String不可变长字符串：char[]
StringBuilder,StringBuffer可变长字符串
StringBuilder线程非安全，效率高，单线程
StringBuffer线程安全，效率低，多线程
如果使用，请使用StringBuilder,效率高
StringBuilder.append()(追加)
insert（）（插入）
delete() (删除)
reverse（翻转）
7.集合Collection
java.util
集合关系图
Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素
Connection接口(根接口)
List
ArrayList
ArrayList（顺序结构动态数组类，实现ICollection和IList接口）
add（）
添加
remove（）
删除
set（）
修改
get（）
查询
size（）
获取容器大小
clear（）
list.clear（）
清空list
toArray()
容器转数组
例题
遍历容器 1 2 3
LinkedList(链表)
LinkedList（链表结构）
面试题： ArrayList和LinkedList的区别
1.ArrayList底层数据结构为数组
查迅速的快，增删改速度慢 线程非安全
效率高
2.LinkedList底层数据结构为双向链表
增删改效率高，查询慢 线程非安全
效率高
getFirst（）
getList()
addFirst()
addList()
Vector（向量）
Vector （向量类）
线程安全
效率低
List（容器）类型本身是可以存放任何对象的，也就是只要是数据都可以存储的。
Set（不包含重复元素的Collection）
HashSet
TreeSet（有序）
树的先序遍历、中序遍历、后序遍历
看根节点位置
LinkedHashSet
Map接口:
HashMap
HashMap
size()
put(K,V)
key唯一，如果key重复，则会覆盖，与value无关
put方法向里添加存放键值对，与存放顺序无关
get(Object key)v
remove(Object key)
map.entrySet() Set<Entry<K,V>>
List、Set、Map的区别
List的内容存放有序，数据可重复
Set存放的是对象，无序，数据唯一
Map存放的是键值对，并且无序，key值唯一
例题
输出
TreeMap有序
HashTable
数组和容器的区别
1.数组存储的数据是固定的，容器可变，可随时向里添加，删除
2.数组存储的类型一致，比如都为int类型，容器存储类型可一致也可不一致
3.遍历输出时数组{1，2, 3}，容器 1 2 3
都是存储数据用的
Iterator(迭代器)
提供一种方法访问一个容器对象中各个元素去，迭代器负责定义访问和遍历元素接口
Collections
sort(List)
shuffle(List)
Map
for(; ; )和while（true）都是死循环，但前者效率比较高
容器转为数组是toArray()
三种遍历方式
for循环
foreach遍历
遍历数组
一维数组
二维数组
三维数组
遍历容器
见上集合关系
rq.Iterator()ff
集合转数组
格式
foreach的语句格式： for(元素类型t 元素变量x : 遍历对象obj){ 引用了x的java语句;（就是sysout(x)） }
for (int x : arr) { System.out.println(x); //逐个输出数组元素的值 }
Iterator集合迭代器
配合while()循环实现遍历输出
while()中的判断条件it.hasNext()用于判断it中是否还有下一元素，有的话就继续循环，输出语句中的it.next()既可以使“指针”往后走一位，又能将当前的元素返回，用于输出。
输出 1 3 4
配合for()循环实现遍历输出
同上
lt
子主题 1
实现Comparable接口，重写comareTo方法
在实际的需求中，我们需要根据对象的各种属性(标题，时间，点击率，销售额...)进行排序(升序，降序)，可以在数据库的sql上进行处理,但是 不是每一个场景 都适合在sql上进行处理，我们有时候需要在程序根据不同的属性，对一个对象进行各种排序 通过页面呈现给用户。
在程序根据不同的属性，对一个对象进行各种排序
例题
输出结果
例题链接
https://www.cnblogs.com/111testing/p/9158140.html
8.Exception异常
是什么
异常的分类
运行时异常（非检查异常）
只有当运行时，才会抛出的异常
编译异常（检查异常）
语法错误
句法错误
调用方法时，该方法声明时抛出了异常
throws关键字 在方法后声明
throw关键字 在方法体内声明
Throwable(它的父类)~T的父类是Object
Exception
需要处理的
Error
当出现时，必须及时修正代码及逻辑，不能在try{}catch（）{}中进行处理
Java标准库内建了一些通用的异常，这些类以Throwable为顶层父类。Throwable又派生出Error类和Exception类。
错误
Error类以及他的子类的实例，代表了JVM本身的错误。错误不能被程序员通过代码处理，Error很少出现。因此，程序员应该关注Exception为父类的分支下的各种异常类。
异常
Exception以及他的子类，代表程序运行时发送的各种不期望发生的事件。可以被Java异常处理机制使用，是异常处理的核心
图
当出现异常时的处理
使用throw关键字向上层继续抛出（不建议使用）
使用try{}catch(Exception e){}finally{}来异常处理（推荐使用）
finally一定要执行
子主题 1
输出B C D
分析
try中代码如果有异常，异常下的其他代码不执行 直接跳到catch，执行catch语句，（打印异常信息，或者输出语句等） finally不管怎样一定要执行
一般try中写逻辑 finally做最后资源的释放
catch语句会从小异常找到大异常，不能直接找父类，找子类，没有子类再找父类
例如找Number FormatException()，再找RuntimeException，再找.Exception
return跳出掉用方法，只执行最后的这个return
输出3
Exception e异常的类型
常见的运行时异常（RuntimeException）
NullpointerExeption(空指针异常)
Array Index Out Of BoundExeption(数组下标越界异常)
Number FormatException()
数字格式异常
IllegalArgumentException
非法传递参数异常
ArithmeticException
算术运算异常
ClassCastException - 类型强制转换异常。
ArrayStoreException - 向数组中存放与声明类型不兼容对象异常
NegativeArraySizeException - 创建一个大小为负数的数组错误异常
SecurityException - 安全异常
UnsupportedOperationException - 不支持的操作异常
String Index Out Of Exception()
Pate FormatException()
日期格式异常
自定义异常
1.extends Exception
2.构造方法中调用父类的有参构造方法super(String message)
9.I/O流
分类
处理数据的基本单位
字节流(99%用)(byte)...(一字节等于8位二进制数)
图片、音频、视频
FileInputStream(文件读入流)
FileOutputStream（写出流）
缓冲流
用空间换的时间
举例为其它流相当于小车一次运送一个人，缓冲流相当于用公交车一次运送50人
字符流（char）
（适合）字符串、纯文本
FileReader（字符读入流）
FileWriter（字符写出流）
记一个打印字符流（ PrintWriter）
按方向（流向）
输入流
数据提供者，可从中读取数据出来
输出流
数据接收者，可往其中写数据
例
D:a.avi-->读（输入）-->内存-->写（输出-->F盘）
File
exsists()
isFile()
isDirectory()
length()
lastModified()
...
例题
子主题 1
比较全的方法
文件的拷贝（复制）
必须会默写
例题
File 类将当前路径的内容转化为一个对象
文件和文件夹都可以作为File对象
-1代表了文件的结尾
Properties类的使用（加载Properties资源文件）
load(InputStream)void
getProperty(String key)String
例题
使用static静态代码块加载
静态代码块中语句在static加载之后构造方法之前输出
prop.
获取这个类的类加载器，用这个类的类加载器，以流的方式加载这个资源
通过Interger.parseInt将String类型转化为Int类型
控制台输出800
补充小知识点
相对路径
是从盘符开始的路径，形如 C:\windows\system32\cmd.exe
绝对路径
是从当前路径开始的路径，假如当前路径为C:\windows 要描述上述路径，只需输入 system32\cmd.exe 实际上，严格的相对路径写法应为 .\system32\cmd.exe
资源路径写法
\\或者/
\表示的转义字符
在文件中一个汉字占两个字节，英文字母占一个字节（byte）
buffer缓冲
-1代表了文件的结尾
10.java中多线程
线程是什么？
线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中；
一个进程可以并发多个线程，每条线程并行执行不同的任务；
多线程程序设计的好处是提高了程序的执行吞吐率和执行效率。
多线程的常见应用场景
后台任务，例如：定时向大量用户推送信息例如广告邮件，不胜其扰，大家一定有体会
异步处理，例如：批量I/O操作，发微博、记录日志等
分布式计算，共享稀有资源和平衡负载
web服务器本身，例如：Tomcat
Tomcat是一个服务器。我们将写好的服务端代码部署到Tomcat中进行工作，一个Tomcat服务器可以同时负载多个不同的项目的服务，每个服务又可以是多线程的。
创建线程有几种方式？
方式一：继承Thread类并重写run()方法
方式二：实现Runnable接口
总结：推荐这种创建方式，它有两大好处：1.实现接口避免了单继承的局限性，2. 实现了数据和代码的有效分离。但也有不足，比如启动时需借助Thread类的帮助。
方式五：使用线程池
方式三：匿名内部类
方式四：使用Timer定时器（java.util.Timer）
方式六：实现Callable接口(java.util.concurrent.Callable)
java中如何实现多线程（两种创建线程的方法）
extends Thread类
implements Runable接口
重写run方法
就是更新运行过程
例题
实现Runnable接口
或者继承Thread类
测试类
start()方法来启动一个线程，这时此线程处于就绪（可运行）状态，并没有运行，一旦得到cpu时间片，就开始执行run()方法
run()称为线程体，它包含了要执行的这个线程的内容，Run方法运行结束，此线程随即终止。
线程中的一些方法
1.wait()的作用是让当前线程进入等待状态，同时，wait()也会让当前线程释放它所持有的锁。“直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法”，当前线程被唤醒(进入“就绪状态”)
2.notify()和notifyAll()的作用，则是唤醒当前对象上的等待线程；notify()是唤醒单个线程，而notifyAll()是唤醒所有的线程。
线程优先级
setPriority(1~10)
有可能被CPU调度的机会
main->5
Thread.Sleep(毫秒数);
步骤
第一，继承 Thread 类
第二，重写 run 方法（就是更新运行过程）, 实现用户自己的过程
第三，创建线程实例（就是创建一个线程）
第四，使用线程实例的 start() 方法启动线程, 启动以后线程会尽快的去并发执行 run()
11.反射机制
反射能干什么
通过反射机制拿到类的对象，可以获取类对象的构造方法，变量，普通方法，并对其进行修改。如把private的访问权限修改为public
实例
我们用Alt+/快捷方式时候用的就是java的反射机制
反射的解释
1.反射是一种机制，一种规范，和jvm一样 2.通过反射机制创建对象 3.主要用于创建对象获取对象的属性，构造方法，普通方法等
如何通过反射机制创建类的对象
1.Class.forName(String className)
2.对象.getClass()
1
2.获取完全限定名
3.获取简单的名字
4.获取类加载器
自定义的类加载器名称叫AppClassLoader
5.获取int的类加载器
jdk提供的类的类加载器输出为null
3.int.class/User.class
通常用于开发接口的时候
反射中的一些方法
Class<?>
getName（）
获得完全限定名
getSimpleName()
获取一个简单的名字
getClassLoader()
AppClassLoader
自定义的类
null
JDK提供的类
Constructor<？>[]<-clz.getConstructors()
获取类对象的构造方法
Filed<?><-clz.getFileds()
获取类的全部变量（只能拿到public修饰的）
Method[]<?><-clz.getMethods()
获取类的全部方法
在java.lang.reflect.*包中(需要导包)
泛型
类加载器
例题
.通过类反射机制创建对象
子主题 3
Java中关键字
子主题 1
• abstract：表明类或类中的方法是抽象的； • assert：声明断言； • boolean：基本数据类型之一，布尔类型； • break：提前跳出一个块； • byte：基本数据类型之一，字节类型； • case：在 switch 语句中，表明其中的一个分支； • catch：用于处理例外情况，用来捕捉异常； • char：基本数据类型之一，字符类型； • class：类； • continue：回到一个块的开始处； • default：用在 switch 语句中，表明一个默认的分支； • do：用在"do while"循环结构中； • double：基本数据类型之一，双精度浮点数类型； • else：在条件语句中，表明当条件不成立时的分支； • extends：用来表明一个类是另一个类的子类； • final：用来表明一个类不能派生出子类，或类中的方法不能被覆盖，或声明一个变量是 常量； • finally：用于处理异常情况，用来声明一个肯定会被执行到的块； • float：基本数据类型之一，单精度浮点数类型； • for：一种循环结构的引导词； • if：条件语句的引导词； • implements：表明一个类实现了给定的接口； • import：表明要访问指定的类或包； • instanceof：用来测试一个对象是否是一个指定类的实例； • int：基本数据类型之一，整数类型； • interface：接口； • long：基本数据类型之一，长整数类型； • native：用来声明一个方法是由与机器相关的语言(如 C/C++/FORTRAN 语言)实现 的； • new：用来申请新对象； • package：包； • private：一种访问方式：私有模式； • protected：一种访问方式：保护模式； • public：一种访问方式：公共模式； • return：从方法中返回值； • short：基本数据类型之一，短整数类型； • static：表明域或方法是静态的，即该域或方法是属于类的； • strictfp：用来声明 FP-strict(双精度或单精度浮点数)表达式，参见 IEEE 754 算 术规范； • super：当前对象的父类对象的引用； • switch：分支结构的引导词； • synchronized：表明一段代码的执行需要同步； • this：当前对象的引用； • throw：抛出一个异常； • throws：声明方法中抛出的所有异常； • transient：声明不用序列化的域； • try：尝试一个可能抛出异常的程序块 • void：表明方法不返回值； • volatile：表明两个或多个变量必须同步地发生变化； • while：用在循环结构中； • enum：声明枚举类型；
类
1.成员变量
成员变量就是java中类的属性
2.成员方法
成员方法就是java中类的行为
定义成员方法的语法格式： 权限修饰符 返回值类型 方法名(参数类型 参数名)[ ……//方法体 return 返回值； ]
3.局部变量
如果在成员方法内定义一个变量，那么这个变量被称为局部变量。
注意： 局部变量在方法被执行时 创建，在方法执行结束时被销毁。 局部变量在被使用时必须进行赋值操作或被初始化，否则会出现编译错误。
4.局部变量的有效范围
可以将局部变量的有效范围称为变量的作用域，局部变量的有效范围从该变量的声明到该变量的结束为止；
子主题 1
5.this关键字：
Java提供例this关键字，在类中，this代表了类本身的对象；
以上代码输出的abc，而不是123，因为this关键字调用了属性name，如果没有this输出的是123；
6.权限修饰符
Java 中的访问控制符，是修饰 Java 中类、属性、方法的访问可见范围的，这些修饰符控制着类和类的成员变量，类的成员方法的访问
public 修饰的，在任何地方都能访问
protected 修饰的，在类内部、同一个包、子类中能访问
[default]修饰的，在类内部和同一个包中可以访问（不建议用）
private 修饰的，仅限当前类内部访问
匿名内部类
aa(new 接口类型/抽象类类型{ 重写的方法 })
当一个方法参数是一个接口类型或抽象类的类型时，不想写一个类去继承或实现，因为我们只可能想用一次，这个时候用匿名内部类，保证里面重写的方法只想用一次
类的构造方法
构造方法是一个与类同名的方法，对象的创建就是通过构造方法完成的。每当类实例化一个对象时，类都会调用构造方法。 构造方法就是创建类的对象过程中运用的方法，也就是对象的初始化运用； 注意：在定义构造方法时， 构造方法没有返回值，并且不用加void关键字修饰；
语法： public book(){ ……//构造方法体 }
1.对象初始化:
在构造方法中可以为成员变量赋值，这样当实例化一个本类时，相应的成员变量也将被初始化。如何类中明确定义构造方法，则编译器会自动创建一个不带参数的默认构造方法； 注意：如果在类中定义的构造方法都不是无参的构造方法，则编译器不会为类创建一个默认的构造方法，当试图调用无参构造方法实例化时，就会报错，。
2.使用this关键字
this关键字可以调用类的成员变量和成员方法，事实上this还可以调用类的构造方法；
子主题 1
3.私有构造方法
构造方法同其他方法一样，也可以用private修饰，私有的构造方法无法在本类外部使用，也就导致本类无法实例化，这样可以控制对象的生成
类的主方法
主方法是类的入口点，他定义了程序是从何处开始；主方法提供对程序的流向控制，java编译器通过主方法来执行程序；
补充
静态变量、常量和方法
静态调用语法： 类名.静态类成员
static对象可以在它的任何对象创建之前访问，无需引用任何对象。
static在类初始化之前就存在所以可以直接调用
1、静态修饰符
由static修饰的变量，常量和方法被称为静态变量、静态常量和静态方法，他们都存在内存的“静态区”中，这些变量和方法有独立的生存周期。 内存中的静态区在整个程序结束后才会释放，所以静态修饰的代码的生命周期，是整个程序的生命周期。
2.静态区
内存中静态区的变量可以被本类共享，其他类调用本类静态变量和静态方法，无需实例化就可以调用；
3、静态变量
在Java中我们把共享的变量用static修饰，该变量就是静态变量。 同一个类的不同实例对象，共用同一个静态变量，如果一个变量将其更改，另一个对象的静态变量也会更改；
4.静态常量
用final static修饰一个成员变量，这个成员变量就会变成静态常量。
5.静态方法
调用类的静态方法无需创建类的对象； 注意： 在静态方法中不可以使用this关键字； 在静态方法中不可以直接调用非静态方法； 不能将方法体内的局部变量声明为static；
6.静态代码块
在类中成员方法之外，用static修饰代码区域可以称之为静态代码块。定义一个静态代码块，可以完成类的初始化操作，在类声明时就会运行；