JavaEE

链接x963

.+

JavaSe笔记

一、基础班知识点

1、交换数据，打乱顺序：

int temp = arr[i];
    arr[i] = arr[index];
    arr[index] = temp;

2、String字符串的用法

//1、public int length(): 获取字符串的长度
System.out.println(s.length());
// 2、public char charAt(int index): 获取某个索引位置处的字符
char 变量名 = 字符串.charAt(i);
System.out.println(s.charAt(1));
System.out.println(s.charAt(5));
//遍历
for (int i = 0; i < s.length(); i++) {
    System.out.print(s.charAt(i));
}
System.out.println();
// 3、public char[] toCharArray(): 把字符串转换成字符数组
System.out.println("===========");
char[] chars = s.toCharArray();
//遍历数组
for (int i = 0; i < chars.length; i++) {
    System.out.print(chars[i]);
}

// 4、public String substring(int beginIndex, int endIndex) ：截取内容，(包前不包后的)
System.out.println("\n" + s.substring(2, 7));
System.out.println("\n" + s.substring(0, 8));
// 5、public String substring(int beginIndex):从当前索引一直截取到末尾
System.out.println("\n" + s.substring(0));
System.out.println("\n" + s.substring(7));
// 6、public String replace(CharSequence target, CharSequence replacement)：
// 使用新值，将字符串中的旧值替换，得到新的字符串
System.out.println("\n" + s.replace("小", "大"));
// 7、public boolean contains(CharSequence s)：判断字符串中是否包含了某个字符串
System.out.println("\n" + s.contains("小"));
System.out.println(s.contains("大"));
// 8、public boolean startsWith(String prefix)：判断字符串是否以某个字符串内容开头
System.out.println("\n" + s.startsWith("小"));
System.out.println(s.startsWith("浩"));
// 9、public String[] split(String s): 按照某个内容把字符串分割成字符串数组返回
String s1 = "小,浩,浩,lo,ve";
String[] name = s1.split(",");
for (int i = 0; i < name.length; i++) {
    System.out.println("\n" + name[i]);
}
// 10、public String trim()：删除字符串首尾空格，返回一个新字符串
String s2 = "  小浩浩  ";
String name1 = s2;
System.out.println("\n" + name1.trim());
// 11、public String toUpperCase()：将此 String所有字符转换为大写
String s3 = "Syl123";
String s4 = "傻吴wzy";
System.out.println("\n" + s3.toUpperCase());
System.out.println("\n" + s4.toUpperCase());

#### 3、ArrayList集合的用法

// 1、public boolean add(E e)： 将指定的元素添加到此集合的末尾
list.add(“小浩浩”);
list.add(“小叶叶”);
list.add(“小吉吉”);
list.add(“小白白”);
list.add(“小花花”);
list.add(“小黑黑”);
System.out.println(list);
// 2、public void add(int index,E element)：往集合中的指定索引位置处添加一个数据
list.add(3, “小喽啰”);
System.out.println(list);
// 3、public E get(int index)：返回指定索引处的元素
System.out.println(list.get(4));
System.out.println(list.get(0));
// 4、public int size()：返回集合中的元素的个数
System.out.println(list.size());
// 5、public E remove(int index)：删除指定索引处的元素，返回被删除的元素
System.out.println(list.remove(3));
System.out.println(list);
// 6、public boolean remove(Object o)：删除指定的元素，返回删除是否成功
System.out.println(list.remove(“小啵啵”));
System.out.println(list.remove(“小黑黑”));
System.out.println(list);
// 7、public E set(int index,E element) 修改指定索引处的元素，返回被修改的元素
System.out.println(list.set(3,“小蓝蓝”));
System.out.println(list);

    //遍历arraylist集合:size(),get()
    for (int i = 0; i < list.size(); i++) {
        System.out.print(list.get(i)+ " " + "\n");
    }
    System.out.println("=============");
    //增强for循环
    for (String o : list) {
        System.out.println(o + " ");
    }
}

}

