Java基础----重点

Java程序运行机制
翻译型 ， 解释型
程序运行机制源程序（.java文件） Java编译器（.javac,.java) 字节码（*.class文件） 类装载器 字节码效验器 解释器（JVM 实现了跨平台服务） 操作系统平台（Windows ，Linux等等）
一. 标识符和关键字
1.标识符：由数字、字母、下划线（-）及$组成。如：d12abc；
注意：数字不能作为标识符的开始。如：12as；
2.用户自定义标识符：是由用户按标识符的规则生成的非保留字的标识符。如：abc , name 就是一个标识符， myint , MString , intString(也是标识符)。
3.关键字：具有特殊含义的标识符。如：int , void , main , String…
数据类型：boolean , int , long , short , byte , float , double , char , interface.
流程控制：if , else , do , while , for , switch , case , default , break , continue , return , try , catch , finally.
修饰符：public ，protected , private , final , void , static , strict , abstract , transient ,volatile , native , synchonized.
动作：package、import、throw、throws、 extends、implements、 this、supper、instanceof、new.
保留字：true、false、null、goto、const.
二，Java命名规则
1.Java类的命名规则：
类的首字母大写，如果由多个单词组成，则每个单词首字母大写（大驼峰命名法） 如:HelloWorld Demo01
首个单词的首字母小写，后面的单词首字母大写 （小驼峰命名法） 如：helloWorld dayMyYou
注意：Java严格区分大小写，public是关键字，Public不是关键字，一般不用关键字的其他形式来表示
2.Java的注释： // 单行注释 /** /多行注释 /** */文档注释。
三，Java变量的声明的初始化
变量：用来存放数据
1，Java是强类型的语言，必须先定义，后使用；指定类型的变量只能接受类型与之匹配的值。
2，声明变量：DataType:变量类型，如：int , string , char 和 double等；
identifier：标识符，也叫变量名称；
value：声明变量是的值。
3，变量命名语法：变量类型 变量名字 赋值符号 值；（批量命名法，不推荐使用）
全局变量：定义在方法 (函数)和代码块之外的变量；
局部变量：定义在方法或代码块之前的变量；（方法里定义的变量 、 代码块中定义的变量 、 方法参数里定义的变量）
四、Java中的常量
在程序的运行中保持不变的量。
1.常量：是形式化的表现形式
2.常量值：是常量的具体和直观的表现形式；
3.常量值的分类：
整型常量值：十进制（12） 、 八进制（0125） 、十六进制（0x345）
实型常量值：十进制（12.56） 、 科学计数法（1.75e5 或 32E8）
布尔型常量值：只有两个值 true 和 false；
4.转义字符：\r 回车 ， \n 执行 ， \b 退格 ， \t 横排跳格
5.定义常量：声明常量的同时要给一个初始值 ，常量一旦被定义赋值则不可在不被修改 ；
使用的关键字是final
6.常量类型：静态常量 ，局部常量，成员常量。
成员常量 如：final double PI = 3.14159;

静态常量：使用 final static 关键字修饰。
成员常量和静态常量在定义的同时必须初始化。

