Corejava学习整理

第一章
Java特点、java前身、常用cmd命令、main方法、命名规范等
1、java语言是由 SUN公司开发的，后来由于SUN公司被Oracle公司收购，所以现在的java是属于Oracle（甲骨文）公司的。
2、Java之父----James Gosling （詹姆斯.高斯林）。
3.java前身—Oak语言，小小的脚本语言。
4.Java语言从1995年发行第一版 jdk1.0。到现在java已经到了jdk10 也就是说超过10个版本。
5.Java从1995年面世以来，已经发展到三个方向
(1)JavaSE: 开发桌面应用程序
(2)JavaEE: 开发internet应用程序
(3)JavaME: 开发手机端应用程序
6、java语言的特点：
(1)面向对象的开发语言；
(2)跨平台性；
(3)安全健壮;
(4)支持多线程;
(5)垃圾自动回收机制。
7、java是编写在 .java文件里面的，可以经过编译器编译成 .class文件。
8、java文件需要经过 编写 (.java)—编译(.class)—运行 三个阶段才能平台输出。
9、Java文件是如何转变成二进制代码的？

10、JVM、JDK、JRE分别表示什么意思？
(1)JVM（java虚拟机）是java的核心和基础，是java编译器和平台之间的虚拟处理器。
(2)JDK：java开发工具包(JRE+编译器+其他工具)
(3)JRE: java运行环境
11、cmd命令
（1）Java -version (java和-version之间有一个空格)
表示 获取jdk的版本
（2）javac AAA.java 将后面的java文件编译成class文件
java AAA 运行AAA这个类

（3）标点符号必须是英文
盘符: (回车) 打开指定的盘符

（4）cd aaa 表示 打开指定的目录
cd … 表示返回上一接 （cd 和 …之间有空格）
DOS命令中清屏的命令是 cls
exit 退出命令提示窗口
Cd \ 多级回退
Cd javac\javas 进入多级目录
Dir 查看文件目录命令
2.类名和文件名必须一样

• 3.main()方法是java程序入口方法
• 4.main()方法四要素：
• a.public 公共的
• b.static 静态的
• c.void 没有返回值的
• d.String[] args 程序运行参数
• 5.类名的命名规范（大驼峰命名法）
• a.类名的每个单词字母必须大写
• b.类名可以由数字、字母、下划线构成，但是不能以数字开头
• 6.{}、()之间要一一对应。
• 7.输出语句
• 输出之后换行
• System.out.println("");
• 输出之后不换行
• System.out.print(""); ’
• 8.转义符
• \t-- 将光标移动到下一个制表位 制表位表示8个字节长度
• \n – 换行符
• 9.java开发规范：
• a.我们一行只写一条语句;
• b.每一行语句以;号结束;
  c.代码必须有明确的缩进，可以使得代码具有可读性(tab键缩进，也可以用空格缩进)
  d.类名用public修饰
  10.{} 叫 代码块 “{” 一般放在每一行的最末端 “}” 要放在每一行的开头
  11.注释–标注解释 用来解释代码的作用
  单行注释 //
  多行注释 /* /
  文档注释 /* */
  第二章
  变量、数据类型
  1.变量就是一个数据存储空间的表示;
  2.内存就是计算机用来处理记忆数据的地方;
  3.每个变量在内存中都会开辟不同的内存空间，每个空间都会有一个地址，
  用来标明不同的变量;
  4.由于内存地址太复杂不容易记忆，那么我们获取内存中的数据，使用
  变量的方式去获取，变量可以看做是内存的别名。
  数据类型：
  数值
  整型 非整型
  int(比如10) double (比如121.89) 双精度浮点型
  float(比如 121.5f) 单精度浮点型
  short 短数值类型
  long 长数值类型
  byte 字节类型
  1b = 8 位
  1KB = 1024b —> byte 字节
  1MB = 1024KB
  1GB = 1024MB
  1TB = 1024G
  非数值
  String （字符串 “中国”） char(字符 ‘c’)
  字符单引号，字符串双引号
  boolean (布尔类型 只有两种值 true 正确 false 错误 )

我们讲了九个数据类型：
1.八大基本数据类型：
byte(1字节)boolean(1字节) short(2字节) char(2字节) int(4字节) float(4字节) double(8字节) long(8字节)
8位 8 位 16 位 16 位 32位 32 位 64位 64位
2.引用数据类型：

