javaSE相关知识点总结

1.软件

1. 软件系统：Windows，linux，mac，unix，dos
2. $应用软件$
   1. $B/S架构软件：通过浏览器访问应用软件。$eg：淘宝，京东
      • 优点：使用方便，无须安装客户端；升级方便，服务端升级只要刷新浏览器；数据安全（存于浏览器中）
      • 缺点：界面粗糙（太过精美会对服务器造成很大压力）；服务器压力大
   2. $C/S架构软件：通过客户端访问软件。$eg：office，大型网游
      • 优点：界面精美；服务器压力小
      • 缺点：必须安装客户端；服务器升级，客户端也要升级；不安全（数据保存到客户端）
3. $程序：为了模拟虚拟世界，解决现实问题而编写的一系列有序指令集合$

2.java概述

1. Java的发展史：95年由sun公司的詹姆斯~高斯林发明，09年由甲骨文（oracle）公司收购
2. Java是一种跨平台，面向对象的，强类型的，编译解释型的高级语言

2.1 Java优点：

1. 简单（垃圾自动回收机制（GC），自动类型检查机制）
2. 跨平台（可以再Linux，mac，window等系统运行）
3. 面向对象（贴合人类思维模式）
4. 安全性高（由强大的类型检查机制）

2.2 语言执行机制

1. 解释执行机制：将源文件交给不同平台独有的解释器解释执行 eg：python，javascript

   特点：可以垮平台，执行效率低

2. 编译解释执行机制：将源文件编译为平台中间文件（.class或者字节码文件），然后将中间文件交给不同平台的jvm解释执行 eg：java

$2.3Java三大体系$

1. JavaSE：Java标准版，Java核心语法，用作面向桌面应用程序
2. JavaEE：Java企业平台，Java企业级开发，用作internet应用程序开发
3. JavaME：Java平台微型版，嵌入式或移动手机端开发，用来做机顶盒或手机移动开发

$2.4Java五大应用$

1. 面向桌面程序应用
2. 面向internet应用程序
3. 用来做机顶盒或手机移动开发
4. 为大型企业提供解决方案
5. 为学习大数据做基础

3.Java环境搭建

3.1 安装jdk步骤：

1. 创建一个存放jdk的文件夹（bin存放Java命令；jre存放运行环境；lib存放jar包；src.zip存放Java源码）
2. 安装jre
3. 进入dos命令检测是否安装成功
4. 配置环境变量JAVA_HOME=jdk安装路径 path：%JAVA_HOM%\bin
5. 再次进入dos输入Javac检查环境是否配置成功，输入Java检查是否安装成功，输入Java -version查看jdk版本信息

3.2 DOS常用命令

1. 切换盘符：盘符：
2. 切换盘符当前的目录：cd 文件夹路径名
3. 返回上一级：cd…
4. 返回根目录：cd \
5. 查看目录：dir 目录名
6. 创建目录：md 目录名
7. 创建空文件：type nul>文件名
8. 文件中加入内容：echo 内容>文件名
9. 删除空目录的命令:rd 目录
10. 删除文件:del 路径名+文件名
11. 复制: copy 源文件路径 目标路径（注意:只能复制文件,不能复制文件夹）
12. 清屏:cls
13. 退出dos系统: exit;

3.3 DOS运行Java的第一个程序步骤

1. 步骤一：再一个txt文件中编写代码，类名要和文件名相同
2. 步骤二：在dos中进入到该文件的路径下运行 javac 文件名.java
3. 步骤三：如果编译通过在dos中 运行 Java 文件名

$4.Java的八大规范$

1. Java严格区分大小写
2. Java只认识英文
3. 代码要有层次
4. 一行只写一条语句并以“；”结尾
5. 用public修饰的类框架只能有一个，并且类框架名要和源文件名相同；没由用public修饰的类框架不能和源文件同名；一个Java程序可以由多个类框架，在编译后会生成多个字节码文件（.class），但是只能有一个类框架能用public修饰
6. 一个类框架只能有一个mian方法
7. 一个类框架只能生成一个字节码文件（.class）
8. 每个结构的大括号,开始的大括号在这一结构结尾,结束的大括号独占一行且与这一结构开头字母对齐.

5.包

1. 声明包的语法:package 包名;
2. 声明位置:在类框架上面.
3. $包名的命名规则：域名.公司名/组织名.项目名.结构名$
4. $带包编译的命令：javac-d.java源文件名.java$

$6.Java的运行原理$

1. Java程序是在内存中运行的

2. jdk的组成：编译器+jvm+jre等

3. jvm的作用：跨平台（不同平台有不同的jvm），垃圾回收机制

   

4. 计算机单位:

   ​ 8bit=1byte
   ​ 1024byte=1KB
   ​ 1024KB=1MB
   ​ 1024MB=1GB
   ​ 1024GB=1TB
   ​ 1024TB=1PB

5. 注释

   • 单行注释//

   • 多行注释/**/

   • $文档注释/\ast \ast \ast /$

     注意：生成javadoc文档命令：javac -d . java源文件名.java

     eg：文档注释

     /**
     *该类的作用
     *@author 作者
     *@versions date 版本号 时间
     *@since 技术点
     */
     

$7.标识符$

1. 标识符由数字，字母，下划线，美元符号组成
2. 标识符只能由字母，下划线，美元符开头
3. 标识符可以包含数字，但是不能以数字开头
4. 标识符除了以下划线，美元符以外，不能有其他任何特殊符号
5. 标识符要见名思义
6. 标识符不能是Java的关键字
   • 帕斯卡命名法：每个单词的首字母大写，其他字母小写 eg:HelloWo（方法名，）
   • 驼峰式命名法：第一个单词首字母小写，其他字母首字母大写 eg:helloWorld（变量名，）

8.java基本语法

$8.1变量$

1. 变量的组成：数据类型+变量名+值

2. 变量名采用驼峰式命名

3. 变量必须先声明在赋值

   变量声明和赋值的三种方法

   • 先声明变量再赋值
   • 声明和赋值一起
   • 声明多个相同数据类型的变量，并可以赋值

4. 变量分类：

   • 基本数据类型变量
   • 引用数据类型变量

5. 按变量声明位置分

   • 局部变量：在类里，在方法体外面
   • 成员变量：在方法体中

6. 常量语法：final 数据类型 常量名 = 赋值

$8.2种常用数据类型$

1. 整数数据类型：
   • byte(1个字节；8位；-2的8次方~2的8次方-1)
   • short(2个字节；16位；-2的15次方~2的16次方-1)
   • int(4个字节；32位；-2的32次方~2的32次方-1)
   • long(8个字节；64位；-2的64次方~2的64次方-1)
   • float（4个字节；32位；-2的32次方~2的32次方-1）
   • double（8个字节；64位；-2的64次方~2的64次方-1）
   • char:存单个字符(值要用单引号引起来,2个字节)
   • 布尔类型:boolean(值为true/false)
2. 引用数据类型：String,数组,类,接口

8.3 数据类型转化

兼容：数据类型相同或者范围包含关系

1. 自动类型转换（小->大）: 语法:大数据类型 变量名=小类型的变量

   两种类型要兼容.

   目标类型大于原类型

2. 强制类型转换（大->小）: 语法:小数据类型 变量名=(小数据类型)大类型的变量;

   注意:强制类型转换有风险.会损失精度.

3. 算术式子中有一个为大类型,整个式子结果提升为大类型.（int+double最终结果位double）

   double result1=11+3.14;
   

8.4 运算符:

1. -,*:与数学中用法一样.

