Java的特点

1. Java语言是面向对象的语言（OOP面向对象编程）
2. Java支持多线程
3. Java语言拥有自动垃圾回收
4. Java具有简单性，省去了很多C和C++的复杂的语言，比如：goto……
5. Java语言具有跨平台的特性，一次编写到处运行
6. Java具有鲁棒（健壮性），很严谨，Java属于请类型的编程使用变量之前必须声明变量的数据类型，Java拥有异常处理机制……

注释

• 单行注释
• 多行注释
• 文档注释

Java的转义字符

快捷键：Ctrl + w ，快速选中一段内容

变量

变量：变化的量

变量的组成：

1. 数据类型
2. 变量名字

3. 变量的值

   变量使用的注意事项

4. 变量表示一个内存空间

5. 每一个空间都有自己的 名称（变量名）和 类型（数据类型）
6. 变量一定要先声明后使用
7. 这个 存储空间（变量）中的值是可以不停变化的，但是数据类型不可变
8. 变量在同一个作用域中变量名称不可以重复，作用域就是一个{}

标识符的命名规范

变量，方法，类，有开发人员自定义的内容就是标识符

命名的规则

在Java中对标识符有严格的规范（必须遵守）

1. 由26个字母，0-9数字，_和 $ 组成
2. 可以包含数字但是不可以用数字开头
3. 不能是保留字或者关键字,关键字最直白的表现就是在开发工具中会有对应的颜色
4. 变量命名严格区分呢大小写
5. 标识符中不要有空格

命名的规范可以让代码更加清晰,体现开发人员的专业性

程序中 “+” 的用法

程序中+的作用,由 “+” 左右两边的类型决定

• 如果两边是数字,进行加法运算
• 两边出现字符,进行连接的操作

快捷键(快速生成变量):变量值.var

数据类型

在Java中对每一个数据都有明确的数据类型,Java是一种 强类型的编辑语言,在每一个变量声明之前必须声明数据类型
每一个数据类型所占用的空间大小是不一样的

Java中的数据类型分为两大类

• 基本数据类型
• 引用数据类型
  • 类
  • 接口
  • 数组

基本数据类型(四类八种)

整数类型使用的注意事项

Java中所有的整数 默认都是 int 类型,如果使用long类型,需要在变量值的后面加L或者l
了解:
bit(位):计算机中最小的存储单位
byte(字节):是计算机中的基本存储单元
换算:1 byte = b bit
byte 是一个字节的大小,八位

堆和栈的概念和区别

Java程序在运行时都要开辟空间，任何软件在运行时都要在内存中开辟空间，Java虚拟机运行时也要开辟空间的，JVM运行时在内存中开辟一片内存区域，启动时在自己的内存区域中进行更细致的划分，因为虚拟机中每一片内存处理的方式都不同，所以眼单独进行管理。

内存管理:由JVM管理
堆:new出来的对象(包括实例变量)
栈:正在调用的方法中的局部变量(包括方法的参数)
方法区:.class字节码文件(包括静态变量、所有方法)

JVM内存的划分由五片：

1. 寄存器
2. 本地方法区
3. 方法区
4. 栈内存
5. 堆
6. 内存

我们重点来说一下堆和栈：

栈内存

栈内存首先时一片内存区域，存储的都是局部变量，凡是定义在方法中的都是局部变量（方法外的是全局变量），for循环内部定义的也是局部变量，是先加载函数才能进行局部变量的定义，所以方法先进栈，然后再定义变量，变量有自己的作用域，一旦离开作用域，变量就会被释放。栈内存的更新速度很快，因为局部变量的生命周期都很短。

堆内存

存储的是数组和对象（其实数组就是对象），凡是new建立的都是在堆中，堆中存放的都是实体（对象），实体用于封装数据，而且是封装多个（实体的多个属性），如果一个数据小时，这个实体也没有消失，还可以用，所以堆是不会随时释放的，但是栈不一样，栈里存放的都是单个变量，变量被释放了，那就没有了。堆里的实体虽然不会被释放，但是会被当成垃圾，垃圾有垃圾回收机制不定时的收取。

详细堆和栈

比如主方法里的语句 int[] arr = new int[3];在内存中是怎么定义的:
主函数先进栈，在栈中定义一个变量arr,接下来为arr赋值，但是右边不是一个具体值，是一个实体。实体创建在堆里，在堆里首先通过new关键字开辟一个空间，内存在存储数据的时候都是通过地址来体现的，地址是一块连续的二进制，然后给这个实体分配一个内存地址。数组都是有一个索引，数组这个实体在堆内存中产生之后每一个空间都会进行默认的初始化（这是堆内存的特点，未初始化的数据是不能用的，但在堆里是可以用的，因为初始化过了，但是在栈里没有），不同的类型初始化的值不一样。所以堆和栈里就创建了变量和实体：