•  String 类 字符串类型  不能算是基本数据类型
  

  数组
  接口
  3.基本数据类型的取值范围:
  byte 取值范围 -128~127 之间
  int 取值范围 2^-31~231-1之间
  Float：比特数为32，有效数字为6-7，数值范围为 -3.4E+38 和 3.4E+38
  2、Double：比特数为64，有效数字为15-16，数值范围为-1.7E-308～1.7E+308
  4.数据类型的大小排序
  byte < int < float < double
  double的取值范围>float的取值范围>long的取值范围
  声明变量—表示在内存中开辟一块空间
  变量命名的规则
  1.首字母可以是 字母、下划线_、$符号，但是不能是数字2.其余部分可以是字母、下划{线}_{、}$符号和数字。
  3.变量名最好不要随意起，一定要见名知意
  4.变量名首字母小写，其后面每个单词的首字母大写

     变量声明的注意事项：
     变量使用必须要经过赋值，也叫做变量必须初始化。
     局部变量不能声明两个相同的变量名。
  

变量赋值有两种方式：
1.先声明后赋值,然后使用
2.声明的同时并且赋值，然后使用
String字符串类型的 变量 数据必须写在双引号中
char 字符类型 数据必须写在单号中
float 单精度浮点型 必须后面跟上f
boolean 布尔数据类型 值只有两个 true和false
字符a-z所对应的int值是 97-122
* 字符A-Z所对应的int值是 65-90
1、double取值范围比float的取值范围大
double转float需要强转
float转double自动转化
2、float 转 int强制转化
int 转 float自动类型转化
double转int强制转化
int 转 double 自动类型转化
第三章 运算符、分支结构、循环结构
运算符的优先级：
1.最高优先级 小括号 即();
2.最低优先级 赋值运算符 即 =
3.优先级顺序 算数运算符–>关系运算符–>逻辑运算符
当运算符比较多的时候，我们一般会用小括号进行分割
运算符：
1、赋值运算符 =
将 等号 右边的值赋值给左边
2、算数运算符
+ - *（乘法） /（除法） % (取余)
3、关系运算符 > < == != >= <=
三元表达式
表达式 ? 情况1 : 情况2
当表达式的返回值是true的时候，输出情况1
当表达式的返回值是false的时候，输出情况2
自增 i++; 先输出，后增加+1
++i; 先增加，后输出
自减 i–; 先输出，后减少-1
–i; 先减少，后输出
/(除法) %(取余)
小类型和大类型做运算，最终结果需要向大类型靠拢。
要想在控制台输入信息，就必须要扫描器Scanner
//实例化扫描器对象
Scanner input = new Scanner(System.in);
如果想获取int类型的数据 使用 input.nextInt();
如果想获取String类型的数据 使用 input.next();
如果想获取double类型的数据 使用 input.nextDouble();
int zhangScore = input.nextInt();
多重if结构

• if(条件1){

•  代码块1
  

• }else if(条件2){

•  代码块2
  

• }else if(条件3){

•  代码块3
  

• }else{

•  代码块4
  

• }
  嵌套if选择结构
• if(条件){

•  if(条件){
  

•  }else{
  

•  } 
  

• }else{
• }
  if选择结构的书写规范
