JavaSE基础【吐血整理汇总】，javase吐血汇总

JavaSE基础【吐血整理汇总】，javase吐血汇总

作为JavaSE基础的进阶版也希望给大家一些帮助：https://blog.csdn.net/flyingwzb/article/details/85130517

1. 方法

1.1 定义方法的完整格式

• 定义方法的完整格式:

  修饰符 返回值类型 方法名称(参数类型 参数名称, ...) {
      方法体
      return 返回值;
  }
  

• 定义一个两个int数字相加的方法。三要素：

  • 返回值类型：int
  • 方法名称：sum
  • 参数列表：int a, int b

• 方法的三种调用格式。

注意：此前学习的方法，返回值类型固定写为void，这种方法只能够单独调用，不能进行打印调用或者赋值调用。

1.2 有无参数的方法

• 有参数：小括号当中有内容，当一个方法需要一些数据条件，才能完成任务的时候，就是有参数。
  
  例如两个数字相加，必须知道两个数字是各自多少，才能相加。
• 无参数：小括号当中留空。一个方法不需要任何数据条件，自己就能独立完成任务，就是无参数。
  
  例如定义一个方法，打印固定10次HelloWorld。

1.3 使用方法注意事项

1.4 方法的重载

• 对于功能类似的方法来说，因为参数列表不一样，却需要记住那么多不同的方法名称，太麻烦。
• 方法的重载（Overload）：多个方法的名称一样，但是参数列表不一样。
  • 好处：只需要记住唯一一个方法名称，就可以实现类似的多个功能。

方法重载与下列因素无关：

2. 数组

2.1 数组的概念与特点

• 数组的概念：是一种容器，可以同时存放多个数据值。
• 数组的特点:
  • 数组是一种引用数据类型
  • 数组当中的多个数据，类型必须统一
  • 数组的长度在程序运行期间不可改变
• 数组的初始化：在内存当中创建一个数组，并且向其中赋予一些默认值。
  • 两种常见的初始化方式：
• 动态初始化数组的格式：
  数据类型[] 数组名称 = new 数据类型[数组长度];
  • 解析含义：

2.2 动态初始化与静态初始化

• 动态初始化（指定长度）：在创建数组的时候，直接指定数组当中的数据元素个数。
• 静态初始化（指定内容）：在创建数组的时候，不直接指定数据个数多少，而是直接将具体的数据内容进行指定。
• 静态初始化基本格式：
  • 数据类型[] 数组名称 = new 数据类型[] { 元素1, 元素2, … };
• 注意事项：
  • 虽然静态初始化没有直接告诉长度，但是根据大括号里面的元素具体内容，也可以自动推算出来长度。

2.3 静态初始化格式

• 使用静态初始化数组的时候，格式还可以省略一下。
• 标准格式：
  • 数据类型[] 数组名称 = new 数据类型[] { 元素1, 元素2, … };
• 省略格式：
  • 数据类型[] 数组名称 = { 元素1, 元素2, … };
• 注意事项：
• 使用建议：
  • 如果不确定数组当中的具体内容，用动态初始化；否则，已经确定了具体的内容，用静态初始化。

2.4 数组索引

• 数组的索引编号从0开始，一直到“数组的长度-1”为止。
• 如果访问数组元素的时候，索引编号并不存在，那么将会发生
  数组索引越界异常
  ArrayIndexOutOfBoundsException
• 原因：索引编号写错了。
  解决：修改成为存在的正确索引编号。

3. 面向对象

面向过程：当需要实现一个功能的时候，每一个具体的步骤都要亲力亲为，详细处理每一个细节。

面向对象：当需要实现一个功能的时候，不关心具体的步骤，而是找一个已经具有该功能的人，来帮我做事儿。

3.1 new对象

• 通常情况下，一个类并不能直接使用，需要根据类创建一个对象，才能使用。

• 注意事项：
  • 如果成员变量没有进行赋值，那么将会有一个默认值，规则和数组一样。

3.2 局部变量和成员变量

3.3 面向对象三大特征

• 面向对象三大特征：封装、继承、多态
• 封装性在Java当中的体现：
• 封装就是将一些细节信息隐藏起来，对于外界不可见。

3.4 封装

• 问题描述：定义Person的年龄时，无法阻止不合理的数值被设置进来。
• 解决方案：用private关键字将需要保护的成员变量进行修饰。
• 一旦使用了private进行修饰，那么本类当中仍然可以随意访问。
  但是！超出了本类范围之外就不能再直接访问了。
• 间接访问private成员变量，就是定义一对儿Getter/Setter方法
• 必须叫setXxx或者是getXxx命名规则。
  • 对于Getter来说，不能有参数，返回值类型和成员变量对应；
  • 对于Setter来说，不能有返回值，参数类型和成员变量对应。

3.5 构造方法