那么堆和栈是怎么联系起来的呢?

 我们刚刚说过给堆分配了一个地址，把堆的地址赋给arr，arr就通过地址指向了数组。所以arr想操纵数组时，就通过地址，而不是直接把实体都赋给它。这种我们不再叫他基本数据类型，而叫引用数据类型。称为arr引用了堆内存当中的实体。（可以理解为c或c++的指针，Java成长自c++和c++很像，优化了c++）                                                                <br />![](https://cdn.nlark.com/yuque/0/2022/png/23182771/1650609474128-e1166538-f23c-4eb6-b570-9e1142082306.png#clientId=udfff2921-8e6a-4&crop=0&crop=0&crop=1&crop=1&from=paste&id=u1844c5bd&margin=%5Bobject%20Object%5D&originHeight=476&originWidth=666&originalType=url&ratio=1&rotation=0&showTitle=false&status=done&style=none&taskId=u7af63f0f-b11d-4394-b5fa-03fc44fe4bb&title=)<br />     
          如果当int [] arr=null;
          arr不做任何指向，null的作用就是取消引用数据类型的指向。
          当一个实体，没有引用数据类型指向的时候，它在堆内存中不会被释放，而被当做一个垃圾，在不定时的时间内自动回收，因为Java有一个自动回收机制，（而c++没有，需要程序员手动回收，如果不回收就越堆越多，直到撑满内存溢出，所以Java在内存管理上优于c++）。自动回收机制（程序）自动监测堆里是否有垃圾，如果有，就会自动的做垃圾回收的动作，但是什么时候收不一定。
         所以堆与栈的区别很明显：
        1.栈内存存储的是局部变量而堆内存存储的是实体；
        2.栈内存的更新速度要快于堆内存，因为局部变量的生命周期很短；
        3.栈内存存放的变量生命周期一旦结束就会被释放，而堆内存存放的实体会被垃圾回收机制不定时的回收。

[

](https://blog.csdn.net/pt666/article/details/70876410)

浮点数类型

Java中使用浮点数类型来表示小数

浮点数的类型

浮点数的使用

1. 浮点数进行运算,会造成精度的丢失
2. 不建议使用小数进行比较
3. 当我们使用float类型的时候,我们需要在变量值的尾部加上f或者F
4. Java中所有的小数 默认都是 double 类型的

字符型char

Java中的字符型表示单个的字符,用char来进行声明,变量的值必须使用’’(单引号)包括
单个的字符:在’’ 中只能有一个字,不管是数字,中文,英文还是标点

ACSII值表

因为每一个字符对应着一个数字,所以字符是可以计算的

布尔类型

在Java中表示真和假,代码中对应着 true 和false
在大多数情况下是在流程控制中使用的

注意:Java中的 boolean 并不对应任何数字

基本数据类型的转换

数据类型转换:将类型转换成另一个类型
转换的方式分为两种

• 自动类型转换(隐式转换)
• 强制类型转换

自动类型转换

在程序赋值或者运算的过程中，将 数据范围小的类型转换为数据范围到的类型 不需要任何的操作，直接赋值即可，所以被称为自动类型转换，隐式转换

大小顺序
byte < short < int < long < float < double
char < int < long < float < double

自动类型转换的注意事项

注意点一:多种数据类型混合使用 系统会首先 将所有的数据类型提升为数据范围最大的那个,之后再进行计算

注意点二:byte short 不能和char 进行转换

注意点三:byte short char 编译器规定这三者在进行计算的时候,先提升到 int 类型在进行计算

强制类型转换

强制类型转换是 大类型 转换成 小类型
通过()来实现
注意:在进行强制类型转换的时候会造成精度的丢失
情况二:数据溢出

强制类型转换的注意点

强制类型转换只能操作最近的数字
解决方案:为整个表达式()阔起来

运算符

• 算数运算
• 关系运算
• 逻辑运算
• 三元运算
• 位运算

算数运算

关系运算符

关系运算结果是一个布尔值,要么是 true,要么是 false
经常在 分支语句 和 循环语句中使用

总结:

1. 关系运算组成的表达式,我们称之为 关系表达式

2. 注意 “=” 和 “==” 不要搞混了,单独等号代表赋值的意思,两个等号是判断关系

   逻辑运算符

   作用:用于连接多个条件(多个关系表达式),最终获得一个布尔值

3. 短路与&&

   1. 表达式1 && 表达式2
      1. 如果表达式1和表达式2的结果为 true 的情况下,逻辑运算结果为true,如果有一个表达式为false,结果就是false
         1. 如果表达式1可以直接判断结果,就不进行表达式2的运算,表达式1为false的时候,运算会停止
         2. 会比逻辑与少算一次,效率更高
         3. 在实际开发中,我们会使用短路与进行比较,效率极高
4. 段落或||
   1. 表达式1 || 表达式2
      1. 如果表达式1 和表达式2 的结果为 false 的情况下,逻辑运算的结果false,如果有一个表达式为true,结果就是true
         1. 如果表达式1可以直接判断结果,就不进行表达式2 的运算,表达式1 为true的时候,运算会停止
         2. 会比逻辑与少算一次效率更高
         3. 在实际开发中,我们会使用短路或进行比较,效率极高
5. 取反!
   1. 作用:取相反的值,使用”!”
6. 逻辑与&
   1. 表达式1 & 表达式2的结果为 true 的情况下,逻辑运算的结果true,如果有一个表达式为false,结果为fale
      1. 逻辑与:不管表达式1的结果是 true 还是 false ,都会运算表达式2,会比短路与多运算一次
7. 逻辑或|
   1. 表达式1 |表达式2
      1. 如果表达式1 和表达式2 的结果为 false的情况下,逻辑运算的结果false,如果有一个表达式为true,结果就是true
         1. 不管表达式1的结果是true 还是 false ,都会运算表达式2,会比短路与多运算一次
8. 逻辑异或^
   1. 需要一边是 true 一边是 false

赋值运算符

+=
-=
*=
/=
%=

三元/三目运算

基本语法

条件表达式 ? 表达式1 : 表达式2;
//运算规则
//如果表达式的结果为真 true,运算的结果就是表达式1的结果
//反之结果就是表达式2 的结果

键盘输入

在编程中,需要接收用户输入的一些信息,通过键盘的输入局域来获取
需要扫描器,Scanner,是Java的开发人员编写的,我们可以直接用的
步骤:

1. 导入该类所在包,java.util
2. 创建这个类的对象(声明变量)
3. 调用对象的功能

位移运算

• 作位移 : >> , 6 >> 3 对应 6除以2的三次方
• 作位移 : << , 6 << 3 对应 6乘以2的三次方

流程控制

1. 代码的正常执行是从上向下,按照流程执行
2. 分支语句,会根据条件来判断执行哪些语句
3. 循环,在某些特殊情况下需要代码执行多次,会用到循环

分支语句 if-else

if(/*条件判断*/) {
    //if中的代码
}else if{
    //else if 中的代码    
}else{
    //else 中的代码
}

流程:首先判断的结果是否是 true ,如果是 true 执行 if 中的代码,反之跳过 if ,直接向下执行
if else if多分支只会走一个分支,走一个之后其他的就不会走了

switch-case 多分支

语法:

switch(变量) {
    case 值1:
        //如果变量和值1相同,走这里的代码
        break;
    case 值2:
        //如果变量和值2相同,走这里的代码
        break;
    case 值3:
        //如果变量和值3相同,走这里的代码
        break;
    ......
    default:
        //如果变量和前面左右case的值都不同,走这里的代码
        break;
}

if-else-if 和 switch 的区别

• if-else-if 主要针对于范围型的 , 每一个分支都要进行判断 , 效率较慢
• switch 只要针对于固定的值 , 而且分支较少 , 效率较高 , 直接用变量和case中的值进行匹配

循环

就是反反复复的重复
在某些特殊的情况下我们需要相同代码执行多次

while循环

语法 :

while(条件表达式) {
    //条件表达式要么为真,要么为假
    //如果条件表达式为true,执行循环体,反之退出循环
}

do-while循环

do {
    //循环体
}while(条件判断);

for循环

for(声明计数器变量; 条件表达式; 操作表达式) {
    //循环体
}

break 和 continue

• break:休息,在Java 的循环中代表着停止循环
• continue:继续,在循环中对应的功能的功能是,跳出当此,直接进行下一次循环

数组

数组的特点：可以在数组中存储多个数据，但是数据类型要一致
比如整数的数组只能存放整数，不能放小数和字符串

数组的使用

1. 声明数组
2. 数组中的元素赋值
3. 使用数组中的元素

• 静态声明：在声明的时候直接给数组中的元素赋值
• 动态声明：在声明的时候直接给数组中的元素赋值

数组的遍历

下标：是指数组中每一个元素的位置，从0开始
如果要使用数组中的元素需要通过下标获得

数组的默认值

使用数组进行动态声明的时候,此时数组只有长度,并没有赋值,但是每一个元素都有一个对应数据类型的默认值

集合框架

集合

集合是多个元素组成的一个单元
类似于数组，但是数组是有缺陷的
数组的缺陷：

1. 数组的长度是固定，一但创建长度就不可以改变，使用超过了下标位置的元素 ArrayIndexOutOfBoundsException异常
2. 数组只能存放一种数据类型

所有的集合都是java.util的子类

集合的分类

1. 注意:集合中只允许存放引用类型,不允许存放基本数据类型
2. Java的集合分为三种
   1. set集合
      1. 无须且不重复
      2. 继承了Collection接口,是一个单列集合
      3. set不区分元素的顺序(存入和取出),不允许有重复的元素
   2. list集合
      1. 有序可重复的
      2. 继承了Collection接口,是一个单列集合
      3. list集合区分元素的顺序(存入和取出),而且允许重复的元素
      4. list集合会在添加元素的时候指定元素的索引/下标,所以可以存在重复元素的
   3. map集合
      1. 没有继承Collection接口,是一个双列集合
      2. map结合存储数据是以 键值对的方式(key ===> value)
      3. 不能有重复的key(键),但是可以有重复的 value(值)
         1. key:身份证
         2. value:人多的名字

Collection集合结构(继承接口实现类)

List接口的实现类

1. LinkedList:增删的效率高
2. ArrayList:查询效率高
3. Vector:线程同步,线程安全

ArrayList类

特点:查询数据的效率很高,性能优越
存储方式:ArrayList采用的和数组一样的存储方式,在内存中开辟了多个空间

ArrayList的常用方法

1. 构造方法ArrayList:构造一个初始容量为十的空列表
2. void add(int index,Object ele):在 index的位置插入元素
3. boolean addAll(int index,Collection eles):index位置开始将eles中的所有元素添加进来
4. Object get(int index):获取指定下标的元素
5. int indexOf(Object o):返回参数o在集合中首次出现的位置,如果没有找到返回-1
6. int lastIndexOf(Object o):返回参数o在集合中末次出现的位置,如果没有找到返回-1
7. Object remove(int index):移除指定下标位置元素,并返回这个元素
8. Object set(int index,Object ele):设置指定下标位置的元素为ele,相当于替换
9. List subList(int FronIndex,int toindex);返回从fromindex(含)到toIndex(不含)位置的集合
10. boolean contains(Object ele):用来判断元素是否存在
11. int size(Object ele):获取集合中元素的个数
12. boolean containsAll(Collection c):用来判断多个元素是否存在,实现自List接口中的方法

Arrays类

使用 sort 对 int 类型的数组进行排序

//定义一个数组
//测试Arrays这个类中的sort数组排序方法
int[] arr1 = {345, 234, 3453, 123};
//使用sort方法对数组进行排序
Arrays.sort(arr1);
//遍历数据,观察排序是否成功
for (int i = 0; i < arr1.length; i++) {
    System.out.println(arr1[i]);
}

copyOf() : 数组扩容方法 , 生成一个新数组

System.out.println("测试copyOf扩容功能");
//copyOf(复制的数组,复制过后的长度)
//生成一个新的数组,长度是指定的复制后的长度,其中还包含原数组中的元素
//复制一个新的数组,指定对一应长度,功能是为数组扩容设计的
int[] intArr = {12, 34, 56};
//将intArr扩容2个元素
int[] intArr2 = Arrays.copyOf(intArr,intArr.length + 2);
for (int i = 0; i < intArr2.length; i++) {
    System.out.println(intArr2[i]);
}

toString():将数组元素转换成字符串显示

//toString()
int[] tstArr = {78,65,12,455,65};
String str = Arrays.toString(tstArr);
System.out.println(str);
System.out.println(Arrays.toString(tstArr));

基本数据类型和引用数据类型

引用数据类型:

• 类:class,比如String,Scanner
• 接口
• 数组

  在 JVM Java虚拟机的内存 , 分为两个空间 栈内存 : 存储基本数据类型的 , 引用数据类型的地址/引用 堆内存 : 存放引用数据类型的内容

基本数据类型 (四类八种) : byte , short , int ,long , float ,double , char , boolean

基本数据类型存储直接将数值存储 栈内存中 , 如果我们要使用基本数据类型的变量 , 直接使用对应的数值

引用数据类型
引用数据类型的变量在 栈内存 中存放一个地址 , 这个地址直接指向 堆内存中的一个空间 , 引用数据类型的内容实际存储的位置在 堆内存中的

基本数据类型赋值直接赋值的是变量数值内容

多维数组

之前学习的内容是一维数组 , 多维数组主要是对于 二维数组的学习
一维数组 :

二维数组 :

多维数组的遍历

使用for循环遍历二维数组

//遍历二维数组
int[][] arrA = {
    {12,34,56,78,90},//0
    {11,22,33,44,55}//1
};
//有几个一维数组
System.out.println("二维数组的长度:" + arrA.length);//2
//二维数组中一维数组的长度
System.out.println("二维数组中一维数组的长度:" + arrA[0].length);//5
//先遍历二维数组
for (int i = 0; i < arrA.length; i++) {
    //通过arrA[i]取到一位数组
    //遍历一维数组
    for (int j = 0; j < arrA[i].length; j++) {
        //i:对应维数组的下标
        //j:对应一维数组中元素的下标
        System.out.print(arrA[i][j] + "\t");
    }
    System.out.println();
}

冒泡排序

非常重要 , 非常重要 , 非常重要

面向对象编程

类和对象

现有技术是无法实习的 : 不理数据的管理 , 效率很低
解决方案 : 通过类和对象实现

类和对象

在 Java 中万物皆为对象
对象的组成 : **属性和方法**

对象也可以被称作为实例
实例 : 实际存在的例子
创建对象的过程 也可以称作为 , 实例化对象 , 实例化类

问题一 : 类名称一定要大写（大驼峰）
问题二 : 明确你要创建的是哪个类 , 模板别选错了

对象在内存中的表现

类的组成 : 属性 和 方法

属性

属性是类的组成部分之一
别名 : 成员 ( 类中的一个成员 ) 变量 , 字段 field
属性可以不赋值 , 在创建了对象之后 , 通过对象进行赋值的
属性如果不复制 , 程序会规定一个默认值 , 默认值和数组的是相同的

方法

方法的作用
方法的作用就是定义一些特殊的功能代码 , 通过对象来进行调用 , 实现我们想要的功能
如果调用了方法 , 对应着也会执行方法体中的代码

有参数的方法

方法的优势

• 如果没有方法的话 , 我们实现功能的代码要写很多次
• 如果使用了方法的话 , 我们可以将代码直接写到方法中 , 通过对象调用实现功能

方法的可变参数

如果我们没有办法确定方法的参数的数量 , 有可能有1个 , 有可能有多个 , 也可能一个都没有 , 可以通过可变参数实现

可变参数的注意点 :

• 可变参数必须在参数列表 ( 多个参数 ) 的后面
  
• “ … “ 必须在参数和数据类型之间 , 有无空格皆可 , 但是为了规范要写空格
• 可变参数就是一个数组

方法的返回值

语法 :
返回值可以是任意类型的数据 , 基本数据类型 , 引用数据类型 ( [] , String , Cat …. )

注意 : 方法的返回的数值 , 要和方法的返回值类型相同 , 比如 : 返回值类型是int , 返回的数值内容必须是数字

问题 : 如何判断方法是否该定义返回值 ?
如果我们通过方法计算获得的数据值使用一次 , 而且之后再也不会操作它 , 我们可以不用返回值
如果我们通过计算获得结果会被之后的程序使用 , 我们就需要定义返回值

总结 :

1. 方法的返回值分为两种情况 , 第一种有返回值 , 第二种是无返回值
2. 如果方法有返回值 , 必须要有 return 关键字
3. return 关键字后面数据的数据类型 , 必须和方法的返回值类型一致
4. return 必须放在方法的最后一行

1. return 只能返回一个值
   
2. 方法如果没有返回值类型 , 返回值类型就是 void , 不用在方法中写 return , 不能有返回值
   
3. 没有返回值类型的方法也可以使用 return 关键字 , 退出方法 , 方法结束
   

方法之间的调用

如果出现这种情况 , 我们正在编写一个方法 , 但是我们发现这个方法中的某些功能在别的方法中实现过 , 我们就可以不写这个功能的代码 , 直接调用方法来实现这个功能即可

面向对象编程

所谓的面向对象编程就是 , 编写一个类 , 声明他的属性 , 定义方法 , 方法中定义我们需要实现的功能 , 然后实例化这个类的对象 , 通过这个对象调用方法实现我们想要的功能

变量的作用域

通过 for 循环类理解变量的作用域
作用域 : 变量的有效范围 , 就是一个 { } 之间的范围
注意 : 代码编写时的格式 , 代码一定要有缩进的规范 , 为了让开发人员第一时间明确作用域的范围
成员变量 & 局部变量

注意点 :

• 如果在方法中定义一个变量(局部变量) , 必须必须必须赋值之后再使用
• 如果定义一个成员变量 , 可以不赋值直接使用 , 使用的结果就是数据类型的默认值
  整数 0 , 浮点数 0.0 , 布尔类型 false , 字符 \u0000

使用方法的特殊情况

现在我们的方法都是在同一个包中使用 , 如果先要使用不同包之中的方法 , 需要 : 导包
之前说学习的关于导包的操作 , 导入 Scanner , Arrays , 是Java开发人员写在 java.util 包中的
String 也是一个类 , 写在 java.lang 包 , 凡是写在 java.lang 包下的类是不需要导包的

return 关键字

在无返回值的方法中 , 使用 return 关键字 , 后面什么都不写直接写分号
如果是这种情况 , 一位这代码走到return这一行的时候 , 方法会停止 , 退出整个方法
break : 终止循环 , 跳出循环
continue : 跳出当次循环 , 直接进行下一次循环
return : 方法停止 , 退出整个方法

面向对象三大特性

• 封装
• 继承
• 多态

  面向对象之封装

封装 : 字面意思将信息隐藏起来 , 不然其他人看到 , 在代码中这种行为就叫做封装
在 Java 中的封装主要是对属性实现的过程进行封装

使用封装 , 通过 private(私有的) 关键字对成员进行封装 分为两部 第一步 : 给属性进行私有化的操作 , 将原来的 public 改成 private 第二步 : 将刚刚私有化的属性 , 一个一个的编写 getter 和 setter 方法

*记住*
*记住*
*记住*
封装的意义 : Java中封装的意义就是对对象的属性和方法进行封装 , 目的在于隐藏属性的实现细节 , 实现数据的安全性
*记住*
*记住*
*记住*

• 封装的注意点
  • 所有被 private 修饰的属性 , 无法直接通过对象调用
  • 如果在未来的编写类的过程中 , 不管有没有提到封装 , 都要进行封装

面向对象之继承

在现实生活中 , 继承象征这子承父业 , 是父与子的关系
在 Java 程序中 , 也是父与子的关系 , 我们称之为 子类 和 父类

*记住*
*记住*
*记住*

什么是继承 , 以及继承的优势
1, 继承就是子类继承父类的成员 ( 属性 &方法 ) , 私有化无法被使用
2, 优势1 : 实现了代码的重用性 , 生去了很多重复的代码
3, 优势2 : 增强了代码的可维护性

*记住*
*记住*
*记住*

继承的关键字 : **extends 代码实例 被继承的语法 : 子类 extends 父类**

• 使用继承的时候的注意点

1. Java 中类之间的继承 , 是单继承 , 一个子类只能有一个父类

一个儿子 一个爹

1. 父类可以有多个子类
2. 多重继承

什么时候会用到继承

比如我们的项目中需要创建一些类 , 讲师类 , 班主任类 , 学生类
老师 : Teacher
班主任 : Charge
学生 : Student
规定每一个类都有 name , age , gender , 以及 getter 和 setter
如果在没有继承的情况下 , 我们会编写大量的重复性的代码 , 工作量巨大 , 重复的代码非常多 , 代码重用性很低
解决方案 : 使用继承
将这些类中的共性的内容抽取出来 , 形成一个父类 , 让这个父类拥有这些共有的内容 , 让其他的类继承他
父类 : 超类 , 基类
子类 : 派生类
idea快速生成 getter 和 setter : Alt + Insert

• 重用性

将各个类中共性内容抽取出来 , 实现了代码的重用性

• 可维护性

体现在后对代码的修改上 , 比如我们需要给每一个来添加一个属性 “地址” , 如果就没有继承我们需要给每一个类反复的写相同的代码用来添加新的属性 , 工作效率极低 , 容易出现失误
使用继承之后 , 可以将新加入属性写在父类中 , 子类直接继承 , 减少工作量

构造器 / 构造方法

每当我们创建一个对象的时候 , 都会调用这个方法

• 隐式构造方法
• 显示构造方法

如果开发人员不去写这个类的构造方法 , 那么Java会给这个类自动提供一个隐式的构造方法用于创建对象
显示构造方法是我们自己编写的

注意 :
1. **如果我们编写了显示的构造方法 , 那么隐式的构造方法将不在提供
2. 构造方法的 public 可以省略
3. 构造方法可以使用 private 修饰 , 如果构造方法私有化 , 就无法直接创建对象**

问题 : 使用有参的构造方法的时候有可能出现的问题
解决方案

1. 写参数
2. 再创建一个无参的构造方法

• 构造方法的优势

1. 代替了 setter 方法
2. 构造方法可以存在多个 , 可以有参数 , 也可以没有参数 , 在可以有部分参数
   我们在实例化对象的时候更加的灵活

• 构造方法的注意事项

1. 只要存在显示的构造方法 , 隐式的构造方法 Java 将不在提供
2. 如果类中没有编写构造方法 , Java 默认会提供一个 无参构造方法
3. 构造方法实在创建对象的时候调用 , 当我们使用 new 关键字在创建类对象的时候

4. 在创建对象的时候, 传入的参数和类型, 要和构造方法的参数列表一致
   什么时候创建对象

5. 构造方法没有返回值的 , 不需要写 void

构造方法不会被继承
构造方法不会被继承
构造方法不会被继承
构造方法不会被继承
构造方法不会被继承
构造方法不会被继承

方法的重载

方法的组成 : 方法名 + (参数) + 方法体
println() 就是一个实现了方法的重载的方法

使用 println() 的时候 , 参数可以是任意类型
方法明名相同 , 方法的参数不同 , 这种行为就是方法的重载

所谓的参数不同指的是

1. 参数类型不同
2. 参数顺序不同
3. 参数数量不同

方法重载的口诀 : 同名不同参 , 与返回值无关

构造方法的重载

构造方法的重载 , 可以是我们在实例化的时候更加的多样性 , 更加的灵活

坑 : 普通方法也可以使用类名命名 , 是不会报错的 类但是无法代替构造方法

this关键字

this : this关键字在 Java 程序中代表 当前类 , 当前对象
this() : 代表调用本类的构造方法

• 使用规范

1. this() 要在构造方法中使用
2. this() 如果在构造方法中使用 , 必须在第一行
3. this() 代表调用本类的无参构造方法 , this(“xxx”) 代表调用本类的有参构造 , 参数是一个字符串
4. this() 只能调用本类的构造 , 调用不了其他的方法

重写

如果子类继承父类中的方法，发现父类中的方法无法完成子类中要求的特有功能，子类就可以对父类的方法进行重写

• 方法重写的注意事项
  • 必须在继承的基础上
  • 在子类重写父类方法时，必须保证方法名称完全相同，参数，返回值一致
    • 返回值要么完全相同，要么是父类方法返回值类型的子类
  • 子类重写父类方法，访问权限不要小于父类
    • public > protected > 缺省 > private

      重写和重载的区别

      | 名称 | 发生的范围 | 方法名 | 参数 | 返回值 | 修饰符 | | —- | —- | —- | —- | —- | —- | | 重载 | 本类 | 相同 | 不同(数量,类型,顺序) | 无关 | 无关 | | 重写 | 继承,子类重写父类 | 相同 | 相同 | 相同,或者是父类返回值类型的子类 | 子类 >= 父类 |

static 关键字

• 需求
  定义 Player 玩家类 , 指定属性用户名 , 密码 , 不断有用户上线 ( 存在实例 ) , 计算用户上线的数量

问题 : count 是一个独立的变量 , 和我们的对象不发生任何关系 , 让 count 和对象产生联系
解决思路 : 将 count 变成对象的属性

静态变量

凡事使用 static 修饰的内容都是静态的成员 , 静态成员被所有的对象共享
如果我们修改一个类的静态成员 , 所有的这个类的对象中这个成员会被一同修改
静态变量 / 类变量 / 静态属性

推荐大家使用第一种
如果静态变量被私有化 , 仍然无法访问

静态变量在使用时的细节

• 类变量是被所有对象拥有的 , 如果修改 , 所有对象一起改
• 类变量和属性的区别
  类变量是被所有对象拥有的 , 属性是对象独有的

• 加上 static 是静态变量 , 如果不加 属性 / 实例变量 / 非静态变量 / 普通变量

• 类方法的使用注意事项 :

1. 类方法中不要出现和对象相关的关键字 , this(当前类的当前对象) 和 super(父类)
2. 类方法 / 静态方法可以直接访问静态的成员 ( 静态变量 , 静态方法 ) , 但是不能直接访问非静态成员

如果想要访问静态成员需要通过实例化对访问

1. 如果是非静态的方法可以直接访问非静态的成员

记住一个关于静态的口诀 : 静态调用静态 , 非静态可以调用静态和非静态

main()

public : jvm(java虚拟机) 在调用类的主方法的时候 , 必须是public 的不然调用不到
2, static : jvm在调用主方法的时候 , 重来没有创建对象 , 必须是static
3, void : 主方法的作用是用来执行程序的 , 但是并不会给我们一个结果
4, main(String[] args) : 这个字符串数组参数 , 是我们在运行 Java 程序是传入的参数 , 不管我们传入什么都是字符串

如何使用 idea 开发工具给项目添加主方法传入的参数

代码块

代码块就是 { } 之中的内容
java中的代码块分为2种

• 静态代码块
  语法 :

  static {
   //代码
  }

• 非静态代码块 (实例块)
  语法 :

  {
   //代码
  }

  
  代码块的执行的规则 :

1. 静态块在实例化的过程中 , 不管你创建了几个对象都只执行一次
2. 实例块 , 只要创建对对象就会执行一次

14,1 创建对象的调用顺序

首先调用静态成员

getAge()被执行了 , 说明对象在对静态变量age进行了初始化的操作
静态成员初始化的顺序由编写顺序决定的

再调用普通成员

实例块 , 属性

OO：面向对象
OOA：面向对象分析
OOD：面向对象设计
OOP：面向对象编程

引用转型

• 向上转型（子转父）
• 向下转型（父转子）

向上转型

儿子====>父亲

• 前提条件:继承
• 多态的向上转型
  • 子类对象转换成父类引用

    父类类型 引用 = new 子类类型();

    向上转型注意事项:

1. 可以调用父类中的所有非私有化成员
2. 不能调用子类的特有方法(原因这个方法既不是继承父类中方法)

3. 最终运行的效果看子类的具体实现（重写法方法）

   //定义一个父类
   class Father {
    private String name;
    public void m() {
        System.out.println("父类的m()被执行了......");
    }
   }
   //定义一个子类
   class Son extends Father {
    //重写父类的方法
    @Override
    public void m() {
        System.out.println("子类的m()执行了......");
    }
    //定义一个子类的独有方法
    public void show() {
        System.out.println("子类的show()方法被执行了");
    }
   }

向下转型

如果我们要在多态的情况下调用子类的特有方法,需要用到向下转型

子类类型 引用 = (子类类型)父类引用();

注意:

1. 只能墙砖父类引用,但是不能转换父类的对象
2. 要求父类的引用必须指向当前转换的 目标类型对象

3. 当向下转型的时候,可以调用子类的特有方法的

   //定义一个父类
   class Animal{
    String name = "动物";
    int age = 10;
    public void eat(){
        System.out.println("我爱干饭");
    }
    public void play(){
        System.out.println("玩游戏");
    }
   }

   class Dog extends Animal {
    public void sleep(){
        System.out.println("小狗正在睡觉");
    }
   }

   //父转子
   //先创建一个父类的对象
   Animal an = new Animal();
   Dog dog = (Dog)an;

   

   //要求父类的引用必须指向目标类型的对象
   Animal d = new Dog();
   Dog dog2 = new (Dog)d;
   //通过向下转型的获得的子类调用子类的独有方法
   dog2.sleep();

   

   instanceOf

   instanceOf是Java的一个保留关键字，左边是对象，右边是类，返回类型是 Boolean 类型。它的具体作用是测试左边的对象是否是右边类或者该类的子类创建的实例对象，是，则返回true，否则返回true

   instanceOf使用注意事项

4. 现有继承关系，再由instanceof的使用。

5. 当该测试对象创建时右边的生命类型和左边的类其中的任意一个跟测试类必须得是继承树的同一分支或存在继承关系，否则编译会报错

   public class Application {
   public static void main(String[] args) {
    // Object > Person > teacher
    // Object > Person > Student
    // Object > String
    Object o = new Student(); // 主要看这个对象是什么类型与实例化的类名
    // instanceof关键字可以判断左边对象是否是右边类或者子类的一个实例
    System.out.println(o instanceof Student); // o 是Student类的一个实例对象 所以判断右边类跟student有无关系 以及显示声明有无关系
    System.out.println(o instanceof Person); // true
    System.out.println(o instanceof Object); // true
    System.out.println(o instanceof String); // false
    System.out.println(o instanceof Teacher); // 无关系
    System.out.println("========================");
    Person person = new Student();
    System.out.println(person instanceof Person); // true
    System.out.println(person instanceof Object); // true
    // System.out.println(person instanceof String); // 编译错误
    System.out.println(person instanceof Teacher); // 无关系
   }
   }
   ————————————————
   版权声明：本文为CSDN博主「yangyssaltedfish」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
   原文链接：https://blog.csdn.net/qq_37680825/article/details/107580782

   instanceof应用场景

   需要用到对象的强制类型转换时，需要使用instanceof进行判断

   抽象方法

   在Animal中有一个eat（），但是方法中的方法体没有意义，因为子类需要重写这个方法实现多态的特性，所以我们不得已在分类中写一个eat（）方法
   存在的问题：父类的方法无法确定具体实现的功能
   解决方法：
   当父类中某些方法，需要声明，但是不确定如果实现具体的功能的时候，可以将这个方法定义为抽象方法，那么拥有这个抽象方法的类就是抽象类

   关键字：abstract

   ```java //定义一个子类继承抽象的父类 class Cat extends Animal { public Cat(String name, int age) {

    super(name, age);

   } //子类如果继承抽象的父类,重写父类中的抽象方法 public void eat() {

    System.out.println("我爱吃鱼......");

   } }

//如果定义抽象方法,类一定要是一个抽象类 abstract class Animal { private String name; private int age; public Animal(String name, int age) { this.name = name; this.age = age; } //定义一个方法动物的行为 //问题: 父类的方法无法确定具体实现的功能 //为方法加入 abstract(抽象) 关键字 //抽象的方法不能拥有方法体 public abstract void eat(); }

总结：<br />当父类一些方法不确定的时候，可以使用 abstract 关键字修饰方法<br />当方法就是抽象方法的时候，有这个抽象方法的类就要是一个抽象类 abstract 修饰的类
<a name="QtgiC"></a>
## 抽象类的介绍
1. 抽象类就是 abstract 修饰的类
1. 使用 abstract 修饰的方法就是抽象方法
1. 抽象类的价值在于设计，设计好了之后，让子类来实现抽象方法
<a name="YsQ68"></a>
## 抽象类的使用细节
> 1. 抽象类不能实例化
> 1. 抽象类不一定要有抽象方法,但是可以有普通方法
> 1. 包含抽象方法的类,一定是抽象类
> 1. abstract 只能用于修饰类和方法,不能修饰属性和其他内容
> 1. 抽象类中可以有任意的成员,因为抽象类的本质就是一个类
> 
构造,属性,静态属性,普通方法
> 6. 抽象方法没有方法体
> 6. 如果有一个类继承了抽象类的,子类必须事项抽象类中的所有抽象方法,但是如果是子类是抽象类就不需要重写了
> 6. 抽象方法(abstract)不能和 private,final,static 这个单个关键词一同使用,因为这些关键字和重写违背
> 6. private:子类无法使用 private 的成员,所以无法重写
> 6. final:最终的意思,是不会被重写的
> 6. static:和重写无关
<a name="i3Zvr"></a>
## 抽象方法的例子
```java
public class TestDemo {
    public static void main(String[] args) {
        //测试实例化抽象类的对象
        A a = new A();//报错
    }
}
//定义一个抽象类
abstract class A {
}

//定义一个抽象类
abstract class A {
    public void hello(){
        system.out.println("这是一个普通方法");
    }
}

//定义一个抽象类
class A {//报错
    public abstract void hello(){//abstract 报错
    System.out.println("包含抽象方法的类,一定是抽象类");
    }
}

//定义一个和抽象类
abstract class A {
    private abstract String name;//abstract报错
    public void Aoo(){
    System.out.println("abstract 只能用于修饰类和方法 , 不能修饰属性和其他内容");
    }
}

//定义一个抽象类
abstract class B {
    //属性
    private String name;
    //静态属性
    private static int count;
    //构造方法
    public B() {
    }
    //普通方法
    public void hello() {
        System.out.println("Hello World~~~");
    }
}

//定义一个父类
abstract class Father {
    public abstract void hello();
    //抽象方法除了方法体没有, 参数,返回值都可以有
    public abstract int sum(int i, int j);
}
//普通类继承抽象类
//子类继承抽象父类
//需要重写抽象父类的所有抽象方法
class Son extends Father {
    @Override
    public void hello() {
        System.out.println("子类实现的hello()方法....");
    }
    @Override
    public int sum(int i, int j) {
        return i + j;
    }
}

//抽象类继承抽象类
abstract class Brother extends Father {
    @Override
    public void hello() {
        System.out.println("抽象子类实现的弗雷的方法");
    }
    public abstract void m();
}

//定义一个子类,继承 Brother 抽象类
class C extends Brother {
    @Override
    public void m() {
    }
    @Override
    public void hello() {
    }
    @Override
    public int sum(int i, int j) {
        return 0;
    }
}

接口 interface

在 Java 中 interface 是程序的组成之一
在现实生活中，不断的使用到接口，比如电脑的接口
我们可以将手机，相机，鼠标，键盘…硬件通过 USB 接口连接到电脑上
我们不需要考虑 USB 接口具体链接的是哪个硬件,我们直接连接就可以实现功能
但是 usb 固定了接口的尺寸

通过代码类模拟usb接口,理解接口的特点及作用

//定义一个usb的接口
public interface Usb {
    //定义两个方法
    //链接接口开始工作
    public void start();
    public void end();
}

• 使用接口,通过类来使用

• 关键字 implements (实现) 通过这个关键字创建 实现类

  //手机类
  //通过implements来创建实现类
  //实现了接口,就要实现接口中的方法
  public class Phone implements Usb {
    @Override
    public void start(){
    System.out.println("手机连接 usb 开始工作了");
    }
    public void end(){
        System.out.println("手机退出 usb 停止工作了");
    }
  }

  //相机类
  public class Camera implements Usb{
    @Override
    public void start(){
        System.out.println("相机链接接口开始工作了");
    }
    @Override
    public void end() {
        System.out.println("相机退出接口停止工作了");
    }
  }

• 我们已经有一个接口了 , 接口应该方法在哪里 ?

• 创建一个 Computer 类 , 编写 work 方法 , 参数是 Usb 类型 , 通过接口的实现类将手机和相机链接到电脑上

public class Computer {
    //定义一个work方法
    //实现相机和手机的连接
    public void work(Usb usb) {
        //通过接口调用方法
        usb.start();
        usb.end();
    }
}

public class Test {
    public static void main(String[] args) {
        //创建手机,相机,电脑各一个
        Phone phone = new Phone();
        Camera camera = new Camera();
        Computer computer = new Computer();
        //通过接口实现手机和相机链接电脑开始工作的操作
        //链接手机
        //方法参数是Usb接口类型,传入的是实现类的对象
        computer.work(phone);//向上转型
        //链接相机
        computer.work(camera);
    }
}

接口的介绍

接口就是给出一些没有实现的方法,封装到一起
到某个地方要去使用的时候,再根据实际情况把这些方法写出来

[访问修饰符] interface 接口名 {
    //属性
    //方法
}

class 类名 implements 接口名 {
    //自己写的属性
    //自己写的方法
    //必须实现接口的方法
}

• 注意点 ( 需要记住的 )
  • 在 JDK1.7前 接口中所有的方法都没有方法体 , 都是抽象方法
  • JDK1.8 之后接口中可以有静态方法 , 默认方法 , **接口可以有方法的具体实现

public interface AInterFace {
    //写属性
    public int n = 100;
    //写抽象方法
    //在接口中,抽象方法可以省略 abstract 关键字
    public void hello();
    //在JDK1.8之后,可以有默认方法,需要使用default,来修饰
    default public void m1() {
        System.out.println("默认方法m1......");
    }
    //在JDK1.8之后,可以有静态方法
    public static void m2() {
        System.out.println("静态方法m2......");
    }
}

何时使用这个接口

项目经理手下有三位程序员 , 三个人共同开发一个软件
为了控制和管理软件 , 项目经理定义一些接口 , 然后由程序员实现
程序员 A B C 编写类类实现链接数据库的功能 , MySql , DB2 , Oracle

在没有使用接口的情况下

存在的问题 : 如果现在有一个类需要从不同的数据库中取数据 , 在这种情况下 , 通过三者所写的类去链接数据库会发现方法的名字都不一样 , 对于相同的方法管理非常混乱

使用了接口之后

• 优势1 : 定义好接口之后规定每个程序员实现这个接口
  实现接口就要重写接口中的方法 , 这样方法的名称就统一了
• 优势2 : 在使用的时候 , 接口会识别不同类型的对象 , 调用链接不同数据库的方法

接口使用的注意事项

细节1 : 接口不能实例化

细节2 : 接口中的方法是 public abstract 修饰的 , 可以不用 abstract

细节3 : 一个普通类实现接口 , 必须将接口中的所有方法实现

//普通类实现接口
class AI implements InterfaceA {
    @Override
    public void hello() {
        System.out.println("重写的hello方法");
    }
    @Override
    public void sleep() {
        System.out.println("重写的sleep方法");
    }
}
interface InterfaceA {
    void hello();
    void sleep();
}

细节4 : 抽象类实现接口 , 不需要将所有的抽象方法实现

interface InterfaceA {
    void hello();
    void sleep();
}
//抽象类实现接口
abstract class AAI implements InterfaceA {
}

细节5 : 类可以实现多个接口

interface IB {
    void hello();
}
interface IC {
    void sleep();
}
//让 Cat 类实现, IB, IC这两个接口
class Cat implements IB,IC {
    @Override
    public void hello() {
    }
    @Override
    public void sleep() {
    }
}

细节6 : 接口中的属性必须是 **public static final** 静态常量

接口中属性的访问形式 : 接口名.属性名

interface ID {
    //等价于public static final int age = 100;
    int age = 100;
}

测试

细节7 : 接口不能继承其他类 , 但是可以继承多个接口

interface IAa {}
interface IBb {}
interface ICc extends IAa,IBb {}

细节8 : 接口的访问修饰符只能是 public 和 默认的 , 这一点和类相同

实现接口和继承类的区别

小猴子会爬树 , 继承了老猴子相关的能力
如果小猴想要学会飞行 , 就需要通过学习 , 实现小鸟的能力
如果小猴想要学会游泳 , 就需要通过学习 , 实现鱼的能力
实现和继承的关系 : 实现机制是 Java 对于单继承机制的一种补充

代码实例

父类 : Monkey
姓名
爬树 climbing()
子类 : LittleMonkey 继承 Monkey

class Monkey {
    private String name;
    public Monkey(String name) {
        this.name = name;
    }
    public void climbing() {
        System.out.println(name + "会爬树...");
    }
}

接口

//定义两个接口
//小鸟
interface Bird {
    void fly();
}
//鱼
interface Fish {
    void swimming();
}

继承父类 , 实现接口的 子类

先继承胡实现

class LittleMonkey extends Monkey implements Bird,Fish{
    public LittleMonkey(String name) {
        super(name);
    }
    @Override
    public void fly() {
        System.out.println("通过学习会飞了....");
    }
    @Override
    public void swimming() {
        System.out.println("通过学习会游泳了...");
    }
}

测试

LittleMonkey wk = new LittleMonkey("悟空");
wk.climbing();
wk.fly();
wk.swimming();

总结 :

继承 , 当子类继承父类的时候 , 就自动拥有了父类的功能

如果子类需要扩展功能 , 可以通过实现接口来进行扩展

可以理解为实现接口是对 Java 单继承的一种补足

继承和实现的不同之处

• 实现和继承解决的问题不同
  • 继承的价值 : 解决代码的复用型 , 提高代码的可维护性
  • 接口的价值 : 设计 , 设计好各种方法 ( 规范 ) , 让其他的类去实现
• 接口比继承更加灵活
  • 继承满足 is - a 关系
    比如 : Cat is a Animal
  • 接口满足 like - a 关系
    比如 LittleMonkey like a Bird | 关键字 | abstract 抽象类 | interface 接口 | | —- | —- | —- | | 属性 | 可以 | 普通属性没有, 只能有静态常量 | | 构造方法 | 可以 | 不可以 | | 普通方法 | 可以 | 不可以 , 在 JDK 1.8 版本之后可以有静态方法 , 默认方法 , 这两个方法是可以有方法体的 | | 子类 | 单继承 | Java 中的接口是多继承 , 继承的是接口 , 可以被实现类多实现 |

• 看图写结果 , 如果报错请描述修正的方式 , 如果没有报错请描述程序输出的结果

interface A {
    int x = 0;//默认是 public final static int x = 0; 
}
class B {
    int x = 1;
}
class C extends B implements A {
    public void pX() {
        System.out.println(x);
    }
    public static void main(String[] args) {
        new C().pX();
    }
}

报错 , 原因不明确的 x 变量

修改后想要即能取到接口中的静态常量 , 又能拿到父类的属性

拿到接口中的静态常量 : A.x

大道父类中的属性 : super.x

public void pX(){
    System.out.println(A.x + " " + super.x);
}

选择题

关于接口的说法 , 正确的是 ( D )

A, 接口中的方法只能在接口的实现类中实现

B, 在接口中可以定义成员变量

C, 接口中不能定义静态常量

D, 以上都不对

编程练习

编写程序,求柱体的体积:

(1)、为柱体的底面设计一个接口Geometry，包含计算面积的方法getArea();

(2)、为柱体设计类pillar，要求：

a)有两个成员变量，底面和高度。底面是任何可以计算面积的几何形状。

b)实现构造方法，对成员变量赋值。