• 1.每个if和else的代码都用大括号括起来；
• 2.相匹配的一对if else应该左对齐；
• 3.内层if要相对于外层if有一定的缩进。
  A.equals(B) A等于B A==B
  * == 比较的是A和B的地址和值是否一致
  * equals() 比较的只是A和B的值是否一致，一般只用于字符串类型
  变量分为局部变量和全局变量
  * 1.全局变量整个类都是可以使用的，变量声明类的下面，不声明在方法内部
  * 2.局部变量 一般声明在方法内部，或者是代码块中，作用域只能是所在
  * 代码块区域。
  *
  * 常量 常量是不可改变的量
  * final 修饰常量 常量名一般全部大写
  一个类中只能有一个main()方法
  • switch(表达式){ //分支结构 – 》 选择结构的一种
    • case A:

    •  break;
      

    • case B:

    •  break;
      

    • default:

    •  break;
      

    • }
      break 作用 跳出当前语句
    • switch表达式的数据类型在1.7之前只能为 byte,short,char,int,枚举以及对应的包装类Byte、Short、Integer、Character、
    • 1.7之后可以使用 byte,short,char,int,枚举,String
    • jdk1.7之后引入了String作为表达式。
      • switch不可作用于long double float boolean，包括他们的包装类
    • switch 括号内的表达式必须是 等值判断
    • switch 中的default块可以放在任意位置
    • 如果每个case 执行完之后要跳出，每个case执行完之后不要忘记写break;
      区间判断 if选择结构
      等值判断 switch选择结构
      if选择结构
      基本if选择结构： 处理单一或组合条件的情况
      if-else选择结构：处理简单的条件分支情况
      多重if选择结构：处理复杂的条件分支情况
      嵌套if选择结构：用于较为复杂的流程控制
      switch选择结构
      多重分支并且条件判断是等值判断的情况
      循环： 在条件范围内，重复去做某一件事情；
  • 循环的特点:
  • 1.循环条件
  • 2.循环操作
    while(循环条件){
    • //当条件表达式的返回值为true的时候，才能进入循环

    •  循环操作
      

    • }
    • while循环 必须先判断，再执行
    • 使用while的步骤：
    • 1.先确定循环条件和循环操作
    • 2.套用while循环代码
    • 3.检查循环是否能够退出
      在字符串取固定位置的字符
      char yunsuan = input.next().charAt(0);
      do{
      循环操作
      }while(循环条件)
      特点：先执行，在判断
      不管这样，先执行一次循环操作，然后再做判断
      while循环和do…while循环的不同：
      执行顺序：
      while循环 先判断，在执行
      do…while循环 先执行，再判断
      初始值不符合条件：
      while循环 一次循环操作都不会执行
      do…while循环 至少执行一次循环操作
      循环有4个不可或缺的条件**(重点)
    • 1.初始化变量 2.循环条件 3.循环体 4.循环迭代部分
    • for(表达式1;表达式2;表达式3){
    • 循环操作
    • }
    • 表达式1、表达式2、表达式3 都可以省略，
    • 但是表达式之间的 ; 分号是不能省略的
    • 如果省略掉 表达式2 即 循环条件，那么循环就会进入死循环。
    • 如果都省略掉不写，就会陷入死循环。
    • while、do…while、for循环区别
    • 执行顺序：
    • while — > 先判断，在执行
    • do…while循环 --> 先执行，再判断
    • for --> 先判断，再执行
    • 使用情况:
    • while、do…while循环适用于 循环次数不确定的情况
    • for循环适用于 循环次数确定的情况
      第五章 程序调试、break和continue区别
      程序调试的步骤：
    • 1.设置断点
    • 2.单步运行
    • 3.观察变量
    • 程序调试的目的：
    • 解决我们程序中出现的缺陷（Bug）
      break；跳出
  • 当用在while,do…while,for循环中的时候，
  • 表示跳出当前的循环，执行循环之外语句。
    continue作用，
  • 只能用在循环里面，表示跳过当前循环中剩余的语句，
  • 进入下一次循环
    第六章 数组
    数组：
    数组的默认初始化值
    整数型默认初始化值都是0
    布尔型默认初始化值是false
    浮点型默认初始化值是0.0
    字符型默认初始化值是\u0000
    引用数据类型默认初始化值是null
  • 数组也是一个变量，存储具有相同数据类型的一组数据。
  • 声明一个普通变量就是在内存中开辟一块空间，
  • 声明一个数组变量就是在内存中开辟一串连续的空间。
  • 数组基本要素：
  • 1、标识符： 其实就是数组名，用来标识每一个数组
  • 2、数组元素： 数组中的每一个数据
  • 3、元素下标：表示每个元素在数组中的位置，下标从0开始
  • 4、元素类型：数组中每个元素（每个数据）的数据类型。
  • 数组注意事项：
  • 1、数组的长度是固定不变的，所以要避免数组越界。
  • 2、数组中的数据必须属于相同的数据类型。
  • 3、数组的下标表示的是数据中每个元素的位置编号，

  •  编号从0开始，所以下标最大等于数组长度-1。
    

使用变量 数组本质上就是一个变量
1.先声明，后赋值，再使用
2.声明的同时并赋值，然后使用
使用数据分为四步走：
1.声明数组 有两种方式 1、数据类型[] 数组名称 2、数据类型 数据名称[]
声明数组就是告诉计算机数组的数据类型是什么。 声明数组的时候不需要分配空间
2.分配空间 告诉计算机分配几个连续的空间
数据类型[] 数组名 = new 数据类型[大小];
3.赋值 向格子中存放数据 因为每个格子都会有一个下标，下标从0开始
数组名称[下标] = 值;
数组下标越界异常 ArrayIndexOutofBoundsException
4.使用 变量 = 数组名称[下标]
数组赋值的两种方式
1、边声明边赋值的方式
int[] nums = {19,20,22};
int[] scores = new int[]{99,98,100};
通过Scanner动态输入并赋值给数组
int[] ages = new int[4];
数组名.length 数组长度
Arrays.sort(数组名); 对数组中的元素进行升序排列