常量命名规则：
1.常量名全用大写；（如：PI , PRICE)
2.当常量名由多个单词组成时采用下划线分割。(如：HTTP_CODE, HTTP_STATUS_CODE)
五、Java中的数据类型：
考：1.基本数据类型（八种）
byte 字节型（-128–127）、
short 短整型 （-32768–32767） 、int 整型 、 long 长整型 、
float 单精度浮点型 (6–7个有效位)
double 双精度浮点型 （15个有效位） 、 char 字符型 、
Boolean 布尔型
注意：长整型必须在长整型末尾加大写的"L"或小写的"l"；
单精度浮点型必须在数字末尾加大写的"F"或小写的"f"；
java中小数默认的是double ; 字符型的值用单引号，当值为整数形式时不需要单引号；
Java中的Boolean型只有true和false
2.引用数据类型：包括 数组 、类 和 接口
除了基本数据类型，其他全部是引用数据类型 如：String 、数组 等。
null类型：null可以转换任何引用类型
注意：空引用（null）只可以转换为引用类型，不能转换为基本类型；null不能赋值给基本数据类型的变量。
六、数据类型转换
1.隐式转换（自动类型转换）小类型数据转换为大类型数据
满足条件：a、两种数据类型彼此兼容
b、目标类型的取值范围大于原数据类型（低级类型数据转换成高级类型数据）
数据类型的排行榜：byte—>short—>int—>long—>float—>double.
字符型转换为整型：char—>int
2.显式转换（强制类型转换）大类型数据转换为小类型数据需要强制转换
语法： 小类型 变量名 = （需要转换的类型（小类型）） 大类型 ；
注意：大类型数据转换为小类型数据有可能会造成精度丢失和溢出
short类型和char类型在转换时都需要强制转换
String str1 = “Hello”;
int num1 = (int) str1;//不能强转；
String str1 = (String) num1;//不能强转；
注意：两种数据类型彼此兼容，否则不能互相转换
基本数据类型不能与引用数据类型转换
b1+num 需将数据类型统一之后在运算（往大类型数据统一）
Java运算符：
注意：+号可以用作算术符号，也可以做字符串拼接
String s1 = num1 +“”;//这样就可以相加。
任何数据类型与字符串做+ 运算都会变为字符串
七、运算符
1、一元运算符：
-：取反 ++：自增 --：自减
注意： num4 = num3 ++; // 先将 num3 赋值给num4，然后num3再自增 1
num6 = ++ num5; // 先num5自增1，然后再将自增之后的值赋值给 num6
2、二元运算符：
Java 语言中算术运算符的功能是进行算术运算：
除了经常使用的加（+）、减（-）、乘（）和除（\）外，
还有取模运算（％）。加（+）、减（-）、乘（）、除（\）
除法运算：是求商（没有特殊规定一般取不到小数）如：5/3运算后结果是1
取余运算：是求余数 如：5/3运算后结果为2
3、Java中赋值运算符：
=：赋值符号
+=: 如， num += 2; -----> 本质：num = num + 2;
-=: 如， num -= 2; -----> 本质：num = num - 2;
*=: 如， num *= 2; -----> 本质：num = num * 2;
/=: 如， num /= 2; -----> 本质：num = num / 2;
%=: 如， num %= 2; -----> 本质：num = num % 2;
4、Java中逻辑运算符： 与、或、非
&&（短路与）：如：a && b, 如果ab全部为true则结果为true，否则为false
||（短路或）：如：a || b, a或者b有一个为true，或者ab均为true，则为true，否则为false
！：a为true，则结果为false，a为false，则结果为true
& (逻辑与)： 如：a&b ，ab全部为true时，计算结果为true，否则为false
| (逻辑或): 如：a|b ， ab全部为false时，计算结果为false，否则为true
注意：&& 与 & 区别：如果 a 为 false，则不计算 b（因为不论 b 为何值，结果都为 false） || 与 | 区别：如果 a 为 true，则不计算 b（因为不论 b 为何值，结果都为 true）
八：引用数据类型之间的比较
1.两个引用数据类型之间要有父子继承关系、接口关系，就可以进行 == 和 != 的比较
2.引用数据类型比较的是“两个引用是否指向同一个对象
3.关系运算符的优先级：> , < , >= , <= 具有相同的优先级 高于 != , == 两个具有相同优先级
​ 关系运算符的优先级 低于 算术运算符的优先级 ， 结合方式是“自左向右”
s1.equals(s3):比较s1与s3的内容是否相同
4.equals(obj)方法和 == 的区别：
equals方法 比较的是两个对象的内容是否相等
== 比较的是两个对象在内存中存放的地址是否为同一个
5.Scanner的基本使用：
​ java中的扫描器：用户从控制台输入数据 ， 后台Java程序接收
​ 创建扫描器对象：Scanner scan = new Scanner(System.in)
​ nextBigDecimal()方法：在关于算钱方面，可以存放很大的数
​ next()方法：是获取字符串的
注意：next()与nextline()区别：
当遇到空格或者回车的时候 next() 方法停止读取
​ 当遇到回车的时候 nextline() 方法停止读取
九、Java的位运算符
1.位运算包括：&(与) ， |(或) , -(非) ， ~(异或)
&：二进制数比较相同取一样，不同取”0“。则任何数与”0“按位与运算，结果都是0
|：二进制数比较相同取相同， 不同取”1“
位异或运算：相同取”0“ 不同取”1“
2.位移运算符：>>(右移位运算符)：除以n个2 ，
<<(左移位运算符)：乘以n个2 。
Java关系运算符
注意：关系运算符的值为布尔值类型
字节码是二进制；
Java的字面量

