Boolean类型

java中 返回true or false
而在C语言中 返回0表示false 其余皆为true

类型转换

隐式类型转换

隐式类型转换支持字节数小的类型自动转换为字节数大的类型，整数类型自动转换为小数类型，转换规则如下：
● byte→short(char)→int→long→float→double

是全长度参与计算 , 所以看似小的float也可以容纳long , 只是会丢失部分精度

显示类型转换

显式类型转换也叫做强制类型转换，也就是说，违反隐式转换的规则，牺牲精度强行进行类型转换。

String builder

int a = 1;
int b = 2;
System.out.println(a+b);
// 输出 12   调用String builder方法相加

for循环

for无限循环

for (; ; ) {
        //循环执行的内容
        }

for(;?{}
while(true){}

2022年9月26日19:49:02

算法问题收集:
相同
青蛙台阶问题
斐波那锲数列
通项公式

递归
    if (n == 0 || n == 1) return 1;
    return fib(n - 1) + fib(n - 2);

2022年10月4日20点31分

String是一个类 不是基本类型 String定义的变量也是引用类型的变量
scanner内部使用流 用完之后需要close();

2022年10月5日12点21分

1. 成员变量
   就是预先在其他类中定义的各种类型的变量
   是属于对象的
   也可以预先给定成员变量初始值

• int整型不给初始值 默认是0
• String不给初始值 默认是null

2. 成员方法

• java给封装好的方法

3. 方法

• 一堆语句的集合
  • 需要有返回值
  • 可以没有返回值
  • 主方法不能有返回值 只能为void

在方法中 return是直接结束程序 break是跳出循环 然后继续向下执行

21点33分
基本类型只会传值 而引用类型会带着变量而变化

2022年10月10日21:17:10

• 成员属性
  指对象所具有的,某具体的对象才能使用的属性
  实例化出来的对象能直接进行使用的属性才叫做成员属性
• 静态变量和静态方法
  是属于类的内容 , 是所有对象共享的
  -- 通过static声明后的变量或者方法是静态的
  所有通过这个类创建的对象都是操作的同一个目标 , 一旦被改变 那么之后读取的都是改变后的值
  一般直接通过类调用静态属性 而不是通过实例化后的对象
  在java中 每一个类生成一个.class文件,丢给JVM去执行, 而JVM并不会一开始就加载全部的类和方法
  • 只有遇到
    - 访问类的静态变量 , 或者为静态变量赋值
    - new创建类的实例(隐式加载)
    - 调用类的静态方法
    - 子类初始化时
    所有静态内容(含有static关键字) 会在类刚加载的时候就分配 而不是实在对象创建的时候分配 , 所以 静态的内容会在第一个对象初始化前加载完成

2022年10月12日14:40:27

• 如果全部都有被调用 则顺序为

  • 静态变量
  • 静态代码块
  • 成员变量
  • 普通代码块
  • 构造方法
    反之如果没有调用 则不会加载

• 访问权限控制
  public > protected > default(不指定) > private

  • 静态导入
    其作用是用于导入指定类的静态属性，这样我们可以直接使用静态属性

• 封装 , 继承 , 多态

  • 类的封装
    把对象和方法结合在一起成为一个整体 隐藏内部细节 提供访问接口
    目的是为了保证变量的安全性

2022年10月15日12:47:19

• 静态构造方法
  在类中采用static关键字+类名+封装名来直接封装构造方法

总结: 封装就是通过权限控制来实现对 类 的访问

• 继承
  • A extends B
    称B是A的父类 或者 超类(super)
    父类中可见的所有属性都可以被访问 除了 private
    而父类B无法直接使用子类A中的方法 , 只能使用自身所包含的所有方法
  • 在不同的类中 可以定义 重名的成员变量
    在子类存在和父类同名关键字时 如name 则要访问父类的name应该使用 super.name
• 区分
  • this.name是指当前的类
  • super.name是指父类(super不能连续向上)

2022年10月16日18:15:13

• 方法的重写

  • 含义
    将本来有的覆盖掉 体现了多态的 特性, 重载是 使方法 多样化
    2022年10月17日09:47:34

  • @Override
    使用该关键字进行说明检查

  • 在子类重写后的方法中调用重写前的方法 达到再次使用的目的
    使用super关键字

  • 禁止重写
    在方法中添加final关键字, 表示该方法已经是最终形态 , 不可再修改

  • final
    用在方法中 只能重载 不能重写

  • static方法
    无法使用this和super关键字

• 抽象

  • 概念
    只保留方法的定义 不编写方法的主体内容

• 抽象类

  • 一般只用作继承
  • 和普通类相比可以具有抽象方法
  • 同时可以有抽象方法和实现方法

• 抽象方法
  定义在抽象类中的带有abstract关键字的方法
  该方法由具体的子类来实现

  • 子类
    必须使用@override重写 实现 抽象方法(新建idea会提示实现抽象方法的重写)
  • 访问权限不能为private , 否则子类无法使用

2022年10月17日21:03:13

• 接口
  -接口可以有多个实现 , 但是在java中只能单继承
  -抽象方法默认实现
  - default void test(){}

2022年10月18日11:07:45

• 接口是 多继承
  • 重名方法
    • 允许重名方法,但是重名方法是直接进行覆盖 并非多个同名方法
  • 实现方法访问顺序(子类继承 实现接口)
    • 子类 -> 父类 -> 接口
  • Object类不能在接口中定义默认实现 只能抽象的调用
    直接定义默认实现是没有意义的 最终都会继承自Object

2022年10月20日16:13:34

• 枚举
  --- 属于java.lang.Enum

2022年10月21日21:11:46

• 基本类型包装类

  • 以对象的形式使用基本类型

  • 包装类:

    • Character
    • Number
      • short
      • Byte
      • Integer
        • 自动装箱

        Integer i = 10;
        相当于
        Integer i = Integer.valueOf(10);
        

        因为包装的是一个类 不是基本类型 所以是两个不同的对象(虽然值相等)
        • 自动拆箱

        Integer i  = 11;
        int a = i;
        

        虽然是引用类型 但是可以借助自动拆装直接参与运算
        自动装箱的相等 仅在range -128 to 127,如果超出 得到的对象就不想同了
      • Float
      • Double
    • Boolean
      void对应的包装类型也是Void

  • 特殊的包装类型

    • BigInteger
      • 不支持自动拆箱装箱
      • Integer属于final类型 不能再修改

        BigInteger i = BigInteger.valueOf(100);
        BigInteger o = i.multiply(BigInteger.TEN);
        System.out.println(i);
        System.out.println(o);
        输出
        100
        1000
        

      • 计算幂 数

      //        计算 幂
      	BigInteger a = BigInteger.valueOf(Long.MAX_VALUE);
      	BigInteger b = a.pow(100);
      	System.out.println(b);
      

2022年10月22日09:50:19

• 数组
  • 一维数组
    • foreach(增强for循环)
      用于遍历数组的每一个元素
      编译后还是普通的for循环格式 属于是皮肤了
      基本类型的数组不支持自动拆箱装箱
      由于基本类型和引用类型不同 所以int类型的数组不能被Object类型的数组变量接收
    • 数组支持向上转型

      String [] arr1 = new String[10];
      Object [] test = arr1;
      System.out.println(arr1.getClass());
      

    • 支持向下转型

2022年10月29日11:22:59

• 断言表达式
  • 属于jvm默认关闭的功能 判断失败会抛出错误 (作用不大)
  • 语法(先开启 在jvm中开启 -enableassertions)

    关键字 assert
    // 判断结果 true为继续运行
    	assert true;
    // 判断结果 false为跳出程序  返回错误1
    	assert false;
    // 举例
    	int a = 10;
    	assert a>10 : "a是大于10的"
    

  • 开启断言过程
    • 1
      
    • 2
      
    • 3
      
    • 效果
      • 断言判断为false
        
      • 断言判断为true
        
      • 举例(assert是错误提示)
        

2022年10月29日17:48:18

• 数学工具类

2022年10月30日15:29:06

• 数组工具类
  • Arrays
    • ToString 一维数组遍历

      int[] arr1 = new int[]{1, 23, 1};
      System.out.println(Arrays.toString(arr1));
      

    • deepToString多维数组遍历

      int [] [] array = new int[][] {{1,2,3},{3,5,9,7}};
      System.out.println(Arrays.deepToString(array));
      

    • equals 相等 true为相等 false不相等

      int [] a = new int[] {1,2,34,5};
      int [] b = new int[] {1,2,34,5};
      System.out.println("是否是用一个数组"+Arrays.equals(a,b));
      

      • 三维数组

        //        三维数组
        int[][][] a11 = new int[][][]{
        		{{1, 2, 34, 5}, {1, 2, 34, 5}},
        		{{1, 2, 34, 5}, {1, 2, 34, 5}}
        };
        int[][][] b11 = new int[][][]{
        		{{1, 2, 34, 5}, {1, 2, 34, 5}},
        		{{1, 2, 34, 5}, {1, 2, 34, 5}}
        };
        System.out.println(Arrays.deepEquals(a11,b11));
        

2022年12月4日18点44分

• 泛型
• 泛型&&数组工具类
  • 代码

   Arrays.sort(arr, new Comparator<Integer>() {
          @Override
          public int compare(Integer o1, Integer o2) {
              return 0;
          }
      });
  

  • 解释
    这里new Comparator 是一个接口

    比较其两个参数的顺序。当第一个参数小于、等于或大于第二个参数时，返回负整数、零或正整数。在前面的描述中，符号sgn（expression）表示数学符号函数，它被定义为根据表达式的值是负、零还是正返回-1、0或1中的一个。实现者必须确保所有x和y的sgn（compare（x，y））-sgn（compare，x））实现者还必须确保关系是可传递的：（（compare（x，y）>0）&&（compare）y，z）>0）表示比较（x，z）>0。最后，实现者必须确保compare（x，y）0表示所有z的sgn（compare，z）==sgn（比较（y，z。一般来说，任何违反这一条件的比较器都应明确指出这一事实。推荐的语言是“注意：此比较器强制执行与等于不一致的排序。”参数：o1–要比较的第一个对象。o2–要比较的第二个对象。返回：负整数、零或正整数，因为第一个参数小于、等于或大于第二个参数。抛出：NullPointerException–如果某个参数为空，并且此比较器不允许空参数ClassCastException–如果参数的类型阻止此比较器对其进行比较。
    总结: 返回大于零则大于 小于零则小于 等于零则等于

    	Arrays.sort(arr, new Comparator<Integer>() {
    		@Override
    		public int compare(Integer o1, Integer o2) {
    			return o2-o1;
    

// 返回值 大于0表示前面大 小于0表示前面小 等于0表示相等
// 可以写 前面减去后面 表示从小到大
// 或者 替换前后关系
// 则表示为 后面减去前面 表示从大到小
}
});
````

2022年12月8日

• 泛型 -- 类型擦除机制
  实际上 对于泛型而言 在编译后是执行对应的上界的类 普通不指定上界就是执行Object类
  其实际类型以上界为准 而不是用到谁就是什么类型
  换而言之 只要不指定 类型根据使用的类型而定

2022年12月9日

问题记录:

桥接方法没看懂, 此处编译后生成重写的桥接方法来调用 自己编写的方法

• 泛型类型不支持创建参数化类型数组

// 此处不能指定new出来的数组泛型的实际类型
Test<String>[] arr = new Test[10];

• 函数式接口
  属于1.8新特性 专供于lambda表达式
  lambda表达式: 必须是一个接口 接口中有且只有一个需要实现(未实现)的方法,也可以包含其他已经实现的方法
  • 例子
    • supplier

    @FunctionalInterface
    public interface Supplier<T> {
    	T get();
    }
    

2022年12月29日

• 二叉查找树
  特点 左孩子比结点小 右孩子比节点大
• 平衡二叉树
  • 一定是二叉查找树
  • 任意结点的左子树一定是一颗平衡二叉树
  • 从根结点开始 左右子树高度差不超过1 否则视为不平衡

2023年1月11日

• Map(键值对)
  • set
    • hashSet(无序创建线性表)
    • linkedHashSet(有序的线性表)
      本质上来说是一个LinkedHashMap, 其底层调用的都是map的方法
• stream流
  • filter(条件)
    过滤器 满足条件的都留下 (筛选的条件是什么)
  • distinct
    去除重复
  • collect
    整合最终结果
    collect(Collectors.toList()) // 整理起来 再转为list

2023年1月16日

- 问题记录:
	FileInputStream文件读取流, 再使用强制类型转换时输出会造成乱码

```
public class Main {
	public static void main(String[] args) {
//        绝对路径 完整的路径
//        FileInputStream inputStream = new FileInputStream("E:\\learning\\java2022\\javase_bili\\src\\main\\java\\new2\\se108相对路径和绝对路径\\new1.txt");
////        相对路径
//        FileInputStream inputStream1 = new FileInputStream("src/main/java/new2/se108相对路径和绝对路径/new1.txt");
//        项目 根目录
//        FileInputStream inputStream3 = new FileInputStream("new1.txt");
//        utf8中文字符  占三个字节
		try (FileInputStream inputStream3 = new FileInputStream("new1.txt")) {
			System.out.println(inputStream3);
//          字节流读取
			int i = inputStream3.read();
			System.out.println((char) i);
			int j = inputStream3.read();
			System.out.println((char) j);
			int k = inputStream3.read();
			System.out.println(k);
		} catch (IOException e) {
//			throw new RuntimeException(e);
			e.printStackTrace();
		}
	}
}
```