第七章 面向对象—>OOP、无参方法和有参方法
类和对象
private 私有的 public 公共的
* 对象：对象是描述客观事物的一个实体，由一组属性和方法构成。
* 客观事物—》类
* 属性：就是对象具有的特征，一般是名词
* 方法：就是对象的操作，一般是动词
*
* 对象的属性和方法是相辅相成的，我们通常把属性和方法封装在一起
* 类是一个抽象的概念。
* 对象则是一个实际存在的，能够看得见、摸得到的物体。
*
* 类是对象的抽象，对象是类的实体。
* 把类变成对象的过程叫做实例化。
*
* java语言是一个面向对象的语言–》OOP
*
* 面向对象的优点：
* 1、与人类思维习惯一致
* 2、提高了程序的可重用性
* 3、信息隐藏提高程序的可维护性和安全性
声明一个类的步骤

• 1、定义一个类 2、定义属性 3、 定义方法
• 全局变量 定义在类的下面的，方法的外面。 供全类使用。
• 局部变量 定义在方法内部，只能供方法内部使用。
• java是面向对象开发的
• 面向对象开发有三个特点：
• 1、封装
• 2、继承
• 3、多态
  对象实例化 其实就是在内存中开辟一块空间。new 类名();
• 对象初始化 其实就是给开辟的内存空间 赋值
  定义属性 数据类型 属性名称;
  不同数据类型的变量的默认值
  • String类型的变量默认值是 null;
  • int 类型的变量的默认值是 0;
  • double 类型的变量的默认值是 0.0;
  • boolean 类型的变量的默认值是 false;
  • 字符 类型的变量默认值是 ‘\0’ 或 \u0000
  • 在同一个包中不允许有两个相同名字的类名出现
    创建对象 ==> 把类创建成对象的过程，称之为实例化
    类名 对象名 = new 类名();
    创建完成对象之后，一定要对 对象初始化
    调用对象中的 属性和方法
    使用 对象名.属性名
    使用 对象名.方法名
    无参方法的语法结构：
    访问修饰符(public) 返回值类型 方法名(){
    方法体
    }
    返回值类型有两种情况：
• 1、有返回值的，方法中必须使用关键字return返回该值，

•  并且返回值类型要和返回的值的类型一致
  

• return 跳出方法，返回结果
• return 只可以返回一个值
• 2、没有返回值的，返回值类型为void
• 方法的调用：
• 1、本类中方法和方法之间可以互相调用，而且只需要写方法名即可；
• 2、A类调用B类中的方法show()，那么在A类的方法中创建出B类对象，
• 然后使用对象名.方法名()调用。
• 1、有static关键字修饰的方法，我们叫做静态方法。
  有static关键字修饰的属性，我们叫做静态属性
• 2、静态的属性和方法，不需要实例化对象就可以在内存中开辟空间。
• 因为静态的属性和方法不属性对象，它是属于类的，所以会优先
• 于其他属性和方法加载到内存中。
• 3、因为静态的东西是属于类的，所以调用的时候 直接使用
• 类名.属性名或类名.方法名调用。
• 方法的注意事项
• 1、return 不能返回多个值，只能返回一个值
• 2、void和return不能同时出现
• 3、多个方法之间不能相互嵌套
• 4、方法外部不能够写程序逻辑代码
  成员变量和局部变量的不同
  1、作用域不同
  局部变量的作用域仅局限于定义它的方法
  成员变量的作用域可以供整个类使用
  2、初始值不同
  成员变量是有初始值的，
  局部变量是没有初始值的。
• 有参
• public 返回值类型 方法名(参数列表){

•  方法体
  

• }
• 参数列表的语法：
• 数据类型 参数1,数据类型 参数2,数据类型 参数3
• 定义有参方法的时候，括号中的参数列表称之为形式参数（形参），
• 形式参数只是起到占位作用，并没有在内存中开辟空间。
  在有参方法被调用的时候，方法括号填入的参数成为实际参数（实参），