十、Java流程控制语句
if语句：
单分支结构
if（条件表达式）{
}
双分支结构
if（条件表达式）{
//条件为true执行
//代码块
}else{
//条件为false执行
}
多分支结构
if（条件表达式）{
}else if（表达式）{
}else if（表达式）{
}…{
}else{
//最后的else语句可要可不要} if语句的嵌套：
if(boolean){
if(boolean){
…
}
}else{
if(boolean){
…
}
}

复合语句：是语句块，很多语句的组合。如：int num2 ; num += 1 ;
2.三目运算符
语法：
条件表达式 ? 表达式1 ： 表达式2
当表达式结果true，执行表达式1，否则执行表达式2
条件表达式 ？ （条件表达式1 ？ 表达式1 ：表达式2） ：（条件表达式2 ？ 表达式1 ：表达式2）
switch语句：
switch（表达式）{
case 值1：
语句块1；
break；
case 值2：
语句块2；
break；
…
case 值n:
语句块n；
break；
default:
语句块n+1;
break;
}
没有break会照成switch穿透，它会继续读取满足条件的表达式
switch可以嵌套、case可以存放byte 、 short 、 int 、 char 、 String
第三周笔记：
3.if语句和switch语句的区别
1.从使用效率上区分
判断条件多用switch语句
判断条件少时可以用if语句
2.从实际性上区分
switch语句不如if语句
4.while 和 do while循环
1.Java 5 后有了for-each循环语句，for-each语句本质上还是for循环
初始化语句：初始化语句在循环开始前执行
循环条件：是一个Boolean表达式
循环体：这部分的代码块会重复执行
迭代语句：在循环体执行结束后，对循环条件求值之前执行
while循环：
语法：
while（循环条件）{
循环体；
}
do while循环：
do{
循环体
}while(循环条件)；

2.while 和 do while的区别：
while是先判断再执行，do…while循环时先执行后判断
do…while循环至少执行 一次
3.while 和 do while的特点：
都是循环执行某一语句，循环次数不固定
4.for循环：
语法：
for（表达式1；表达式2；表达式3）{
循环体；
}
特点：循环次数固定
5.循环嵌套：
如果循环嵌套层数超过3层，那么一定是逻辑出了问题
6.for-each循环：
访问数组元素：通过数组下标访问元素；如：arr[i]则表示访问数组arr下标为i的元素
遍历数组元素：将数组元素进行逐一的访问，arr.length获取数组的长度
for(int index = 0; index < arr.length; index ++){
}快捷方法：arr.length.for
for-each 语法：
for（迭代变量类型 变量的名字 ：需要遍历（迭代）的对象）{
语句块；
}
例：
int [] array ={12,13,56,78,45,48};
for(int num : array){
}快捷方法：array.for 可以快速的知道”迭代变量类型“
注意：不需要赋值
7、break语句、continue语句、return：
break作用：结束当前循环；在循环嵌套时，break只能结束一个循环
switch语句中的break是终止匹配
continue作用：结束本次循环，强制加入下一次循环
return作用：跳出当前方法的循环
十一、方法：
方法（函数）的类型：
1.无参数，无返回值
修饰符 void 方法名（）{方法体}
public static void print(String str){ ​ System.out.println(str);
}
2.无参数，有返回值
修饰符 返回值类型 方法名（）{方法体}
int fun1(){ ​ return 12; ​ }
3.有参数，无返回值
修饰符 void 方法名（参数1 ， 参数2 ， …）{方法体}
public String fun2(int[] array, double dou, long num, Date time){ ​ return “hhh”;
}
4.有参数，有返回值
修饰符 返回值类型 方法名（参数1 ， 参数2 ， …){方法体}
int fun3(int num , String str){
return 0 ;
}
方法的作用及特点：
1.封装一段 特定的业务逻辑功能
2.尽可能独立，一个方法只干一件事
3.方法可以被反复多次的调用
4.减少代码的重复，有利于代码的维护，有利与团队的协作
定义方法：
例：比较两个数大小，返回布尔值
计算用户输入i的阶乘
用户定义方法名字：首字母小写
方法调用：
1.通过 对象 . 方法名字（参数）
2.类名 . 方法（参数）
3.方法（参数）
Scanner 没有返回值类型也没有void；
public 方法名 {
}称为构造函数（构造器）
如：public Demo04{
}
作用：用来创建对象
没有static修饰的方法称为 成员方法
有static修饰的方法称为 静态方法
方法调用的快捷方法：
在方法调用后面+ . var
如：Demo04 d4 = new Demo04();
"d4.isMax(56, 78).var"就可以得到 Boolean b = d4.isMax(58,78);
调用没有static关键字修饰的方法，
语法： 对象 . 方法（参数）
如：int max = d4.max(3,5);
调用被static关键字修饰的方法，
语法： 类名 . 方法
如：String grade = Demo04.grade(56);
方法重载：
重载就是在一个类中，有相同函数名称，但参数列表不同的方法
public void fun1(){
System.out.println(“无参数无返回值的方法”); }
public int fun1(int num){
System.out.println(“有参数有返回值的方法参数int num”); return 0;
}
public void fun1(double d){
System.out.println(“有参数无返回值的方法参数double d”); }
public String fun1(){
System.out.println(“无参数有返回值的方法参数
int number int num”);
return null;
}
注意：方法重载只与方法名字有关和参数列表有关 ， 与方法的返回值类型无关
方法签名：方法名字 + 参数列表
方法重载规则：
1.方法名字必须相同
2.参数列表必须不同（参数个数不同 、 类型不同 、 参数排列顺序不同等等）
3.方法的返回值可以相同 ， 也可以不同（方法的重载与返回值类型无关）
4.仅仅只有返回类型不同的话 ， 则不足以称为方法重载
重载方法调用规则：
编译器在编译时会根据方法的签名自动绑定调用的方法
方法的可变参数：
可变参数最终会被封装成一个数组。
一个方法只能指定一个可变参数 ， 且它必须位于参数列表的最后一位
如：public void num(int num, double d){
}//固定参数的方法
public void fun1(int… num){
}//可变参数的定义
递归：
1.递归算法：在函数调用的过程中函数内部，直接或间接地调用自己的算法
2.递归算法解决问题的特点：
（1）递归就是在过程或函数里调用自身
（2）必须有一个明确的递归结束条件，称递归出口
（3）递归算法解题的运行效率较低，一般不提倡
3.递归的条件：
可以通过递归调用来缩小问题的规模，且新问题与原问题有着相同的形式（自身调用）
存在一种简单情景，可以使递归在简单情景下退出（递归出口）
4.递归三要素：
一定有一种可以退出程序的情况；
总是在尝试将一个问题化简到更小的规模；
父问题与子问题不能有重叠的部分；
十一、数组
1.数组定义： 用来存放相同类型的一组数据
2.查找数组的元素：
数组下标从0开始，对数组元素进行操作是通过数组的下标（索引）数组的最后一个元素的下标为：数组长度-1
3.数组的语法：
静态创建数组
数据类型[] 数组名 = {值1，值2…}
数据类型 数组名[] = {值1，值2…}
例：int arr[] = {1, 2, 4, 8, 9};
特点：创建数组的同时给数组元素赋值
动态创建数组
数据类型[] 数组名 = new 数据类型[数组长度]
数据类型 数组名[] = new 数据类型[数组长度]
例：long[] arr1 = new long[5];
int arr2[] = new int[]{1, 5, 8, 9};
特点：创建数组时指定数组的长度
数组元素赋值
语法：数组名[索引] = 值 如： dArr[1] = 0.618;
注意：数组一旦被创建，则数组的长度不可被修改；
数组元素必须是相同类型的，不允许出现混合类型。
创建main方法的快捷方式：psvm
输入语句的快捷方法：sout
3.数组的使用和随机数的生成
数组的使用：
1.基本数据类型数组的初始值：
int[] 的初始值 “0”
double[] 的初始值“0.0”
boolean[] 的初始值“false”
char[] 的初始值 空格的编码
byte[] 的初始值 “0”
float[] 的初始值“0.0”
long[] 的初始值“0”
引用数据类型数组的初始值为“null”
4.数组的边界：
数组下标的合法区间：[0,length-1],如果在这个范围之外将会报错，称为数组下标越界
Java.lang.ArrayIndexOutOfBoundsExeption:-1
//数组下标越界异常
参数数组下标越界异常的原因：
操作数元素的索引（下标）超出数组界限
随机数的生成：
1.Random random = new Random();
System.out.println(random.nextInt());
//说明：nextInt(int bound)
生成指定范围内的随机数random.nextInt(10)
Import java.lang.* //可以访问许多的包，不需要声明
2.Double random = Math.random();
生成随机数的范围0.0 —1.0，但是永远到不了1
十二、二维数组：
1，数组的定义
动态定义：
数据类型 数组名[ ] [ ]=new 数组类型[m] [n]
数组类型[ ] [ ] 数组名 = new 数组类型[m] [n]
数组类型[ ] 数组名[ ] =new 数组类型[m] [n]
本质：数组的元素还是数组
2，Arrays类
给数组赋值：通过调用fill方法
例：Arrays.fill(arr1 , 99);
对数组进行排序：通过sort方法
例：Arrays.sort(arr);
比较数组：通过equale方法比较数组中元素值是否相等
例：Arrays.equals(b1 , b2);
查找数组中的元素：通过binary Search方法能对排序好的数组进行二分查找操作
例:int result = Arrays.binarySearch(arr , 96);//96是查找的元素
注：该方法的返回值为查找到的元素下标
将数组转为字符串输出：通过toString方法实现
例：Arrays.toString(arr)
3，数组的复制
(1).System.arraycopy(浅拷贝) //不可随便用
System.arraycopy(src , 1 , dest , 0 , 6)
src:原数组 1：复制的起始位置 dest:目标数组
0：目标数组放置的起始位置 6：复制的长度
浅拷贝：对于基本类型而言，它拷贝是对象的引用，而不是去新建一个新的对象
(2).Arrays.copyOf(浅拷贝)//可随便用
可以用于数组的扩容与缩容
dest = Arrays.copyOf(src , 2);
src:原数组 dest:目标数组 2：复制的位数
(4).Object.clone
dest = (int[ ]) src.clone();//使用clone创建
clone复制实现数组全部复制
注意：clone()比较特殊，对于对象而言，它是深拷贝；但对于数组而言，它是浅拷贝
(5).Arrays.copyOfRange
dest = Arrays.copyOfRange(src , 1 , 3);

