java学习笔记＜第一周＞

关键字

1.关键字的概述

关键字：就是被java语言赋予了特定含义的单词

2.关键字的特点

常用的代码编辑器

针对关键字有特殊的颜色标记，非常直观

常量

1.常量的概述

常量：在程序运行过程中，其值不可以发生改变的量。

2.常量的分类

数据类型

1.计算机存储单元
我们知道计算机是可以用来存储数据的，但是无论是内存还是硬盘，计算机存储设备的最小信息单元叫“位（bit）”,我们又称之为“比特位”，通常用小写的字母“b”表示。而计算机最小的存储单元叫“字节（byte）”,通常用大写字母“B”,字节是由连续的8个位组成。
除了字节外还有一些常用的存储单位，大家比较熟悉，我们一起来看看:
1B（字节）= 8bit
1KB= 1024B
1MB= 1024KB
1GB = 1024MB
1TB = 1024GB

2.数据类型

java语言是强类型语言，对于每一种数据都给出了明确的数据类型，不同的数据类型也分配了不同的内存空间，所以它们表示的数据大小也是不一样的。

3.数据类型内存占用和取值范围

变量

1.变量概述

变量：在程序运行过程中，其值可以发生改变的量。

从本质上讲，变量是内存中一小块区域。

2.变量定义

格式：数据名称 变量名 = 变量值；

范例：int a = 10;

3.变量的试用

变量的使用：取值和修改值

取值格式：变量名

范例：a

修改值格式：变量名 = 变量值；

范例：a = 20;

4.变量使用的注意事项

名字不能重复；

变量未赋值，不能使用；

long类型的变量定义的时候，为了防止整数过大，后面要加L；

float类型的变量定义的时候，为了防止类型不兼容，后面要加F；

标识符

1.标识符概述

标识符：就是给类，方法，变量等起名字的符号。

2.标识符定义规则

由数字、字母、下划线（_）和美元符（$）组成

不能以数字开头

不能是关键字

区分大小写

3.常见命名约定
小驼峰命名法：方法、变量
约定1：标识符是一个单词的时候，首字母小写
范例1：name
约定2：标识符由多个单词组成的时候，第一个单词首字母小写，其他单词首字母大写
范例2：firstName
大驼峰命名法：类
约定1：标识符是一个单词的时候，首字母大写
范例1：Student
约定2：标识符由多个单词组成的时候，每个单词的首字母大写
范例2：GoodStudent

类型转换

1.类型转换分类

自动类型转换

强制类型转换

2.自动类型转换

把一个表示数据范围小的数值或者变量赋值给另一个表示数据范围大的变量

范例：double d = 10;

3.强制类型转换

把一个数据范围大的数值或者变量赋值给另一个表示数据范围小的变量

格式：目标数据类型 变量名 = （目标数据类型）值或者变量；

范例：int k = （int）88.88;

方法

1.什么是方法

方法是将具有独立功能的代码块组织成为一个整体，使其具有特殊功能的代码集。

注意：

方法必须先创建才可以使用，该过程称为方法定义

方法创建后并不是直接运行的，需要手动使用后才执行，该过程称为方法调用

方法的定义和调用

1.方法定义

格式：

