javaSE知识点总结

1.java数据类型分为几类几种

四类八种：
整数型： byte short int long
小数型 ：float double
字符型： char
布尔型 ：boolean

2.&&和&的区别？||与|的区别？

&&：只要两个条件中有一个为false，结果就为false。
||： 只要两个条件中有一个为true，结果就为true。
&：称为单与， 不管左边条件是否为false，右边都将参与运算。
|：称为单或，不管左边条件是否为true，右边都将参与运算。

3.前++和后++的区别？前–和后–的区别？

不参与运算时：前++（–）和后++（–）没有区别。
在参与运算时：前++（–）是先自身+1（-1）再赋值，后++（–）是先赋值再自身+1（-1）、

4.while与do-while的区别？

while:先判断条件为true执行，为false语法错误，一般用于范围较大的循环。
do{}while:先执行后判断，不管条件是否成立，最少执行一次。

5.break，continue，return三者的区别？

break:中断for循环,再循环和switch中使用。
continue：中断本次循环，进入下次循环，只能在循环中使用。
return：直接结束方法。

6.数组的定义方式有哪些？

数据类型[] 数组名 = new 数组类型[数组长度]；
数据类型[] 数组名 = new 数据类型[] {数据};
数据类型[] 数组名 = {数据1，数据2，… ,数据n}；

7. 方法（定义在类中的实际操作语句）

public static void text（int a）{ ）

                [return返回值];   //当反回值类型为void时，没有返回值，不写return语句
}

调用方法：方法名称（参数）；
形参为定义方法时定义的，此时并没有具体的数值，而实参则为调用方法时赋的具体的值，执行的操作为实参数据拷贝，赋值给形参。
实参和形参储存在不同的栈帧中，在对形参的数值进行操作时，不会影响到实参的数据。

8.方法递归

方法在执行过程中又调用自身的过程，称为递归。使用递归要满足以下三个条件：
1 一个大问题可以拆分为若干个小问题
2拆分后的子问题与原问题除了数据规模不同之外，解决的思路完全相同
3存在递归终止条件，即分到什么时候不用分也能得出结果
递归实质运行起来就是一个往下一层一层递下去再一层一层返回处理的过程（有些不用返回，没有返回值的可以理解为一个循环，因为上层执行语句的时候不需要返回值参与）

9.引用数据类型

三大引用类型分别为：类、数组与接口，他们的默认值为null。所有引用数据类型的变量，保存的都是存储内容的地址，并非实际的内容。另外，当引用数据类型的值为默认值null时，表示不指向任何对象，无法通过该引用数据类型进行任何操作，操作的话会产生NPE错误。

10.关键字

1.this：

1 this修饰成员变量 ：this.属性名称 表示直接从类中寻找同名变量，防止编译器的就近匹配原则产生bug。
2 this修饰方法：修饰成员方法：表示调用类中的成员方法。 this.方法名称
当有继承关系后，明确调用的是当前类的成员方法，加上this
调用构造方法： this（参数）;（构造方法之间才能相互调用）这种调用体现在，当一个构造方法是另一个构造方法的一部分时，可以调用this（参数）直接调用那部分构造方法，然后再写其他的语句。
3 this表示当前对象的引用：在语句中出现this时，当前方法或属性是哪个实例对象调用的，那么这个this就指代那个实例对象。

2.static

static与具体实例对象无关，是静态的，与类有关。
staitc修饰属性，称为类属性，静态属性，存放在JVM的方法区，类属性在没有对象时（即指代值为null时也可以使用，但是成员方法和成员变量不可以）也能使用。

3. super

super指的是父类对象
一般在子类与父类名字冲突时，使用super来区分，被super调用的变量就是父类的变量。

11内部类

将一个类定义在另一个类的内部，这个类就叫内部类。
内部类分为四种：成员内部类，静态内部类，方法内部类（局部内部类），匿名内部类
我们最需要注意的一点就是，内部类与其外部类之间无论使用什么权限对其各自的属性或方法进行封装，他们都仍然可以互相访问到对方的属性和方法，只不过有些情况是需不需要创建对象的区别。因为内部类仍然处在外部类的内部，我们可以认为它们可以是一体的。

12.代码块

四种代码块：
普通代码块：直接定义在方法内部，不加任何修饰符定义的代码块 { } ；代码块内部就是各个变量的作用域
构造块：直接定义在类中，{ }内的代码块 特别的 构造块优先于构造方法执行
静态代码块：一般用于初始化静态变量 使用static修饰，直接定义在类中的代码块。在类加载时执行一次。特别的，主类中的静态代码块会优先于主方法执行。
同步代码块：使用synchronized（）{}包裹起来的代码块，在多线程环境下，对共享数据的读写操作是需要互斥进行的，否则会导致数据的不一致性。同步代码块需要写在方法中。

13.面向对象

三大特性：封装、继承与多态

封装：

①、将属性私有化，被private修饰，加入权限修饰符
②、提供public修饰的方法让别人来访问使用
③、即使外界可以通过方法来访问属性了，但是也不能随意访问，因为可以在方法中加入限制条件。
④、设置getter、setter方法，给别人提供访问的路径，idea快捷键：alt+insert键快速生成

继承：·