src:原数组 1：起始下标 3：结束下标
十三、面向对象
面向对象与面向过程的区别：
面向对象：
1.将问题分成若干部分，用一个方法来完成，再进行面向过程的思考
2.适合处理复杂问题和一些需要多人合作的问题
面向过程：
1.步骤清晰简单，符合我们做事的思想
2.适合处理一些比较简单的问题
面向过程的结果化程序设计弊端：
1.缺乏对数据的封装
2.数据与方法（操作数据）的分离
1.面向对象定义：以类的方式组织代码，以对象来组织（封装）数据。
2.抽象数据类型：将不同类型的数据的集合组成一个整体，用来描述一种新事物。如：对象类型数据
对象----类：现实世界—>对象 类是基于对象的抽象描述
1.对象：真实存在的单个个体
类：类型/ 类别，代表一个类体
2.类包含：
所有对象所有共有的属性/特征 ----------成员变量
所有对象所共有的行为 ---------------------方法
3.一个类可以创建多个对象
同一类型所创建的对象， 结构相同，数据不同
4.类是对象的模板，对象是类的具体实例
面向对象的三大特征：
封装 ，继承，多态
5.构造方法（构造函数）：
每一个Java类必须包含构造方法，如果程序员没有手动添加构造方法，则编译器会在编译时添加一个默认的无参构造方法。名字与类名相同
关于构造方法的特点：1、构造方法的方法名字必须与类名完全相同（包括大小写必须相同），
2、构造方法没有任何返回值，连void关键字也没有。
构造方法的语法：
修饰符 类名(参数){
方法体…
}
构造方法的作用：用于创建类的对象（实例化对象），还可以初始化成员变量的初始值
注意：当我们手动添加构造器（构造方法）之后，编译器将不在为我们添加默认的无参构造器