public static void 方法名（）{`

//方法体

}

范例：

public static void isEvenNumber(){

//方法体

}

2.方法调用

格式：方法名（）；

范例：isEvenNumber();

注意：

方法必须先定义后调用，否则程序将报错

3.方法调用过程

带参数方法的定义和调用

1.带参数方法定义

格式：public static void 方法名（参数）{…}

格式（单个参数）：public static void 方法名(数据类型 变量名){…}

范例（单个参数）：public static void isEvenNumber(int number){…}

格式（多个参数）：public static void 方法名(数据类型 变量名1，数据类型 变量名2，…){…}

范例（多个参数）：public static void getMax(int number1,int number2){…}

注意：

方法定义时，参数中的数据类型与变量名都不能缺少，缺少任意一个程序将报错

方法定义时，多个参数之间使用逗号（，）分隔

2.带参数方法调用

格式：方法名（参数）；

格式（单个参数）：方法名（变量名/常量值）；

范例（单个参数）：isEvenNumber(5);

格式（多个参数）：方法名（变量名1/常量值1，变量名2/常量值2）；

范例（多个参数）：getMax(5,6);

注意：

方法调用时，参数的数量与类型必须与方法定义中的设置相匹配，否则程序将报错

3.形参和实参

形参：方法定义中的参数等同于变量定义格式，例如：int number

实参：方法调用中的参数等同于使用变量或常量，例如：10 number

带返回值方法的定义和调用

1.带返回值方法定义

格式：

public static 数据类型 方法名（参数）{

return 数据；}

范例1：

public static boolean isEvenNumber(int number){

return true;}

注意：

方法定义时return后面的返回值与方法定义上的数据类型要匹配，否则程序将报错

2.带返回值方法调用

格式1：方法名（参数）；

范例：isEvenNumber(5);

格式2：数据结构 变量名 = 方法名（参数）；

范例：boolean flag = isEvenNumber(5);

注意：

方法的返回值通常会使用变量接收，否则该返回值将无意义

方法的注意事项

1.方法不能嵌套定义

void表示无返回值，可以省略return，也可以单独书写return，后面不加数据

2.方法的通用格式

格式：

public static 返回值类型 方法名（参数）{

​ 方法体；

​ return 数据；

}

定义方法时，要做到两个明确

明确返回值类型：主要是明确方法操作完毕之后是否还有数据返回，如果没有，写void；如果有，写对应的数据类型明确参数：主要是明确参数的类型和数量

调用方法时:

void类型的方法，直接调用即可

非void类型的方法，推荐用变量接收调用

方法重载

1.方法重载概述

多个方法在同一个类中

多个方法具有相同的方法名

多个方法的参数不相同，类型不同或者数量不同

2.方法重载特点

重载仅对应方法的定义，与方法的调用无关，调用方式参照标准格式

重载仅针对同一个类中方法的名称与参数进行识别，与返回值无关，换句话说不能通过返回值来判定两个方法是否相互构成重载

方法的参数传递

1.方法参数传递（基本类型）

对于基本数据类型的参数，形式参数的改变，不影响实际参数的值

2.方法参数传递（引用类型）

对于引用类型的参数，形式参数的改变，影响实际参数的值

分支语句

顺序结构

顺序结构是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行,程序中大多数的代码都是这样执行的。

if语句

1.if语句格式

格式：

if(关系表达式){

​ 语句体；

}

执行流程：

首先计算关系表达式的值

如果关系表达式的值为true就执行语句体

如果关系表达式的值为false就不执行语句体

继续执行后面的语句内容

2.if语句格式2

格式：

if(关系表达式){

​ 语句体1；

}else{

​ 语句体2；

}

执行流程：

首先计算关系表达式的值

如果关系表达式的值为true就执行语句体1

如果关系表达式的值为false就执行语句体2

继续执行后面的语句内容

3.if语句格式3

if(关系表达式){

​ 语句体1；

}else if{

​ 语句体2；

}

…

else{

​ 语句体n+1；

}

执行流程：

首先计算关系表达式的值

如果值为true就执行语句体1;如果值为false就计算关系表达式2的值

如果值为true就执行语句体2;如果值为false就计算关系表达式3的值

如果没有任何关系表达式为true，就执行语句体n+1。

注意事项：

正确数据、边界数据、错误数据

switch语句

1.switch语句格式

格式：

switch（表达式）{

case值1：

​ 语句体1；

​ break；

case值2：

​ 语句体2；

​ break；

…

default:

​ 语句体n+1；

​ {break;}

}

格式说明:

表达式:取值为byte、short、 int、char，JDK5以后可以是枚举，JDK7以后可以是String.

case:后面跟的是要和表达式进行比较的值。

break:表示中断，结束的意思，用来结束switch语句。

default:表示所有情况都不匹配的时候，就执行该处的内容，和if语句的else相似。

执行流程:

首先计算表达式的值。

依次和case后面的值进行比较，如果有对应的值，就会执行相应的语

句，在执行的过程中，遇到break就会结束。

如果所有的case后面的值和表达式的值都不匹配，就会执行default

里面的语句体，然后程序结束掉

注意事项：在switch语句中，如果case控制的语句体后面不写break，将出现穿透现象，在不判断下一个case值的情况下，向下运行，直到遇到break，或者整体switch语句结束

循环结构

for循环结构

1.循环结构的组成

初始化语句:用于表示循环开启时的起始状态，简单说就是循环开始的时候什么样条件

判断语句:用于表示循环反复执行的条件，简单说就是判断循环是否能一直执行下去

循环体语句:用于表示循环反复执行的内容，简单说就是循环反复执行的事情

条件控制语句:用于表示循环执行中每次变化的内容，简单说就是控制循环是否能执行下去

循环结构对应的语法：

初始化语句:这里可以是一条或者多条语句，这些语句可以完成一些初始化操作

条件判断语句:这里使用一个结果值为boolean类型的表达式，这个表达式能决定是否执行循环体。例: a<3

循环体语句:这里可以是任意语句，这些语句将反复执行

条件控制语句:这里通常是使用一条语句来改变变量的值，从而达到控制循环是否继续向下执行的效果。常见i+ +,i–这样的操作

2.for循环语句格式

格式：

for（初始化语句；条件判断语句；条件控制语句）{

​ 循环体语句；

}

案例：水仙花

分析：

1.三位数的各位数字如何求

371 1就是原始数字对10进行取余运算的结果 371%10=1

2.三位数的百位数字如何求

371 3就是原始数字除以100的结果（整除）371/100=3

3.三位数的十位数字如何求

371 371通过除以10，可以将7移动到个位上（整数）371/10=37

37通过对10进行取余运算可以得到最后一位的值7 37%10=7

371/10%10 = 7

4.思考：任意数字的指定位上的数值如何求

先使用整除操作将要求的数字移动到个位上，再使用取余操作取出最后一位上的值

1234567 先整除10000得到12345，再对10取余得到5

while循环语句

1.while循环语句格式

基本格式：

while（条件判断语句）{

​ 循环体语句；

}

do…while循环语句

1.do…循环语句格式

基本格式：

do{

​ 循环体语句；

}while（条件判断语句）；

2.三种循环的区别：

for循环和while循环先判断条件是否成立，然后决定是否执行循环体（先判断后执行）

do…while循环先执行一次循环体，然后判断条件是否成立，是否继续执行循环体（先执行后判断）

for和while的区别：

条件控制语句所控制的自增变量，因为归属for循环的语法结构中，在for循环结束后，就不能再次被访问到了。

条件控制语句所控制的自增变量，对于while循环来说不归属其语法结构中，在while循环结束后，该变量还可以继续使用

死循环格式：

for(;😉{}

while(true){}

do{}while(true);

while的死循环是最常用的

命令提示符窗口中Ctrl+C可以结束死循环

跳转控制语句

1.跳转控制语句概述

continue用在循环中，基于条件控制，跳过某次循环体内容的执行，继续下一次的执行

break：用在循环中，基于条件控制，终止循环体内容的执行，也就是结束当前的整个循环

循环嵌套

1.循环嵌套概述

顺序结构

分支语句

循环语句

Random

1.Random的作用和使用步骤

作用：用于产生一个随机数

使用步骤：

导包

import java.util.Random;

导包的动作必须出现在类定义的上面

创建对象

Random r = new Random();

上面这个格式里面，r是变量名，可以变，其他的都不允许变

获取随机数

int number = r.nextInt(10);//获取数据的范围：[0,10)包括0，不包括10

上面这个格式里面，number是变量名，可以变，数字10可以变，其他的都不允许变

数组

数组定义格式

1.数组概述

一次性声明大量的用于存储数据的变量

要存储的数据通常都是同类数据，例如：考试成绩

2.什么是数组

数组是一种用于存储多个相同类型数据的存储模型

3.数组的定义格式

格式一：数据类型[] 变量名

范例：int[] arr

定义了一个int类型的数组，数组名是arr

格式二：数据类型 变量名[]

范例： int arr[]

定义了一个int类型的变量，变量名是arr数组

数组初始化之动态初始化

1.数组初始概述

java中的数组必须先初始化，然后才能使用

所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值

2.数组初始化方式

动态初始化

静态初始化

3.动态初始化

初始化只指定数组长度，由系统为数组分配初始值

格式：数据类型[] 变量名 = new 数据类型[数组长度]；

范例：int[] arr = new int[3];

数组元素访问

1.数组元素访问

数组元素访问方式

格式：数组名

数组内部保存的数据的访问方式

格式：数组名[索引]

索引是数组中数据的编号方式

作用：索引用于访问数组中的数据使用，数组名[索引]等同于变量名，是一种特殊的变量名

注意：

索引是从0开始

索引是连续的

索引是逐一增加，每次加一

内存分配

1.java中内存分配

Java程序在运行时，需要在内存中分配空间。为了提高运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

栈内存：存储局部变量

定义在方法中的变量，例如：arr

使用完毕，立即消失

堆内存：存储new出来的内容（实体，对象）

数组在初始化时，会为存储空间添加默认值

整数：默认值0

浮点数：默认值0.0

布尔值：默认值false

字符：默认值是空字符

引用数据类型：默认值是null

每一个new出来的东西都有一个地址值

使用完毕，会在垃圾回收器空闲时被回收

数组初始化之静态初始化

1.数组初始化之静态初始化

静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度

格式：数据类型[] 变量名 = new 数据类型{数据1，数据2，数据3，…}；

范例：int[] arr = new int{1,2,3};

简化格式：数据类型[] 变量名 = {数据1，数据2，数据3，…}

范例：int[] arr = {1,2,3};

数组操作的两个常见小问题

1.数组操作的两个常见小问题

索引越界 ：访问了数组中不存在的索引对应的元素，造成索引越界问题

ArrayIndexOutOfBoundException

空指针异常：访问的数组已经不再指向堆内存的数据，造成空指针异常

NullPointerException

null：空值，引用数据类型的默认值，表示不指向任何有效对象

数组常见操作

1.遍历

遍历通用格式：

int[] arr = {…};

for(int x=0;x<arr.length;x++){

​ arr[x];

}

2.获取数组元素数量

格式：数组名.length

范例：arr.length

3.获取最值

类和对象

1.什么是对象

万物结对象，客观存在的事物皆为对象

2.什么是面向对象

3.什么是类

类是对现实生活中一类具有共同属性和行为的事物的抽象

类的特点：类是对象的数据类型

类是具有相同属性和行为的一组对象的集合

4.什么是对象的属性

属性：对象具有的各种特征，每个对象的每个属性都拥有特定的值

5.什么是对象的行为

行为：对象能够执行的操作

6.类和对象的关系

类：类是对现实生活中一类具有共同属性和行为的事物的抽象

对象：是能够看得到摸得着的真实存在的实体

7.类的定义

类的重要性：是java程序的基本组成单位

类是什么：是对现实生活中一类具有共同属性和行为的事物的抽象，确定对象将会拥有的属性和行为

类的组成：属性和行为

属性：在类中通过成员变量来体现（类中方法外的变量）

行为：在类中通过成员方法来体现（和前面的方法相比去掉static关键字即可）

类的定义步骤：

public class 类名{

​ //成员变量

​ 变量1的数据类型 变量1；

​ 变量2的数据类型 变量2；

​ …

​ //成员方法

​ 方法1；

​ 方法2；

​ …

}

8.对象的使用

创建对象

格式：类名 对象名 = new 类名（）；

范例：Phone p = new Phone();

使用对象

(1).使用成员变量

格式：对象名.变量名

范例：p.brand

(2).使用成员方法

格式：对象名.方法名（）

范例：p.call()

对象内存图

成员变量和局部变量

1.什么是成员变量和局部变量

成员变量：类中方法外的变量

局部变量：方法中的变量

2.成员变量和局部变量的区别

封装

1.private关键字

是一个权限修饰符

可以修饰成员（成员变量和成员方法）

作用是保护成员不被别的类使用，被private修饰的成员只在本类中才能访问

针对private修饰的成员变量，如果需要被其它类使用，提供相应的操作

提供“get变量名（）”方法，用于获取成员变量的值，方法用public修饰

提供“set变量名（参数）”方法，用于设置成员变量的值，方法用public修饰

2.private关键字的使用

一个标准类的编写：

把成员变量用private修饰

提供对应的getXxx()/setXxx()方法

3.this关键字

(1).this修饰的变量用于指代成员变量

方法的形参如果与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量

方法的形参没有与成员变量同名，不带this修饰的变量指的是成员变量

(2).什么时候使用this？解决局部变量隐藏成员变量

(3).this：代表所在类的对象引用

记住：方法被哪个对象调用，this就代表哪个对象

5.封装

封装概述

是面向对象三大特征之一（封装，继承，多态）

是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界是无法操作的

封装原则

将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问成员private，提供对应的getXxx()/setXxx()方法

封装好处

通过方法来控制成员变量的操作，提高了代码的安全性

把代码用方法进行封装，提高了代码的复用性

构造方法

1.构造方法概述

构造方法是一种特殊的方法

作用：创建对象

格式：

public class 类名{

​ 修饰符 类名（参数）{

}

}

功能：主要是完成对象数据的初始化

2.构造对象的注意事项

(1).构造对象的创建

如果没有定义构造方法，系统将给出一个默认的无参构造方法

如果定义了构造方法，系统将不再提供默认的构造方法

(2).构造方法的重载

如果定义了带参构造方法，还要使用无参构造方法，就必须再写一个无参构造方法

(3).推荐的使用方式

无论是否使用，都手工书写无参数构造方法

API

1.API概述

Java APl:指的就是JDK中提供的各种功能的Java类。这些类将底层的实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可，我们可以通过帮助文档来学习这些API如何使用

2.API使用练习

注意：调用方法时，如果方法有明确的返回值，我们用变量接收，可以手动完成，也可以使用快捷键的方式完成（Ctrl+Alt+V）

继承

1.继承概述

继承时面向对象三大特征之一。可以使得子类具有父类的属性和方法，还可以在子类中重新定义，追加属性和方法

继承的格式

格式：public calss 子类名 extends 父类名{}

范例：public class Zi extends Fu{}

Fu：是父类，也成为基类，超类

Zi：是子类，也被称为派生类

继承中子类的特点：

子类可以有父类的内容

子类还可以有自己特有的内容

继承的好处与弊端

继承好处：

提高了代码的复用性（多个类相同的成员可以放到同一个类中）

提高了代码的维护性（如果方法的代码需要修改，修改一处即可）

继承弊端：

继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时子类实现也不得不跟着变化，削弱了子类的独立性

什么时候使用继承？

继承中变量的访问特点

在子类方法中访问一个变量

子类局部范围找

子类成员范围找

父类成员范围找

如果都没有就报错（不考虑父亲的父亲…）

super

super关键字的用法和this关键字的用法相似

this：代表本类对象的引用

this关键字指向调用该方法的对象，一般我们是在当前类中使用this关键字，所以我们常说this代表本类对象的引用

super：代表父类存储空间的标识（可以理解为父类对象引用 ）

继承中构造方法的访问特点

子类中所有的构造方法默认都会访问父类中无参的构造方法

原因：

因为子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化

每一个子类构造方法的第一条语句默认是：super()

如果父类中没有无参构造方法，只有带参构造方法，该怎么办呢：

通过super关键字去显示的调用父类的带参构造方法

在父类中自己提供一个无参构造方法

推荐：自己提供无参构造方法

继承中成员方法的访问特点

通过子类对象访问一个方法

子类成员范围找

父类成员范围找

如果没有就报错（不考虑父亲的父亲…）

8.方法重写

方法重写概述

子类中出现了和父类一模一样的方法声明

方法重写的应用

当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容

@Override

是一个注解（注解后面会学习到）

可以帮助我们检查重写方法的方法声明的正确性

9.方法重写注意事项

私有方法不能被重写（父类私有成员子类是不能继承的）

子类方法访问权限不能更低（public>默认>私有）

10.java中继承的注意事项

java中类只支持单继承，不支持多继承

java中类支持多层继承

修饰符

1.修饰符的分类

权限修饰符

状态修饰符

2.权限修饰符

3.状态修饰符

final（最终态）

static（静态）

4.final

final关键字时最终的意思，可以修饰成员方法，成员变量，类

final修饰的特点

修饰方法：表明该方法是最终方法，不能被重写

修饰变量：表明该变量是常量，不能再次被赋值

修饰类：表明该类是最终类，不能被继承

5.final修饰局部变量

变量是基本类型：final修饰指的是基本类型的数据值不能发生改变

变量是引用类型：final修饰指的是引用类型的地址值不能发生改变，但是地址里面的内容是可以发生改变的

6.static

static关键字是静态的意思，可以修饰成员方法，成员变量

static修饰的特点

被类的所有对象共享

​ 这也是我们判断是否使用静态关键字的条件

可以通过类名调用

​ 当然，也可以通过对象名调用

​ 推荐使用类名调用

7.static访问特点

非静态的成员方法

​ 能访问静态的成员变量

​ 能访问非静态的成员变量

​ 能访问静态的成员方法

​ 能访问非静态的成员方法

静态的成员方法

​ 能访问静态的成员变量

​ 能访问静态的成员方法

总结：静态成员方法只能访问静态成员

多态

1.多态

多态概述

同一个对象，在不同时刻表现出来的不同形态

多态的前提和体现

有继承/实现关系

有方法重写

有父类引用指向子类对象

2.多态中成员访问特点

成员变量：编译看左边，执行看左边

成员方法：编译看左边，执行看右边

左边：父类

右边：子类

为什么成员变量和成员方法的访问不一样呢？

因为成员方法有重写，而成员变量没有

3.多态的好处和弊端

多态的好处：提高了程序的扩展性

​ 具体体现：定义方法的时候，使用父类型作为参数，将来在使用的时候，使用具体的子类型参与操作

多态的弊端：不能使用子类的特有功能

4.多态中的转型

向上转型

​ 从子到父

​ 父类引用指向子类对象

向下转型

​ 从父到子

​ 父类引用转为子类对象

抽象类

1.抽象类概述

在java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类

2.抽象类的特点

抽象类和抽象方法必须使用abstract关键字修饰

​ public abstract class 类名 {}

​ public abstract void eat();

抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类

抽象类不能实例化

​ 抽象类如何进行实例化？参照多态的方式，通过子类对象实例化，这叫抽象类多态

3.抽象类的成员特点

成员变量

​ 可以是变量也可以是常量

构造方法

​ 有构造方法，但是不能实例化

​ 那么，构造方法的作用是什么呢？用于子类访问父类数据的初始化

成员方法

​ 可以有抽象方法：限定子类必须完成某些动作

​ 也可由有非抽象方法：提高代码复用性

接口

1.接口概述

接口就是一种公共的规范标准，只要符合规范标准，大家都可以通用

java中的接口更多体现在对行为的抽象

2.接口的特点

接口用关键字interface修饰

​ public interface 接口名{}

类实现接口用implements表示

​ public class 类名 implements 接口名{}

接口不能实例化

​ 接口如何实例化呢？参照多态的方式，通过实现类对象实例化，这叫接口多态

​ 多态的形式：具体类多态，抽象类多态，接口多态

​ 多态的前提：有继承或者实现关系；有方法重写；有父（类/接口）引用指向（子/实现）类对象

接口的实现类

​ 要么是写接口中的所有抽象方法

​ 要么是抽象类

3.接口的成员特点

成员变量

​ 只能是常量

​ 默认修饰符：public static final

构造方法：

​ 接口没有构造方法，因为接口主要是对行为进行抽象的，是没有具体存在

成员方法：

​ 只能是抽象方法

​ 默认修饰符：public abstract

4.类和接口的关系

类和类的关系：

​ 继承关系，只能单继承，但是可以多层继承

类和接口关系：

​ 实现关系，可以单实现，也可以多实现，还可以继承一个类的同时实现多个接口

接口和接口的关系：

​ 继承关系，可以单继承，也可以多继承

5.抽象类和接口的区别

成员区别：

​ 抽象类 变量，常量；有构造方法；有抽象方法，也有非抽象方法

​ 接口 常量；抽象方法

关系区别：

​ 类与类 继承，单继承

​ 类与接口 实现，可以单实现，也可以多实现

​ 接口与接口 继承，单继承，多继承

设计理念区别：

​ 抽象类 对类抽象，包括属性、行为

​ 接口 对行为抽象，主要是行为

形参和返回值

1.类名作为形参和返回值

方法的形参是类名，其实需要的是该类的对象

方法的返回值是类名，其实返回的是该类的对象

2.抽象类名作为形参和返回值

方法的形参是抽象类名，其实需要的是该抽象类的子类对象

方法的返回值是抽象类名，其实返回的是该抽象类的子类对象

3.接口名作为形参和返回值

方法的形参是接口名，其实需要的是该接口的实现类对象

方法的返回值是接口名，其实返回的是该接口的实现类对象

内部类

1.内部类概述

内部类：就是在一个类中定义一个类。举例：在一个类A的内部定义一个类B，类B被称为内部类

内部类的定义格式

格式：

public class 类名{

​ 修饰符 class 类名{}

}

public class Outer{

​ public class Inner{ }

}

内部类的访问特点

​ 内部类可以直接访问外部类的成员，包括私有

​ 外部类要访问内部类的成员，必须创建对象

2.成员内部类

按照内部类在类中定义的位置不用，可以分为以下两种形式

​ 在类的成员位置：成员内部类

​ 在类的局部位置：局部内部类

成员内部类，外界如何创建对象使用呢？

​ 格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象；

​ 范例：Outer.Inner oi = new Outer().new Inner();

3.局部内部类

局部内部类是在方法中定义的类，所以外界是无法直接使用，需要在方法内部创建对象并使用

该类可以直接访问外部类的成员，也可以访问方法内的局部变量

4.匿名内部类

前提：存在一个类或者接口，这里的类可以是具体类也可以是抽象类

格式：

new 类名或者接口名(){

​ 重写方法；

}

new Inter(){

​ public void show(){}

}

本质：是一个继承了该类或者实现了该接口的子类匿名对象