c)包含成员方法，计算柱体pillar的体积。

(3)、编写测试类圆形类、矩形类实现Geometry接口，编写测试类Test，分别用圆形、矩形作为柱体的底面，并计算其体积。

• 接口

//定义一个底面接口,定义一个求面积方法
interface Geometry {
    double getArea();
}

• 柱体类

//设计柱体类
class Pillar {
    //属性,高度,底面
    private double height;
    private Geometry geometry;//接口引用
    //构造方法为属性赋值
    public Pillar(double height, Geometry geometry) {
        this.height = height;
        this.geometry = geometry;
    }
    public double tiJi() {
        //高度*地步面积
        return height * geometry.getArea();
    }
}

• 图形类

//编写实现类,圆形,矩形
class Yuan implements Geometry {
    private double radius;
    //通过构造方法为半径赋值
    public Yuan(double radius) {
        this.radius = radius;
    }
    @Override
    public double getArea() {
        return radius * radius * 3.14;
    }
}
class Ju implements Geometry {
    private double height;
    private double width;
    public Ju(double height,double width) {
        this.height = height;
        this.width = width;
    }
    @Override
    public double getArea() {
        return height * width;
    }
}

• 测试

public class TestDemo01 {
    public static void main(String[] args) {
        //获得不同类型的底部
        Yuan yuan = new Yuan(10.56);
        Ju ju = new Ju(4, 5);
        //圆形底部
        Pillar pillar1 = new Pillar(10, yuan);
        System.out.println("圆形底部柱体体积:" + pillar1.tiJi());
        //矩形底部
        Pillar pillar2 = new Pillar(20, ju);
        System.out.println("矩形底部柱体体积:" + pillar2.tiJi());
        //求圆形底部的柱体体积,圆形半径5.5
        System.out.println("圆形底部柱体体积:" + new Pillar(10,new Yuan(5.5)).tiJi());
    }
}