构造方法的重载：构造方法都是相同的名称，但方法的参数列表不同

一个构造方法可以通过this关键字调用另一个重载的构造方法
通过构造方法初始化成员变量：构造方法常量于实例化对象和成员变量就能初始化

this关键字的使用：
当我们在方法中不添加this关键字时，编译器会默认补上this关键字

注意：在构造器中使用this关键字调用另外一个重载构造器时，代码必须位于第一行

Java内存分析
1.堆：new出来的对象（包括实例变量）
2.栈：局部变量（包括方法的参数）
3.方法区：class字节码文件（包括方法、静态变量）
常量池：静态常量池，运行时常量池

     静态常量池，即*.class文件中的常量池  不仅仅包括字符串（数字）字面量，还有 类，方法的信息，占用class文件绝大部分空间
     运行时常量池，是jvm虚拟机完成装载后，将class文件中的常量池载入内存中，并保存在方法体中
    常说的常量池是运行时常量池

方法的压栈：

十五, 对象数组

十六，访问控制修饰符
1.public 和 private
private修饰的成员变量和方法只能在本类中访问调用，在其他类中访问这没有权限
public修饰的成员变量和方法可以在任何地方调用，
2.protected 和默认访问控制
protected修饰的成员变量和方法可以被子类及同一个包的类使用
3、默认访问控制，即不写任何访问修饰符，默认访问控制的成员变量和方法可以被同一包中的类调用