• 实参即 实际存在的参数，在内存开辟了空间，并且舒适化了。
• 调用有参方法时
• 1、实际参数和形式参数的个数、数据类型和顺序 必须一致。
• 2、调用方法时，不能指定实参的数据类型。
• 3、调用方法之后，要对返回值做相应的处理。
• 在一个类中不可以出现两个相同的方法。
• 方法重载：（一同三不同）必须发生在同一个类中
• 1、方法名称必须相同
• 2、方法的参数列表必须不同（参数类型不同或者参数个数不同）

第八章
由对象抽象出类需要经历三步：

• 1、定义类名
• 2、定义属性
• 3、定义方法
• 构造方法
• 当对象创建的时候，用来初始化对象信息。
• 构造方法分为 无参构造和有参构造
• 语法：
• 访问修饰符 构造方法名(可以有参数，也可以没有){

•  初始化信息
  

• }
• 1、构造方法名必须和 类名 一致。
• 2、构造方法没有返回值类型。
• 3、类中会自带一个无参构造方法，但是当我们写了有参构造方法之后，无参构造方法就不会默认自带了。
• 4、一个类中可以有很多个构造方法。
• this关键字 表示 本类
• 方法重载：
• 一同三不同
• 1、方法名相同
• 2、参数列表不同（参数个数不同，参数类型不同）
• 3、和返回值类型、访问修饰符无关。
• 面向对象的三大特征之一：封装
• 封装：
• 隐藏类内部的某些信息，不允许外部程序直接访问，
• 通过该类提供方法，实现对类中隐藏信息的访问。
• 封装的好处：
• 隐藏内部细节，提供对外的访问接口。
• 封装的步骤：
• 1、将类中的属性设置为私有 private
• 2、创建公共的getter和setter方法（get方法是取值，set方法是给属性赋值的）；
• 3、在get和set方法中对属性值的合法性进行判断。
• shift+alt+s快捷键创建getter和setter方法
• 访问修饰符–界定方法或者属性的访问权限
• default(默认)、private(私有的)、public(公共的)和protected(受保护的)

static{
静态代码块
内部的代码会优先加载到内存中，并且不需要实例化对象
}
使用import语句来引入所需要的类

• 定义包使用package
• 包名我们一般都是小写的。
• 在Java语言中，自动导入的包是 java.lang
  第九章 抽象
  参数传递的方式
  • 1、按值传递
    就是传递的是值的备份，并不是把内存指向传递过去。
    值传递之后，两者就没有任何关系了，参数传入后的改变不会影响原来参数的值。
    一般我们的基本数据类型都是属于值传递。
  • 2、按引用传递
    就是传递的是数据的引用，也就是说传递是内存空间的指向。
    引用传递后，两者的内存指向同一个内存地址，如果参数数值被改变，则都会改变。
    一般像自定义类、数组、集合、String等这些属于引用传递
    继承：

•  子类名 extends 父类名
  

• 1、java子类只能继承一个父类—》即 java是单继承的。
• 2、在子类中如果想要访问父类中的属性和方法，我们使用super关键字。
• super指代的是父类对象
• 3、子类不能够继承父类所有的成员

•  (1)父类中被private修饰的成员，子类不能继承；
  

•  (2)父类和子类不在同一个包中，修饰符是默认的访问权限的属性和方法，不能被子类继承；
  

•  (3)父类的构造方法，子类不可以继承。
  

• 4、多重继承关系的初始化顺序

•  (1)、父类属性
  

•  (2)、父类的构造方法
  

•  (3)、子类属性
  

•  (4)、子类构造方法
  

• 5、继承是代码重用的一种方式

•  将子类中的公共的属性和方法放到父类中。
  

• 6、父类中的构造方法是不可以被子类重写的。

•  普通方法可以被子类重写。
  

• 7、方法重写（三同一不同） —》 方法重写不能发生在同一个类中

•  					--->  方法重载是发生同一个类中
  

•  (1)、方法名相同
  

•  (2)、返回值类型相同
  

•  (3)、参数列表相同
  

•  (4)、方法具体实现不同
  

•  (5)、访问权限不能比父类的严
  

• 8、方法重写发生在父子类之间，方法重载发生在一个类中。

继承的好处