内部类

内部类的介绍

所谓内部类就是在原有类的基础上,又嵌套了一个类,被嵌套的类就是 内部类(innerclass)
除了嵌套内部类的类之外,被称喂 外部其他类
嵌套内部类的类,被称喂 外部类

class Outer {//外部类
    class Inner {//内部类
    }
}
class Other {//外部其他类
}
class A {//外部其他类
}

特点:

1. 可以直接访问 外部类的私有属性

2. 可以体现类和类的包含关系

   String str1 = new String("123456");
   String str2 = new String("123456");
   sout(str1 == str2);//false
   sout(str1.hashCode);
   sout(str1.hashCode);

   内部类的分类

3. 定义在 局部位置 上的(方法了)

   1. 局部内部类(有类名)
   2. 匿名内部类(没有类名,重点)
4. 定义在成员位置上的
   1. 成员内部类(没有 static 修饰的)
   2. 静态内部类(有 static 修饰)

局部内部类

说明:局部内部类是指定义在外部类的局部位置,如方法中,或者代码块中,并且有类型

1. 可以访问外部类的所有成员,包含私有的
2. 不可以添加访问修饰符,因为它的地位相当于局部变量,仅在局部作用域中好使,局部变量虽然不能添加访问修饰符,但是可以添加 final 关键字