2. +:在java中有两种用途

   • 第一种加法运算作用:+左右两边是数字,起加法运算作用
   • 第二种连接作用:+左右两边有一边为String类型,起连接作用.

3. /:在java中,/起除法运算作用.注意:在java中 int=int/int(整数除以整数一定为整数)

   int num1=10;
   int num2=3;
   int result2=num1/num2;       //3
   

4. %(求余/取模运算符):取两个数的余数作为结果.

   int result5=4%3;
   System.out.println(result5); //1
   

5. ++:在自身变量的值上加1

   • ++变量:变量先自身加1,再作其他处理
   • 变量++:变量先作其他处理,再自身加1

   –:在自身变量的值上减1

   • –变量:变量先自身减1,再作其他处理
   • 变量–:变量先作其他处理,再自身减1

   int num1=8;
   int result1=(++num1)+(num1++)+(num1--)*(--num1)
   				9		9		10		  8
   

6. 逻辑运算符:且(&,&&),或(|,||),非(!) $(一般用短路且和短路非，因为它们更加减少资源的使用)$

   1. 且:且左右两边的式子都为true,结果才为true;有一边为false,结果为false.
      • &(普通且):&左右两边的式子无论如何都会计算的.
      • &&(短路且):&&左边的式子如果为false,右边式子不计算;&&左边的式子如果为true,才会计算右边的式子.
   2. 或:或左右两边的式子都为false,结果才为false;有一边为true,结果为true.
      • |(普通或):|左右两边的式子无论如何都会计算的.
      • ||(短路或):||左边的式子为true,右边式子不计算;||左边的式子为false,才会计算右边的式子.

7. $运算符优先级:()>算术运算符>关系运算符>逻辑运算符>赋值运算符$

8. 三目运算符(三元运算符): 条件?结果1:结果2;

9. $表达式:由操作数+运算符$

   • 算术表达式:操作数+算术运算符组成,叫算术表达式,结果是数值类型.
   • 关系表达式:操作数+关系运算符+其他运算符,叫关系表达式,结果是boolean.

8.5 选择结构

1. $Java中的三大结构$

   • 顺序结构
   • 选择结构
   • 循环结构

2. $基本if选择结构:解决只有一种情况的问题.$

   • 语法:if(条件){
     代码块;
     }

3. $if-else结构:解决有两种情况,且无论如何要执行其中一种的.$

   • 语法:if(条件){
     代码块1;
     }else{
     代码块2;
     }

4. $多重if选择结构:解决有两种及以上情况的问题.$

   • 语法:if(条件1){
     代码块1;
     }else if(条件2){
     代码块2;
     }else if(条件3){
     代码块3;
     }else{
     代码块4;
     }

   $结构特点：$

   • 在多重if结构中,if块有且仅有一个,else if块可以有1到多个,else块有0个到1个
   • 在多重if结构中,最多执行1个大括号中代码块,最少一个大括号都不执行.
   • 用多重if结构解决范围(区间)判断问题时,它的分支之间不一定可以互换位置.用多重if结构解决等值判断问题时,它的分支之间可以互换位置,不影响结果.

5. $嵌套选择结构:在一个选择结构的大括号中完整包含另一个选择结构.$

   • 选择结构之间可以任意嵌套,嵌套要正确.
   • 选择结构间可以嵌套多层,当前阶段一般嵌套两到三层.

6. break:只能在switch中使用，作用是跳出当前结构

   $break跳出标记循环结构：$

   语法：标记名：结构

   ​ break 标记名；

   a:for(int i=1;i<8;i++){
   	for(int i=1;i<8;i++){
   		for(int i=1;i<8;i++){
   			break a;//跳出第一个循环
   		}
   	}
   }
   

9.方法

9.1 方法的声明：

1. 方法的作用：简化代码实现代码的复用性

9.2 方法的类型：

1. $语法：$

    访问修饰符  [static/fianl/abstract]  方法的返回类型  方法名(参数列表){
    			代码块；
    			[return  结果；]
    }
   

   • 访问修饰符：表示使用权限，有pubilc,protect,defulat,private
   • 方法的返回类型：执行完功能返回的结果类型，不想返回就用void
   • 方法名：采用驼峰式命名法
   • 参数列表：执行功能所需的数据，在方法中当作已知变量

2. $四种类型$

   • 无参无返回值

     public static void method(){
     	  代码块;
     }
     

   • 无参有返回值

     public static void method(数据类型 变量名){
     	代码块;
     }
     

   • 有参无返回值

      public static void  method(){
      	代码块;
      }
     

   • 有参有返回值

     public static int method(数据类型  变量名){
         代码块;
     }
     

9.3 方法的调用：

1. 无参:在main方法中直接 方法名(); 调用
2. 有参：在main方法中 方法名(参数); 调用，可以赋值个其他变量接收 int a = 方法名();
3. $形参：在方法声明中小括号的参数，形参前面一定要加数据类型$
4. $实参：方法调用时小括号的参数，实参和形参的个数，类型，顺序一定要相匹配$
5. $传参：将实参的值传给形参$

10.方法重载和递归

$10.1方法重载的三个条件:$

1. 在同一个类中
2. 方法名相同
3. 参数列表不同

public class OverrideTest1 {
	public static void main(String[] args) {
        //调用方法
        double result1=add(11,23);
        
    }
    //方法重载一
    public static double add(double num1,double num2) {
        return num1+num2;
    }
    //方法重载二
    public static double add(double num1,double num2,double num3) {
        return num1+num2+num3;
    }

}

10.2 方法重载的作用:

​ 解决同一个类中功能相同的方法命名和调用问题.

10.3使用递归和条件:

1. 将原问题拆分为若干个子问题,子问题的解决方法与原问题一样.
2. 原问题的解决依赖于所有子问题解决.
3. 递归一定要有出口.

public class DiguiTest1 {
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        int num=input.nextInt();
        int result=digui(num);
    }
    public static int digui(int n) {//n=1
    	if (n==1) {
            return 1;
		} else {
            return n*digui(n-1);
            //5*digui(4)
			//5*4*digui(3);
            //5*4*3*digui(2);
			//5*4*3*2*digui(1)
            //5*4*3*2*1
    }

}

11.数组

$11.1数组的定义和特点$

1. 数组是一种引用数据类型的变量.
2. 数组的组成:数组名,数组数据类型,元素(每个空间的值),索引(下标).
3. 数组的长度:数组名.length
4. 数组的索引范围:[0,数组名.length-1]
5. 数组的每个空间的访问:数组名[索引]
6. 同一个数组,每个元素的数据类型相同;不同的数组数据类型可以不同.
7. 数组一但分配了空间,它的长度是固定.
8. 数组一但分配了空间就有默认值:
   • String类型数组,每个空间默认值为null
   • char类型数组,每个空间默认值为\u0000(空格)
   • int类型数组,每个空间默认值为0
   • double类型数组,每个空间默认值为0.0
   • boolean类型数组,每个空间默认值为false
9. 数组一但分配了空间,就可以使用.
10. 数组直接输出,输出的是内存地址.

$11.2数组的四种使用:$

1. 数据类型[] 数组名=new 数据类型[长度];(推荐)

int[]  array = new int[10];

1. 数据类型 数组名[]=new 数据类型[长度];

int array[] = new int[10];

1. 数据类型[] 数组名=new 数据类型[]{值1,值2…};

int[] array = new int[]{1,2,4};

1. 数据类型[] 数组名= {值1,值2…};

int[] array = {1,2,4};

11.2 遍历数组:

1. 用for循环遍历数组:

for (int i = 0; i <stuNames2.length; i++) {
		System.out.println(stuNames2[i]);
}