• 构造方法是专门用来创建对象的方法，当我们通过关键字new来创建对象时，其实就是在调用构造方法。
• 格式：

  public 类名称(参数类型 参数名称) {
      方法体
  }
  

• 注意事项：

3.6 Java Bean

• 一个标准的类通常要拥有下面四个组成部分：
• 这样标准的类也叫做Java Bean

4. Scanner类

• Scanner类的功能：可以实现键盘输入数据，到程序当中。
• 引用类型的一般使用步骤：
• 获取键盘输入的一个int数字：int num = sc.nextInt();
• 获取键盘输入的一个字符串：String str = sc.next();

4.1 new对象格式

• 创建对象的标准格式：
  • 类名称 对象名 = new 类名称();
• 匿名对象就是只有右边的对象，没有左边的名字和赋值运算符。
  • new 类名称();
• 注意事项：匿名对象只能使用唯一的一次，下次再用不得不再创建一个新对象。
• 使用建议：如果确定有一个对象只需要使用唯一的一次，就可以用匿名对象。

5. Random类

• Random类用来生成随机数字。使用起来也是三个步骤：

6. 数组与集合的区别

• 数组的长度不可以发生改变。
• 但是ArrayList集合的长度是可以随意变化的。
• 对于ArrayList来说，有一个尖括号代表泛型。
  • 泛型：也就是装在集合当中的所有元素，全都是统一的什么类型。
  • 注意：泛型只能是引用类型，不能是基本类型。
• 注意事项：
  • 对于ArrayList集合来说，直接打印得到的不是地址值，而是内容。
  • 如果内容是空，得到的是空的中括号：[]

7. 包装类

• 如果希望向集合ArrayList当中存储基本类型数据，必须使用基本类型对应的“包装类”。

  基本类型	包装类（引用类型，包装类都位于java.lang包下）
  byte	Byte
  short	Short
  int	Integer 【特殊】
  long	Long
  float	Float
  double	Double
  char	Character 【特殊】
  boolean	Boolean

• 从JDK 1.5+开始，支持自动装箱、自动拆箱。
  • 自动装箱：基本类型 --> 包装类型
  • 自动拆箱：包装类型 --> 基本类型

8. String类

java.lang.String类代表字符串。

API当中说：Java 程序中的所有字符串字面值（如 “abc” ）都作为此类的实例实现。

其实就是说：程序当中所有的双引号字符串，都是String类的对象。（就算没有new，也照样是。）

• 字符串的特点：

创建字符串的常见3+1种方式。

• 三种构造方法：
  • public String()：创建一个空白字符串，不含有任何内容。
  • public String(char[] array)：根据字符数组的内容，来创建对应的字符串。
  • public String(byte[] array)：根据字节数组的内容，来创建对应的字符串。
• 一种直接创建：
  • String str = “Hello”; // 右边直接用双引号
    
    注意：直接写上双引号，就是字符串对象。

8.1 String类方法使用

• public int length()：获取字符串当中含有的字符个数，拿到字符串长度。
• public String concat(String str)：将当前字符串和参数字符串拼接成为返回值新的字符串。
• public char charAt(int index)：获取指定索引位置的单个字符。（索引从0开始。）
• public int indexOf(String str)：查找参数字符串在本字符串当中首次出现的索引位置，如果没有返回-1值。

---

• public String substring(int index)：截取从参数位置一直到字符串末尾，返回新字符串。
• public String substring(int begin, int end)：截取从begin开始，一直到end结束，中间的字符串。
  
  备注：[begin,end)，包含左边，不包含右边。

---

• public char[] toCharArray()：将当前字符串拆分成为字符数组作为返回值。
• public byte[] getBytes()：获得当前字符串底层的字节数组。
• public String replace(CharSequence oldString, CharSequence newString)：
  
  将所有出现的老字符串替换成为新的字符串，返回替换之后的结果新字符串。
  
  备注：CharSequence意思就是说可以接受字符串类型。

---

• public String[] split(String regex)：按照参数的规则，将字符串切分成为若干部分。

注意事项：

split方法的参数其实是一个“正则表达式”，今后学习。

今天要注意：如果按照英文句点“.”进行切分，必须写"\\."（两个反斜杠）

9. static关键字

如果一个成员变量使用了static关键字，那么这个变量不再属于对象自己，而是属于所在的类。多个对象共享同一份数据。

9.1 static关键字注意事项

• 一旦使用static修饰成员方法，那么这就成为了静态方法。静态方法不属于对象，而是属于类的。
• 如果没有static关键字，那么必须首先创建对象，然后通过对象才能使用它。
• 如果有了static关键字，那么不需要创建对象，直接就能通过类名称来使用它。
• 无论是成员变量，还是成员方法。如果有了static，都推荐使用类名称进行调用。
  • 静态变量：类名称.静态变量
  • 静态方法：类名称.静态方法()