使用final修饰

1. 作用域:仅仅在定义其方法或者代码快中有效,一旦离开就无法使用了

1. 局部内部类访问外部类的成员,访问方式:直接访问,直接通过名称调用
2. 如果外部类要使用内部类,需要实例化对象

   //定义一个外部类
   class Outer{
    //定义一个私有属性
    private int i = 99;
    //定义一个方法
    public void m1{//方法{}中就是这个类的局部变量
        //定义一个局部内部类
        final class InnerA {
            public void m2(){
                System.out.println("外部类的私有属性i:" + i);
                //直接调用外部类的成员方法
                f2();
            }
        }
        //使用内部类的成员,注意别出作用域
        IneerA ineerA = new InnerA();
        innerA.m2();
    }
    //定义一个方法
    public void f2(){//定义的是外部类的成员方法,在Outer类的任何一个角落都是有效的
        System.out.println("我是 f2()...");
    }
   }

   public class Test {
    public static void main(String[] args) {
    //创建外部类的对象,通过外部类的方法使用局部内部类
        Outer o = new Outer();
        o.m1();
    }
   }

   
   总结:

• 局部内部类定义方法和代码块
• 作用域在方法或者代码块中
• 本质就是一个类

1. 外部类是不能直接访问，因为局部内部类相当于局部变量
2. 如果外部类和局部内部类成员重名的时候，遵循就近原则

