java基础必背知识点

admin管理员组

文章数量:1794759

java基础必背知识点

文章目录

• • day01 【前言、入门程序、常量、变量】
  • • 1. java程序开发三步骤：
    • 2. 6种类型的常量
    • • 常量
      • 常量的分类
    • 3. 8种基本数据类型的变量
    • • 变量
      • 格式
      • 注意事项
    • 4. 标识符
    • • 1. 定义
      • 2. 命名规则
      • 3. 命名规范（建议）
  • day02 【数据类型转换、运算符、方法入门】
  • • 1. 强制转换
    • • 注意事项
    • 2. ASCII编码表
    • 3. 运算符++
    • 4. 三元运算符
    • 5. 位运算
    • 6.除法相关
  • day03【 流程控制语句】
  • • 1. 判断语句--if..else if...else
    • 2. 选择语句switch
    • • 注意事项
      • jdk1.7后switch能用哪些类型
    • 3. for循环
    • 4. while 循环
    • 5. do...while循环
    • 6. break 和continue
    • 7. 嵌套循环
  • day04【 Idea、方法】
  • • 1. idea的相关知识
    • 2. 定义方法
    • • 注意事项
    • 3. 方法调用流程图
    • 4. 方法的重载
  • day05【数组】
  • • 1. 容器
    • 2. 数组概念
    • 3. 数组的定义
    • • 数组的特点
      • 数组的初始化
      • 默认值
    • 5. 索引
    • 6. java虚拟机的内存划分
    • 7. 数组在内存中的存储
    • 8. 遍历数组
    • 9. 最大值
    • 10. 数组反转
    • 11. 数组作为方法参数
    • 12. 数组作为方法返回值
  • day06【类与对象、封装、构造方法】
  • • 1. 面向对象的思想
    • • 概念
      • 特点
    • 2. 类和对象
    • • 2.1类
      • 2.2 对象
      • 2.3 类和对象的关系
    • 3. 类的定义
    • 4. 类的使用
    • • 步骤
      • 注意
    • 5. 对象的定义
    • 6. 对象内存图
    • 7. 成员变量和局部变量区别
    • 8.封装
    • 9.private
    • 10.**Getter/Setter**命名规则
    • 11. this
    • 12. 构造方法
    • • 格式
      • 注意事项
    • 13.java bean
  • day07【Scanner类、Random类、ArrayList类】
  • • 1. API
    • • 概念
      • 使用步骤
    • 2. Scanner类
    • • 2.1什么是Scanner类
      • 2.2 使用步骤
    • 3. 匿名对象
    • • 概念
      • 应用场景
    • 4. Random类
    • • 4.1 作用
      • 4.2 使用步骤
    • 4. ArrayList类
    • • 4.1 定义
      • 4.2 使用步骤
  • day08【String类、static关键字、Arrays类、Math类】
  • • 1. String类
    • • 概述
      • 特点
      • 使用步骤
    • 2. String 常用方法
    • • 判断功能的方法
      • 获取功能的方法
      • 转换功能的方法
      • 分割功能的方法
    • 3. Static关键字
    • • 概述
      • 定义和使用格式
      • 调用格式
      • 静态原理图解
      • 静态代码块
    • 3. Arrays类
    • • 概述
      • 操作数组的方法
    • 4. Math类
    • • 概述
      • 基本运算方法
  • day09【继承、super、this、抽象类】
  • • 1. 继承
    • • 定义
      • 好处
      • 格式
      • 继承后的特点-成员变量
      • 继承后的特点-成员方法
      • 重写
      • 继承后的特点-构造方法
      • 继承的特点
    • 2. super和this
    • • 父类空间优先于子类对象产生
      • super和this的含义：
      • super和this的用法
    • 3. 抽象类
    • • 概述
      • abstract使用格式
      • 抽象的使用
      • 抽象的注意事项
  • day10【接口、多态】
  • • 1. 接口
    • • 概述
      • 定义格式
      • 基本的实现
      • 实现格式
      • 静态方法的使用
      • 接口的多实现
      • 优先级
      • 其他
    • 2. 多态
    • • 概念
      • 前提
      • 格式
      • 多态的好处
      • 引用类型转换
      • 为什么要转型？
      • 如何避免转型异常？
      • 多态经典题
  • day11 【内部类、final、权限】
  • • 1. 内部类
    • • 1. 概念
      • 2. 成员内部类
    • 2. 匿名内部类
    • • 概念
      • 格式
      • 使用方式
    • 3. final
    • • 概述
      • 使用方式
    • 4. 权限修饰符
    • • 不同权限的访问能力

day01 【前言、入门程序、常量、变量】 1. Java程序开发三步骤：

编写、编译、运行。

2. 6种类型的常量 常量

在程序运行期间，固定不变的量。