十七、封装：
设计程序追求“高内聚，低耦合”
高内聚：类的内部数据操作细节由自己完成，不允许外部干涉
低耦合：仅暴露少量的方法给外部调用（使用get/set方法）
封装（对数据的隐藏），禁止直接访问该对象的数据的实际表达，应该通过操作接口来访问，-- 隐藏
意义：
1.对外提供可调用的，稳定的功能
2.封装容易变化的，具体的细节，外界不可访问；如此封装的意义：
a.降低代码出错的可能性，便于维护
b.当内部的实现细节改变时，只要保证对外的功能定义不变，其他模块就不会因此受到牵连。
核心：属性（成员变量）私有化，行为（方法）公开化

为属性提供统一的访问方法 set():设置属性值 get():获取属性值
get,set方法的语法特点：
get属性名（），如：getName(),
set属性名（参数），如：setName(String name)
工具提供的get/ set方法

包机制：（文件夹）
包名不是必须的，一旦有包名，必须位于程序的第一行
一般利用公司的域名倒置作为包名
使用规则：import关键字
import 完整的包名.类名;
十八、继承：

注意：当一个Java类不继承任何类的时候，编译器会默认让该类继承Object类
Object是所有Java类的顶级父类

extends关键字：
通过extends可以实现类的继承
子类可以继承父类的成员变量和成员方法，同时也可以定义自己的成员变量和成员方法
不支持多重继承，一个类只能继承一个父类，但一个父类可以有多个子类
super指的是父类对象

继承关系：当父类的构造方法是无参时，子类没有super（）；也可以，有也不报错
当父类的构造方法是有参时，子类不能没有super（）；否则会报错
父类的引用指向子类的对象：
一个子类的对象可以向上造型为父类，（定义父类型的引用可以指向子类型的对象）
但通过父类的引用只能访问父类所定义的成员，不能访问子类自己定义的成员

super关键字：
使用方法：
1.用于子类的构造方法里（初始化），主要调用的是父类的默认构造方法，当父类不止一个构造方法，可以通过super指定具体的构造方法
注意：super表示当前的父类对象，super()调用的是父类的无参构造方法，即可以对父类进行初始化
2.用于子类调用隐藏或重写的属性或行为
直接访问（如：Cat.sex)，只能访问子类的属性
通过（super.sex)，可以访问父类的属性 语法：super.属性名
, 访问父类的行为 语法：super.方法名（参数）
super和this的区别：
super（参数）：调用基类（父类）中的某一个构造方法（应该位于子类构造方法中的第一条语句）
this（参数）：调用本类中的构造方法（位于构造方法中的第一条语句）
super：引用当前对象的直接父类成员（用来访问直接父类中被隐藏或重写的父类中的成员属性或行为，基类（子类）与派生类中有相同的成员定义
this：代表当前对象名（当产生二义性时，应使用this指明当前对象；方法的形参与类中的成员数据同名时，需要用this来指明成员变量名
调用super（）和this(）都需要在构造方法的第一行，否则会出现错误。每个子类构造方法的第一条语句，都隐含的调用super()，如果父类没有这种形式的构造方法，那会有报错
super（）和this（）区别：super()从子类中调用父类的构造方法
This()在同一类内调用其他方法
super（）和this（）都需放在构造方法的第一行
可以用this调用一个构造器，不能调用两个
super和this不能同时出现在一个构造方法中，因为this会调用其他的构造方法，其他的构造方法会有super语句的存在，所以在同一个构造方法中有相同语句，失去语句的意义，会报错
super（）和this（）都指对象，因此都不能在static环境中使用。包括：static变量、方法、语句块
从本质上讲，this是一个指向本对象的指针，然而super是一个Java关键字。
方法重写：
1.发生在父子类中，方法名相同，参数列表相同，方法体不同
2.重写方法被调用时，看对象的类型
3.遵循“两同两小一大”原则：
两同：
方法名称相同
参数列表相同
两小：子类方法的返回值类型小于或等于父类方法的返回值
a. void时，必须相同
b. 返回值为基本数据类型时，必须相同
c. 返回值为引用数据类型（父类名字或子类）时，小于或等于
子类方法抛出（throws）的异常小于或等于父类方法
一大：子类方法的访问权限要大于或等于父类方法
重写与重载区别：
1，重写：
发生在父子类中，方法名相同、参数列表相同、方法体不同
“运行期绑定”，看对象的类型绑定方法
2，重载：
发生在一个类中，方法名相同、参数列表不同、方法体不同
“编译期绑定”，看参数/引用的类型绑定方法（方法签名）
补充：
编译期：Java源文件，经过编译，生成class字节码文件
运行期：jvm加载，class并运行 .class
编译错误：只是检查语法

多态：指的是同一方法可以根据发送对象的不同而采用多种不同的行为方式。
一个对象的实际类型是确定的，但是可以指向对象的引用类型有多种。
多态存在的条件：
1、有继承关系
2、子类重写父类的方法
3、父类引用指向子类对象
多态的意义：
1、行为的多态（所有抽象方法都是多态的）
2、对象的多态（所有对象都是多态的）
多态的表现形式：
1、重写：根据对象的不同来表现多态
2、重载：根据参数的不同来表现多态
注意：多态是方法的多态性，属性没有多态性
类型转换：
instanceof是Java的一个二元操作符，如：==，>,<等
是Java的保留关键字，它的作用是测试它左边的对象是否是它右边的类的实例（实例指的是“类”在实例化之后叫做一个“实例”)。
实例化：通常把用类创建对象的过程称为实例化），返回 boolean 的数据类型。