如果直接使用同名成员使用的是内部类的
如果想要调用外部类的同名成员，可以使用语法：外部类名.this.成员

//定义一个外部类
class OuterB{
    private String name = "张三";
    //定义一个方法,其中定义内部类
    public void m(){
        class IneerB {
            private String name = "张小宝";
            //定义内部类的方法
            public void f(){
                //OuterB.this.name
                //属性不是静态的类名无法直接调用,需要对象
                //OuterB.this 代表了 OuterB 类的对象
                //通过外部类的对象调用外部类的属性
                System.out.println("内部类的name" + name + "外部类的name:" + OuterB.this.name);//张小宝
            }
        }
        //使用局部内部类
        IneerB ib = new IneerB();
        ib.f();//调用 f()
    }
}

public class TestDemo01 {
    public static void main(String[] args){
        //创建外部类的对象,同通过外部类的方法使用局部内部类
        OuterB ob = new OuterB();
        ob.m();
    }
}

匿名内部类(重点)

特点:

1. 匿名内部类本质上是一个类
2. 内部类
3. 该类没有 可视的名字
4. 等同于一个类的对象

   说明:定义在外部类的局部位置,没有名称

new 类名或者接口 {
    //重写方法
}

匿名内部类的使用

代码实例(基于接口的匿名内部类)*