常量的分类

字符串常量：凡是用双引号引起来的部分，叫做字符串常量。例如：“abc”、“Hello”、“123”

整数常量：直接写上的数字，没有小数点。例如：100、200、0、-250

浮点数常量：直接写上的数字，有小数点。例如：2.5、-3.14、0.0

字符常量：凡是用单引号引起来的单个字符，就做字符常量。例如：‘A’、‘b’、‘9’、‘中’

布尔常量：只有两种取值。true、false。

空常量：null。代表没有任何数据。

3. 8种基本数据类型的变量 变量

程序运行期间，内容可以发生改变的量。

格式

创建一个变量并且使用的格式：

数据类型 变量名称; // 创建了一个变量 变量名称 = 数据值; // 赋值，将右边的数据值，赋值交给左边的变量 数据类型 变量名称 = 数据值; // 在创建一个变量的同时，立刻放入指定的数据值 注意事项

如果创建多个变量，那么变量之间的名称不可以重复。

对于float和long类型来说，字母后缀F和L不要丢掉。

如果使用byte或者short类型的变量，那么右侧的数据值不能超过左侧类型的范围。

没有进行赋值的变量，不能直接使用；一定要赋值之后，才能使用。

变量使用不能超过作用域的范围。【作用域】：从定义变量的一行开始，一直到直接所属的大括号结束为止。

可以通过一个语句来创建多个变量，但是一般情况不推荐这么写。

4. 标识符 1. 定义

指在程序中，自己定义的内容。如类的名字、方法的名字和变量的名字等，都是标识符。

2. 命名规则

• 可以包含英文字母26个(区分大小写)、0-9数字、$和_
• 标识符不能以数字开头
• 不能是关键字 eg. new、1234、car.taxi是非法变量；$Usdollars合规

3. 命名规范（建议）

• 类名：首字母大写，大驼峰
• 方法名：首字母小写，小驼峰
• 变量名：首字母小写，小驼峰

day02 【数据类型转换、运算符、方法入门】 1. 强制转换

转换格式：

数据类型 变量名 = （数据类型）被转数据值； 注意事项

强制类型转换一般不推荐使用，因为有可能发生精度损失、数据溢出。

byte/short/char这三种类型都可以发生数学运算，例如加法“+”.

byte/short/char这三种类型在运算的时候，都会被首先提升成为int类型，然后再计算。

boolean类型不能发生数据类型转换

2. ASCII编码表 '0'--->48; 'A'--->65; 'a'--->97; 3. 运算符++ ++在前，先加后用；++在后，先用后加 4. 三元运算符

格式：

数据类型 变量名 = 布尔类型表达式？结果1：结果2

---

位运算为增加部分，在后边看源码时很多都会用到，如hashmap

5. 位运算

与运算&：

相同位的两个数字都为1，结果为1；否则结果为0

按位或|：

相同位的两个数字只要有1，结果为1；否则结果为0

按位异或^：

相同位的两个数字相同结果为0；不同结果为1

按位左移<< 如 <<1为左移一位

按位右移>> 同理

6.除法相关

• / 整型 时，结果为整型，舍去小数；运算量中有一个为实型，结果为双精度实型 eg. 1/2=0 5/2.5=2.0
• % 取余rem、取模mod 参与变量需要均为整型。取模运算的结果等于两个数相除后的余数 eg. 1%2=1 5%2.0报错

day03【 流程控制语句】 1. 判断语句–if…else if…else

格式：

if (判断条件1) { 执行语句1; } else if (判断条件2) { 执行语句2; } ... }else if (判断条件n) { 执行语句n; } else { 执行语句n+1; } 2. 选择语句switch

格式：

switch(表达式) { case 常量值1: 语句体1; break; case 常量值2: 语句体2; break; ... default: 语句体n+1; break; }

case的穿透性（月份对应的季节）

注意事项

多个case后面的数值不可以重复。

switch后面小括号当中只能是下列数据类型： 基本数据类型：byte/short/char/int 引用数据类型：String字符串、enum枚举

switch语句格式可以很灵活：前后顺序可以颠倒，而且break语句还可以省略。 “匹配哪一个case就从哪一个位置向下执行，直到遇到了break或者整体结束为止。”

jdk1.7后switch能用哪些类型

可以用byte、short、int、char、string 不能用long、float、double

3. for循环

格式：

for(初始化表达式①; 布尔表达式②; 步进表达式④){ 循环体③ } 4. while 循环

格式：

初始化表达式① while(布尔表达式②){ 循环体③ 步进表达式④ } 5. do…while循环

格式：

初始化表达式① do{ 循环体③ 步进表达式④ }while(布尔表达式②); 6. break 和continue break 跳出循环；continue跳过本次循环，继续下一个循环 7. 嵌套循环