• 1、方便代码的修改（因为有bug的话，只需要修改父类代码即可）
• 2、减少代码量（防止代码冗余）
• 所有的类的最大的基类（父类） Object
• 所有的类都是Object类的后代。
  如果想访问父类的构造方法，可以使用super()，
  但是该super()必须是子类构造方法的第一句代码。
  调用父类的有参构造，必须放在子类构造方法中的第一个位置
  Object是所有类的祖先类，其中的equals(),hashCode(),finalize()，toString(),clone()方法
• 可以被子类重写。
• 继承 具有单根性，传递性。
  抽象类 关键字 abstract
• 1、抽象类不能被实例化。（不能被new成对象）
  抽象方法
  • 1、抽象方法没有方法体；
  • 2、抽象方法必须在抽象类中,但是抽象类中的方法不一定都是抽象方法。
  • 3、抽象类中的抽象方法必须在子类中被重写，除非子类也是一个抽象类
    第十章 多态
    1、多态：
    同一种操作，由于条件的不同，产生的结果不一样。
    2、多态的实现有两种方式：
    (1)方法重写：同一个方法在不同类中重写 （三同一不同）
    ①方法名相同，返回值类型相同，参数列表相同
    ②方法的具体实现不同
    ③不能发生在同一个类。
    (2)方法重载：（一同三不同）
    ①方法名相同
    ②参数列表不同（参数类型不同，参数个数不同）
    ③方法重载发生在同一个类中
    ④方法重载和访问修饰符以及返回值类型没有关系。
    3、实现多态的三要素是
    (1)创建具有继承关系的父类和子类
    (2)子类需要重写父类的方法
    (3)使用父类的引用指向子类对象（由父类去new子类对象） （自动类型转换）
    4、同一个方法实现多态的两种形式（多态就是同一个类中的方法可以有多个不同的实现形式）
    (1)以父类类型作为参数
    (2)以父类类型作为方法的返回值
    5、 由子类得到父类 —》 自动类型转换
    由父类得到子类 —》 强制类型转换
    对象名 instanceof 类或接口 表示判断对象属于什么类型
    接口
    1、所有类的基类（祖先类）是object类，
    Object类中有五个方法可以被子类重写: clone()克隆对象、equals()等值判断、finalize()、hashCode()、toString()输出信息
    2、继承关键字 extends ，继承的特点: 1、单一性(一个类只能继承一个类)；2、传递性
    3、因为java是单继承的，那么在有些操作的处理上就存在局限性，我们可以通过继承一个类的同时，实现多个接口，来解决单继承的弊端。
    4、接口: 关键字-------》interface 实现关键字-----》implements
    a)接口中的所有方法都是抽象方法，被public abstract 修饰; （默认也是这个可写可不写）
    b)接口和抽象类一样都不能实例化
    c)实现类必须实现接口中的所有方法;
    d)实现类可以实现多个接口，多个接口之间用, 逗号分隔(我们可以理解为java的多继承)
    e)接口中的属性都是静态的常用（static和final共同修饰也是默认的）
    常量是不会改变的量，所以声明的同时必须赋值，并且常量名必须大写
    public final static(可以省略) String NAME =””;
    （6）因为接口中的属性都得是静态常量，所以final和static可以省略掉
    接口中的方法都是public abstract 修饰那么也可以省略掉其中一个或两个
    5、接口表示的是一种 能力 或者 约束
    a)接口的能力体现在方法上
    b)接口的约束体现在方法名和注释上面。
    c)面向接口编程:不需要关注实现类如何实现的功能，只需要关注接口的能力和约束即可。（也就是说只需要关注接口的能力和注释以及方法名即可）
    Java中接口和抽象类的区别?
    答：1、因为java是单继承的，那么在有些操作的处理上就存在局限性，我们可以通过继承一个类的同时，实现多个接口，来解决单继承的弊端。
    1、接口使用interface修饰，抽象类使用abstract修饰
    2、接口中的方法全部都是抽象方法，抽象类中的方法不一定都是抽象方法
    3、接口中的属性都是静态变量，抽象类中的属性可以是任意变量
    4、接口中的方法必须被实现类重写，抽象类中的方法不一定被子类重写

