JavaSE
卸载JDK
- 找到电脑里面的jdk包（在环境配置那有路径）
- 删除环境配置与java相关的
- java -version查看版本
java基础
变量作用域
main主方法，一个类只能有一个主方法
public class Variable{
static int allClicks=0;//类变量 关键字static静态
String str='hello word';//实例变量 没有关键字
public void method(){
int i=0;//局部变量 在方法里面的
}
}
位运算符
and: & 与
or:| 或
a&b:都为1输出1，否则输出0
a|b:都为0输出0，否则输出1
a^b：相同输出0，否则输出1
位运算符：<<:左移 左移一位*2 效率高
.>>右移：右移一位/2
java流程控制
Scanner对象
可以通过Scanner类来获取用户的输入
基本语法：Scanner s=new Scanner(System.in)
通过Scanner类的next()与nextLine()方法获取输入的字符串,在读取前，我们一般用hasNext()与hasNextLine()判断是否还有输入的数据
public class demo {
public static void main(String[] args) {
//从键盘接收数据
Scanner scanner=new Scanner(System.in);
System.out.println("请输入数据：");
String str=scanner.nextLine();
System.out.println("你输入的数据是：");
System.out.println(str);
scanner.close();
}
}
if结构
单选结构
if(){
}
双选结构
if(){
}else{
}
多选结构
if(){
}else if{
}else{
}
switch多选择结构
语法结构 break不加就会输出满足条件后面的所有东西
switch(expression){
case value:
//语句
break://可选
case value:
//语句
default://可选
}
public class demo {
public static void main(String[] args) {
char grade='C';
switch (grade){
case 'A':
System.out.println("优秀");
case 'B':
System.out.println("良好");
case 'C':
System.out.println("及格");
break;
default:
System.out.println("未知");
}
}
}
while循环
对于while语句而言，如果不满足条件，则不能进入循环
while(布尔表达式){
//循环内容
}
int i=0;
int sum=0;
while(i<=100){
sum=sum+i
i++;
}
System.out.print(sum)
do...while循环至少循环一次
do{
//代码语句
}while(布尔表达式)
For循环
for(初始化;布尔表达式;更新){
//代码语句
}
九九乘法表:
public class demo {
public static void main(String[] args) {
for (int j = 1; j < 9; j++) {
for (int i = 1; i <= j; i++) {
System.out.print(j+"*"+i+"="+(j*i)+"\t");
}
System.out.println();
}
}
}
break跟continue
break：在任何循环语句中的主体部分，均可用break控制循环的流程。break用于强行退出循环
不执行循环中剩余的语句。(break语句也可以在switch中使用)
continue:语句用在循环语句主体中，用于终止某次循环过程，既跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定
java方法
方法包含一个方法头和一个方法体。
- 修饰符：可选的，告诉编译器如何调用该方法。定义了该方法的访问类型
- 返回值类型：方法可能会返回值。returnValueType是方法返回值的数据类型。有些方法执行所需要的操作，但没有返回值。在这种情况下，returnValueType是关键字void
- 方法名：是方法的实际名称，方法名和参数表共同构成方法签名
- 参数类型:参数像是一个占位符。当方法被调用时，传递给参数。
- 方法体:方法体包含具体的语句，定义该方法的功能
修饰符 返回值类型 方法名(参数类型 参数名){
...
方法体
...
return 返回值
}
方法调用
调用方法：对象名.方法名（实参列表）
java支持两种调用方法的方式，根据是否返回值来选择。
1.当返回一个值的时候，方法调用通常被当做一个值。例如
int larger=max(30,40)
2.如果方法返回值是void，方法调用一定是一条语句
System.out.println("Hello")
方法的重载
方法的重载的规则：
- 方法名称必须相同
- 参数列表必须不同（个数不同，类型不同，参数排列顺序不同等）
- 方法的返回值类型可以相同也可以不相同。
- 仅仅返回类型不同不足以成为方法的重载。
可变参数
- 方法声明中，在指定参数类型后加一个省略号(...)
- 一个方法中只能指定一个可变参数，它必须是方法最后一个参数。任何普通参数都要在他之前声明
public class demo {
public static void main(String[] args) {
demo demo=new demo();
demo.test(1,2,3,4);
}
public void test(int... i){//这里的参数i必须是最后一个
System.out.println(i[0]);
}
}
递归
递归是A方法调用A方法！，自己调用自己
递归作用：利用递归可以简单的程序来解决一些复杂的问题。它通常把一个大型复杂的问题层层传递转化为一个与原问题相似的规模较小的问题来求解，递归策略只需要少量的程序就可描述出解题过程所需要多次重复计算，大大地减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。
递归结构包括两个部分：
- 递归头：什么时候不调用自身方法。如果没有头，将陷入死循环
- 递归体：什么时候需要调用自身方法.
//计算阶乘
public static void main(String[] args) {
System.out.println(test(10));
}
public static int test(int i){
if(i==1){
return 1;
}else {
return i*test(i-1);//此处不断调用自己
}
}
数组
数组声明创建
-
首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法：
dataType[] arrayRefVar;//首选的方法 或 dataType[] arrayRefVar[]//效果相同，但是不熟首选的方法 -
java语言使用new操作符来创建数组，语法如下：
dataType[] arrayRefVar=new dataType[arraySize];
获取数组长度：arrays.length
内存分析
冒泡排序
- 冒泡排序无疑是最为出名的排序算法之一，总共有八大排序！
- 冒泡的代码还是相当简单的，两层循环，外层冒泡轮数，里层依次比较，江湖人人尽皆知
- 我们看到嵌套循环，应该立马就可以得出这个算法的时间复杂度为0(n2)
public static void main(String[] args) {
int[] a ={5,8,3,4,5,21,52};
int[] sort=sort(a);
System.out.println(Arrays.toString(sort));
}
public static int[] sort(int[] array){
int temp=0;
//外层循环
for (int i=0;i<array.length;i++){
//内层循环判断两个数，如果后一个比前一个大则交换位置
for (int j=0;j< array.length-1-i;j++){
if (array[j+1]>array[j]) {
temp = array[j];
array[i] = array[j + 1];
array[j + 1] = temp;
}
}
}
return array;
}
实现后面比前面大就换位置
面向对象
面向对象的本质就是：以类的方式组织代码，以对象的组织（封装）数据
三大特性：
- 封装
- 继承
- 多态
创建与初始化对象
使用new关键字创建对象
类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有一下两个特点：(无参构造方法)
- 必须和类的名字相同
- 必须没有返回类型，也不能写void
作用：
- new本质在调用构造方法
- 初始化对象的值
注意点
- 定义有参构造之后，如果想使用无参构造，显示的定义一个无参的构造
- 当你new的时候会自动调用无参构造
super注意点：
-
super调用父类的构造方法，必须在构造方法的第一个
-
super必须只能出现在子类的方法或者构造方法中
-
super喝this不能同时调用构造方法
方法的重写
需要有继承关系，子类重写父类的方法（与属性无关）
- 方法名必须相同
- 参数列表列表必须相同
- 修饰符：范围可以扩大但不能缩小：public>Protected>Default>private
- 抛出的异常：范围可以被缩小，但不能扩大
//静态的方法和非静态的方法区别很大;
//静态方法的调用只和左边的有关
//非静态这样调用才是重写
//下列B是父类
A a=new A();
//输出：A的构造方法
B b=new A();//父类的引用指向了子类
//输出：A的构造方法，B的构造方法
//重写后下面输出的两个都是A的构造方法
为什么需要重写：
- 父类的功能，子类不一定需要，或者不一定满足！
多态
多态存在的条件：
- 有继承关系
- 子类重写父类的方法
- 父类应用指向子类对象
注：多态是方法的多态，属性没有多态
子类能调用本身跟父类的方法
抽象类
由关键字abstract定义
- 不能new这个抽象类，只能靠子类去实现它：约束！
- 抽象类中可以写普通方法
- 抽象方法必须在抽象类中
接口的定义与实现（多继承）
声明接口的关键字是interface
类可以实现接口：implements 接口
实现了接口的类，就需要重写接口的方法
内部类
内部类：就是在一个类的内部在定义一个类，比如A类里面定一个B类则称为内部类，而A相对B就是外部类了
可以获得外部类的私有属性和方法
异常机制
异常处理机制
异常处理五个关键字：try,catch,finally,throw,throws
try{//监控区域
//代码块
}catch(想要捕获的异常类型){//多个catch他们的范围越大写越下面
}finally{//处理善后
}
自定义异常
只需要继承Exception类就行了
自定义异常大体步骤为：
- 创建自定义异常类。
- 在方法中通过throw关键字抛出异常对象。
- 如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理；否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作。
- 在出现异常方法的调用者中捕获并处理异常
=以下为进阶部分====
java常用类
Object类：超类，基类，所有类的直接或间接父类，位于继承树的最顶层
- getclass():返回一个类型
- hashCode()：返回该对象的哈希码值
- toString():返回该对象的字符串表示
- equals():比较两个对象地址是否相等
包装类：
装箱：将基本类型转换成引用类型的过程(既将栈里面的东西转到堆里面)
拆箱：引用类型转为基本类型
//示例
int num1=18//定义了一个基本类型，基本类型是栈里面的
Integer integer1=num1//转换成堆里面的
Integer integer3=new Integer(100);
int num2=integer3
基本类型和字符串之间转换
//1基本类型转换成字符串
int n1=100;
//1.1使用+号
String s1=n1+"",
//1.2使用Integer中的tostring（）方法
String s2=Integer.toString(n1);
//2字符串转换成基本类型
String str="100";
//使用Integer.parsexxx();xxx代表类型
int n2=Integer.parseInt(str);
String类
- public int length():返回字符串的长度
- public char charAt(int index):根据下标获取字符
- public boolean contains(String str):判断当前字符串中是否包含str
- public char[] toCharArray():将字符串转换成数组
- indexOf(String str):查找str首次出现的下标，存在，则返回该下标，不存在，则返回-1
- IndexOf(String str):查找字符串在当前字符串中最后一次出现的下标索引
- trim（）去掉字符串前后的空格
- toUpperCase();//把小写转换成大写
- toLowerCase();//把大写转换成小写
- endWith(str);判断是否以str结尾
- startWith(str);判断是否以str开头
- replace(char old，char new);用新的字符或字符串替换旧的字符
- split();对字符串进行拆分
可变字符串
StringBuffer:可变长字符串，运行效率慢，线程安全。
StringBuilder:可变长字符串，运行效率快，线程不安全。
Data类
Date date=new Date()
Data表示特定的瞬间，精确到毫秒。data类中的大部分方法都已经被Calendar类中的方法所取代
SimpleDateFormat
创建SimpleDateFromat对象 SimpleDateFormat sdf=new SimpleDateFormat
是一个以与语言环境有关的方式来格式化和解析日期的具体类
格式化：（日期->文本），解析（文本->日期）
| 字母 | 日期或时间 | 示例 |
|---|---|---|
| y | 年 | 2019 |
| M | 年中月份 | 08 |
| d | 月中天数 | 10 |
| H | 1天中小时数 | 22 |
| m | 分钟 | 16 |
| s | 秒 | 59 |
| S | 毫秒 | 367 |
//创建SimpleDateFormat对象 y年M月
SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日 HH：mm：ss")
//创建Date
Date date=new Date();
//格式化data（把日期转成字符串）
String str=sdf.format(date);//format格式化字符串
System.out.print(str)
//解析（把字符串转成日期）
Date date2=sdf.parse("1990/06/01 ");//parse解析
System类
系统类，主要用于获取系统的属性数据和其他操作
| 方法名 | 说明 |
|---|---|
| arraycopy() | 复制数组 |
| currentTimeMillis(); | 获取当前系统时间，返回的是毫秒 |
| gc(); | 建议JVM赶快启动垃圾回收器回收垃圾 |
| exit(int status); | 退出jvm，如果参数是0表示正常退出jvm，非0表示异常退出jvm。 |
集合框架
集合
一.集合概念
对象的容器，实现了对对象的操作类似数组功能。
和数组区别：
- 数组长度固定，集合长度不固定
- 数组可以存储基本类型和引用类型，集合只能引用类型（除看基本类型都是引用类型)
Collection体系集合
Collection父接口:代表一组任意类型的对象，无序，无下标，不能重复。
方法
- add(object obj)//添加一个对象
- addAll(Collection c)//将一个集合中的所有对象添加到此集合中。
- clear()//清空此集合中的所有对象
- contains(Object 0)//检查此集合中是否包含o对象
- equals(Object o)//比较此集合是否与指定对象相等
- isEmpty()//判断集合是否为空
- remove(Object o)//在此集合移除O对象
- size()//返回此集合中的元素个数
- toArray()//将此集合转换成数组
使用：
先创建集合（实例）：Collection collection=new ArrayList()
遍历集合的元素
- 使用增强for（因为这个不用下标）
- 使用Iterator迭代器
子接口
List集合
特点：有序，有下标，元素可以重复。
方法：
- add(index ,Object)//可以在index位置插入对象
- addAll(index,c)//将一个集合中的元素添加到此集合中的index位置
- get（index）//返回集合中指定位置的元素
- subList(index,index)//返回之间的集合元素
List实现类
ArrayList
- 数组结构实现，查询快，增删慢；
- 运行效率快，线程不安全
Vector
- 数组结构实现，查询快，增删慢；
- 运行效率慢，线程安全
LinkedList
- 链表结构，增删快，查询慢
泛型
常见形式有泛型类，泛型接口，泛型方法。
好处
- 提高代码的重复性
- 防止类型转换异常，提高代码的安全性
set子接口
特点:无序，无下标，元素不可重复
方法：全部继承自Collection中的方法
set实现类
HashSet:
- 基于HashCode计算元素存放位置。
- 当存入元素的哈希码相同时，会调用equals进确认，如结果为True，则拒绝后者存入
- 存储结构：哈希数表
TreeSet:
- 基于排序顺序实现元素不重复
- 实现了SortedSet接口，对集合元素自动排序
- 元素对象的类型必须实现Comparable接口，指定排序规则。
- 通过CompareTo方法确定是否为重复元素。
Map集合
特点：
- 用于存储任意键值对
- 键：无序，无下标，不允许重复
- 值：无序，无下标，允许重复
方法：
- put //将对象存入到集合中，关联键值。key重复则覆盖原值
- get（）//根据键获取对应的值
- set（）//返回所有key
- Collection
values()//返回包含所有值的Collection集合. - set<Map.Entry<K,V>>//键值匹配的Set集合
Colletions工具类
概念:集合工具类，定义了除了存取以外的集合常用方法。
方法
- reverse()//反转集合中元素的顺序
- shuffle()//随机重置集合元素的顺序
- sort()//升序排序(必须实现Comparable接口)
i/o框架
字节流
字节流的父类（抽象类）：
- InputStream:字节输入流
- public int read(byte[] b)//从流中读取多个字节，将读取到内容存入b数组，返回实际读到的字节数，末尾-1
- OutputStream:字节输出流
- public void write(byte[] b)//一次写多个字节，将B数组中所有字节，写入输出流
字节缓冲流
缓冲流：BufferedInputStream/BufferedOutputStream
- 提高IO效率，减少访问磁盘的次数
- 数据存储在缓冲区中，flush是将缓存区的内容写入文件中，也可以直接close
对象流
对象流：ObjectOutputSteam(序列化)/ObjectInputStream(反序列化)
要求：
- 序列化的类必须实现Serializable接口
- 序列化类中的对象属性要求实现serializable接口
- 序列化版本ID保证序列化和反序列化的类是同一个
- 使用transient(瞬间的)修饰属性，这个属性不能序列化
- 静态属性不能序列化
- 序列化多个对象,可以借助集合来实现
作用：
- 增强了缓冲区功能
- 增强了读写8种基本数据类型和字符串功能
- 增强了读写对象的功能
- readObject():从流中读取一个对象
- writeObject(Object obj):向流中写入一个对象
使用流传输对象的过程称为序列化，反序列化。
字符流
FileReader:
- public int read(char[] c)//从流中读取多个字符，将读取内容存入c数组，返回实际读到的字符数，如果达到文件的尾部，则返回-1.
FileWriter:
- public void write(String str)//一次写入多个字符，将b数组中所有字符，写入输出流
字符流的父类（抽象类）
- Reader:字符输入流
- Writer:字符输出流
字符缓冲流
缓冲流:BufferedReader/BufferedWriter
- 高效读写
- 支持输入换行符
- 可一次写一行，读一行
打印流
PrintWriter:
- 封装了print()/println()方法，支持写入后换行。
- 支持数据原样打印
转换流
桥转换流:InputStreamReader/OutputStreamWriter
- 可将字节流转换为字符流
- 可设置字符的编码方式
