javase重开2022年9月21日

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分

成员变量

就是预先在其他类中定义的各种类型的变量

是属于对象的

也可以预先给定成员变量初始值

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

成员方法

java给封装好的方法

方法

一堆语句的集合
- 需要有返回值
- 可以没有返回值
- 主方法不能有返回值只能为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();

		}

	}

}

```