字符串
1、
字符a-z所对应的int值是: 97-122
字符A-Z所对应的int值是:65-90
数字0-9所对应的int值是:48-57
空格所对应的int值是: 32;
next()不会吸取字符前/后的空格/Tab键，只吸取字符，开始吸取字符（字符前后不算）直到遇到空格/Tab键/回车截止吸取；　nextLine()吸取字符前后的空格/Tab键，回车键截止。
创建字符串的方式
(1)//创建变量并赋值
String s = “Hello World”;
(2)//先实例化String对象，然后再赋值
String name = new String();
name = “张三”;
(3)//实例化String对象的同时并赋值
String address = new String(“北京市”);
2、获取字符串的长度
字符串对象.length()； 而获取数组长度 length属性。
3、两个String对象作比较：
(1)equals()
作用是用来比较两个字符串对象的 内容 （或者说是值）是否一致。
如果一致则返回true，如果不一致则返回false。
(2)==
作用是用来比较两个字符串对象的内存地址和值是否一致，主要用于比较内存地址是否一样。

使用：使用== 先比较两个字符串的值（内容）是否一致，如果一致，则判断内存地址是否一致。
如果值不一致，那么就不需要比较内存地址，直接返回false;
如果值一致，内存地址不一致，返回false;
如果值一致，内存地址一致，返回true;
注：如果两个字符串对象的值一致，只有一个对象是new String()的这种情况是内存地址不一致的。
4、一些比较的方法
equals()表示区分大小写比较两个字符串的内容是否一致
equalsIgnoreCase() 表示不区分大小写比较两个字符串的内容是否一致
toLowerCase() 将字符串转换为小写字符
toUpperCase() 将字符串转换为大写字符
5、字符串连接
1、使用 “+” 号连接
2、使用String类的concat()方法连接
A.concat(B).concat© 表示将B连接到A字符串的后面可以叠加
6、字符串的提取方法:
(1)、A.indexOf(B) 表示字符或者字符串在A字符串中首次出现的位置，存在返回所在位置，不存在返回-1
注意：字符串的下标是从0开始
(2)、A．lastIndexOf(B) 表示字符或者字符串在A字符串中最后一次出现的位置，存在返回所在位置，不存在返回-1
（3）截取字符串
字符串．subString(开始位置) 从开始位置一直截取到最后
字符串.subString(开始位置,结束位置) 从开始位置截取到结束位置-1
（4）字符串．trim() 去除字符串两边的空格
（5）A．contains(B) 表示判断字符串A中是否包含字符串B，返回true或false
（6）A．split(“分隔符”) 将一个字符串分割成子字符串，结果作为数组返回
7、StringBuffer
StringBuffer是String的增强版 它会带有一个缓冲区，对字符串进行频繁的修改，使用它会大大的提高执行效率
创建空对象 StringBuffer sb = new StringBuffer();
创建一个存储字符串222 StringBuffer sb = new StringBuffer(“222”);
Sb.toString() 将sb对象中的字符串转化为String类型
Sb.append() 追加字符串
8、Math类中的一些方法存储在java.lang包中
(1)、Math.abs(a) 求绝对值 -10的绝对值就是10
(2)、以下三种可以求近似值：
1.Math.ceil(b) （向上取整） 10.5555 = 11.0
2.Math.round(b) 四舍五入 10.123=10.0
3.Math.floor(b) 向下取整 10.564=10.0
（3）Math.random() 获取随机数 取值范围【0-1】之间 x>=0并且<1 可以取0不可以取1
基本数据类型int的封装类是__integer___类。

1、java的集合框提供了一套性能优良、使用方便的接口和类，存在java.util包中。
2、为什么学习集合？
因为集合有自动扩容的特点，不需要像数组一样手动扩容。
3、集合的分类：

4、 数组： 具有相同数据类型的一组数据
Collection接口存储 一组 不唯一且无序（插入顺序）的对象; （数据类型可以不同）
List接口存储一组 不唯一，有序（插入顺序）的对象。
Set接口存储一组 唯一，无序（插入顺序）的对象。
Map接口存储一组键值对对象，提供key到value的映射。（键值对一一对应）

List有三个实现类：
（1）ArrayList: 集合由数组构成，查询效率比较高，添加和删除慢,线程不安全。
默认初始化容量是10。当超出这个大小时，每次扩容1.5倍。
（2）LinkedList 集合采用 链表方式，插入、删除元素的效率比较高，查询慢。
双向链表。（hashmap是使用单向链表）
（3）Vetor 底层由数组构成，线程安全的集合。
Vector底层数据结构为数组，增删慢、查询快，线程安全，效率低，每次扩容为原来数组的2倍。
ArrayList底层数据结构为数组，增删慢、查询快，线程不安全，效率高，每次扩容为原来数组的1.5倍。
List接口中的常用方法：