​ 2.增强版的for(foreach)循环:用来遍历数组/集合:

for(String s:stuNames2) {
	System.out.println(s);
}

$11.3数组的扩容$

1. 创建大于原数组长度的新数组,将原数组中元素一一复制到新数组.

//准备一个原数组
int[] nums= {5,8,1,7,6,3};
//创建大于原数组长度的新数组,将原数组中元素一一复制到新数组.
int[] newNums1=new int[nums.length*2];
//将原数组中元素一一复制到新数组
for (int i = 0; i < nums.length; i++) {
	newNums1[i]=nums[i];
}

​ 2. System.arraycopy(源数组,源数组起始位置,新数组,新数组的起始位置,复制的元素的个数)

int[] newNums2=new int[nums.length*2];
System.arraycopy(nums, 0, newNums2, 0, nums.length);

​ 3. Arrays.copyOf(源数组, 要返回的复制的长度);

//Arrays.copyOf(源数组, 要返回的复制的长度);
int[] newNums3=Arrays.copyOf(nums, nums.length*2);
//遍历新数组
for (int i : newNums3) {
	System.out.println(i);
}

$11.4动态参数$

1. 动态参数的实参可以传0个到多个
2. 动态参数在方法中当作数组使用
3. 动态参数可以传递一个数组，只要数组的数据类型和动态参数的类型兼容
4. 因为动态参数必须放在最后一个，所以应该方法最多只能有一个动态参数
5. 动态参数可以和普通参数一起作为方法的形参，但是动态参数必须放在最后

public class DynamicParameterTest1 {
    public static void main(String[] args) {
        int out = add("张三",12,34,13);
        System.out.println("out"+out);//70
    }
    //name作为普通参数，nums作为动态参数
    public static void add(String name,int nums){
        System.out.println(name+"正在计算中...");
        //声明一个变量存总和
        int sum = 0;
        //遍历每个参数值,实现累加
		//在方法中,可以将动态参数当作已知数组来用
        for(int i=1;i<nums.length;i++){
            sum = sum + nums[i];
        }
        return sum;//70
    }
}

10.5排序

1. 求最大值

	public static void main(String[] args) {
		//准备一个数组
		int[] nums= {5,8,1,7,6,3};
		
		//声明一个变量存最大值,默认等于数组中第一个数
		int max=nums[0];
		//声明一个变量存最小值,默认等于数组中第一个数
		int min=nums[0];
		
		//遍历数组,一一比较
		for (int i = 0; i < nums.length; i++) {
			if (max<nums[i]) {
				max=nums[i];
			}
			
			if (min>nums[i]) {
				min=nums[i];
			}
		}
		System.out.println("最大值为:"+max);
		System.out.println("最小值为:"+min);
	}

2. $冒泡排序：$

//定义一个数组
int[] array = {4,6,2,1,8};
//第一个for循环遍历轮数
for(int i = 0;i<array.length-1;i++){
    //第二个循环遍历比较次数
    for(int j = 0;j<array.lenght-i-1){
        //判断前面一个数是否大于后面的数，并交换位置
        if(nums[j]<nums[j+1]) {
			int temp=nums[j];
			nums[j]=nums[j+1];
			nums[j+1]=temp;
		}
    }
    //遍历输出新的数组
    for(int x : array){
        System.out.print(i+"\t");
    }
}

3.插入排序

public static void main(String[] args) {
	//准备一个数组
	int[] nums= {5,8,1,7,6,3};
    //外层循环控制比较轮数
	for (int i = 0; i < nums.length-1; i++) {
    	//内层循环控制比较每个数索引(次数)
		for (int j = i+1; j < nums.length; j++) {
			if (nums[i]>nums[j]) {
					int temp=nums[i];
					nums[i]=nums[j];
					nums[j]=temp;
				}
            }
		}
    //输出排序后的结果
		for (int i : nums) {
			System.out.print(i+"\t");
		}
	}
}

10.6 Arrays:数组的工具类

1. 将数组转换为字符串:Arrays.toString(数组名);
2. 对数组进行排序(默认升序):Arrays.sort(数组名);
3. 对已经排安序的数组用二分查找法查找指定元素:Arrays.binarySearch(数组名, 要查找的元素);
4. 将原数组中指定长度复制到新数组中:Arrays.copyOf(原数组, 长度)

10.7 二维数组

