定义：多个方法的名称一样，但是参数列表不一样。
好处：只需要记住唯一一个方法名称，就可以实现多个类似功能。
方法重载与下列因素有关：
-
参数个数不同
-
参数类型不同
-
参数多类型顺序不同
方法重载与下列因素无关：
-
与参数名称无关删除线格式
-
与方法的返回值类型无关
=========================================================================
Java的内存需要划分为5个部分：
- 栈（Stack）：存放的都是方法中的局部变量。方法的运行一定都在栈当中。
局部变量：方法的参数，或者是方法{}内部的变量。
作用域：一旦超出作用域，立即从栈内存中消失。
- 堆（Heap）：凡是new出来的东西，都在堆当中。
堆内存里面的东西都有一个地址值：16进制。
对内存里面的数据，都有默认值。规则：
如果是整数 默认为0
如果是浮点数 默认为0.0
如果是字符 默认为’\u0000’
如果是布尔 默认为false
如果是引用类型 默认为null
-
方法区（Method Area）：存储.class相关信息，包含方法的信息。
-
本地方法栈（Native Method Stack）：与操作系统相关。
-
寄存器（pc Register）：与CPU相关。
- 一个数组的内存图：
定义数组的array为局部变量，是存储在栈当中的。
new出来的int[3]数组是存储在堆当中的。
array实际存储的为堆中int[3]的地址。
- 两个数组的内存图：
数组与数组之间互不影响。
- 两个引用指向同一个数组
引用指向同一个数组，作用的地址相同。
====================================================================
通常情况下，一个类并不能直接使用，需要根据类创建一个对象，才能使用。
- 导包：也就是指出需要使用的类，在什么位置
import 包名称.类名称
对于和当前类属于一个包的情况，可以省略导包语句不写。
- 创建，格式：
类名称 对象名 = new 类名称();
- 使用，分为两种情况
① 使用成员变量：对象名.成员变量名
② 使用成员方法：对象名.成员方法名(参数0)
- 注意事项：如果成员变量没有进行赋值，那么将会有一个默认值，规则和数组一样。
- 一个对象的内存图
成员变量直接在堆中进行访问使用，成员方法先访问堆中成员方法，获取地址，再进入方法区，获取成员方法，将该方法入栈，执行完后立即出栈。
- 两个对象使用同一个方法的内存
成员变量是分开各自的，成员方法都是记录的地址。
- 两个引用指向同一个对象的
- 使用对象类型作为方法的返回值
当使用一个对象类型作为方法的返回值时：返回值其实就是对象的地址值。
===========================================================================
- 定义的位置不一样
局部变量：在方法的内部。
成员变量：在方法的外部，直接写在类当中。
- 作用范围不一样
局部变量：只有方法当中才可以使用，出了方法就不能再用。
成员变量：整个类全都可以通用。
- 默认值不一样
局部变量：没有默认值，如果想使用，必须手动赋值。
成员变量：如果没有赋值，会有默认值，规则和数组一样。
- 内存的位置不一样
局部变量：位于栈内存。
成员变量：位于堆内存。
- 生命周期不一样
局部变量：随着方法进栈而诞生，随着方法出栈而消失。
成员变量：随着对象创建而诞生，随着对象被垃圾回收而消失。
=======================================================================
对于基本类型中的boolean值，Getter方法一定要写成isXxx的形式，而setXxx规则不变。
====================================================================
构造方法是专门用来创建对象的方法，当我们通过关键字new来创建对象时，其实就是在调用构造方法。
public 类名称(参数类型 参数名称){
方法体
}
注意事项：
-
构造方法的名称必须和所在的类名完全一样，就连大小写也要一样。
-
构造方法不能有返回值，不要写返回值类型，连void都不写。
-
构造方法可以重载。（方法名称相同，参数列表不同）
====================================================================
一个标准的类通常要拥有以下四个组成部分：
-
所有的成员变量都要使用private关键字修饰
-
为每一个成员变量编写一对儿Getter/Setter方法
-
编写一个无参数的构造方法
-
编写一个全参数的构造方法
这样标准的类也叫做Java Bean
=========================================================================
对于ArrayList来说，有一个尖括号< E >代表泛型。
泛型：也就是装在集合中的所有元素，全都是统一的什么类型。
注意：泛型只能是引用类型，不能是基本类型。
===================================================================
字符串的特点：
-
字符串的内容用不可变。
-
正是因为字符串不可改变，所以字符串是可以共享使用的。
-
字符串效果上相当于chart[]字符数组，底层原理是byte[]字节数组。
字符串常见的3+1中创建方式：
三种构造方法：
public String():创建一个空白字符串，不含有任何内容。
public String(char[] array):根据字符数组的内容，来创建对应的字符串。
public String(byte[] array):根据字节数组的内容，来创建对应的字符串。
一种直接创建：
String str = “Hello”; // 右边直接用双引号
注意：直接写上双引号，就是字符串对象。
字符串常量池：程序当中直接写上的双引号字符串，就在字符串常量池中。new的不在常量池当中。
对于基本类型来说，==是进行数值比较。
对于引用类型来说，==是进行地址值比较。
======================================================================
一旦使用static修饰成员方法，那么这就成为了静态方法。静态方法不属于对象，而是属于类的。
如果没有static关键字，那么必须首先创建对象，然后通过对象才能使用它。
如果有了static关键字，那么不需要创建对象，直接就能通过类名称来使用它。
无论是成员变量，还是成员方法。如果有了static，都推荐使用类名称进行调用。
静态变量：类名称.静态变量
静态方法：类名称.静态方法()
注意事项：
- 静态不能直接访问非静态。
原因：因为在内存当中是【先】有的静态内容，【后】有的非静态内容。
“先人不知道后人，但是后人知道先人。”
- 静态方法当中不能用this。
原因：this代表当前对象，通过谁调用的方法，谁就是当前对象。
- 静态static的内存图
根据类名称访问静态成员变量的时候，全程和对象没有关系，只和类有关系。
==================================================================
继承主要解决的问题是：共性抽取
在继承关系中，“子类就是一个父类”。也就是说，子类可以被当作父类看待。
例如父类是员工，子类是讲师，那么"讲师就是一个员工"。关系 ： is-a
定义父类的格式：（一个普通的类定义）
public class 父类名称 {
// …
}
定义子类的格式：
public class 子类名称 extends 父类名称 {
// …
}
在父子类的继承关系当中，如果成员变量重名，则创建子类对象时，访问有两种方式：
直接通过子类对象访问成员变量：
- 等号左边是谁，就优先用谁，没有则向上找。
间接通过成员方法访问成员变量：
- 该方法属于谁，就优先用谁，没有则向上找。
区分子类方法中重名的三种
-
局部变量： 直接写成员变量名
-
本类的成员变量： this.成员变量名
-
父类的成员变量： super.成员变量名
在父子类的继承关系当中，创建子类对象，访问成员方法的规则：
创建的对象是谁，就优先用谁，如果没有则向上找。
注意事项：
无论是成员方法还是成员变量，如果没有都是向上找父类，绝对不会向下找子类的。
重写（Override）
概念：在继承关系当中，方法的名称一样，参数列表也一样。
重写（Override）：方法的名称一样，参数列表【也一样】。覆盖、覆写。
重载（Overload）：方法的名称一样，参数列表【不一样】。
方法的覆盖重写特点：创建的是子类对象，则优先用子类方法。
方法覆盖重写的注意事项：
- 必须保证父子类之间方法的名称相同，参数列表也相同。
@Override：写在方法前面，用来检测是不是有效的正确覆盖重写。
这个注解就算不写，只要满足要求，也是正确的方法覆盖重写。
- 子类方法的返回值必须【小于等于】父类方法的返回值范围。
小扩展提示：java.lang.Object类是所有类的公共最高父类（祖宗类），java.lang.String就是Object的子类。
- 子类方法的权限必须【大于等于】父类方法的权限修饰符。
小扩展提示：public > protected > (default) > private
备注：(default)不是关键字default，而是什么都不写，留空。
继承关系中，父子类构造方法的访问特点：
-
子类构造方法当中有一个默认隐含的“super()”调用，所以一定是先调用的父类构造，后执行的子类构造。
-
子类构造可以通过super关键字来调用父类重载构造。
-
super的父类构造调用，必须是子类构造方法的第一个语句。不能一个子类构造调用多次super构造。
总结：
子类必须调用父类构造方法，不写则赠送super()；写了则用写的指定的super调用，super只能有一个，还必须是第一个。
super关键字的用法有三种：
-
在子类的成员方法中，访问父类的成员变量。
-
在子类的成员方法中，访问父类的成员方法。
-
在子类的构造方法中，访问父类的构造方法。
在第三种用法当中也要注意：
A. this(…)调用也必须是构造方法的第一个语句，唯一一个。
B. super 和 this 两种构造调用，不能同时使用
super关键字和this关键字图解
==================================================================
如果父类当中的方法不确定如何{}方法体实现，那么这就应该是一个抽象方法。
抽象方法：就是加上abstract关键字，然后去掉大括号，直接分号结束。
抽象类：抽象方法所在的类，必须是抽象类才行。在class之前写上abstract即可。
如何使用抽象类和抽象方法：
-
不能直接创建new抽象类对象。
-
必须用一个子类来继承抽象父类。
-
子类必须覆盖重写抽象父类当中所有的抽象方法。
覆盖重写（实现）：子类去掉抽象方法的abstract关键字，然后补上方法体大括号。
- 创建子类对象进行使用。
==================================================================
接口就是一种公共的规范标准。
只要符合规范标准，就可以大家通用。
接口就是多个类的公共规范。
接口是一种引用数据类型，最重要的内容就是其中的：抽象方法。
如何定义一个接口的格式：
public interface 接口名称 {
// 接口内容
}
备注：换成了关键字interface之后，编译生成的字节码文件仍然是：.java --> .class。
如果是Java 7，那么接口中可以包含的内容有：
-
常量
-
抽象方法
如果是Java 8，还可以额外包含有：
-
默认方法
-
静态方法
如果是Java 9，还可以额外包含有：
- 私有方法
- 接口的抽象方法定义及使用
① 定义
在任何版本的Java中，接口都能定义抽象方法。
格式：
public abstract 返回值类型 方法名称(参数列表);
注意事项：
-
接口当中的抽象方法，修饰符必须是两个固定的关键字：public abstract
-
这两个关键字修饰符，可以选择性地省略。（今天刚学，所以不推荐。）
-
方法的三要素，可以随意定义。
package cn.itcast.day10.demo01;
public interface MyInterfaceAbstract {
// 这是一个抽象方法
public abstract void methodAbs1();
// 这也是抽象方法
abstract void methodAbs2();
// 这也是抽象方法
public void methodAbs3();
// 这也是抽象方法
void methodAbs4();
}
② 使用
接口使用步骤：
- 接口不能直接使用，必须有一个“实现类”来“实现”该接口。
格式：
public class 实现类名称 implements 接口名称 {
// …
}
- 接口的实现类必须覆盖重写（实现）接口中所有的抽象方法。
实现：去掉abstract关键字，加上方法体大括号。
- 创建实现类的对象，进行使用。
注意事项：
如果实现类并没有覆盖重写接口中所有的抽象方法，那么这个实现类自己就必须是抽象类。
package cn.itcast.day10.demo01;
public class MyInterfaceAbstractImpl implements MyInterfaceAbstract {
@Override
public void methodAbs1() {
System.out.println(“这是第一个方法！”);
}
@Override
public void methodAbs2() {
System.out.println(“这是第二个方法！”);
}
@Override
public void methodAbs3() {
System.out.println(“这是第三个方法！”);
}
@Override
public void methodAbs4() {
System.out.println(“这是第四个方法！”);
}
}
- 接口的默认方法定义及使用
① 定义
从Java 8开始，接口里允许定义默认方法。
格式：
public default 返回值类型 方法名称(参数列表) {
方法体
}
备注：接口当中的默认方法，可以解决接口升级的问题。
② 使用
默认方法会被接口的实现类自动继承
-
接口的默认方法，可以通过接口实现类对象，直接调用。
-
接口的默认方法，也可以被接口实现类进行覆盖重写。
- 接口的静态方法定义及使用
① 定义
从Java 8开始，接口当中允许定义静态方法。
格式：
public static 返回值类型 方法名称(参数列表) {
方法体
}
提示：就是将abstract或者default换成static即可，带上方法体。
② 使用
注意事项：不能通过接口实现类的对象来调用接口当中的静态方法。
正确用法：通过接口名称，直接调用其中的静态方法。
格式：
接口名称.静态方法名(参数);
- 接口的私有方法定义及使用
① 定义
问题描述：
我们需要抽取一个共有方法，用来解决两个默认方法之间重复代码的问题。
但是这个共有方法不应该让实现类使用，应该是私有化的。
解决方案：
从Java 9开始，接口当中允许定义私有方法。
- 普通私有方法，解决多个默认方法之间重复代码问题
格式：
private 返回值类型 方法名称(参数列表) {
方法体
}
- 静态私有方法，解决多个静态方法之间重复代码问题
格式：
private static 返回值类型 方法名称(参数列表) {
方法体
}
② 使用
普通私有方法，解决多个默认方法之间重复代码问题
静态私有方法，解决多个静态方法之间重复代码问题
- 接口常量的定义和使用
① 定义
接口当中也可以定义“成员变量”，但是必须使用public static final三个关键字进行修饰。
从效果上看，这其实就是接口的【常量】。
格式：
public static final 数据类型 常量名称 = 数据值;
备注：
一旦使用final关键字进行修饰，说明不可改变。
注意事项：
-
接口当中的常量，可以省略public static final，注意：不写也照样是这样。
-
接口当中的常量，必须进行赋值；不能不赋值。
-
接口中常量的名称，使用完全大写的字母，用下划线进行分隔。（推荐命名规则）
② 使用
直接用接口.常量使用
接口总结
在Java 9+版本中，接口的内容可以有：
- 成员变量其实是常量，格式：
[public] [static] [final] 数据类型 常量名称 = 数据值;
注意：
常量必须进行赋值，而且一旦赋值不能改变。
常量名称完全大写，用下划线进行分隔。
- 接口中最重要的就是抽象方法，格式：
[public] [abstract] 返回值类型 方法名称(参数列表);
注意：实现类必须覆盖重写接口所有的抽象方法，除非实现类是抽象类。
- 从Java 8开始，接口里允许定义默认方法，格式：
[public] default 返回值类型 方法名称(参数列表) { 方法体 }
注意：默认方法也可以被覆盖重写
- 从Java 8开始，接口里允许定义静态方法，格式：
[public] static 返回值类型 方法名称(参数列表) { 方法体 }
注意：应该通过接口名称进行调用，不能通过实现类对象调用接口静态方法
- 从Java 9开始，接口里允许定义私有很乏，格式：
普通私有方法：private 返回值类型 方法名称(参数列表) { 方法体 }
静态私有方法：private static 返回值类型 方法名称(参数列表) { 方法体 }
注意：private的方法只有接口自己才能调用，不能被实现类或别人使用。
接口注意事项：
-
接口是没有静态代码块或者构造方法的。
-
一个类的直接父类是唯一的，但是一个类可以同时实现多个接口。
public class MyInterfaceImpl implements MyInterfaceA, MyInterfaceB {
// 覆盖重写所有抽象方法
}
-
如果实现类所实现的多个接口当中，存在重复的抽象方法，那么只需要覆盖重写一次即可。
-
如果实现类没有覆盖重写所有接口当中的所有抽象方法，那么实现类就必须是一个抽象类。
-
如果实现类锁实现的多个接口当中，存在重复的默认方法，那么实现类一定要对冲突的默认方法进行覆盖重写。
-
一个类如果直接父类当中的方法，和接口当中的默认方法产生了冲突，优先用父类当中的方法。
接口与类的关系：
-
类与类之间是单继承的。直接父类只有一个。
-
类与接口之间是多实现的。一个类可以实现多个接口。
-
接口与接口之间是多继承的。
注意事项：
-
多个父接口当中的抽象方法如果重复，没关系。
-
多个父接口当中的默认方法如果重复，那么子接口必须进行默认方法的覆盖重写，【而且带着default关键字】。
==================================================================
面向对象三大特征：封装、继承、多态
extends继承或者implements接口的实现，是多态的前提。
代码当中体现多态性，其实就是一句话：父类引用指向子类对象。
格式：
父类名称 对象名 = new 子类名称();
或者：
接口名称 对象名 = new 实现类名称();
多态中成员变量的使用规则
-
直接通过对象名称访问成员变量：看等号左边是谁，优先用谁，没有则向上找。
-
间接通过成员方法访问成员变量：看该方法属于谁，优先用谁，没有则向上找。
多态中成员方法的使用规则
在多态的代码当中，成员方法的访问规则是：
看new的是谁，就优先用谁，没有则向上找。
口诀：编译看左边，运行看右边。
对比一下：
成员变量：编译看左边，运行还看左边。
成员方法：编译看左边，运行看右边。
多态的好处
多态的好处，体现在，可以使程序编写的更简单，并有良好的扩展。
对象的向上转型和向下转型
含义：
-
右侧创建一个子类对象，把它当作父类来看待使用。
-
将父类对象，还原为本来的子类对象。
格式：
-
向上转型：父类名称 对象名 = new 子类名称();
-
向下转型：子类名称 对象名 = (子类名称)父类对象;
注意：
-
向上转型一定是安全的
-
**对象一旦向上转型为父类，就无法调用子类原本特有的内容。**解决方案：向下转型
如何才能知道一个父类引用的对象，本来是什么子类？
格式：
对象 instanceof 类名称
这将会得到一个boolean值结果，也就是判断前面的对象能不能当做后面类型的实例。
========================================================================
final关键字代表最终、不可改变的。
常见四种用法：
-
可以用来修饰一个类
-
可以用来修饰一个方法
-
还可以用来修饰一个局部变量
-
还可以用来修饰一个成员变量
① 修饰类
当final关键字用来修饰一个类的时候，格式：
public final class 类名称 {
// …
}
含义：当前这个类不能有任何的子类。（太监类）
注意：一个类如果是final的，那么其中所有的成员方法都无法进行覆盖重写（因为没儿子。）
② 修饰成员方法
当final关键字用来修饰一个方法的时候，这个方法就是最终方法，也就是不能被覆盖重写。
格式：
修饰符 final 返回值类型 方法名称(参数列表) {
// 方法体
}
注意事项：
对于类、方法来说，abstract关键字和final关键字不能同时使用，因为矛盾。
③ 修饰局部变量
一旦使用final用来修饰局部变量，那么这个变量就不能进行更改。“一次赋值，终生不变”
对于成员变量来说，如果使用final关键字修饰，那么这个变量也照样是不可变。
1. 由于成员变量具有默认值，所以用了final之后必须手动赋值，不会再给默认值了。
2. 对于final的成员变量，要么使用直接赋值，要么通过构造方法赋值。二者选其一。
3. 必须保证类当中所有重载的构造方法，都最终会对final的成员变量进行赋值。
对于基本类型来说，不可变说的是变量当中的数据不可改变
对于引用类型来说，不可变说的是变量当中的地址值不可改变
④ 修饰成员
对于成员变量来说，如果使用final关键字修饰，那么这个变量也照样是不可变。
-
由于成员变量具有默认值，所以用了final之后必须手动赋值，不会再给默认值了。
-
对于final的成员变量，要么使用直接赋值，要么通过构造方法赋值。二者选其一。
-
必须保证类当中所有重载的构造方法，都最终会对final的成员变量进行赋值。
=======================================================================
| | public | protected | default（空的） | private |
| — | — | — | — | — |
| 同一类中 | √ | √ | √ | √ |
| 同一包中(子类与无关类) | √ | √ | √ | |
| 不同包的子类 | √ | √ | | |
| 不同包中的无关类 | √ | | | |
可见，public具有最大权限。private则是最小权限。
编写代码时，如果没有特殊的考虑，建议这样使用权限：
-
成员变量使用private ，隐藏细节。
-
构造方法使用public ，方便创建对象。
-
成员方法使用public ，方便调用方法。
===================================================================
如果一个事物的内部包含另一个事物，那么这就是一个类内部包含另一个类。
例如：身体和心脏的关系。又如：汽车和发动机的关系。
分类：
-
成员内部类
-
局部内部类（包含匿名内部类）
成员内部类的定义格式：
修饰符 class 外部类名称 {
修饰符 class 内部类名称 {
// …
}
// …
}
注意：内用外，随意访问；外用内，需要内部类对象。
如何使用成员内部类？有两种方式：
- 间接方式：在外部类的方法当中，使用内部类；然后main只是调用外部类的方法。
类名称 对象名 = new 类名称();
【外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();】
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！
由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）
总结
这个月马上就又要过去了，还在找工作的小伙伴要做好准备了，小编整理了大厂java程序员面试涉及到的绝大部分面试题及答案，希望能帮助到大家
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！
. 内部类
===================================================================
如果一个事物的内部包含另一个事物，那么这就是一个类内部包含另一个类。
例如：身体和心脏的关系。又如：汽车和发动机的关系。
分类：
-
成员内部类
-
局部内部类（包含匿名内部类）
成员内部类的定义格式：
修饰符 class 外部类名称 {
修饰符 class 内部类名称 {
// …
}
// …
}
注意：内用外，随意访问；外用内，需要内部类对象。
如何使用成员内部类？有两种方式：
- 间接方式：在外部类的方法当中，使用内部类；然后main只是调用外部类的方法。
类名称 对象名 = new 类名称();
【外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();】
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。[外链图片转存中…(img-NGog6p1i-1713467061023)]
[外链图片转存中…(img-d2jyDVZE-1713467061025)]
[外链图片转存中…(img-2egFeN2p-1713467061027)]
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！
由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）
总结
这个月马上就又要过去了，还在找工作的小伙伴要做好准备了，小编整理了大厂java程序员面试涉及到的绝大部分面试题及答案，希望能帮助到大家
[外链图片转存中…(img-WEMJsrNm-1713467061028)]
[外链图片转存中…(img-0vH0Mpem-1713467061030)]
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！
1703
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