//定义一个接口
interface IA{
    //相当于public abstract void eat();
    void eat();
}

//如果我们按照传统方式,我们需要实现类
//重写其中的抽象方法
class Cat implements IA {
    @Override
    public void eat() {//重写eat()
        System.out.println("瞄~我爱吃鱼!!");
    }
}

public class TestDemo02 {
    public static void main(String[] args){
        //通过实现类来创建一只小猫
        Cat cat = new Cat();
        cat.eat();
    }
}

问题:
如果我们按照传统的实现类的方式,如果 Cat 只使用一次,单独写一个类很不划算,因为以后不会再用了,而且如果这个时候 Dog类还需要创建一个,但是Dog也只用一次,按照传统的实现类还是很繁琐的
解决方案:通过匿名内部类简化

代码实例

public class TestDemo2 {
    public static void main(String[] args) {
        //通过实现类来创建一只小猫
        AA Cat = new AA(){
            @Override
            public void eat(){
                System.out.println("汪~我爱啃骨头~~");
            }
        };//注意";"别省
        dog.eat():
        //通过 getClass() 方法
        //作用获得匿名内部类的运行类型,也就是匿名内部类对应的实现类
        //底层的实现类TestDemo2
        System.out.println("dog引用对应的运行类型:" + dog.getClass());
    }
}