1. 语法：

   • 数据类型[][] 数组名=new 数据类型[][]{{值11,值12…}

     int aa = new int{{1,2,4},{4,6,7},{3,6,3}}
     

   • 数据类型[][] 数组名={{值11,值12…},{值21,值22}…};

     int bb = {{1,2,4},{46,746,84},{4,56,46,4},{4,647,4}}
     

   • 数据类型[][] stuNames1=new String[3][】；

     ​ 单独给二维数组每个空间的一维数组分配空间

     ​ stuNames1[0] = new String[3];

     ​ stuNames1[1] = new String[6];

     ​ stuNames1[2] = new String[9];

     int aa = new int[3][];
     aa[0] = new int[4];//给二维数组的第一个一维数组赋长度为4
     aa[1] = new int[8];//给二维数组的第二个一维数组赋长度为8
     aa[2] = new int[5];//给二维数组的第三个一维数组赋长度为5
     

12.文档注释

1. 解释说明作用:说明这个类,这个方法,这个变量的作用：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(

2.eclipse生成javadoc文档步骤:

选中项目->鼠标右键->export->java/javadoc->选中要生成文档注释的项目，同时在destination后面选择文档生成的目的地->下一步->下一步在vm option选择下写字符编码(-encoding UTF-8 -charset UTF-8)->-下一步>finish

13. 面向对象

13.1.$对象：$

1. 面向过程：将一件事情分为若干分，自己亲力亲为的按照顺序一步步做，用来解决简单的问题

2. 面向对象：将做一件事的所有参与者找出来，调用参与者将事情协调配合完成，用来解决复杂的问题。

   eg: 面向过程：自己洗衣服得先倒洗衣粉，加水，揉搓，拧干。

   面向对象：直接把衣服放入到洗衣机中，洗衣机把加水，揉搓，拧干这些步骤帮你做了

3. $对象$：用来描述客观事务的实体叫对象（可以用具体数据描述的事务）

   类：具有一组相同属性和方法的对象集合

   属性：对象的静态特征（比如人的肤色）

   方法：对象是动态特征（比如人跑的动作）

   类是对象的模板（如果对象是钱，类就是印板）；类是对象的抽象；；类是对象的数据类型（）

   对象是类的典型代表；对象是类的具体变量名

13.2. 类

1. ​ 声明类的语法：

   访问修饰符	class	类名{
   	访问修饰符	数据类型	变量名；//成员变量
   }
   
   

2. 声明类的关键字：class

3. 声明类的关键字只能是public和默认（defulat），不能用其他修饰符

4. 类名采用帕斯卡命名法，变量名和方法用驼峰

5. 一个类可以有0到多个变量和方法

6. 在声明类时，我们只研究问题相关的属性和方法

13.3. 创建对象

注意：类中的成员变量和方法都属于对象，每个对象的属性和方法都独有一份，互不相干

1. 创建对象的语法：

   类名	对象名 = new	类名();
   

2. $对于创建对象的三种理解：$

   • 由类生成对象（因为对象相对于钱，类相对于钱印版）
   • 类是一种引用数据类型，对象是变量名
   • 调用构造方法创建对应的对象

3. 属性的调用

   • 在同一个类中：属性名直接调用
   • 在不同类中：对象名.属性名

4. 方法的调用

   • 在同一个类：方法名（形参）
   • 在不同类：对象名.方法名（形参）

13.4 $成员变量和局部变量的区别：$

1. 声明位置不同
   • 成员变量在类中方法外面声明的变量叫成员变量;
   • 局部变量在方法中声明的变量叫局部变量;
2. 内存分配不同
   • 成员变量存在内存的堆中;
   • 局部变量存在内存的栈中.
3. 作用范围不同
   • 成员变量的作用范围由访问修饰符决定;
   • 局部变量的作用范围仅在声明它的大括号中有用.
4. 生命周期不同
   • 成员变量的生命周期与对象同生共死(成员变量属于对象).
   • 局部变量的生命周期仅在声明时产生,在声明的大括号执行完就销毁.
5. 初始值不同
   • 成员变量不赋值,系统会给成员变量赋默认值,
   • 局部变量的初始值和定义他的数据类型有关
6. 访问修饰符不同
   • 成员变量一定会有访问修饰符;
   • 局部不能用访问修饰符.
7. 优先级不同
   • 当成员变量和局部变量同名时,局部变量的优先级更高.

13.5 $构造方法的五大特点$

声明的语法:访问修饰符 方法名(数据类型1 参数1,数据类型2 参数2…){}

1. 构造方法没有方法的返回值，连void都没有，方法名和类名相同

2. 构造方法在创建对象的时候调用

3. 一个Java类无论如何都有构造方法，如果我们没有给Java类声明构造方法，系统会默认分配一个没有返回值的构造方法，如果我们自己写了一个构造方法，系统就不会分配了，会使用自己写的构造方法

4. 作用：创建对象;创建对象同时给对象的属性赋值.

5. 场景：如果只是想创建对象,用系统默认分配构造方法就可以了,不用自己给类写构造方法;

   ​ 如果想在创建对象的同时给对象的属性赋值,就需要自己给类写构造方法,一般情况下给类写构造方法时,习惯性写一个无参构造方法,使你创建对象的灵活性更高

13.6 this关键字

1. 调用当前类的属性:this.属性名,注意此时this可以省略
2. 当方法形参赋值给当前对象属性时,且形参名与属性名相同时,属性名一定要用this调用,此时this不可以省略
3. 调用当前类的方法:this.方法名([实参列表]),此时this可以省略.
4. 调用当前类的构造方法:this([实参列表]),在构造方法中用this([实参列表])调用其他构造方法是地,this([实参列表])必须写在方法体的第一句.

14. 封装和继承

14.1 封装

​ 定义：隐藏事务的内部细节，提供对外的访问方法。作用：实现代码复用；保护数据安全

1. ​ 对功能封装：将功能封装成一个方法，实现代码的复用
2. 对属性的封装：私有化属性，给属性提供公有获得属性设值属性的get和set方法供外界使用

14.2 $继承$

1. 作用：简化代码实现代码的复用
2. 子类可以继承父类用public或protected的方法和属性，子类不可以继承父类构造方法,不能继承父类私有的属性和方法.
3. 创建子类对象时,我们在子类中没有写代码调用父类构造,系统默认先调用父类的无参构造,再调用子类指定构造方法;如果写代码调用父类指定构造,系统不会默认调用,按照我们写的调用父类指定构造,再调用子类指定构造.
4. 单继承的特性：
   • 单根性:一个Java类只能有一个直接父类.
   • 传递性:A类继承B类,B类继承C类,那么A类间接继承C类.

14.3 访问修饰符

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-D12AM6ow-1625406333083)(K:\Typora\Study\image\访问修饰符.png)]

14.4$方法的重写$

1. 适用场景：当子类继承父类的方法后，这个方法无法满足子类的需求，这时就须要方法的重写

2. 方法重写的条件：

   • 发生在父子类继承关系中
   • 重写的方法和被重写的方法名和参数列表要一致
   • 重写的方法和被重写的方法的返回值类型要相同或者兼容
   • 重写的方法的访问修饰符和被重写的访问修饰符要相同或者范围更大
   • 在重写的上面加@Override系统会自动判断当前方法是否为父类的重新方法

3. $方法重写和重载的区别：$

   • 作用不同：重写是为了满足子类继承父类，但是父类的方法满足不了子类的需求时使用

     ​ 重载是为了解决在同一个类中功能相同的方法命名和调用问题

   • 条件不同：重写是发生在父子类关系中，并且重写的方法要和父类方法的名字和参数相同，返回值类型相同，子类的访问修饰符 权限要大于父类。

     ​ 重载是发生在同一个类中，方法名相同，参数列表不同，与访问修饰符和返回值类型无关

   • 检查不同：方法重写可以用@Override系统自动判断，重载只能自己判断

4. $this和super的区别：$

   • 作用范围不同：this指当前类对象的引用，在当前类中可以使用

     ​ super指代父类的对象的引用，在所有子类中可以使用

   • 使用不同：this在方法形参与属性名相同时使用

     ​ super都不可以使用

   • 用this或者super调用构造方法时，都必须写在首行

15.多态

15.1$多态的三种用法：$

1. ​ $用父类或父接口作为数据类型，创建不同的子类对象，调用同一个方法，执行不同的操作$

   //定义一个父类
   class Animal{
       public void eat(){
           System.out.println("动物吃东西")
       }
   }
   //定义一个子类猫
   class Cat extends Animal{
       //重写父类吃的方法
       @Override
        public void eat(){
           System.out.println("猫吃鱼")
       }
   }
   //定义一个子类狗
   class Dog extends Animal{
       //重写父类吃的方法
       @Override
        public void eat(){
           System.out.println("狗吃骨头")
       }
   }
   //定义一个测试类
   class Test{
       //将Animal作为数据类型
       Animal a1 = new Cat();
       Animal a2 = new Dog();
       //调用同一个方法吃
       a1.eat();//猫吃鱼
       a2.eat();//狗吃骨头
   }
   

2. $多态的第二种应用:用父类或父接口作为方法形参,实参传不同子类对象,调用同一种方法,执行不同操作$

   //定义一个父类
   class Animal{
       public void eat(){
           System.out.println("动物吃东西")
       }
   }
   //定义一个子类猫
   class Cat extends Animal{
       //重写父类吃的方法
       @Override
        public void eat(){
           System.out.println("猫吃鱼")
       }
   }
   //定义一个子类狗
   class Dog extends Animal{
       //重写父类吃的方法
       @Override
        public void eat(){
           System.out.println("狗吃骨头")
       }
   }
   //定义一个主人类，来获得猫狗
   class Master{
       public void feed(Anmial a){//主人类写一个喂养的方法，将父类作为形参传入
           a.eat();//调用父类吃的方法
   }
   //定义一个测试类
   class Test{
       //创建主人类对象
      	Master m1 = new Master();
       //将子类实列化并作为实参写入
       m1.feed(new Cat());//调用猫类吃的方法输出：猫吃鱼
       m1.feed(new Dog());//调用狗类吃的方法输出：狗从骨头
   }
   

3. $多态的第三种应用:用父类作为方法返回值类型,实际返回任意一个子类对象,调用同一种方法,执行不同操作$

   //定义一个父类
   class Animal{
       public void eat(){
           System.out.println("动物吃东西")
       }
   }
   //定义一个子类猫
   class Cat extends Animal{
       //重写父类吃的方法
       @Override
        public void eat(){
           System.out.println("猫吃鱼")
       }
   }
   //定义一个子类狗
   class Dog extends Animal{
       //重写父类吃的方法
       @Override
        public void eat(){
           System.out.println("狗吃骨头")
       }
   }
   //定义一个主人类
   class Master{
       //主人获得宠物,查看一下的方法
       public Anmial look(String s){//获取用户输入的值
         	Anmial m = null;
   		if (s.equals("猫")) {//判断输入的值是否为猫
   			m = new Cat();//
   		}else if (s.equals("狗")) {
   			m = new Dog();
   		}
   		return m;
   	}
   }
   //定义一个测试类
   class Test{
       //创建主人类对象
      	Master m1 = new Master();
       //用对象调用方法
       Anmail a1 = m1.look("猫"); 
       a1.eat();//调用猫类吃的方法输出：猫吃鱼
       Anmail a2 = m1.look("狗");
       a2.eat();//调用狗类吃的方法输出：狗从骨头
   }
   

15.2 多态的作用：实现代码的可扩展性

15.3$拆箱和装箱$

1. ​ 向上转型（装箱）：将子类对象存在父类或父接口的类型中，叫向上转型，向上转型是自动转化

   • 适用场景：多态
   • 语法：父类型/符父接口 对象名 = 子类对象

2. 向下转型（拆箱）：将父类型的对象转换为原本的子类对象,叫向下转型.向下转型有风险的.

   • 适用场景:当用父类作为数据类型创建子类对象,想调用子类独有的方法或属性时,就可以使用向下转型.

   • 语法:子类型 对象名=(子类型)父类型对象;

     注意：因为向下转型有风险,是将父类型的对象转换为原来子类对象,如果我们不是很清楚这个父类型的对象原本是什么类型,不方便转换,这时就需要用到类型判断

     语法：boolean result=对象名 instanceof 子类类型;

     //Animal作为父类；Rabbit,Tiger作为子类
     //创建对象,向上转型
     Animal a1 = new Rabbit();
     Animal a2 = new Tiger();
     //用父类作为数据类型创建的对象,只能调出从父类继承的属性和方法或重写的方法,不能调出子类独有属性和方法
     a1.eat();
     a2.eat();
     //因为向下转换,是将父类型的对象转换为原来子类对象,如果我们不是很清楚这个父类型的对象原本是什么类型,所以要先判断
     if(a1 istanceof Rabbit){//判断如果a1是否的对象Rabbit
         Rabbit r1 = (Rabbit)a1;
         r1.jump();//调用子类独有的方法
     }else if(a1 istanceof Tiger){
         Tiger t1 =(Tiger)a1;
         a1.cilbmTree();//调用子类独有的方法
     }
     

15.4 随机数

语法：int result=(int)(Math.random()*(max-min+1)+min);

//随机生成[0,1)范围的数
double nums = Math.random();
//随机生成[10,99]的数
int nuns = (int)(Math.radom()*(99-10)+1)

16.abstract,fianl,stiact

abstract

1. abstract:扩展修饰符,抽象的.可以修饰类和方法.

   • 抽象类:用abstract修饰的类叫抽象类
     1. 抽象类的应用场景:当一个类创建对象没有任何意义,这个类就可以声明为抽象类;当一个类中的方法无法确定具体实现时,这个方法就可定为抽象方法,那么类必须为抽象类.
     2. 抽象类的特征:
        • 抽象类不能实例化(不能创建对象),但是抽象类有构造方法,其作用供子类调用.
        • 抽象类中可以有0到多个抽象方法,也可以有0到多个普通方法.
        • 抽象类也可以作为数据类型,指向子类对象.
     3. 抽象类的作用:
        • 让子类继承,从而实现代码复用;规定子类必须拥有的行为.
   • 抽象方法:用abstract修饰的方法叫抽象方法.
     1. 抽象方法应用场景:
        • 当一个方法无法确定方法具体实现,这个方法声明为抽象方法.
     2. 抽象方法的特征:
        • 抽象方法没有方法体,连大括号都没有.
        • 抽象方法必须写在抽象类中.
        • 抽象方法必须被子类重写,除非子类也是抽象的,就让孙子类去重写.
        • 抽象方法不能用private修饰.
     3. 抽象方法的作用:
        • 规定子类必须拥有的行为.

   static

   1. static:修饰属性.
      • 静态变量的特征:静态变量属于类,与类共存亡.当前类的所有对象共享这个类的静态变量
      • 静态变量的优点:可以让这个类的所有对象共享同一个数据.
      • 静态变量的缺点:耗内存.
      • 静态变量的适用场景:当一个类中属性值,需要多个对象共享时,这个属性就可以定为静态变量.
   2. 静态方法:用static修饰的方法叫静态方法.
      1. 静态方法特征.
         • 静态方法中只能直接调用静态的属性和方法,不能直接调用非静态的属性和方法,如果在静态方法中想调用非静态的属性和方法,可以通过对象调用.
         • 在非静态的方法中可以直接调用静态属性和方法,也可以直接调用非静态属性和方法
         • 在静态方法不能用this关键字,原因是静态方法属于类,直接用类名调用,因此无法用this.普通方法中可用this关键字,原因普通方法属于对象,要用对象调用,用哪个对象调用这个普通方法,this就指代当前这个对象
      2. 静态方法的优点:调用方便(用类名调用方法).
      3. 静态方法的缺点:使用受限(静态方法中只能直接调用静态的属性和方法,不能直接调用非静态的属性和方法).
      4. 静态方法的适用场景:当一个类为工具类,那么这个类中方法为了调用方便,全部声明为静态方法.

   final

   1. 最终类:用final修饰的类叫最终类,不能被继承.
   2. 最终方法:用final修饰的方法叫最终方法,不能被重写.
   3. 常量:用final修饰的变量叫常量.常量一生只可以赋一次值,一但赋值不可更改.
      • 成员常量:在类中直接声明常量叫成员常量.成员常量可以在声明时赋值,或在构造方法中赋值或动态代码块中赋值
      • 局部常量:在方法中直接声明常量叫局部常量. 局部常量可以在声明时给值,也可以先声明再赋值.

17接口

1.接口的定义

1. 接口特点:
   • 接口中方法默认全是抽象方法,所以接口中方法默认系统会加public abstract修饰;接口中变量全是静态常量,所以接口中变量默认系统会加public static final.
   • 接口不能实例化.接口中没有构造方法.
   • 接口中抽象方法必须被子类实现(重写),除非子类也是抽象的,让孙子类去实现.
   • 类与类之间是继承的关系,类与接口之间是实现的关系,接口与接口之间是继承的关系.一个类只能直接继承一个父类,一个类可以实现多个接口,一个接口可以继承多个接口.
   • 一个类只能直接继承一个父类,但是一个类可以实现多个接口,所以从某种程序上来说,接口弥补Java单继承的缺陷.
   • 接口中默认的方法全是抽象方法,但在jdk1.8之后,接口中还可以有静态方法和扩展方法.接口中静态方法供子类调用,不能继承或重写.接口中扩展方法,可以被子类继承或重写.
   • 接口是一种引用数据类型,与类同级别.
2. 接口作用:提高程序可扩展性和维护性.

2.抽象类 VS 接口

1. 相同点:
   • 都不能实例化(创建对象);
   • 都可以声明抽象方法和静态常量;
   • 都是一种引用数据类型.
   • 它们的抽象方法都必须被子类重写,除非子类也是抽象的,被孙子类去重写.
   • 都可以编译之后生成.class文件.
   • 都与自己同类型之间是继承关系.
2. 不同点:
   • 作用不同:抽象类的作用让子类去继承,从而实现代码复用及规定子类必须拥有的行为;接口作用提高程序可扩展性和可维护性.
   • 构造不同:抽象类中有构造方法,它的构造方法供子类调用;接口中没有构造方法.
   • 方法不同:抽象类中可以有任何方法;接口中默认全是抽象方法,在jdk1.8后接口中还可有扩展方法和静态方法.
   • 静态常量不同:抽象类中可以有成员变量,静态常量,静态变量;接口中只能有静态常量.
   • 继承和实现不同:一个类只能继承一个抽象类,一个类可以实现多个接口,一个接口也可以继承多个接口.
   • 修饰符不同:抽象类中抽象方法必须用abstract修饰;接口中抽象方法可以不用abstract修饰,系统默认用public abstract修饰.
   • 代码块不同:抽象类中可以用静态代码块和动态代码块;接口不可用静态代码块和动态代码块

扩展

1. JDK1.8后,接口中可以静态方法和扩展(默认)方法
2. 接口静态方法只能调用不能继承,提高接口使用灵活性.
3. 接口扩展方法可以让子类继承,提高程序可扩展性.
4. 当一个类的父类与父接口具有相同的方法时,子类继承的父类的方法(类优先于接口)
5. 当一个类的两个父接口中具有相同的方法时,子类实现这两个父接口后会报错,让子类重写这个相同的方法就可解决冲突.

18.常用类

1.内部类：

成员实例内部类

1. 在成员实例内部类中可以直接使用外部类的属性,方法.
2. 外部类不能直接调用内部类属性和方法,但是可以通过内部类的对象调用
3. 当外部类与成员实例内部的属性同名时,在内部类中输出内部类中同名属性.在内部类中调用外部类中同名属性,用外部类的对象.属性名;

成员静态内部类：

1. 在成员静态内部类中只能直接调用外部类的静态属性和方法,不能直接调用外部类的非静态属性和方法,如果想调用可以用对象调用.
2. 在外部类中可以用类名直接调用成员静态内部类中静态属性和方法,不能调用非静态属性和方法,如果想调用可以用对象调用

$匿名内部类$

1. 适用场景:当一个类一生只需要一个对象,且这个对象一生只使用一次就可以使用匿名内部类.

2. 使用语法:

   父接口或父抽象类 对象名=new 父接口或父抽象类(){
   	访问修饰符 数据类型 变量名1;
   	访问修饰符 数据类型 变量名2;
   	。。。
   	访问修饰符 返回值类型 方法名1(形参列表){
   	}
   	。。。
   }
   

   注意:匿名内部类一定要有父接口或父抽象类.

3. 一个Java类对应一个.class字节码文件：

   • 成员内部类命名：外部类名$内部类名.class
   • 局部内部类命名：外部类名$编号内部类名.class
   • 匿名内部类命名：外部类名$编号.class

2.Object类

1. Object类:是所有Java类的根类,基类,超类.所有Java类都直接或间接继承Object类.

   1. finalize():标记对象为垃圾对象,让垃圾对象在回收队列进行排队等待回收.
   2. getClass():获得当前对象的.class文件对象,一个类只有一个.class文件对象. 注意:用它可以实现判断两个对象是否同一个类型的.
   3. hashCode():如果对象所在的类中没有重写hashCode(),通过对象的内存地址经过一系列运算得到哈希码值,如果对象内存地址不同,得到哈希码值不同,如果对象内存地址相同,得到哈希码值相同;如果对象所在的类中重写hashCode(),根据对象的值计算哈希码值,这时只要对象内存地址相同或值相同得到哈希码值相同.
   4. toString():如果当前对象是直接继承Object类的toString(),自己没有重写,那么得到的是对象内存地址字符串形式;如果当前对象所在的类中重写Object类的toString(),那么调用toString()输出对象的属性值.

2. $==VSequals()都可以比较变量$

   1. ==：左右两边如果是基本数据类型,比较的是变量值; ==左右两边如果是引用数据类型,比较的是变量的内存地址.
   2. equals():如果equals()左右两边变量所在的类中,没有重写Object继承过来的equals(),比较是变量内存地址(效果等同于==);如果equals()左右两边变量所在的类中,重写Object继承过来的equals(),比较的是变量值.

   public static void main(String[] args) {
       Student stu1=new Student("张三", 18);
   	Student stu2=new Student("张三", 18);
   	int num1=11;
   	int num2=11;
   	//因为==左右是基本数据类型,比值
   	System.out.println(num1==num2);//true
   	//因为==左右是引用数据类型,比地址
       System.out.println(stu1==stu2);//false
       //如果stu1和stu2所在类Student中没有重写equals(),比地址,重写了就比值
       System.out.println(stu1.equals(stu2));
   }
   

3.包装类

1. 八种基本数据类型违反了Java是一种纯面向对象的语言.所以Java为了保证自己是一种纯面向对象 的语言给八种基本数据类型提供包装类.

2. 包装类:将基本数据类型封装成类,叫包装类

   byte—Byte short—Short int—Integer long—Long float—Float double—Double char—Character boolean—Boolean

3. 八种基本数据类型的包装类都是引用数据类型.

4. 以后成员变量的数据类型建议用包装类作为数据类型,原因是包装类型的变量的默认值为null,方便判断变量;包装类型变量可以调用其他方法,方便后续处理.

5. 基本数据类型和包装类的相互转换

   • 装箱:将基本数据类型转换包装类
   • 拆箱:将包装类转换为基本数据类型

4.Stirng

1. String类:是最终的类,一但赋值不可更改.

   注意:String有个常量池, 常量池中值不可重复.常量指的就是固定值.

2. 因为String类底层重写equals(),所以String调用equals()永远比较是值.又因为String类调用==,比较内存地址.

3. $其他数据类型转换为String的方法$

   • 其他数据类型的变量+"",将其他类型转换为String
   • String.valueOf(Object obj) ,将其他类型转换为String
   • 其他数据类型的对象.toString(),将其他类型转换为String
   • Arrays.toString(一维数组名),将数组转换为String
   • String类的构造方法可以将byte[],char[],StringBuffer,StringBuilder转换为String类型

4. $String类型转换为其他数据类型,注意转换有风险.$

   • 用其他类型构造方法将String类型转换其他类型,除了Character类型
   • 其他类型.valueOf(String s),除了Character类型
   • 其他类型.parse数据类型(String s),除了Character类型

5. “” VS null:""表示开辟空间,空间没存值;null表示没有开辟空间.

6. $String类的常用方法$

   1.charAt(int index)返回指定索引处的字符值。 
   2.compareTo(String anotherString) 按字典顺序比较两个字符串。如果字符串在参数字符串前面返回负数,在后面返回正数,相同返回0
   3.compareToIgnoreCase(String str) 按字典顺序比较两个字符串，忽略大小写
   4.concat(String str) 将指定的字符串连接到该字符串的末尾,产生新的字符串    
   5.contains(CharSequence s) 当且仅当此字符串包含指定的char值序列时才返回true
   6.endsWith(String suffix) 测试此字符串是否以指定的后缀结尾
   7.startsWith(String prefix) 测试此字符串是否以指定的前缀开头    
   8.equals(Object anObject) 将此字符串与指定对象进行比较。
   9.equalsIgnoreCase(String anotherString) 将此 String与其他 String比较，忽略大小写
   10.format(String format, Object... args) 使用指定的格式字符串和参数返回格式化的字符串
   11.indexOf(String str) 返回指定子字符串第一次出现的字符串内的索引。    
   12.lastIndexOf(String str) 返回指定子字符串最后一次出现的字符串中的索引    
   13.join(String 分隔符, CharSequence... elements) 将多个字符串按照指定分隔符拼接成一个新的字符串    
   14.length() 返回此字符串的长度
   15.matches(String regex) 告诉这个字符串是否匹配给定的 regular expression    
   16.replace(String oldChar, String newChar) 返回从替换所有出现的导致一个字符串 oldChar在此字符串 newChar    
   17.split(String regex) 将此字符串分割为给定的 regular expression的匹配    
   18.substring(int beginIndex, int endIndex) 返回一个字符串，该字符串是此字符串的子字符串。包头不包尾    
   19.toLowerCase() 将所有在此字符 String使用默认语言环境的规则，以小写    
   20.toUpperCase() 将所有在此字符 String使用默认语言环境的规则大写    
   21.trim() 返回一个字符串，其值为此字符串，并删除任何前导和尾随空格    
   

$5.StringBuffer和StringBuilder区别$

相同点:

• 都是最终类.
• 都是引用数据类型.
• 都可以存字符串.
• 底层都是用char[]存值.

不同点：

• String是不可变的最终类,一但赋值,空间不可更改.
• StringBuffer是可变的最终类,在多线程中使用安全,在单线程中效率低.
• StringBuilder是可变的最终类,在多线程中使用不安全,在单线程中效率高.

6.BigDecimal类:精确计算浮点数

1. BigDecimal类的常用方法

BigDecimal num1=new BigDecimal(10.0);
BigDecimal num2=new BigDecimal(3.0);
//计算两数之和
BigDecimal result1=num1.add(num2);
//计算两数之差
BigDecimal result2=num1.subtract(num2);
//计算两数之积
BigDecimal result3=num1.multiply(num2);
//计算两数之商,BigDecimal如果除不断会报错
//BigDecimal result4=num1.divide(num2);
//第一个参数是除数,第二个参数是保留的小数位数,第三个参数是取舍模式(舍入模式向零舍入)
BigDecimal result4=num1.divide(num2,2,BigDecimal.ROUND_DOWN);

7.Date类:日期类

//获得当前系统日期
Date today=new Date();
System.out.println("当前系统日期为:"+today);
System.out.println("获得当前系统时间毫秒数:"+today.getTime());

//获得其他日期
Date d2=new Date(1000);
System.out.println("时间2为:"+d2);

//比较两个日期,日期在参数日期之前返回负数,之后返回正数,相等返回0
int result1=d2.compareTo(today);
System.out.println(result1);

8.SimpleDateFormat:将日期与String之间进行相互转换工具类.

//获得当前系统日期
Date today=new Date();
System.out.println("当前系统日期为:"+today);

//创建日期格式化对象
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//将系统日期转换为指定格式字符串
String s1=sdf.format(today);
System.out.println("当前系统日期格式化为:"+s1);

//将字符串转换为日期,有风险,字符串必须符合格式化对象中指定格式
Date d3=sdf.parse("2021-04-25 11:10:19");
System.out.println("d3为:"+d3);

9.Calendar:日期类

Calendar c1=Calendar.getInstance();
System.out.println(c1);
System.out.println("年:"+c1.get(Calendar.YEAR));
//设置月份
//c1.set(Calendar.MONTH, 4);
System.out.println("月:"+(c1.get(Calendar.MONTH)+1));
System.out.println("日:"+c1.get(Calendar.DAY_OF_MONTH));
System.out.println("时:"+c1.get(Calendar.HOUR));
System.out.println("分:"+c1.get(Calendar.MINUTE));
System.out.println("秒:"+c1.get(Calendar.SECOND));

//当前月中最大日
System.out.println(c1.getActualMaximum(Calendar.DAY_OF_MONTH));
//当前月中最小日
System.out.println(c1.getActualMinimum(Calendar.DAY_OF_MONTH));
//所有月中最大日
System.out.println(c1.getMaximum(Calendar.DAY_OF_MONTH));
//所有月中最小日
System.out.println(c1.getMinimum(Calendar.DAY_OF_MONTH));

10.System:系统类

Scanner input=new Scanner(System.in);

System.out.println("我是千锋人");
System.err.println("错误输出");

//退出jvm
System.exit(0);

System.out.println("系统时间毫秒数:"+System.currentTimeMillis());
System.out.println("系统时间纳秒数:"+System.nanoTime());
System.out.println("系统配置:"+System.getProperties());
System.out.println("Java安装目录:"+System.getProperty("java.home"));

11.Math类:对数字作处理工具类.

//声明一个变量
double num1=25.5;

//向上取整
double num2=Math.ceil(num1);
//向下取整
double num3=Math.floor(num1);
//四舍五入
double num4=Math.round(num1);
//求一个数几次方,求2的三次方
double num5=Math.pow(2, 3);
//求[min,max]范围随机整数 int result=(int)(Math.random()*(max-min+1)+min);
//[16,25]
int result1=(int)(Math.random()*10+16);

12.Random:生成随机数的类

//创建随机数对象
Random r=new Random();
//调用方法生成随机数[10,99]
int result2=r.nextInt(90)+10;
//生成[min,max]范围内随机整数int result=r.nextInt(max-min+1)+min;

19.集合

1.List

#### $\textcolor{red}{1.ArrayList}$

1. ArrayList:存储有序的,可重复的单一对象.底层采用Object[]结构存值.默认按照1.5倍扩容.

   优点:按顺序添加效率高，遍历和修改集合中元素效率高

   缺点:删除和按指定索引添加效率低．

   语法：

   //创建方法一
   List list = new ArrayList();
   //创建方法二
   ArrayList list = new ArrayList();
   //添加方法
   	list.add()
   //删除
       list.remove()
   //修改
       list.set(索引,替换值)
   //查询
       list.get(索引)
   

2. $过滤器：$

   //创建集合
   List alist2=new ArrayList();
   alist2.add(66);
   alist2.add(67);
   alist2.add(68);
   alist2.add(47);
   alist2.add(57);
   //用过滤器对象删除集合中元素,方法参数用匿名内部类过滤器对象
   alist2.removeIf(new Predicate() {
       @Override
   	public boolean test(Object t) {
           if (t.toString().startsWith("6")) {
               return true;//满足条件,删除
   		} else {
               return false;//不满足条件,留下
           {    
       }
   });
   

$2.LinkedList$

1. LinkedList:存储有序的,可重复单一对象.底层采用双向链表结构存值

   优点:添加和删除效率高

   缺点:遍历和修改效率低

3.$Vector和ArrayList区别$

• 相同点:

  都是存储有序的,可重复的单一对象.底层都是采用Object[]结构存值.

• 不同点:

  推出的时间不同:Vector在jdk1.0时就推出;ArrayList在jdk1.2时推出集合框架时才推出.

  扩容不同:Vector默认按原来2倍扩容;ArrayList默认按原来1.5倍.

  安全性不同:Vector线程安全,效率低;ArrayList效率高,但是在多线程中使用不安全

  ArrayList拥有的所有的方法Vector都有,Vector还有自己独有的方法

4.泛型

1. 泛型:将引用数据类型参数化.(将引用数据类型作为参数传递)
2. 因为普通集合存数据时要频繁进行数据类型转换,遍历集合中数据时,又要频繁转换为原来的类型,使用不太方便且浪费运行内存,所以用泛型集合

2.Set

$2.1.HashSet$

1. 特点：存储无序的,唯一的单一对象.底层采用HashMap的Key存值（最底层是数组+链表）

2. 优点:去重性.（通过hashCode()和equals()两个方法来实现去重）

   底层去重原理解释：根据HashMap的key值调用hashCode方法获得哈希码——>再根据哈希码和数组的长度计算存储的索引位置index——>

   索引位置有两种情况：

   ​ 没有值：将当前的key-value对存在该索引的位置上

   ​ 有值：则用key调用equals()方法判断该位置上的值和将要存入的值进行判断，又分两种情况：

   ​ 值相等：当前的key-value中的key不存，value将原来的value覆盖

   ​ 值不相等：将key-value接着存入节点的index的位置中

$2.2.TreeSet$

1. 特点：存储的无序的,可排序的,唯一的单一对象.底层采用TreeMap的key存值

   注意:TreeSet一定要用排序器.如果用无参构造创建的TreeSet,默认采用自然排序器,要求TreeSet泛型类中实现自然排序器接口(Comparable),重写排序方法compareTo();如果用有参构造创建的TreeSet,要将自定义排序器(Comparator)对象作为参数传给构造方法,采用自定义排序器中排序方法compare() 来排序.

2. 优点:可排序,去重性.

   可排性:通过排序器的排序方法返回负数排在前面,返回正数排在后面.

   去重性(唯一性):通过排序器排序方法返回0,表示相同元素不存.

数据存储解释：存第一个数66，所以66在第一，

​ 存44和66比，44比66小所以在左边

​ 存88和66比，88比66大存右边

​ 存33和66比，33比66小存左边，左边有值44，再和44比较，33小存左边

​ 存99和66比，99比66大存右边，左边有值88，再和88比较，99大存左边

​ 。。。。

$3.排序器的三种方法$

1. 自然排序器

   步骤1：创建一个类并实现Comparable接口
       public class Teacher implements Comparable<Teacher>{
           //定义两个属性
           public String tname;
   		public Integer tage;
           //重写同String方法
           @Override
           public String toString() {
               return "Teacher [tname=" + tname + ", tage=" + tage + "]";
           }
           //创建无参构造
           public Teacher() {
   			
   		}
           //创建有参构造
   		public Teacher(String tname, Integer tage) {
               super();
               this.tname = tname;
               this.tage = tage;
           }
   步骤2：重写compareTo方法，并定义排序规则
       	/**
            * 自然排序方法
            * 排序:先根据对象姓名进行升序来排序,姓名相同再根据年龄升序排序
            * this 表示当前要添加元素
            * @param o 表示从根节点开始每个要比较的节点对象
            * @return int 返回负数排在前面,返回正数排在后面,返回0表示相同元素
            */
           @Override
           public int compareTo(Teacher o) {
               if (this.tname.compareTo(o.tname)!=0) {//姓名不同
                   return this.tname.compareTo(o.tname);
               }else {//姓名相同
                   if (this.tage<o.tage) {
                       return -1;
                   }else if (this.tage>o.tage) {
                       return 1;
                   }else {//姓名相同,年龄相同
                       return 0;
                   }
               }
           }
       }
   步骤3：写一个测试类
       public void Test(){
       	public static void main(String[] args) {
               //创建集合对象
               TreeSet<Teacher> set2=new TreeSet<Teacher>();
               //向集合中添加元素
               set2.add(new Teacher("hh", 66));
               set2.add(new Teacher("aa", 44));
               set2.add(new Teacher("bb", 33));
               set2.add(new Teacher("aa", 55));
               set2.add(new Teacher("mm", 88));
               set2.add(new Teacher("ww", 77));
               set2.add(new Teacher("pp", 99));
               set2.add(new Teacher("hh", 66));
               /*遍历集合*/
               //获得集合跌代器对象
               Iterator<Teacher> it2=set2.iterator();
               //每判断一次就跌代一次
               while (it2.hasNext()) {
                   Teacher i=it2.next();
                   System.out.println(i);
               }
               System.out.println("----------------------------------");
               //删除集合中元素
               set2.remove(new Teacher("aa", 44));
               //遍历集合
               for (Teacher i : set2) {
                   System.out.println(i);
               }
           }
   	}
   

2. 自定义排序器(Comparator):

   步骤一：创建一个自定义排序类
       public class MyComparator implements Comparator<Cat>{
           /**
            * 自定义排序器的排序方法
            * 排序:先根据年龄降序,年龄相同,再根据昵称升序
            * @param o1 当前要添加元素
            * @param 02 表示从根节点开始每个要比较的节点元素
            * @return int 返回负数排在前面,返回正数排在后面,返回0表示相同元素
            */
           @Override
           public int compare(Cat o1, Cat o2) {
               if (o1.age.compareTo(o2.age)!=0) {//年龄不同
                   return -o1.age.compareTo(o2.age);
               }else {//年龄相同
                   return o1.nickName.compareTo(o2.nickName);
               }
           }
       }
   步骤二：创建一个测试类
       public void Test(){
           public static void main(String[] args) {
               //创建自定义排序器对象
               MyComparator mc=new MyComparator();
               //创建集合对象,将自定义排序器对象作为构造方法的参数传入
               TreeSet<Cat> set2=new TreeSet<Cat>(mc);
               //向集合中添加元素
               set2.add(new Cat("hh", 66));
               set2.add(new Cat("aa", 44));
               set2.add(new Cat("bb", 33));
               set2.add(new Cat("aa", 33));
               set2.add(new Cat("mm", 88));
               set2.add(new Cat("ww", 77));
               set2.add(new Cat("pp", 99));
               set2.add(new Cat("hh", 66));
               /*遍历集合*/
               //获得集合跌代器对象
               Iterator<Cat> it2=set2.iterator();
               //每判断一次就跌代一次
               while (it2.hasNext()) {
                   Cat i=it2.next();
                   System.out.println(i);
               }
               System.out.println("----------------------------------");
   
               //删除集合中元素
               set2.remove(new Cat("aa", 44));
   
               //遍历集合
               for (Cat i : set2) {
                   System.out.println(i);
               }
           }
   	}
   

3. 匿名内部类自定义排序器:

   public static void main(String[] args) {
   		//创建集合对象,将匿名内部类自定义排序器对象作为构造方法的参数传入
   		TreeSet<Cat> set2=new TreeSet<Cat>(new Comparator<Cat>() {
   			/**
   			 * 自定义排序器排序方法
   			 * 排序:先根据昵称降序排序,昵称相同再根据年龄降序
   			 * @param o1 当前要添加的元素
   			 * @param o2 从根节点开始每个要比较节点元素
   			 * @return int 返回负数排在前面,返回正数排在后面,返回0相同
   			 */
   			@Override
   			public int compare(Cat o1, Cat o2) {
   				if (o1.nickName.compareTo(o2.nickName)!=0) {//昵称不同
   					return -o1.nickName.compareTo(o2.nickName);
   				} else {//昵称相同,根据年龄降序
   					return -o1.age.compareTo(o2.age);
   				}
   			}
   		});
   		
   		//向集合中添加元素
   		set2.add(new Cat("hh", 66));
   		set2.add(new Cat("aa", 44));
   		set2.add(new Cat("bb", 33));
   		set2.add(new Cat("aa", 33));
   		set2.add(new Cat("mm", 88));
   		set2.add(new Cat("ww", 77));
   		set2.add(new Cat("pp", 99));
   		set2.add(new Cat("hh", 66));
   		
   		/*遍历集合*/
   		//获得集合跌代器对象
   		Iterator<Cat> it2=set2.iterator();
   		//每判断一次就跌代一次
   		while (it2.hasNext()) {
   			Cat i=it2.next();
   			System.out.println(i);
   		}
   		System.out.println("----------------------------------");
   		
   		//删除集合中元素
   		set2.remove(new Cat("aa", 44));
   		
   		//遍历集合
   		for (Cat i : set2) {
   			System.out.println(i);
   		}
   	}
   }