父类静态代码块优先子类静态代码块执行，都是最早执行的
· 父类实例代码块和父类构造方法紧接着执行
· 子类的实例代码块和子类构造方法在接着执行
· 第二次实例化对象时，父类和子类的静态代码块都不会在执行

多态

对象的多态性，从概念上非常好理解，在类中有子类和父类之分，子类就是父类的一种形态 ，对象多态性就从此而来。
ps: 方法的重载 和 重写 也是多态的一种， 不过是方法的多态（相同方法名的多种形态）。
重载： 一个类中方法的多态性体现 。
重写： 子父类中方法的多态性体现。
多态的使用：对象的类型转换
类似于基本数据类型的转换：
向上转型：将子类实例变为父类实例 |- 格式：父类 父类对象 = 子类实例 ；
向下转型：将父类实例变为子类实例 |- 格式：子类 子类对象 = （子类）父类实例 ；

14Object类

Object是java中所有类的父类，不需要使用extends明确写出继承。只要是class声明的类，就都有一个父类Object。
1 因此Object是参数的最高统一化，所有类的对象都可以通过Object引用进行接收
2 Object中的所有方法都可以在子类中进行覆写。

15.字符串

String类

1，创建String对象的两种方式

String str1 = new String("abc");
String str2 = "abc";

第一个是有两个地址，str1存放在新的地址里面
第二个存放在常量池中

2，String的值不能被修改

因为String被final修饰，所以他的原有值不能修改，但是可以添加，因为他没有被protected修饰

3，String中常用的方法

1.char charAt(int index)：返回 char 指定索引处的值。
2.int compareTo(String anotherString)：按字典顺序比较两个字符串。
3.String concat(String str)：将指定的字符串连接到该字符串的末尾。
4.boolean equals(String suffix)：此字符串是否以指定的后缀结尾。
5.boolean equals(Object anObject)：将此字符串与指定对象进行比较。
6.boolean equalsIgnoreCase(String anotherString)：与指定字符串进行比较（忽略大小写）
7.byte[] getBytes() ：将 String 编码为字节序列，将结果存储到新的字节数组中。
8.int indexOf(String str)：返回指定子字符串第一次出现的位置。
9.boolean isEmpty()：判断字符串是否为空。
10.String trim()：返回一个字符串，其值为此字符串，并删除任何前导和尾随空格。
11.String[] split(String regex)：将此字符串以给定的 regex 字符串为分割点进行分割（regex 被去掉）。

StringBuffer 和 StringBuider类

常用方法

1.StringBuffer append(String str)：添加字符。
2.char charAt(int index)：返回指定位置的字符。
3.StringBuffer delete(int start, int end)：删除字符。4.StringBuffer insert(int offset, Object obj)：将 Object 参数的字符串表示插入到此字符串序列中。
5.StringBuffer replace(int start, int end, String str)：用指定的 String 中的字符替换此序列的子字符串中的 String。
6.StringBuffer reverse()：将此字符串倒置。
7.String substring(int start)：从 start 开始截取新的子字符串。
8.String toString()：返回此序列的字符串。

区别

StringBuffer 和 StringBuilder 都是 Java 中的字符串处理类，它们都继承自 AbstractStringBuilder 类。这两个类都可以用来构建字符串，但它们之间有一些重要的区别。
StringBuffer 是线程安全的，也就是说，多个线程可以安全地同时访问一个 StringBuffer 对象。因此，如果你需要在多线程环境中构建字符串，那么使用 StringBuffer 是更好的选择。但是由于线程安全会带来一定的性能开销，所以 StringBuffer 的效率比 StringBuilder low。
StringBuilder 是线程不安全的，也就是说，如果多个线程同时访问一个 StringBuilder 对象，可能会发生不可预期的结果。因此，如果不需要考虑多线程问题，那么使用 StringBuilder 效率更高。
总而言之，如果你需要在多线程环境中构建字符串，使用 StringBuffer ，否则使用 StringBuilder 。

三者的相同与不同之处

1.相同：底层都是通过char数组实现的
2.不同：String对象一旦创建，其值是不能修改的，如果要修改，会重新开辟内存空间来存储修改之后的对象；而StringBuffer和StringBuilder对象的值是可以被修改的；当需要考虑线程安全的场景下使用StringBuffer，如果不需要考虑线程安全，追求效率的场景下可以使用 StringBuilder。

16.异常

1.概念

异常分为 编译时异常 和 运行时异常。
所有异常都是在 运行阶段 发生的。因为只有程序运行阶段才可以 new对象。
因为异常的发生就是 new异常对象
受检异常：CheckedException
受控异常
运行时异常
未受检异常：UnCheckedException
非受控异常

2处理方式

throws

在方法声明的位置上使用 throws 关键字抛出，谁调用我这个方法，我就抛给谁。抛给 调用者 来处理。
这种处理异常的态度：上报。

try…catch

这个异常不会上报，自己把这个事儿处理了。
异常抛到此处为止，不再上抛了。
注意：
只要异常没有捕捉，采用上报的方式，此方法的 后续代码不会执行。
try语句块中的某一行出现异常，该行 后面的代码不会执行。
try…catch捕捉异常之后，后续代码可以执行。

3.finally字句

在finally子句中的代码是最后执行的，并且是 一定会执行 的，即使try语句块中的代码出现了异常。finally子句必须和try一起出现，不能单独编写。