## 二、静态static&继承
#### 1.有static修饰的成员变量叫什么？怎么访问？有啥特点？
类变量（静态成员变量）
![image.png](https://img-blog.csdnimg.cn/img_convert/cd1be28ec11fcaa8b16edbe43735c770.png)
特点：属于类，与类一起加载一次，在内存中只有一份，会被类的所有对象共享
###### 1.1 类变量：属于类，与类一起加载一次，在内存中只有一份，可以被类和类的所有对象共享。
###### 1.2 实例变量：属于对象，每个对象中都有一份，只能用对象访问。
#### 2.类方法的常见应用场景
###### 2.1类方法最常见的应用场景是做工具类
###### 2.2工具类是什么？
2.2.1、 我们有时候会开发一些非常实用的、具有独立功能的方法，而且希望这些方法可以被重复使用，就像一个个小工具一样。
2.2.2 、这些方法所在的类，就被我们称为是工具类，而工具类中的方法，我们习惯上设置为类方法。
2.2.3、为什么工具类要用类方法，而不是用实例方法？
类方法可以不创建对象，直接调用，使用方便。
节省内存实例方法需要创建对象来调用，会浪费内存。
2.2.4、工具类定义时有什么建议？
工具类不需要创建对象，建议将工具类的构造器私有化
#### 3.使用类方法、实例方法时的几点注意事项
###### 3.1、类方法中可以直接访问类的成员，不可以直接访问实例成员。
static方法能访问static的成员，不能访问非static成员
###### 3.2、实例方法中既可以直接访问类成员，也可以直接访问实例成员。
非static方法，访问一切
###### 3.3、实例方法中可以出现this关键字，类方法中不可以出现this关键字的。
本质：静态的内容是跟随类加载而加载的，此时还没有对象，也就没有this和实例内容
总结:
    1. 静态方法只能访问静态内容,实例方法可以访问任何内容
    2. 静态方法中不能用this
#### 4.代码块
4.1、代码块概述
代码块是类的5大成分之一（成员变量、构造器、方法、代码块、内部类）。
代码块分为两种：
1.静态代码块：
格式：static{}
特点：类加载时自动执行，由于类只会加载一次，所以静态代码块也只会执行一次。
作用：完成类的初始化，例如：对类变量的初始化赋值。
2.实例代码块（了解）：格式：{}
特点：每次创建对象时，执行实例代码块，并在构造器前执行。
作用：和构造器一样，都是用来完成对象的初始化的，例如：对实例变量进行初始化赋值。

![image.png](https://img-blog.csdnimg.cn/img_convert/c45606145a638fdf2f243e4abdff62f3.png)
#### 5.继承
5.1什么是继承 ?  继承后有啥特点 ？
继承：就是用extends关键字，让一个类和另一个类建立起一种父子关系。
特点：子类能继承父类的非私有成员变量和方法子类。
内部可以使用父类的非私有成员变量和方法。
5.2对象创建出来后，可以直接访问哪些成员？
对象能直接访问什么成员，是由子父类这多张设计图共同决定的，这多张设计图对外暴露了什么成员，对象就可以访问什么成员。
5.3继承有什么好处？
减少重复代码的编写。
#### 6.权限修饰符和单继承
权限修饰符有几种：各自的作用是什么
1.private只能本类(本类)
2.缺省本类、同一个包中的类(本类、本包)
3.protected本类，同一个包中的类、子孙类中(本类、本包、本后代) 
4.public任意位置（任意）
private<缺省< protected <public
![image.png](https://img-blog.csdnimg.cn/img_convert/b0c7f0489a2667de51ba57fca54055c7.png)
###### 单继承
Java是单继承的，Java中的类不支持多继承，但是支持多层继承（继承链）。
1、继承相关的两个注意事项？
Java是单继承的：一个类只能继承一个直接父类；Java中的类不支持多继承，但是支持多层继承。
Object类是Java中所有类的祖宗。我们写的任何一个类，其实都是Object的子类或子孙类。
#### 7.方法重写
###### 7.1、什么是方法重写？
 当子类觉得从父类中继承到的某个方法不好用，或者无法满足自己的需求时，子类可以重写一个方法名称、参数列表一样的方法，去覆盖掉继承到的这个方法，这就是方法重写。
 注意：重写后，方法的访问会遵循就近原则 。
2、方法重写的其它注意事项
2.1、在重写的方法上标注Override注解，可以指定java编译器，检查我们方法重写的格式是否正确。
2.2、子类重写父类方法时，访问权限必须大于或者等于父类该方法的权限（ public > protected > 缺省 ）
2.3、重写的方法返回值类型，必须与被重写方法的返回值类型一样，或者范围更小。
2.4、私有方法、静态方法不能被重写，如果重写会报错的。
#### 8.子类中访问其他成员的特点
###### 8.1、在子类方法中访问其他成员（成员变量、成员方法），是依照就近原则的。
先子类局部范围找。
然后子类成员范围找。
然后父类成员范围找，如果父类范围还没有找到则报错。
###### 8.2、如果子父类中，出现了重名的成员，会优先使用子类的，如果此时一定要在子类中使用父类的怎么办？
可以通过super关键字，指定访问父类的成员：super.父类成员变量/父类成员方法.
#### 9.子类构造器
###### 9.1、特点：子类的全部构造器，都会先调用父类的构造器，再执行自己。
###### 9.2、子类构造器是如何实现调用父类构造器的：
默认情况下，子类全部构造器的第一行代码都是 super() （写不写都有） ，它会调用父类的无参数构造器。如果父类没有无参数构造器，则我们必须在子类构造器的第一行手写super(….)，指定去调用父类的有参数构造器。
###### 9.3、子类构造器调用父类构造器的应用场景
我们经常在子类构造器中调用父类的有参构造器给父类传递参数来完成父类对象的初始化
###### 9.4、补充知识：this(…)调用兄弟构造器
 任意类的构造器中，是可以通过this(…) 去调用该类的其他构造器
###### 9.5、this(...)和super(…)使用时的注意事项：
this(…) 、super(…) 都只能放在构造器的第一行，因此，有了this(…)就不能写super(…)了，反之亦然。	
## 三、多态&抽象类&接口
#### 1.多态
###### 1.1什么是多态？多态是在继承或者实现情况下的一种现象，表现为：对象多态、行为多态（同一个对象，调用父类的同一个方法，结果不同）。
###### 1.2多态的具体代码体现
![image.png](https://img-blog.csdnimg.cn/img_convert/899d17a56d14efec0b190bf70645eb73.png)
###### 1.3多态的前提有继承/实现关系；存在父类引用指向子类对象；存在方法重写。 
多态的一个注意事项
多态是对象、行为的多态，Java中的属性(成员变量)不谈多态。
###### 1.4、调用成员变量：
编译看左边：javac编译代码的时候，会看左边的父类中有没有这个变量，如果有，编译成功，如果没有编译失败。
运行也看左边：java运行代码的时候，实际获取的就是左边父类中成员变量的值
###### 1.5、调用成员方法：编译看左边，运行看右边
编译看左边：javac编译代码的时候，会看左边的父类中有没有这个方法，如果有，编译成功，如果没有编译失败。
运行看右边：java运行代码的时候，实际上运行的是子类中的方法。
#### 2.多态的好处
###### 2.1、在多态形式下，等号左右两边松耦合，更便于修改和维护
###### 2.2、定义方法时，使用父类类型的形参，可以接收一切子类对象，扩展性更强、更便利
###### 2.3、多态的弊端
多态下不能使用子类的独有功能。引出的：2.4和2.5
###### 2.4、类型转换
自动类型转换：父类 变量名 = new 子类(); 
强制类型转换：子类 变量名 = (子类) 父类变量
###### 2.5、类型转换注意事项
存在继承/实现关系就可以在编译阶段进行强制类型转换，编译阶段不会报错。
运行时，如果发现对象的真实类型与强转后的类型不同，就会报类型转换异常（ClassCastException）的错误出来。
###### 2.6、instenceof
如果想避免风险,可以所在使用前使用instenceof判断数据类型
#### 3.final（面试题）
###### 3.1、final 关键字是最终的意思，可以修饰（类、方法、变量）
修饰类：该类被称为最终类, 类不能再被继承
修饰方法：该方法被称为最终方法, 方法不能被重写
修饰变量：该变量只能被赋值一次, 赋值完毕之后不能再修改
成员变量: 声明时或者在构造方法结束之前完成赋值
局部变量: 在使用之前完成赋值
###### 3.2、final修饰变量的注意
final修饰基本类型的变量，变量存储的数据不能被改变。
final修饰引用类型的变量，变量存储的地址不能被改变，但地址所指向对象的内容是可以被改变的。
#### 4.抽象类
###### 4.1、什么是抽象类？
在Java中有一个关键字叫：abstract，它就是抽象的意思，可以用它修饰类、成员方法。
abstract修饰类，这个类就是抽象类；修饰方法，这个方法就是抽象方法。
###### 4.2、抽象类的特点
4.2.1抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类。
4.2.2类该有的成员（成员变量、方法、构造器）抽象类都可以有。
4.2.3抽象类最主要的特点：抽象类不能创建对象，仅作为一种特殊的父类，让子类继承并实现。
4.2.4一个类继承抽象类，必须重写完抽象类的全部抽象方法，否则这个类也必须定义成抽象类。（父债子偿）
###### 4.3、抽象类的场景和好处
多个类中只要有重复代码（包括相同的方法签名），我们都应该抽取到父类中去，此时，父类中就有可能存在只有方法签名的方法，这时，父类必定是一个抽象类了，我们抽出这样的抽象类，就是为了更好的支持多态。
###### 4.4、模板方法设计模式
4.4.1、模板方法设计模式解决了什么问题？
一个功能的完成需要经过一系列步骤,这些步骤是固定的,但是中间某些步骤具体行为是待定的,在不同的场景中行为不同
1、定义一个抽象类(父类)，提供模板方法
2、模板方法中，需要让子类自己实现的地方，定义为抽象方法
3、子类只需要继承该抽象类，重写抽象方法即可完成些完成的功能
4.4.2、多学一招:建议使用final关健字修饰模板方法
模板方法是给对象直接使用的，不能被子类重写。一旦子类重写了模板方法，模板方法就失效了。
###### 4.5、象类的作用是什么样的？
抽取共性时，无法确定方法体（打印语句不一样），就把方法定义为抽象的。
强制让子类按照某种格式重写。
抽象方法所在的类，必须是抽象类。
#### 5.接口
###### 4.5.1、认识接口
Java提供了一个关键字interface，用这个关键字我们可以定义出一个特殊的结构：接口。
public interface 接口名 {      
            成员变量（接口中的成员变量都是常量, 默认是被public static final修饰的）        
            成员方法（接口中的成员方法都是抽象方法, 默认是被public abstract修饰的）
JDK7以前：接口中只能定义抽象方法。
JDK8的新特性：接口中可以定义有方法体的方法
JDK9的新特性：接口中可以定义私有方法
           注意: 接口中不能有构造方法和代码块     
}
###### 4.5.2、注意事项
1.   接口不能直接创建对象
2.   接口是用来被类实现（implements）的，实现接口的类称为实现类。
3.   一个类可以实现多个接口，实现类实现多个接口，必须重写完全部接口的全部抽象方法，     
  否则实现类需要定义成抽象类。    
4.格式
修饰符 class 实现类 implements 接口1, 接口2, 接口3 , ... {
###### 4.5.3、接口的好处
（重点是理解）让程序可以面向接口编程，这样程序员就可以灵活方便的切换各种业务实现。(解耦合)
###### 4.5.4、接口和类之间的关系
类和类的关系：
继承关系，只能单继承，不能多继承，但是可以多层继承.
类和接口的关系：
实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实王见多个接口
接口和接口的关系：
继承关系，可以单继承，也可以多继承
## 四、内部类&泛型&常用Api
#### 1、内部类
##### 1.1、概念
内部类是类中的五大成分之一（成员变量、方法、构造器、代码块、内部类）如果一个类定义在另一个类的内部，这个类就是内部类。场景：当一个类的内部，包含了一个完整的事物，且这个事物没有必要单独设计时，就可以把这个事物设计成内部类。
##### 1.2、内部类分为四种
###### 1.2.1成员内部类[了解]：位于一个类里面成员位置的类
就是定义在一个类中成员位置的类，在内部类中也可以定义成员属性和方法
![image.png](https://img-blog.csdnimg.cn/img_convert/4a86eef00d933a3ad84a7dbe74d4f139.png)
###### 1.2.2成员内部类中访问其他成员的特点：
1、成员内部类中可以定义实例成员，静态成员 (注意: 静态成员从JDK16开始支持)
2、成员内部类中的实例方法中，可以直接访问外部类的实例成员，静态成员
3、如果内部类和外部类出现了重名的成员，可以通过(外部类名.this.xxx) 强行访问外部类的成员
###### 1.2.3、静态内部类[了解]：使用static修饰的成员内部类
使用static修饰的成员内部类
![image.png](https://img-blog.csdnimg.cn/img_convert/dae048089d38b042f7c7497e55ae1d4a.png)
###### 1.2.4、静态内部类中访问外部类成员的特点
可以直接访问外部类的静态成员，不可以直接访问外部类的实例成员。
###### 1.2.5、局部内部类[了解]：在方法里面定义的类
###### 1.2.6、匿名内部类[重点]：一种特殊的局部内部类
这是一种特殊的局部内部类
所谓匿名：指的是程序员不需要为这个类声明名字
#### ![image.png](https://img-blog.csdnimg.cn/img_convert/4dd4a278d052a61de526446d66bff82c.png)
###### 1.2.7、作用：更方便的创建一个子类对象(简化操作类、接口的代码)
本质：匿名内部类本质就是一个子类，并会立即创建出一个子类对象
场景:通常作为一个参数传输给方法
#### 2、泛型
##### 1.1概念
定义类、接口、方法时，同时声明的类型变量（如：<E>） ，称为泛型。
![image.png](https://img-blog.csdnimg.cn/img_convert/660d402b362ec27c6c0b09db4739c8d4.png)
1.1.1、作用：泛型提供了在编译阶段约束所能操作的数据类型，并自动进行检查的能力！这样可以避免强制类型转换，及其可能出现的异常。
1.1.2、本质：把具体的数据类型作为参数传给类型变量
1.1.3分类：泛型类、泛型接口、泛型方法
## 五、
##### 1、BigDecimal
###### 1.1、bigDecimal的作用是什么？
表示较大的小数和解决小数运算精度失真问题。
###### 1.2、BigDecimal的对象如何获取?两种方式
BigDecimal bd1 = new BigDecimal("较大的小数");
BigDecimal bd2 = BigDecimal.valueOf(0.1);
###### 1.3、常见操作加：add
减：subtract
乘：multiply
除：divide（四舍五入：RoundingMode.HALF_UP)