• 注意事项：
  • 静态不能直接访问非静态。
    
    原因：因为在内存当中是【先】有的静态内容，【后】有的非静态内容。
    
    “先人不知道后人，但是后人知道先人。”
  • 静态方法当中不能用this。
    
    原因：this代表当前对象，通过谁调用的方法，谁就是当前对象。

9.2 静态代码块

• 静态代码块的格式是：

  public class 类名称 {
      static {
          // 静态代码块的内容
      }
  }
  

• 特点：当第一次用到本类时，静态代码块执行唯一的一次。
  
  静态内容总是优先于非静态，所以静态代码块比构造方法先执行。
• 静态代码块的典型用途：
  用来一次性地对静态成员变量进行赋值。

10. Math类

• java.util.Math类是数学相关的工具类，里面提供了大量的静态方法，完成与数学运算相关的操作。

  public static double abs(double num)：获取绝对值。有多种重载。<br>
  
  public static double ceil(double num)：向上取整。<br>
  
  public static double floor(double num)：向下取整。<br>
  
  public static long round(double num)：四舍五入。<br>
  

• Math.PI代表近似的圆周率常量（double）。

11. 继承

• 在继承的关系中，“子类就是一个父类”。也就是说，子类可以被当做父类看待。
  • 例如父类是员工，子类是讲师，那么“讲师就是一个员工”。关系：is-a。
• 定义父类的格式：（一个普通的类定义）

  public class 父类名称 {
      // ...
  }
  

• 定义子类的格式：

  public class 子类名称 extends 父类名称 {
  // ...
  }
  

11.1 继承访问成员变量

• 在父子类的继承关系当中，如果成员变量重名，则创建子类对象时，访问有两种方式：
  • 直接通过子类对象访问成员变量：
    • 等号左边是谁，就优先用谁，没有则向上找。
  • 间接通过成员方法访问成员变量：
    • 该方法属于谁，就优先用谁，没有则向上找。

11.2 继承中变量的访问

• 局部变量： 直接写成员变量名
• 本类的成员变量： this.成员变量名
• 父类的成员变量： super.成员变量名

11.3 继承中方法重写

• 在父子类的继承关系当中，创建子类对象，访问成员方法的规则：
  • 创建的对象是谁，就优先用谁，如果没有则向上找。
• 注意事项：
  • 无论是成员方法还是成员变量，如果没有都是向上找父类，绝对不会向下找子类的。
• 重写（Override）
  • 概念：在继承关系当中，方法的名称一样，参数列表也一样。
  • 重写（Override）：方法的名称一样，参数列表【也一样】。覆盖、覆写。
  • 方法的覆盖重写特点：创建的是子类对象，则优先用子类方法。
• 重载（Overload）：方法的名称一样，参数列表【不一样】。

11.4 方法覆盖重写的注意事项

11.5 继承中构造方法访问

• 继承关系中，父子类构造方法的访问特点：
• 总结：
  • 子类必须调用父类构造方法，不写则赠送super()；
  • 写了则用写的指定的super调用，super只能有一个，还必须是第一个。

12. 抽象

• 抽象方法：就是加上abstract关键字，然后去掉大括号，直接分号结束。
• 抽象类：抽象方法所在的类，必须是抽象类才行。在class之前写上abstract即可。
• 如何使用抽象类和抽象方法：

13. 接口

• 接口就是多个类的公共规范。
• 接口是一种引用数据类型，最重要的内容就是其中的：抽象方法。
• 如何定义一个接口的格式：

  public interface 接口名称 {
      // 接口内容
  }
  

• 备注：换成了关键字interface之后，编译生成的字节码文件仍然是：.java --> .class。
• 如果是Java 7，那么接口中可以包含的内容有：
• 如果是Java 8，还可以额外包含有：
  3. 默认方法
  4. 静态方法
• 如果是Java 9，还可以额外包含有：
  5. 私有方法
• 接口使用步骤：
• 注意事项：
  • 如果实现类并没有覆盖重写接口中所有的抽象方法，那么这个实现类自己就必须是抽象类。

13.1 接口实现重点

13.2 接口中静态方法的调用

• 注意事项：不能通过接口实现类的对象来调用接口当中的静态方法。
• 正确用法：通过接口名称，直接调用其中的静态方法。
• 格式：
  • 接口名称.静态方法名(参数);

13.3 接口中定义抽象方法

• 在任何版本的Java中，接口都能定义抽象方法。
• 格式：
  public abstract 返回值类型 方法名称(参数列表);
• 注意事项：

13.4 接口中的常量

• 接口当中也可以定义“成员变量”，但是必须使用public static final三个关键字进行修饰。
• 从效果上看，这其实就是接口的【常量】。
• 格式：
  public static final 数据类型 常量名称 = 数据值;