在此案例中 dog 对象的 运行类型 和 编译类型
dog的编译类型:IA
dog的运行类型:TestDemo2
dog对象底层的实现

class TestDemo2 implements IA {
    @Override
    public void eat() {
        System.out.println("汪~我爱啃骨头!!");
    }
}

注意:匿名内部类使用了一次之后,就不能再使用了,当时通过匿名内部类创建的对象可以多次使用

public class TestDemo03 {
    public static void main(String[] args) {
        //使用匿名内部类创建一个小猫
        AA cat = new AA() {
            @Override
            public void cry() {
                System.out.println("小猫喵喵叫~~~");
            }
        };
        cat.cry();
    }
}
//定义一个抽象类
abstract class AA {
    public abstract void cry();
}

代码实例 ( 基于普通类的匿名内部类 )

• 定义类

//定义一个普通的Person类
class Person {
    private String name;
    public Person() {
    }
    public Person(String name) {
        this.name = name;
    }
    public void holle() {
        System.out.println("Hello World");
    }
    public String getName() {
        return name;
    }
    public void show(String name) {
        System.out.println("你好我是" + name);
    }
}

测试

public class TestDemo04 {
    public static void main(String[] args) {
        //通过普通类来定义匿名内部类
        //new Person() {...}就是Person的对象
        new Person() {
            public void hello() {
                System.out.println("匿名内部类的Hello");
            }
        }.hello();
        new Person() {
            @Override
            public void show(String name) {
                System.out.println("我是匿名内部类:" + name);
            }
        }.show("张三");
        //问:这两个对象的运行类型是Person吗?
        Person p = new Person() {};
        //TestDemo04$3
        System.out.println("对象p的运行类型是:" + p.getClass());
    }
}

对象 p 编译类型 和 运行类型

编译类型 : Person

运行类型 : TestDemo04$3

底层 :

class TestDemo04$3 extends Person {
}

4,2 匿名内部类的注意点

• 不能添加访问修饰符 , 应为匿名内部类相当于一个局部成员 , 等同于局部变量
• 作用域 : 仅在在定义其的方法或者代码块中有效
• 匿名内部类访问外部类成员的方式 : 直接访问

• 如果匿名内部类和外部类的属性重名 , 遵循 就近原则
  直接使用 , 使用的是匿名内部类的
  如果要使用外部类的重名属性怎么办 , 语法 : 外部类名.this.属性名

  //定义一个外部类
  class OuterC {
   private int num = 100;
   public void m() {
       //基于普通类定义一个匿名内部类
       new Person() {
           //定义一个重名的属性
           private int num = 999;
           public void f() {
               System.out.println("匿名内部类的num:" + num + ",外部类的num:" + OuterC.this.num);
           }
       }.f();//通过匿名内部类对象直接调用方法
   }
  }

  public class TestDemo05 {
   public static void main(String[] args) {
       //测试:实例化外部类对象,调用声明了匿名内部类的方法
       OuterC oc = new OuterC();
       oc.m();
   }
  }

  

• 外部其他类不能访问匿名内部类 , 因为匿名内部类只是一个局部的变量

匿名内部类的最佳实践

public class TestDemo06 {
    //定义一个静态方法,将参数类型只为IB接口类型
    //意味着这个方法只能传入 IB 接口的实现类对象
    public static void m(IB b) {
        b.show();//是指通过实现类对象调用重写的show()方法
    }
    public static void main(String[] args) {
        //通过匿名内部类简化
        //匿名内部类实现 IB 接口
        //将重写和穿参融为一体
        m(new IB() {
            @Override
            public void show() {
                System.out.println("匿名内部类重写的show方法");
            }
        });
    }
}
//定义一个接口
interface IB {
    void show();
}

5, 成员内部类

说明 : 成员内部类定义在外部类的成员位置 , 并且没有static 修饰

1. 可以直接访问外部类的所有成员, 包含私有

class OuterA {//外部类
    //定义一个私有的成员变量
    private int num = 100;
    //定义一个成员位置的内部类
    class InnerA {
        //定义一个方法,访问外部类的私有成员
        public void m() {
            System.out.println(num);
        }
    }
    //通过方法使用成员内部类
    public void f() {
        InnerA ia = new InnerA();
        ia.m();
    }
}

测试

public class TestDemo01 {//外部其他类
    public static void main(String[] args) {
        //创建外部类的对象,调用使用类内部类的方法
        OuterA oa = new OuterA();
        oa.f();
    }
}

1. 成员内部类可以添加任意的访问修饰符 : public , protected , 缺省 , private
2. 作用域 : 在类中 , 和方法,属性 ( 类成员 ) , 根据访问修饰符而来
   如果外部类想要使用内部类的成员 ( 属性,方法 ) , 需要通过实例化对象
3. 成员内部类访问外部类的成员 , 方式: 直接访问

4. 外部其他类 访问 成员内部类
   方式1 : 通过特殊的语法访问

   外部类.成员内部类 成员内部类引用 = new 外部类().new 成员内部类();

   class OuterB {
   class InnerB {
       public void hello() {
           System.out.println("成员内部类的hello方法~~~~~~");
       }
   }
   //方式2:通过外部类的方法获得成员内部类的对象
   public InnerB getInnerB() {
       return new InnerB();
   }
   }

   public class TestDemo02 {
   public static void main(String[] args) {
       //使用方式1对成员内部类进行使用
       //语法:外部类.成员内部类 成员内部类引用 = new 外部类().new 成员内部类();
       OuterB.InnerB ib = new OuterB().new InnerB();
       ib.hello();
       //使用方式2获得成员内部类的对象
       OuterB ob = new OuterB();
       OuterB.InnerB innerB = ob.getInnerB();
       innerB.hello();
   }
   }

   

5. 外部类属性 和 成员内部类属性重名
   直接使用 , 遵循就近原则 , 使用成员内部类的
   使用外部类的 , 语法 : 外部类.this.属性名