向上造型：
1、父类的引用指向子类的对象
2、能点出什么，看引用的类型
向下造型：
1、子类的引用指向父类的对像
2、需要进行强转转换
3、能点出什么，看引用的类型
面向对象的设计模式：
设计模式分为3大类：
创建型模式，共5种：工厂方法模式，抽象工厂模式，单例模式，建造者模式，原型模式。
结构型模式，共7种：装饰器模式，代理模式，外观模式，桥接模式，组合模式，享元模式。
行为型模式，共11种：模板方法模式，观察者模式，迭代子模式，责任链模式，命令模式，备忘录模式，状态模式，访问者模式，中介者模式，解释器模式。
还有2类：并发型模式和线程池模式。
设计模式的六大原则：
开闭原则 ，里氏代换原则 ， 依赖倒转原则 ，接口隔离原则 ，迪米特法则（最少知道原则） ，合成复用原则

static和final关键字
static修饰成员变量
1，用static修饰的成员变量不属于对象的数据结构，属于类的数据结构
（用类名调用）没被static修饰的用对象来访问

2，static变量是属于类的变量，通常可以通过类名来引用static成员
3，static成员变量和类的信息一起存储在方法区，而不是在堆中，一个类的static变量只能有一份，无论这个类创建了多少个对象

static修饰方法
方法 在调用时需要隐式传递对象的引用（this）
static修饰的方法不需要针对某些对象进行操作，运行结果仅仅与输入的参数有关，调用时直接用类名引用
static方法中不能对非static成员进行访问，static方法的作用在于提供一些工具方法和工厂方法等
static静态块
static块属于代码块，在类加载中只执行一次，可以用来在软件中加载静态资源。
语法：static{
代码块；
}
final修饰变量
1，final关键字修饰成员变量，表示变量不可被改变
2，final修饰成员变量的2种方式初始化：
声明同时初始化
构造方法中初始化
3，final关键字可以修饰局部变量，使用之前初始化即可
final修饰方法
1，final关键字修饰的方法不可被重写
2，使一个方法不能被重写的意义在于：防止子类在定义新方法时造成“无意间”重写
final修饰类
1，final关键字修饰的类不可被继承
2，JDK的一些基础类库被定义为final的，如：String Math Integer Double
3，使用一个类不能继承的意义在于：可以保护类不被继承修改，可以控制滥用继承对系统造成的危害

static final常量
1，static final修饰的成员变量称为 常量，必须在声明同时初始化，不可被修改
2，static final常量会在编译期被替换