• 备注：
  一旦使用final关键字进行修饰，说明不可改变。
• 注意事项：

13.5 接口定义默认方法

• 从Java 8开始，接口里允许定义默认方法。
• 格式

  public default 返回值类型 方法名称(参数列表) {
      方法体
  }
  

• 备注：接口当中的默认方法，可以解决接口升级的问题。
• 【私有方法】
  • 问题描述：
    • 我们需要抽取一个共有方法，用来解决两个默认方法之间重复代码的问题。
    • 但是这个共有方法不应该让实现类使用，应该是私有化的。
  • 解决方案：
    • 从Java 9开始，接口当中允许定义私有方法。

13.6 接口定义静态方法

• 从Java 8开始，接口当中允许定义静态方法。
• 格式：

  public static 返回值类型 方法名称(参数列表) {
      方法体
  }
  

• 提示：就是将abstract或者default换成static即可，带上方法体。

13.7 接口使用注意事项

13.8 类与接口的关系

• 注意事项：

14. 多态

• 代码当中体现多态性，其实就是一句话：父类引用指向子类对象。
• 格式：
  
  父类名称 对象名 = new 子类名称();
  
  或者：
  
  接口名称 对象名 = new 实现类名称();
  

14.1 多态访问

• 在多态的代码当中，成员方法的访问规则是：
  • 看new的是谁，就优先用谁，没有则向上找。
• 口诀：编译看左边，运行看右边。
• 对比一下：
  • 成员变量：编译看左边，运行还看左边。
  • 成员方法：编译看左边，运行看右边。

14.2 向上向下转型

• 向上转型一定是安全的，没有问题的，正确的。但是也有一个弊端：
  • 对象一旦向上转型为父类，那么就无法调用子类原本特有的内容。
• 解决方案：用对象的向下转型【还原】。

15. final关键字

• final关键字代表最终、不可改变的。
• 常见四种用法：

15.1 final修饰方法

• 当final关键字用来修饰一个方法的时候，这个方法就是最终方法，也就是不能被覆盖重写。
• 格式：

  修饰符 final 返回值类型 方法名称(参数列表) {
      // 方法体
  }
  

• 注意事项：
  • 对于类、方法来说，abstract关键字和final关键字不能同时使用，因为矛盾。

15.2 final修饰类

• 当final关键字用来修饰一个类的时候，格式：

  public final class 类名称 {
      // ...
  }
  

• 含义：当前这个类不能有任何的子类。（太监类）
• 注意：一个类如果是final的，那么其中所有的成员方法都无法进行覆盖重写（因为没儿子。）

15.3 final修饰成员变量

• 对于成员变量来说，如果使用final关键字修饰，那么这个变量也照样是不可变。

16. Java中有四种权限修饰符

范围	public	protected	(default)	private
同一个类（我自己）	YES	YES	YES	YES
同一个包（我邻居）	YES	YES	YES	NO
不同包子类（我儿子）	YES	YES	NO	NO
不同包非子类（陌生人）	YES	NO	NO	NO

注意事项：(default)并不是关键字“default”，而是根本不写。

17. 内部类

• 如果一个事物的内部包含另一个事物，那么这就是一个类内部包含另一个类。
  • 例如：身体和心脏的关系。又如：汽车和发动机的关系。
• 分类：
• 成员内部类的定义格式：

  修饰符 class 外部类名称 {
      修饰符 class 内部类名称 {
          // ...
      }
      // ...
  }
  

注意：内用外，随意访问；外用内，需要内部类对象。

17.1 成员内部类

• 如何使用成员内部类？有两种方式：

【外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();】

17.2 局部内部类1

• 局部内部类，如果希望访问所在方法的局部变量，那么这个局部变量必须是【有效final的】。
• 备注：从Java 8+开始，只要局部变量事实不变，那么final关键字可以省略。
• 原因：

17.3 局部内部类2

• 如果一个类是定义在一个方法内部的，那么这就是一个局部内部类。
• “局部”：只有当前所属的方法才能使用它，出了这个方法外面就不能用了。
• 定义格式：

  修饰符 class 外部类名称 {
      修饰符 返回值类型 外部类方法名称(参数列表) {
          class 局部内部类名称 {
              // ...
          }
      }
  }
  

17.4 类的权限修饰符

• public > protected > (default) > private
• 定义一个类的时候，权限修饰符规则：

17.5 匿名内部类

• 如果接口的实现类（或者是父类的子类）只需要使用唯一的一次，
  那么这种情况下就可以省略掉该类的定义，而改为使用【匿名内部类】。
• 匿名内部类的定义格式：

  接口名称 对象名 = new 接口名称() {
      // 覆盖重写所有抽象方法
  };
  

• 对格式“new 接口名称() {…}”进行解析：
• 另外还要注意几点问题：