看不懂的话进去看看
1.Java的三个版本
JAVASE 基本
JAVAME 微缩
3.java的特点
跨平台：jvm将java文件转变为字节码文件（.class）在多个系统中运 行字节码文件
5.Java的三个组件
JDK 语言开发包
JRE 运行环境
JVM 虚拟机
6.基本数据类型
整数：byte(1字节) short(2) int(4) long(8)
浮点：float(4) double(8)
字符串：char(2)
布尔：boolean
5.基本数据类型精度
byte<short<char<int<long<float<double
6. 基本数据类型之间的转换规则
1.低精度给高精度 自动转换
2.高精度给低精度 强制转换
3.不同类型进行运算时，先将低精度转为高精度，精度一致后再进行计算
7.break,continue
break 跳出循环
cotinue 跳出本次循环
8.三目运算符
判断条件?条件满足:条件不满足
9.switch 数据类型
buty,short,int,char,String
10.while do..while区别
while 先判断后执行
switch 数据类型 buty,short,int,char,String
11.获取控制台的信息
Scanner s1=new Scanner(System.in);
while (s1.hasNext()){
String str1=s1.next();
12.数组的缺点
13.创建多维数组:
1.int[ ][ ] a1=new int[3][ ];
a1[0]=new int[1];
2.int[ ][ ] a1=new int[3][ ];
3. int[][] a3={{1},{2,3},{4,5,6,7},{7,4,5,1}};
14.冒泡排序
int[] arr = {2, 11,4,7,5,22,15,37,12,1};
int zjvalue = 0;//中间值
boolean boo=false;
//冒泡比较相邻元素将小的提前打的放后
//外层循环时用来控制轮数
//内存循环控制每一轮的；排序
//每个元素都走完一遍全部的长度
for (int i = 0; i < arr.length ; i++) {
boo=false;
//每一轮排序都会将最大的一个排到最后 所以-i
for (int j = 0; j <arr.length - 1-i; j++) {
if (arr[j] > arr[j + 1]) {
//存储小的值
zjvalue = arr[j];
//把大的值赋给小的
arr[j ] = arr[j+1];
//把小的值赋给大的
arr[j+1] = zjvalue;
}
boo=true;
}
if (boo==false){
break;
}
}
for (int a : arr) {
System.out.print(a + ",");
}
System.out.println();
15.杨辉三角
int[][] arr=new int[7][];
for (int i = 0; i < arr.length; i++) {
arr[i]=new int[i+1];
}
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j <arr[i].length ; j++) {
if (j==0||j==arr[i].length-1){
arr[i][j]=1;
}else{
arr[i][j]=arr[i-1][j]+arr[i-1][j-1];
}
}
}
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j <arr[i].length ; j++) {
System.out.print(arr[i][j]);
}
System.out.println();
}
16.递归算法的条件
递归：
//1.有出口
17.数组的三个方法
1.是否相等 Arrays.equals
2.复制：system.arraycopy
arraycopy(Object src, int srcPos, Object dest, int destPos,int length);
3.排序Arrays.sort
18.String的方法 （至少十个）
1。charAt()
2。replace() 替换字符串 ,replace(旧内容，新内容) 全部对应元素都要改变 str2.replace("a","q");
3。isEmpty() 判断字符串是否为空
4。concat() 连接字符串
6。indexOf() 查询字符第一次出现的位置
7。lastIndexOf() 查询字符最后一次出现的位置
8.endsWith() 判断字符串是否以。。。结尾
9。toUpperCase()
10。toLowerCase()
11。contains()
12。subString() 截取字符串
13。split() 拆分字符串，变成数组
14。equals() 判断字符串是否相等
15。compareTo() 比较两个字符串
1.如果相同返回0；
2.第一次不同如果是数值,返回长度差
第一次不同如果是字符,返回两个字符的Ascrll码的差值
16. startsWith("a");以。。开始
17.lenght() 数组长度
19.Math的方法10个
1.Math.max(20.0,10) 最大值 二选一
2.Math.min(20.0,10) 最小值
3.Math.abs(2-1) 绝对值
4.Math.ceil(9.1)相上取整 浮点数
5.Math.floor(8.9) 向下取整
6.Math.round(8.6)四舍五入
7.Math.pow(x,y) x的y次幂'
8.Math.sqrt(64)开平方
9. Math.random()[0,1)随机数
10.Math.PI 圆周率
20.全局遍历和局部变量的区别
//【区别】:1.初始值不同：成员变量有系统给定的默认值
//局部变量没有初始值 需要使用必须赋予初始值
//2.作用域:成员变量可以在整个类中使用；
//局部变量只能在声明的区域内使用
//3。内存地址不同：成员变量存储在堆，局部变量存储在栈
21.什么是面向对象及其特征
//1.面向对象：面向对象是一种编程思想，所有的操作都是针对对象的属性和方法进行操作
//万事万物皆对象
// 2.面对对象的特征：封装，继承，多态，抽象
22.什么是类什么是对象
//3。类：class,类就是描述事物的抽象概念，可以看作一类物的模板
//4.对象：对象就是类的具体实例
//5.类与对象的关系：类是对象的模板，对象是类的实例
23.构造方法
//【构造方法】：1.没有返回值也不用加void
//2.方法名和类名一样
//构造方法：默认无参构造方法--当没有 有参构造方法时，可写可不写，系统默认提供
//当有了构造方法 需要使用无参构造方法时，必须写出来无参构造；
24.值传递与==
//值传递：
//1.基本数据类型传递的是值
//2.类类型传递的是地址
//==
//1.基本数据类型比较的是值
//2.类类型比较的是地址
25.静态
//关键字 static:静态
//静态修饰的对象： 变量 方法 代码块
//静态修饰的变量：1.调用方法： 引用.静态变量；类名.静态变量
//2.在类加载到内存时，还没有创建对象就已经分配了内存
//3.静态只能调静态
// 静态修饰 的方法：1.静态方法只能访问静态成员变量
//2.静态方法中，不能使用this和super
//3.静态方法只能调用其他的静态方法；不能调用其他实例方法
//静态修饰的代码块：类的加载顺序1.静态代码块在没有创建对象之前，【主动执行一次】
//2.非静态代码块，在【每次】创建对象之前都会主动执行一次
26.封装的概念及其可见性和好处
//【封装】：java把变量和方法封装到类中，通过可见性实现封装
//可见性：
//1.public：公共的 在工程中可见
//2.protected:受保护的，当前类可见，本包可见，外包的子类
//3.default: 不写的时候(默认) 本类，本包可见；
//4.private:私有的，本类可见
//【封装的好处】：1.提供方法名供外界调用
// 2.对内隐藏数据，防止被破坏
27.包装类已经自动装箱，自动拆箱
//int------Integer *
//char---Character *
//【自动装箱】:把基本数据类型转换成对应的封装类
//【自动拆箱】：把封装类转换成基本数据类型
28.重载与重写
【重载 Overload】:在同一个类中 方法名相同，参数的个数或类型不同；
//【重写 @Override】 ：在子类重写父类方法时，同名，同参，同返回类型 ；
//重写后的子类的可视性不能比父类的可视性更严格
29.有继承关系的加载顺序
//（前两步）只执行一次
//父类静态代码块
//子类静态代码块
//（后四步）每次对象创建就执行一次
//父类非静态代码块
//父类构造方法
//子类非静态代码块
//子类构造方法
30.//【继承关系中的构造方法】
// 1.父类和子类都没有构造方法时，系统会给父类与子类分别提供默认的无参构造方法（父类只提供父类，子类提供父类和子类）
//2.如果父类存在有参构造方法，子类必须在构造方法的第一行用super(传参)调用父类的构造方法
31.【super】
//1.区分父类的成员变量和子类的成员变量
//2.子类可以在第一行用super(传参)调用父类的构造方法
//3.子类可以在实例方法用super.实例方法 来调用父类的实例方法
32.This
1.区分成员变量和局部变量
//2. 在构造方法的第一行,用this(传参)调用其他的构造方法
//3.在实例方法使用this.方法名调用其他的实例方法
// 33. 【final】
1.final 定义的量叫常量，一经修改就不能改变
//2.final 修饰的类不能被继承
// 3.final 修饰的方法不能被重写但可以重载
34.// 【向上转型】 【向下转型】 动态绑定
//【向上转型】:父类的引用指向子类的对象
//1.只能调用父类的方法和父类的属性,不能调用子类的方法和属性；
//2.如果子列重写了父类的方法，调用的是子类的重写方法
//【向下转型】:父类的引用 赋值给子类的引用
//1.可以调用父类和子类的属性和方法
//2.父类的引用必须是：向上转型的引用
3.向下转型的子类必须和向上转型的子类一致
动态绑定 ：在执行期间 而非编译期间，判断引用的类型，根据实际情况调用方法和属性
35.抽象及其在描述抽象时不可以使用的关键字
//[抽象]:共性的内容抽取到父类,但是某些内容无法在父类中具体实现
//1.抽象方法只有方法声明,没有方法体({})
//可见性 abstract 方法名();
//2.包含抽象方法的类必须声明为抽象类
//3.抽象类里可以有实例反法,构造方法和属性
//4.抽象类不能直接new对象,用来给子类new对象和初始化成员变量
//5.继承抽象类的子类,必须重写父类所有的抽象方法
//final因为final类 不能继承,final方法不能被重写
//static 在类加载时已经分配了内存,无法继承和重写
//private仅本类可见,外包无法访问
//使用抽象方法: 必须要重写,有共性
36.接口
//[关键字]:声明接口 interface
//:实现接口 implements
//1.默认被 public static final 修饰的静态常量;
//2.不能写构造方法
//3. 默认被public abstract修饰的抽象方法
//4.接口可以多实现,用","分割
//5.接口可以继承接口 可以【多继承】（java单继承）
//接口 extends 接口1，接口2.。。
//6.如果类是带有继承关系的接口，
//那就需要把所有父接口和子接口的抽象方法全部实现一遍
接口回调
接口的对象指向了 （已经实现了此接口）类的对象
// 这个变量只能调用此接口和父接口在实现类中重写和方法和属性（此接口）
37.java集合体系
//6个接口： 单列 :Collection,(父接口)
// 1.List 有序（有下标，存储位置）（不能去重）
// 2.set 无序（无法使用下标）（可以去重）
//2.1 SortedSet
// 多列：Map
// 1.SortedMap
//一个工具类：Collections
38.[泛型]：
在集合中用来规定集合的类型
List： 实现类，及其区别
Arraylist 2.LinkedList
//1.ArrayList底层是数组存储，LinkList底层是双向列表
//2.ArrayList适合查找，LinkList适合增删
39.List的常用方法
//1.添加元素(在末尾添加，指定位置添加)add可以添加null 并在集合中出现 返回的是布尔类型
//2.删除元素 remove
//3.清空集合
//4。判断是否为空 isEmpty()
//5.查看集合是否包含某个元素 contains
//6.查找元素下标 indexOf
40.遍历集合三种
//1.for-each循环 元素 集合是整数类型，当有null不能使用，会有空指针异常
for (int i:list1){
System.out.println(i);
}
//2.下标长度 list1.size() 获取值 list1.get(i)
for (int i=0;i<list1.size();i++){
System.out.println(list1.get(i));
}
//迭代器 Iterator 是一个接口 提供了遍历集合的方法
Iterator<Integer> it = list1.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
41.// LinkList 独有的方法
//独有的 打印第一个值：list2.getFirst()
//打印最后一个值：list2.getLast()
//删除第一个值： list2.removeFirst();
//删除最后一个值：list2.removeLast();
42.集合 数组互转
//List和数组转换
//1.集合转数组list1.toArray();
//2.数组转集合Arrays.asList(brr);
Set及其接口的实现类和子接口实现类的区别
//【Set】:继承于Collection集合(无序)
//实现类：HashSet
//【SortedSet】:set的子接口
//实现类：TreeSet
//HashSet
//1.去重，可以添加空 不可以选择添加的位置
//2.for-下标 不能使用 s1.get（i）报错
//3.indexOf 无法使用
//TreeSet
//1.不能添加null,按照数字，字母顺序排序，去重，无法通过指定下标写入
//2.for-下标 不能使用 s1.get（i）报错
//3.indexOf 无法使用
//4.不能添加存储类类型 需要重写compareTo方法；
重写equals
@Override
public boolean equals(Object obj){
// 对比的双方是本体 this指向前面的引用名
if (obj==this){
return true;
}
if (obj instanceof People){
People pp=(People)obj;
return pp.sfz.equals(this.sfz);
}else {
return false;
}
}
//在重写equals时，必须重写hashCode
@Override
public int hashCode() {
return Objects.hash(sfz);
}
Map的实现类与实现类的特点与区别
//【Map】:双列集合，键值对形式存储，映射关系(kay,value)
//实现：HashMap
//子接口：SortedMap Map的子接口
//实现类：TreeMap
//HashMap
//1。可以插入null
//2.key不可以重复 会覆盖value值
//3.value值可以重复
// TreeMap
1.key不可以为null
//1.添加 put 返回值不是布尔类型
获取key value和key value对（方法和返回值类型就行）
//2.遍历 普通for循环无法使用get
//1.key
//keySet() 返回值为Set集合 Key为int 存储不能为null
Set<Integer> setkey= m1.keySet();
for (int i:setkey){
System.out.print(i);
}
System.out.println();
//2.value
//values() 返回值为Collection
Collection<String> cc=m1.values();
Iterator it=cc.iterator();
while (it.hasNext()){
System.out.println(it.next());
// 3.key和valueentrySet 返回值为Set<Map.Entry<ket类型，value类型>>
Set<Map.Entry<Integer,String>> entry= m1.entrySet();
for (Map.Entry<Integer,String> en:entry){
System.out.print("key:"+en.getKey()+","+"value:"+en.getValue());
System.out.println();
}
Iterator it3=entry.iterator();
while (it3.hasNext()){
System.out.println(it3.next());
}
常见异常
//1.ArrayIndexOutOfBoundsException 数组下标越界异常
// 2.StringIndexOutOfBoundsException 字符串下标越界异常
//3.NullPointerException 空指针异常
//4.ClassCastException 类转换异常
//5.ArithmeticException 算术异常
//6.NumberFormatException 数字转换异常
50. 【异常的五个关键字】
// try： 指定一个代码块预防所有异常，需要紧跟catch
//后面可以跟多个catch,按照异常顺序捕获异常
//如果有0个catch必须跟上finally
//catch：放在try后面，用来捕获异常类型
//finally: 无论是否发生异常,fianlly都会执行
//在return之前执行.
//
//throws:放在方法名后面主动抛出异常;
//throw:放在方法体里,主动抛出异常;
51. [自定义异常];
//1.新建异常类,继承Execption类,创建构造方法,设置message信息
//2.在需要的地方 用throw new 新的异常类 来抛出异常
52.File的方法
System.out.println(f1.getPath());//地址
System.out.println(f1.getAbsolutePath());//绝对地址
System.out.println(f1.getName());//文件名
System.out.println(f1.exists());//文件是否存在
System.out.println(f1.length());//文件大小
System.out.println(f1.lastModified());//最后一次修改的毫秒数
//创建文件 createNewFile() 文件前的地址一定要存在否则报IoExecption
//创建目录
//mkdir 如果地址不存在 返回false 创建失败
//mkdirs 如果地址不存在 会把所有的父级目录全都创建一次
//创建文件 createNewFile() 文件前的地址一定要存在否则报IoExecption
//创建目录
//mkdir 如果地址不存在 返回false 创建失败
//mkdirs 如果地址不存在 会把所有的父级目录全都创建一次
//【i/o体系】：及其创建
//1.处理单位：字节流，字符流
// 2.处理流向：输入流，输出流
//3.处理功能：节点流，处理流
字节：
FileInputStream input=null;
FileOutputStreamoutput=null;
input=new FileInputStream(path); output=new FileOutputStream(path)
字节处理流：
BufferedInputStream input = null;
BufferedOutputStream output = null;
input = new BufferedInputStream(new FileInputStream(path));
output = new BufferedOutputStream(new FileOutputStream(path)
字符：
FileReader input = null;
FileWriter output = null;
input = new FileReader(path;
output = new FileWriter(path);
字符 处理流
BufferedReader input = null;
BufferedWriter output = null;
input = new BufferedReader(new FileReader(path) {
});
output = new BufferedWriter(new FileWriter(path));
54.字节流和字符流用于读取什么文件
//字节流：适合处理音频，视频，图片读取汉字 分成三个数字
//字符流：通常适合用于处理汉字多的文本文件 读取汉字 分成一个数字
Write和append的区别
write 不可以写空 append可以为空
Write穿的是 int 和byte
append可以直接串String