抽象类
抽象类描述：在Java语言使用中abstract class来定义抽象类
抽象类不能被实例化对象，需要被继承，才能被使用
一个类只能继承一个类，一个类可以实现多个接口
抽象方法使用abstract关键字修饰：
抽象方法没有方法体，连{}也没有
抽象方法允许有方法重载
注意：如果一个类包含抽象方法，那么该类必须声明为抽象类
抽象方法只有声明没有实现
abstract只能用与普通方法，不能修饰static的方法和构造方法
抽象方法特征：没有方法体；必须存在于抽象类中；子类重写父类时，必须重写父类所有抽象方法
注意：abstract关键字修饰方法时不能使用private修饰
抽象方法必须被子类重写
抽象类：
1、由abstract修饰
2、包含抽象方法的类，必须是抽象类
不包含抽象方法的类也可以声明为抽象类
3、抽象类不能被实例化
4、抽象类只需要被继承的，子类（派生类）：
重写所有抽象方法（常用）
声明为抽象类（不推荐使用）
5、抽象类的意义：
封装子类所共有的属性和行为 —> 代码复写
给所有子类提供统一的类型 —> 向上造型
可以包含抽象方法，为所有子类提供统一入口
子类的具体行为不同，入口是一致的
抽象类的设计规则：
将子类所共有的属性和行为，抽到父类中—>抽共性
所有子类的行为都一样，设计为普通方法
所有子类的行为都不一样，设计为抽象方法
接口（Interface）
在Java中是一个抽象类型，是抽象方法的集合
接口不是类，它只包含要实现的方法
接口不能被实例化，可以被实现
接口：在接口中定义的变量默认为 public final static 修饰
接口中的方法必须全部是抽象方法（int b(); void a();）
接口中不能有构造器
接口与类的相似：
1、一个接口可以有多个方法
2、接口文件保存在.java结尾的文件中
3、接口的字节码文件保存在.class结尾的文件中
4、接口相应的字节码文件必须在与包名称相匹配的目录结构中
接口与类的区别：
1、接口不能用于实例化对象
2、接口没有构造方法
3、接口所有方法必须是抽象方法
4、接口不能包含成员变量，除static和final变量
5、接口不是被类继承的，而是要被类实现
6、接口支持多继承（接口不能继承类，只能继承接口）
接口不是类，可以有多继承
访问接口中的常量 实现类名.常量名
接口名. 常量名

接口特性：
1、接口中的每一个方法是隐式抽象的，被指定为public abstract
2、接口中可以含变量，但都被隐式为public static final变量（也是常量）
3、接口不能实现接口，只能由类来实现，类中需要重写接口的所有方法
抽象类与接口的区别：
1、抽象类中方法可以有方法体，（能实现方法的具体功能）但接口中的方法不能有方法体
2、抽象类中成员变量可以是各种类型的，接口中的成员变量只能是 public static final 常量
3、接口中不能含有静态代码块以及静态方法（用static修饰的方法）抽象类中可以有静态方法和静态代码块
4、一个类只能继承一个抽象类，而一个类可以实现多个接口
在JDK 1.8后，接口里可以有静态方法和方法体
实现接口（implements）：
1.重写接口中的所有方法
2.将当前类声明为抽象类（不推荐）
接口多实现，多个接口之间用",“隔开
注意：接口不能实现接口，但接口可以继承接口，可以多继承（用”,"隔开）

内部类：
Java内部类的几种类型：成员内部类、静态内部类、方法内部类、匿名内部类
语法：
修饰符 class关键字 类名{类体}
内部类不允许定义静态的变量
内部类不允许定义静态的方法
作用：通常用于服务外部类
创建内部类的对象
语法：
外部类.内部类 = 外部类对象.new 内部类（）；
成员内部类的用法：
成员内部类：是类内部的非静态类。不能有静态方法和变量（final修饰的除外）成员内部类可以看成外部类的一个属性，需要创建对象后才能初始化，与static加载的时段不同
一个类中可以声明多个内部类
使用方法：
1、Inner类定义在Outer类的内部，相当于Outer类的一个成员变量（属性）的位置，Inner类可以使用任意访问控制修饰符
2、Inner类可以直接访问Outer类中的所有方法和属性，私有的方法、静态方法和静态成员变量都可以访问
外部类中实例化内部类，可以直接new内部类（Inner inner = new Inner();）

静态内部类：是static修饰的类
特点：1、静态内部类不能直接访问外部类的非静态成员，可以通过 new外部类().成员 的方式访问。
2、外部类的静态成员与内部类的成员名称相同，可以通过 类名.静态成员 访问外部类的静态成员
外部类的静态成员与内部类的成员名称不相同，直接通过 成员名 调用外部类的静态成员
4、创建静态内部类对象时，不需要外部类的对象，可以直接 内部类 对象名 = new 内部类();（不是本类的也可以）

方法内部类
不能对方法内部类使用访问控制修饰符和static关键字
定义在方法内和类，只能在本方法内使用

匿名内部类：
不能有名称的类，必须在创建时，作为new 语句的一部分来声明。
前提条件：必须继承一个父类或实现一个接口
语法：
new Inter01(){
需要重写继承的父类和接口
};

枚举：
是一个被命名的整型常量集合，用于声明一组带标识符的常量 。
声明枚举：
1、必须使用enum关键字，在定义枚举名称、可访问的属性、基础类型和成员等。
2、任意2个枚举成员不能具有相同的名称
3、常数值必须再改枚举的基础类型的范围内，多个可以用 “,” 隔开
注意：当没有显示声明基础类的枚举，则意味着该类对应的基础类型是int

二、Java高级