经典题型： 直角三角形、倒三角型、等腰三角形的*号

day04【 Idea、方法】 1. idea的相关知识

idea的相关知识汇总在idea小工具

2. 定义方法

方法其实就是若干语句的功能集合。

格式（三要素）：

修饰符 返回值类型 方法名(参数列表){ //代码省略... return 结果; } 注意事项

对于有返回值的方法，可以使用单独调用、打印调用或者赋值调用。 但是对于无返回值的方法，只能使用单独调用，不能使用打印调用或者赋值调用。

3. 方法调用流程图

4. 方法的重载

• 方法重载：指在同一个类中，允许存在一个以上的同名方法，只要它们的参数列表不同即可，与修饰符和返回值类型无关。

• 参数列表：个数不同，数据类型不同，顺序不同。

• 重载方法调用：JVM通过方法的参数列表，调用不同的方法。

day05【数组】 1. 容器

将多个数据存储到一起，每个数据称为该容器的元素。

2. 数组概念

数组就是存储数据长度固定的容器，保证多个数据的数据类型要一致。

3. 数组的定义 数组的特点

数组是一种引用数据类型

数组当中的多个数据，类型必须统一

数组的长度在程序运行期间不可改变

数组的初始化

在内存当中创建一个数组，并且向其中赋予一些默认值。

动态初始化：

数组存储的数据类型[] 数组名字 = new 数组存储的数据类型[长度];

静态初始化：

数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3...};

静态简写：

数据类型[] 数组名 = {元素1,元素2,元素3...}; 默认值

如果是整数类型，那么默认为0； 如果是浮点类型，那么默认为0.0； 如果是字符类型，那么默认为’\\u0000’； 如果是布尔类型，那么默认为false； 如果是引用类型，那么默认为null。

5. 索引

• 索引：** 每一个存储到数组的元素，都会自动的拥有一个编号，从0开始，这个自动编号称为数组索引(index)，可以通过数组的索引访问到数组中的元素。

6. java虚拟机的内存划分 区域名称作用

寄存器	给CPU使用，和我们开发无关。
本地方法栈	JVM在使用操作系统功能的时候使用，和我们开发无关。
方法区	存储可以运行的class文件。
堆内存	存储对象或者数组，new来创建的，都存储在堆内存。
方法栈	方法运行时使用的内存，比如main方法运行，进入方法栈中执行。

7. 数组在内存中的存储