LinkedList集合的特殊方法

1、基本数据类型和包装类的关系：
数据类型：
基本数据类型： byte int short long float double boolean char
引用数据类型： String、数组、集合、接口、自定义类

基本数据类型怎样变成引用数据类型？
答案 变不成
但是基本数据类型拥有包装类，包装类是引用数据类型
基本数据类型 包装类
byte ---- Byte
int ---- Integer
short ---- Short
long ---- Long
float ---- Float
double ---- Double
boolean ---- Boolean
char ---- Character
2、泛型集合 List Set Map<K,V>
要求泛型部分 T 必须是引用数据类型，那么基本数据类型必须使用包装类进行泛型限制。
泛型是用来限制添加的集合信息是否符合规定的，泛型在编译阶段有效，如果编译的时候发现添加的数据不符合规定，则直接报错。
创建泛型集合 泛型表示一种参数类型，也就是说该stulist集合只能添加 Student类数据
List stuList = new ArrayList();
使用泛型之后不需要强制类型转换
创建一个只能添加整数类型的泛型集合
List numsList = new ArrayList();
3、Map集合
简介：map集合是键值对集合，一个键对应一个值，并且键是唯一的，值是可以重复的，
并且键和值之间一一对应。

Map集合的 键 的底层是Set集合写的，因为Set集合是唯一但是无序的，所以Map集合的键时唯一的，并且map集合是无序的。这就意味着map集合不是通过下标去获取集合中的元素的。 (map集合底层是用红黑树写的。)
而是通过 键名 去获取该 键 所对应的值的。
Map集合中的方法：
(1) 集合名称.put(键,值) 添加信息
(2) 集合名称.get(键名) 根据键名获取所对应的值
(3)集合名称.keySet() 获取所有键的集合
(4)集合名称.values() 获取所有值的集合
(5)集合名称.remove(键名) 根据键名删除指定的值
4、增强for循环遍历map集合 （掌握）
for(集合中每一个元素的数据类型 每一个元素的变量名: 要遍历的集合名称){

}
5、迭代器获取方法 （了解）
Iterator it =集合名称.iterator();
it.hasNext() 判断迭代中还有没有下一个要访问的元素
It.next() 迭代下一个元素
对象比较器 (compareTo())
在实体类先实现Comparable泛型接口
然后重写compareTo()方法
collections.sort(集合名称);
1.HashMap和HashTable的区别？
答：1、线程安全
Hashtable 是线程安全的，HashMap 不是线程安全的。
为什么说 HashTable 是线程安全的？
来看下 Hashtable 的源码，Hashtable 所有的元素操作都是 synchronized 修饰的，而 HashMap 并没有。
2、性能优劣
既然 Hashtable 是线程安全的，每个方法都要阻塞其他线程，所以 Hashtable 性能较差，HashMap 性能较好，使用更广。
如果要线程安全又要保证性能，建议使用 JUC 包下的 ConcurrentHashMap。
3、NULL
Hashtable 是不允许键或值为 null 的，HashMap 的键值则都可以为 null。
可以看出 Hashtable key 为 null 会直接抛出空指针异常，value 为 null 手动抛出空指针异常，而 HashMap 的逻辑对 null 作了特殊处理。
可以看出两者继承的类不一样，Hashtable 继承了 Dictionary类，而 HashMap 继承的是 AbstractMap 类。
Dictionary 是 JDK 1.0 添加的，貌似没人用过这个。
5、容量扩容
HashMap 的初始容量为：16，Hashtable 初始容量为：11，两者的负载因子默认都是：0.75。
当现有容量大于总容量 * 负载因子时，HashMap 扩容规则为当前容量翻倍，Hashtable 扩容规则为当前容量翻倍 + 1。
6、迭代器
HashMap 中的 Iterator 迭代器是 fail-fast 的，而 Hashtable 的 Enumerator 不是 fail-fast 的。
所以，当其他线程改变了HashMap 的结构，如：增加、删除元素，将会抛出 ConcurrentModificationException 异常，而 Hashtable 则不会。
这条同样也是 Enumeration 和 Iterator 的区别。
快速失败的原理是线程安全问题，如果一个线程遍历，一个线程删除就可能会出现这种异常。其中有个计数器，因为遍历和删除线程都会使计数器加一，而其数值是固定的。源码中进行判断如果不相等，抛出异常。