8. 遍历数组 public static void main(String[] args) { int[] arr = { 1, 2, 3, 4, 5 }; for (int i = 0; i < arr.length; i++) { System.out.println(arr[i]); } } 9. 最大值 public static void main(String[] args) { int[] arr = { 5, 15, 2000, 10000, 100, 4000 }; //定义变量，保存数组中0索引的元素 int max = arr[0]; //遍历数组，取出每个元素 for (int i = 0; i < arr.length; i++) { //遍历到的元素和变量max比较 //如果数组元素大于max if (arr[i] > max) { //max记录住大值 max = arr[i]; } } System.out.println("数组最大值是： " + max); } 10. 数组反转 public static void main(String[] args) { int[] arr = { 1, 2, 3, 4, 5 }; /* 循环中定义变量min=0最小索引 max=arr.length-1最大索引 min++,max-- */ for (int min = 0, max = arr.length - 1; min <= max; min++, max--) { //利用第三方变量完成数组中的元素交换 int temp = arr[min]; arr[min] = arr[max]; arr[max] = temp; } // 反转后，遍历数组 for (int i = 0; i < arr.length; i++) { System.out.println(arr[i]); } } 11. 数组作为方法参数 public static void main(String[] args) { int[] arr = { 1, 3, 5, 7, 9 }; //调用方法，传递数组 printArray(arr); } /* 创建方法，方法接收数组类型的参数 进行数组的遍历 */ public static void printArray(int[] arr) { for (int i = 0; i < arr.length; i++) { System.out.println(arr[i]); } } 12. 数组作为方法返回值 public class Demo12ArrayReturn { public static void main(String[] args) { int[] result = calculate(10,20,30); System.out.println("main方法接收到的返回值数组是："); System.out.println(result); System.out.println("总和:"+result[0]); System.out.println("平均:"+result[1]); } public static int[] calculate(int a, int b, int c){ int sum = a+b+c; int avg = sum/3; // 两个结果都希望进行返回 /* int[] array = new int[2]; array[0] = sum;// 总和 array[1] = avg;//平均数 */ int[] array = {sum,avg}; System.out.println(array); return array; } } day06【类与对象、封装、构造方法】 1. 面向对象的思想 概念

一种程序设计思想，这里的对象泛指现实中一切事物，每种事物都具备自己的属性和行为。面向对象思想就是在计算机程序设计过程中，参照现实中事物，将事物的属性特征、行为特征抽象出来，描述成计算机事件的设计思想。强调的是通过调用对象的行为来实现功能。

特点

更符合我们的思考习惯，将复杂的事情简单化，并将我们从执行者变成指挥者。面向对象的语言中，包含了三大基本特征，即封装、继承和多态。

2. 类和对象 2.1类

• 类：是一组相关属性和行为的集合。可以看成是一类事物的模板，使用事物的属性特征和行为特征来描述该类事物。
• 属性：就是该事物的状态信。
• 行为：就是该事物能够做什么。

2.2 对象

对象：是一类事物的具体体现。对象是类的一个实例，必然具备该类事物的属性和行为。

2.3 类和对象的关系

• 类是对一类事物的描述，是抽象的。
• 对象是一类事物的实例，是具体的。
• 类是对象的模板，对象是类的实体。

3. 类的定义 public class ClassName { //成员变量 //成员方法 }

• 定义类：就是定义类的成员，包括成员变量和成员方法。
• 成员变量：和以前定义变量几乎是一样的。只不过位置发生了改变。在类中，方法外。
• 成员方法：和以前定义方法几乎是一样的。只不过把static去掉，static的作用在面向对象后面课程中再详细讲解。

4. 类的使用 步骤

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

导包：也就是指出需要使用的类，在什么位置。 import 包名称.类名称; import cn.itcast.day06.demo01.Student; 对于和当前类属于同一个包的情况，可以省略导包语句不写。

创建，格式： 类名称 对象名 = new 类名称(); Student stu = new Student();

使用，分为两种情况： 使用成员变量：对象名.成员变量名 使用成员方法：对象名.成员方法名(参数) （也就是，想用谁，就用对象名点儿谁。）

注意

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

5. 对象的定义

创建对象：

类名 对象名 = new 类名();

使用对象访问类中的成员:

对象名.成员变量； 对象名.成员方法()； 6. 对象内存图

一个对象

[外链图片转存失败(img-yrB8jONO-1564111828103)(img\\2.jpg)]

两个对象，调用同一个方法内存图

[外链图片转存失败(img-UTsYHDSy-1564111828105)(img\\3.jpg)]

7. 成员变量和局部变量区别

定义的位置不一样【重点】 局部变量：在方法的内部 成员变量：在方法的外部，直接写在类当中

作用范围不一样【重点】 局部变量：只有方法当中才可以使用，出了方法就不能再用 成员变量：整个类全都可以通用。

默认值不一样【重点】 局部变量：没有默认值，如果要想使用，必须手动进行赋值 成员变量：如果没有赋值，会有默认值，规则和数组一样

内存的位置不一样（了解） 局部变量：位于栈内存 成员变量：位于堆内存

生命周期不一样（了解） 局部变量：随着方法进栈而诞生，随着方法出栈而消失 成员变量：随着对象创建而诞生，随着对象被垃圾回收而消失

8.封装

封装性在Java当中的体现：

方法就是一种封装

关键字private也是一种封装

封装就是将一些细节信隐藏起来，对于外界不可见。

9.private

超出了本类范围之外就不能再直接访问了。间接访问private成员变量，就是定义一对儿Getter/Setter方法

10.Getter/Setter命名规则

对于Getter来说，不能有参数，返回值类型和成员变量对应； 对于Setter来说，不能有返回值，参数类型和成员变量对应；

对于基本类型当中的boolean值，Getter方法一定要写成isXxx的形式，而setXxx规则不变。

11. this

方法的局部变量和类的成员变量重名的时候，根据“就近原则”，优先使用局部变量。如果需要访问本类当中的成员变量，需要使用格式： this.成员变量名

通过谁调用的方法，谁就是this。

12. 构造方法

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

格式 public 类名称(参数类型 参数名称) { 方法体 } 注意事项

构造方法的名称必须和所在的类名称完全一样，就连大小写也要一样

构造方法不要写返回值类型，连void都不写

构造方法不能return一个具体的返回值

如果没有编写任何构造方法，那么编译器将会默认赠送一个构造方法，没有参数、方法体什么事情都不做。 public Student() {}

一旦编写了至少一个构造方法，那么编译器将不再赠送。

构造方法也是可以进行重载的。 重载：方法名称相同，参数列表不同。

13.java bean

一个标准的类通常要拥有下面四个组成部分：

所有的成员变量都要使用private关键字修饰

为每一个成员变量编写一对儿Getter/Setter方法

编写一个无参数的构造方法

编写一个全参数的构造方法

day07【Scanner类、Random类、ArrayList类】 1. API 概念

API(Application Programming Interface)，应用程序编程接口。Java API是一本程序员的字典 ，是JDK中提供给我们使用的类的说明文档。

使用步骤

打开帮助文档。

点击显示，找到索引，看到输入框。

你要找谁？在输入框里输入，然后回车。

看包。java.lang下的类不需要导包，其他需要。

看类的解释和说明。

学习构造方法。

使用成员方法。

2. Scanner类 2.1什么是Scanner类

一个可以解析基本类型和字符串的简单文本扫描器。

Scanner sc = new Scanner(System.in); int i = sc.nextInt();

备注：System.in 系统输入指的是通过键盘录入数据。

2.2 使用步骤 1. 导包 import 包名.类名; import java.util.Scanner; 2. 创建对象 数据类型 变量名 = new 数据类型(参数列表); Scanner sc = new Scanner(System.in); 3. 使用 变量名.方法名(); int i = sc.nextInt(); // 接收一个键盘录入的整数 3. 匿名对象 概念

创建对象时，只有创建对象的语句，却没有把对象地址值赋值给某个变量。

匿名对象 ：没有变量名的对象

应用场景

作为方法的参数和返回值

• 作为参数

  class Test { public static void main(String[] args) { // 普通方式 Student stu = new Student("小强",18); input(stu); //匿名对象作为方法接收的参数 input( new Student("小强",18) ); } public static void input(Student stu){ stu.method(); } }
  • 作为返回值
  class Test2 { public static void main(String[] args) { // 普通方式 Student stu = newInstance(); } public static Student newInstance(){ //普通方式 //Student stu = new Student("小强",18); //return stu; //匿名对象作为方法返回值 return new Student("小强",18); } }

4. Random类 4.1 作用

它的实例用于生成伪随机数

4.2 使用步骤 //1. 导包 import java.util.Random; public class Demo01_Random { public static void main(String[] args) { //2. 创建键盘录入数据的对象 Random r = new Random(); for(int i = 0; i < 3; i++){ //3. 随机生成一个数据 int number = r.nextInt(10); //4. 输出数据 System.out.println("number:"+ number); } } } 4. ArrayList类 4.1 定义

java.util.ArrayList 是大小可变的数组的实现，存储在内的数据称为元素。此类提供一些方法来操作内部存储的元素。 ArrayList 中可不断添加元素，其大小也自动增长。

4.2 使用步骤

查看类

• java.util.ArrayList <E> ：该类需要 import导入使后使用。

<E> ，表示一种指定的数据类型，叫做泛型。我们使用一种引用数据类型将其替换即可，表示我们将存储哪种引用类型的元素。代码：ArrayList<String>，ArrayList<Student>

查看构造方法

• public ArrayList()：构造一个内容为空的集合。

day08【String类、static关键字、Arrays类、Math类】 1. String类 概述

java中所有的字符串文字都可以被看做是实现此类的实例

特点

字符串不变： 字符串的值在创建后不能被更改

String对象是不可变的，所以可以被共享

"abc"等效于char[] data = {‘a’,‘b’,‘c’}

例如： String str = "abc"; 相当于： char data[] = {'a', 'b', 'c'}; String str = new String(data); // String底层是靠字符数组实现的 使用步骤

• 查看类
  • java.lang.String:此类不需要导入
• 查看构造方法
  • public String(): 初始化新创建的String对象，以使其表示空字符序列
  • public String(char[] value): 通过当前参数中的字符数组来构造新的String
  • public String(byte[] bytes): 通过使用平台默认字符集解码当前参数中的字节数组来构造新的String

//无参构造 String str = new String(); // 通过字符数组构造 char chars[] = {'a', 'b', 'c'}; String str2 = new String(chars); // 通过字节数组构造 byte bytes[] = {97,98,99}; String str3 = new String(bytes); 2. String 常用方法 判断功能的方法

• public boolean equals (Object anObject): 将次字符串与指定对象比较
• public boolean equalsIgnoreCase(String anotherString)忽略大小写

获取功能的方法

• public int length ():返回此字符串的长度
• public String concat(String str): 将指定的字符串拼接到字符串的末尾
• public char charAt(int index): 返回指定索引处的char值
• public int indexOf(String str): 返回指定字符串第一次出现在该字符串内的索引
• public String substring(int beginIndex): 返回子字符串，从beginindex开始截取字符串到字符串末尾
• public String substring (int beginIndex,int endIndex)：从beginindex到endIndex截取字符串，左闭右开

public class String_Demo02 { public static void main(String[] args) { //创建字符串对象 String s = "helloworld"; // int length():获取字符串的长度，其实也就是字符个数 System.out.println(s.length()); System.out.println("--------"); // String concat (String str):将将指定的字符串连接到该字符串的末尾. String s = "helloworld"; String s2 = s.concat("**hello itheima"); System.out.println(s2);// helloworld**hello itheima // char charAt(int index):获取指定索引处的字符 System.out.println(s.charAt(0)); System.out.println(s.charAt(1)); System.out.println("--------"); // int indexOf(String str):获取str在字符串对象中第一次出现的索引,没有返回-1 System.out.println(s.indexOf("l")); System.out.println(s.indexOf("owo")); System.out.println(s.indexOf("ak")); System.out.println("--------"); // String substring(int start):从start开始截取字符串到字符串结尾 System.out.println(s.substring(0)); System.out.println(s.substring(5)); System.out.println("--------"); // String substring(int start,int end):从start到end截取字符串。含start，不含end。 System.out.println(s.substring(0, s.length())); System.out.println(s.substring(3,8)); } } 转换功能的方法

• public char[] toCharArray (): 将此字符串转化为新的字符数组
• public byte[] getBytes ():使用默认字符集将String编码转换为新的字节数组
• public String replace(CharSequence target, CharSequence replacement): 将与target匹配的字符串用replacement字符串替换

public class String_Demo03 { public static void main(String[] args) { // 创建字符串对象 String s = "abcde"; // char[] tpCharArray() 把字符串转换为字符数组 char[] chs = s.toCharArray(); for(int x = 0; x<chs.length;x++) { System.out.println(chs[x]); } System.out.println("==========="); // byte[] getBytes ():把字符串转换为字节数组 byte[] bytes = s.getBytes(); for(int x = 0; x < bytes.length; x++) { System.out.println(bytes[x]); } System.out.println("-----------"); // 替换字母it为大写IT String str = "itcast itheima"; String replace = str.replace("it", "IT"); System.out.println(replace); // ITcast ITheima System.out.println("-----------"); } }

CharSequence 是一个接口，也是一种引用类型，作为参数类型，可以把String对象传递到方法中。

分割功能的方法

• public String[] split(String regex): 将此字符串按照给定的regex拆分为字符串数组

3. Static关键字 概述

用来修饰成员变量和成员方法，被修饰的成员属于 类

定义和使用格式

• 类变量：使用static关键字修饰的成员变量

格式：

static 数据类型 变量名;

应用： 学号编号

• 类方法： 使用static关键字修饰的成员方法，称为静态方法

格式：

修饰符 static 返回值类型 方法名(参数列表){ // 执行语句 }

• 静态方法调用的注意事项：
  • 静态方法可以直接访问类变量和静态方法
  • 静态方法不能直接访问普通成员变量和成员方法
  • 静态方法，不能使用this关键字

小贴士：静态方法只能访问静态成员

调用格式

被static修饰的成员可以并且建议通过类名直接访问

静态原理图解

static 修饰的内容：

• 是随着类的加载而加载的，且只加载一次。
• 存储于一块固定的内存区域（静态区），所以，可以直接被类名调用。
• 它优先于对象存在，所以，可以被所有对象共享。

静态代码块

定义在成员位置，使用static修饰的代码块{}，随着类的加载而执行，且执行一次，优先于main方法和构造方法的执行。

作用：给类变量进行初始化赋值

3. Arrays类 概述

java.util.Arrays此类包含用来操作数组的各种方法，所有方法均为静态方法。

操作数组的方法

• public static String toString(int[] a): 返回指定数组内容的字符串表示形式
• public static void sort(int[] a): 对指定的int 型数组按数字升序排序 案例：倒序打印

4. Math类 概述

基本数学运算，也是静态方法，不用创建对象

基本运算方法

• public static double abs(double a): 返回double的绝对值
• public static double ceil(double a): 返回大于等于参数的最小的整数
• public static double floor(double a): 返回小于等于参数最大的整数
• public static long round(double a): 返回最接近参数的long(相当于四舍五入)

day09【继承、super、this、抽象类】 1. 继承 定义

多个类存在相同的属性和行为时，共性抽取。

子类继承父类的属性和行为，可以直接访问父类的非私有属性和行为。

好处

提高代码的复用性

类与类之间产生了关系，是多态的前提。

格式 class 父类 { ... } class 子类 extends 父类 { ... } 继承后的特点-成员变量

• 成员变量不重名 没有影响
• 成员变量重名 有同名的成员变量，访问父类中非私有成员变量时，使用super关键字，修饰父类成员变量

一般遵循封装的原则，private修饰成员变量，如何访问父类的私有成员变量？用父类提供的公共的getXxx和setXxx方法

继承后的特点-成员方法

• 成员方法不重名 没有影响
• 成员方法重名 重写（override）

重写

子类出现重名的成员方法(返回值类型，方法名和参数列表都相同)，访问是特殊情况，叫方法重写，又叫覆写，声明不变，重新实现。

应用： 新旧手机（super.父类成员方法表示调用父类的成员方法）

注意事项

子类方法覆盖父类方法，必须要保证权限大于等于父类权限。

子类方法覆盖父类方法，返回值类型、函数名和参数列表都要一模一样。

继承后的特点-构造方法

构造方法的名字是与类名一致的。所以子类是无法继承父类构造方法的。

构造方法的作用是初始化成员变量的。所以子类的初始化过程中，必须先执行父类的初始化动作。子类的构造方法中默认有一个super() ，表示调用父类的构造方法，父类成员变量初始化后，才可以给子类使用。

继承的特点

Java只支持单继承，不支持多继承。

Java支持多层继承(继承体系)。

子类和父类是一种相对的概念。

2. super和this 父类空间优先于子类对象产生

在每次创建子类对象时，先初始化父类空间，再创建其子类对象本身。目的在于子类对象中包含了其对应的父类空间，便可以包含其父类的成员，如果父类成员非private修饰，则子类可以随意使用父类成员。代码体现在子类的构造方法调用时，一定先调用父类的构造方法。

super和this的含义：

• super： 代表父类的存储空间标识（可以理解为父类的引用）
• this： 代表当前对象的引用（谁调用就代表谁）

super和this的用法

• 访问成员

this.成员变量 -- 本类的 super.成员变量 -- 父类的 this.成员方法名() -- 本类的 super.成员方法名() -- 父类的

• 访问构造方法

this(...) -- 本类的构造方法 super(...) -- 父类的构造方法

子类的每个构造方法中均有默认的super()，调用父类的空参构造。手动调用父类构造会覆盖默认的super()。

super() 和 this() 都必须是在构造方法的第一行，所以不能同时出现。

3. 抽象类 概述

我们把没有方法主体的方法称为抽象方法。Java语法规定，包含抽象方法的类就是抽象类。

abstract使用格式

• 抽象方法

修饰符 abstract 返回值类型 方法名 (参数列表)；

• 抽象类

abstract class 类名字 { } 抽象的使用

继承抽象类的子类必须重写父类所有的抽象方法。否则，该子类也必须声明为抽象类。最终，必须有子类实现该父类的抽象方法，否则，从最初的父类到最终的子类都不能创建对象，失去意义。

此时的方法重写，是子类对父类抽象方法的完成实现，我们将这种方法重写的操作，也叫做实现方法。

抽象的注意事项

抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。

理解：假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义。

抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。

理解：子类的构造方法中，有默认的super()，需要访问父类构造方法。

抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。

理解：未包含抽象方法的抽象类，目的就是不想让调用者创建该类对象，通常用于某些特殊的类结构设计。

抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象类。

理解：假设不重写所有抽象方法，则类中可能包含抽象方法。那么创建对象后，调用抽象的方法，没有意义。

day10【接口、多态】 1. 接口 概述

接口，是java语言中一种引用类型，是方法的集合，接口的内部主要就是封装了方法，包含抽象方法(JDK 7及以前)，默认方法和静态方法(JDK 8)，私有方法(JDK 9)。

接口的定义，与定义类相似，但是使用interface关键字。不能创建对象，但是可以被实现(implements，类似于被继承)。一个实现接口的类，需要实现接口中的所有的抽象方法，创建该类对象，就可以调用方法了，否则它必须是一个抽象类。

默认方法：以Iterator接口为例，用户通常不会使用remove方法，1.8以后将remove方法设为默认方法，默认实现。

default void remove() { throw new UnsupportedOperationException("remove"); } 定义格式

• 含有抽象方法

public interface InterFaceName { public abstract void method(); }

• 含有默认方法和静态方法

public interface InterFaceName { public default void method() { // 执行语句 } public static void method2() { // 执行语句 } } 基本的实现

类与接口的关系为实现关系，类实现接口，该类称为接口的实现类，也可以称为接口的子类。

非抽象子类实现接口：

必须重写接口所有的抽象方法

继承了接口的默认方法，既可以直接调用，也可重写。

实现格式 class 类名 implements 接口名 { // 重写接口中抽象方法【必须】 // 重写接口中默认方法【可选】 } 静态方法的使用

静态只能用接口名调用，不可以通过实现类的类名或者实现类的对象调用。

接口的多实现

对于接口而言，一个类可以实现多个接口，这叫接口的多实现。一个类能继承一个父类，同时实现多个接口。

格式：

class 类名 [extends 父类名] implements 接口名1,接口名2,接口名3... { // 重写接口中抽象方法【必须】 // 重写接口中默认方法【不重名时可选】 }

如果抽象方法有重名的，只需要重写一次。

如果默认方法有重名的，必须重写一次。

静态方法不会冲突，因为只能通过各自接口名访问。

优先级

当一个类，既继承一个父类，又实现若干接口，父类的成员方法与接口的默认方法重名，子类执行父类的成员方法。

其他

• 接口中，无法定义成员变量，但是可以定义常量，其值不可以改变，默认使用public static final修饰

• 接口中，没有构造方法，不能创建对象。

• 接口中，没有静态代码块。

• 父类可以作为类型接收子类的对象

  接口可以作为类型接收实现类的对象

2. 多态 概念

是指同一行为，具有多个不同的表现形式。

前提

继承或者实现【二选一】

方法的重写【意义体现：不重写，无意义】

父类引用指向子类对象【格式体现】

格式 父类类型 变量名 = new 子类对象； 变量名.方法名();

父类类型：指子类对象继承的父类类型，或者实现的父接口类型。

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，执行的是子类重写后方法。

成员变量：编译看左边，运行还看左边。 成员方法：编译看左边，运行看右边。 多态的好处

实际开发的过程中，父类类型作为方法形式参数，传递子类对象给方法，进行方法的调用，更能体现出多态的扩展性与便利。可以使程序编写的更简单，并有良好的扩展。

引用类型转换

• 向上转型： 多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的。
• 向下转型：父类类型向子类类型向下转换的过程，这个过程是强制的。

为什么要转型？

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误，不能调用子类拥有，而父类没有的方法。想要调用子类特有的方法，必须做向下转型。

转型的异常：运行报错ClassCastException

如何避免转型异常？ 变量名 instanceof 数据类型 如果变量属于该数据类型，返回true。 如果变量不属于该数据类型，返回false。 多态经典题

A B C D的题，见 day10_test.demo03

day11 【内部类、final、权限】 1. 内部类 1. 概念

将一个类A定义在另一个类B里面，里面的类A就成为内部类，B则为外部类

2. 成员内部类

• 成员内部类： 定义在类中方法外的类

• 格式：

class 外部类 { class 内部类 { } }

• 应用场景：描述事物时，若一个事物内部还包含其他事物，就可以使用内部类，如汽车类中包含发动机类。
• 访问特点：
  • 内部类可以直接访问外部类的成员，包括私有成员
  • 外部类要访问内部类的成员，必须建立内部类的对象
• 内部类对象创建格式

外部类名.内部类名 对象名 = new 外部类型().new 内部类型();

内部类仍然是独立的类，编译后内部类编译为独立的.class如Person$Heart.class

2. 匿名内部类 概念

内部类的简化写法，本质为一个带具体实现的父类或者父接口的匿名的子类对象。

格式 new 父类名或者接口名(){ //方法重写 @Override public void method(){ //执行语句 } }； 使用方式

定义接口

public abstract class FlyAble{ public abstract void fly(); }

创建匿名内部类，并调用：

通常在方法的形参是接口或者抽象类时，可以将匿名内部类作为参数传递

public class InnerDemo1 { public static void main(String[] args){ /* 1. 等号右边： 定义并创建该接口的子类对象 2. 等号左边：是多态，接口类型引用指向子类对象 */ FlyAble f = new FlyAble(){ public void fly() { System.out.println("我飞了~~~"); } }; // 将f传递给showFly方法中 showFly(f); } public static void showFly(FlyAble f){ f.fly(); } }

简化写法

public class InnerDemo2 { public static void main(String[] args){ /* 创建匿名内部类，直接传递给showFly(FlyAble f) */ showFly( new FlyAble(){ public void fly() { System.out.println("我飞了~~~"); } })； } public static void showFly(FlyAble f) { f.fly(); } } 3. final 概述

为了避免这种随意改写继承API中提供的类的内容的情况，Java提供了final 关键字，用于修饰不可改变内容。

• final： 不可改变。可以用于修饰类、方法和变量。
  • 类：被修饰的类，不能被继承。
  • 方法：被修饰的方法，不能被重写。
  • 变量：被修饰的变量，不能被重新赋值。

使用方式

• 修饰类

格式如下：

final class 类名 { }

查询API发现像 public final class String 、public final class Math 、public final class Scanner 等，很多我们学习过的类，都是被final修饰的，目的就是供我们使用，而不让我们所以改变其内容。

• 修饰方法

格式如下：

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

重写被 final修饰的方法，编译时就会报错

• 修饰变量

局部变量——基本类型 被final修饰后，只能赋值一次，不能再更改

局部变量——引用类型 只能指向一个对象，地址不能再更改。但是不影响对象内部的成员变量值的修改

成员变量 涉及到初始化的问题

a. 显示初始化

public class User { final String USERNAME = "张三"; private int age; }

​ b. 构造方法初始化

public class User { final String USERNAME ; private int age; public User(String username, int age) { this.USERNAME = username; this.age = age; } }

被final修饰的常量名称，一般都有书写规范，所有字母都大写

4. 权限修饰符 不同权限的访问能力 publicprotecteddefault（空的）private

同一类中	√	√	√	√
同一包中(子类与无关类)	√	√	√
不同包的子类	√	√
不同包中的无关类	√

本文标签： 知识点基础java