第一阶段笔记整合

第一阶段笔记整合

一、变量：
定义:用来存储数据的容器
Java中数据类型的分类：
1.基本数据类型：创建的时候大小固定存储位置在栈
四型八种：
整型 （默认值为0
字节型 byte 1字节 8位 取值范围-128~127 -2^7 ~ 2^7-1 计算公式负的2的位数次幂到正的2的位数次幂-1
短整型 short 2字节 16位 -3w~3w -2^15 ~ 2^15-1
整型：int 4字节 32位 -21亿多~21亿多 -2^31 ~ 2^31-1
长整型：long 8字节 64位 19位数 -2^63 ~ 2^63-1
）
浮点型（默认值为0.0
单精度浮点型：float 4字节 同为4字节而float容纳的数却多的原因是两种不同的类型不能比较。
双精度浮点型：double 8字节
）
布尔型 boolean 默认值为false
字符型 char 默认值为 ’’
2.引用数据类型 默认值都为null空的常量，存储在栈的常量池中。
类 String 接口 数组

二、书写规范
1.格式要规范
2.所有非注释代码全用英文
3.任何变量（不论基本数据类型或者引用数据类型）必须注释
4.关键性逻辑代码也要注释
5.一行只写个分号
6.一行代码过长要换行符号要跟着到下一行

三、数组（他也是一个容器等同于变量但是跟变量有区别的是他是存多个数据变量存一个数据 一旦定义了一个数组他的长度就不能变了只能从逻辑结构去实现扩容）
数组的写法：
数据类型 [] 名字 = new 数据类型[长度];
数据类型 [] 名字 = {1,2,3,4,5};
数据类型 [] 名字 = new 数据类型 [] {1,2,3,4,5};

四、运算符
1.赋值运算符：=
2.算术运算符：+ - * / % ++ –
3.比较运算符：> < >= <= != .equals()
4.逻辑运算符：& && | ||
5.位运算符：>> << 相当于就是÷2和×2 列子：10/2 --> 10 >> 1 左乘右除

五、条件语句
1.单个判断：if
2.如果否则：if else
3.多个if（每个if都会进行判断）：if…if…if
4.多重if（当有一个if满足条件，后面的if就不会判断了）
5.if … else if … else if … else
6.嵌套if
7.当代码只有一行，可以省略{} 省略之后，必须要有内容，否则报错
8.switch：等值判断 与多重if比较
优点：当判断个数超过5个速度会优于多重if
缺点：判断值不能过多代码太长，不能做区间判断只能做等值判断

六、循环
三种类型：
1.while 2.do…while 3.for
注意点：增强for循环 内部是基于迭代器 for（Object object : array）{}

七、面向对象
类与对象
类（具体的）定义：所有具有相同属性和行为的东西统一称之为一个类比如人统称为人类
对象（抽象的）定义:能够说出具体的属性值和具体的行为的东西称为对象他是一个类的具体化比如人类中的一个人张三他有名字会吃饭
Java的面向对象
一个对象：字段(属性)和方法(功能)
封装：将某个功能写成一个方法然后去调用
作用：
1.可以重复调用
2.安全如果不提供源代码，看不到里面的代码的。
3.减少代码之间的耦合性
继承：代码的重用性
多态：继承父类实现接口 方法重写，同一个方法不同的表现形式 父类引用指向子类对象

八、八种封装类（八种基本数据类型所对应的封装类）
八种封装类的来由：
1.基本数据类型只能做基本运算不能做很多的功能转换，比如把字符串数字变成数字
2.Java是完全的面向对象编程很多的操作都是基于对象来的
注意点：集合中，只能添加对象，基本数据类型不属于对象 基本数据类型的值：是常量，不可更改。

九、数学类
典型Random类：
作用：用来生成随机数
写法：Random rand = new Random rand.nextInt(输入一个你要的范围例如10则会生成1-9之间的数);
注意点：括号里的参数是个种子值（根据这个种子值的基础上进行算法运算最后给出随机的数）
如果两个不同的对象里面的种子值一样那么最后两个值比较是一样的

十、字符串
常用的方法：
length()；返回的是字符串的长度
equalsIgnoreCase()不区分大小写
toUpperCase小写
toLowerCase大写
trim()清空字符串两端的空格
字符串常用提取方法：
IndexOf(int ch)搜索字符串里面第一个出现的字符ch如果没有则返回-1
IndexOf(String value)搜索字符串里面第一个出现的字符value如果没有则返回-1
lastIndexOf(String value)搜索最后一个出现的字符value没有返回-1
Substring(int index)提取从位置索引开始的字符串
Substring(int beginindex，int endindex)提取从begin和end之间的字符串部分截取包左不包右
字符串的拆分：
split("");根据指定的符号去将字符串拆分开来
字符串的创建方式：
1.直接创建 String s11 = “abc”;//内部会自动转化为数组
2.new一个对象 String s12 = new String(“abc”);
操作原理： String s111 = new StringBuilder().append(“abc”).toString();
字符串拼接：
字符串拼接【任何类型】（包括对象）的数据，都会变成字符串。
如果拼接字符串时要进行计算，就要加()，因为()有最先优先运算。
如果字符串要拼接大量的数据，一定要用StringBuilder()原因是如果一次性创建多个字符串他的底层就会一次一次的去new对象非常影响效率而builder底层是一个数组扩容的形式大大的减少了new的次数
十一、this关键字
1.this代表this的类型 例如person类代表的则是person类
2.只有类的任意一个具体对象才能点出属性
3.This就是类中的一个具体对象谁用就是谁
4.哪个对象调用了这个方法，这个方法中this就是调方法的这个对象
十二、集合（底层就是个数组 长度可变是因为底层做了一个扩容机制）
集合出现的作用:为了解决数组的缺点比如数组的长度固定方法（功能有限）
集合分为Collection和map 和迭代器
Collection接口：存储一组不唯一，无序的对象
Collection --> List --> ArrayList，LinkedList,Vector(比较常用的)
Collection --> Set --> HashSet,TreeSet
Map -->HashMap,Hashtable,ThreeMap
List特点：长度可变（有上线）有序（存在下标）可重复（可以有一样的数据）可以通过元素的索引获取内容
Set特点：长度可变 无序 不可重复 底层用的是mao键值对的形式存储数据键是唯一的值可以重复 没有get方法只能用迭代器或增强for去取里面的数据
Map特点：key-value的键值对存储方式 长度可变 键是唯一的值可以重复 只能通过key键去获取对应的值可以获取单个key也可以获取所有key循环获取对应的value

List下的arraylist特点：取数据快类似于switch直接获取下标对应的值 增删改慢因为只要你更新了数据整个数组又要重新去进行排序特别是当数据量非常大的时候弊端就出来了
List下的LinkedList特点：取数据慢类似于多重if从初始节点一直往下找每次都要从头开始找一个一个的往下直到要的那个位置所以查的时候效率非常低 优点：更新数据快只要改变上下节点的对应关系即可不需要整个的去动它

ArrayList在jdk1.8扩容机制：
1.创建的时候容量时：0
2.第一次增加元素自动扩容至：10
3.第二次扩容（增加上一次容量的1/2[一半]）：10 + 10 >> 1 (10 / 2) = 15
十三、文件类操作
常用的操作方法：
创建：
createNewFile()在指定位置创建一个空文件，成功就返回true，如果已存在就不创建，然后返回false。
mkdir() 在指定位置创建一个单级文件夹。
mkdirs() 在指定位置创建一个多级文件夹。
renameTo(File dest)如果目标文件与源文件是在同一个路径下，那么renameTo的作用是重命名， 如果目标文件与源文件不是在同一个路径下，那么renameTo的作用就是剪切，而且还不能操作文件夹。
删除：
delete() 删除文件或者一个空文件夹，不能删除非空文件夹，马上删除文件，返回一个布尔值。
deleteOnExit()jvm退出时删除文件或者文件夹，用于删除临时文件，无返回值。
判断：
exists() 文件或文件夹是否存在。
isFile() 是否是一个文件，如果不存在，则始终为false。
isDirectory() 是否是一个目录，如果不存在，则始终为false。
isHidden() 是否是一个隐藏的文件或是否是隐藏的目录。
isAbsolute() 测试此抽象路径名是否为绝对路径名。
获取：
getName() 获取文件或文件夹的名称，不包含上级路径。
getAbsolutePath()获取文件的绝对路径，与文件是否存在没关系
length() 获取文件的大小（字节数），如果文件不存在则返回0L，如果是文件夹也返回0L。
getParent() 返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回null。
lastModified()获取最后一次被修改的时间。
文件夹相关：
static File[] listRoots()列出所有的根目录（Window中就是所有系统的盘符）
list() 返回目录下的文件或者目录名，包含隐藏文件。对于文件这样操作会返回null。
listFiles() 返回目录下的文件或者目录对象（File类实例），包含隐藏文件。对于文件这样操作会返回null。
list(FilenameFilter filter)返回指定当前目录中符合过滤条件的子文件或子目录。对于文件这样操作会返回null。
listFiles(FilenameFilter filter)返回指定当前目录中符合过滤条件的子文件或子目录。对于文件这样操作会返回null。

十四、递归算法
什么是递归：一个方法体内调用它自身，这样的方法我们称之为方法递归。方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。所以使用递归的计算必须是有规律的，有出口的。

原理：
1、每一级的函数调用都有自己的变量
2、每一次函数调用都会有一次返回。
3、递归函数中，位于递归调用前的语句和各级被调用函数具有相同的执行顺序。
4、递归函数中，位于递归调用后的语句的执行顺序和各个被调用函数的顺序相
5、虽然每一级递归都有自己的变量，但是函数代码并不会得到复制。
优点：实现简单 可读性好
缺点：占用空间大 递归太深容易发生栈溢出的情况 可能会存在重复的计算
三大要素：
1、明确你这个函数想要干什么。
2、寻找递归结束条件。
3、找出函数的等价关系式。

十五、访问权限

This关键字：
定义：this代表引用本类的一个对象，在创建一个类时同时会创建一个this而且只会创建一次所以这个this是不会变的。
This的对象地址是一样的
This对象可以在类里面来引用这个类的属性和方法，也可以作为方法的返回值返回该对象

权限修饰符的作用：
控制着对类和类的成员变量以及成员的访问注意点：局部变量是不能用权限修饰符修饰的
Private修饰符的好处：如果其他的类想要访问该类的方法和属性则需要设置方法来访问这样可以设置一些条件限制别人的访问，从而保护数据的安全性

类的构造方法：
定义：构造方法就是一个与类名同名的方法对象的创建就是通过构造方法完成的每当类实例化一个对象时类都会自己调用构造方法

特点：
没有返回值 与类同名 每次实例化这个类的对象时都会调用一次 如果类中没有明确定义构造方法，编译器会自动创建一个不带参数的构造 如果类中定义的所有构造方法都不是无参构造方法那么编译器是不会为类设置一个默认空的构造方法的

作用:可以对参数进行初始化

对象数组：将一个类的多个对象存储在数之中。这些对象包含有这个类的属性与自身的属性值。

十六、
Static关键字：
定义：static表示“全局”或者“静态”的意思，用来修饰成员变量和成员方法，也可以修饰静态static代码块。
被static修饰的成员变量和成员方法独立于该类的任何对象 也就是说它不依赖特定的实例 被类的所有实例共享只要这个类被加载，java虚拟机就能根据类名在运行的时候数据区的方法区内定找到他们。因此static对象可以在他的任何对象创建之前访问不用应用任何对象

解释：static变量也称作静态变量，静态变量和非静态变量的区别是：
静态变量被所有的对象所共享，在内存中只有 一个副本 ，它当且仅当在类初次加载时会被初始化。而非静态变量是对象所拥有的，在创建对象的时候被初始化，存在 多个副本 ，各个对象拥有的副本 互不影响 。
**注意：**static成员变量的初始化顺序按照定义的顺序进行初始化。访问权限与四种访问权限效果相同。
- 语法：访问权限 + static + 变量类型 + 变量名
- 调用方法：类名.静态变量名

解释：static方法一般称作静态方法，由于静态方法不依赖于任何对象就可以进行访问，因此对于静态方法来说，是没有this的，因为它不依附于任何对象，既然都没有对象，就谈不上this了。并且由于这个特性，在静态方法中不能访问类的非静态成员变量和非静态成员方法，因为非静态成员方法/变量都是必须依赖具体的对象才能够被调用。**注意：**虽然在静态方法中不能访问非静态成员方法和非静态成员变量，但是在非静态成员方法中是可以访问静态成员方法/变量的。
- 语法：访问权限 + static + 返回值类型 + 方法名(参数1,参数2…){方法体}
- 调用方法：类名.静态方法名

Static修饰静态代码块用来优化程序 static块可以置于类中任何地方类中可以有多个static块在初次被加载时会按照static块的顺序来执行每个static块，并且只会执行一次。
static作用总结
1. 放在成员变量中，称为：静态成员变量，静态变量被所有的对象所共享，在内存中只有 一个副本 ，它当且仅当在类初次加载时会被初始化。使用【类名.变量】名直接访问。
2. 放在方法中，称为：静态方法。方法中，不能使用this关键字，不能使用非静态成员变量和非静态成员方法。使用【类名.方法名】进行访问。
3. 放在代码块中，称为：静态代码块。static块可以置于类中的任何地方，类中可以有多个static块。在类初次被加载的时候，会按照static块的顺序来执行每个static块，并且只会执行一次。当不加static时，代码块会在每次创建对象时调用一次。

类的主方法：
主方法是类的入口点，它定义了程序从何处开始；主方法提供对程序流向的控制，Java编译器通过主方法来执行程序。

主方法的特性：
1. 主方法是静态的
2. 主方法没有返回值
3. 主方法的形参为数组，其中args[0]~args[n]分别代表程序的第一个参数到第n个参数，可以使用args.length来获取参数的个数。

十六、类的继承
定义：继承就是子类继承父类的特征和行为使得子类对象具有父类的实例域和方法或子类从父类继承方法使得子类具有父类的相同行为

为什么使用继承：
从已经有的类去派生新的类称为继承
在不同的类中也可能有共同的特征和动作可以把这些共同的特征个动作放在一个类中让其他类共享因此定义一个通用的类然后将其扩展为其他多个特定类这些特定类继承通用类中的特征和动作
继承是 Java 中实现软件重用的重要手段，避免重复，易于维护，易于理解

继承需要注意的地方：
1. 在Java中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类，所以 extends 只能继承一个类。
2. 子类不是父类的子集，子类一般比父类包含更多的数据域和方法。
3. 父类中的 private 数据域在子类中是不可见的，因此在子类中不能直接使用它们。

super关键字的作用
- 调用父类构造方法语法：super();或者super(参数列表);如果父类没有空的构造方法，子类一定要重写父类的构造方法。
- 调用父类的成员变量的语法：super.变量名
- 调用父类的方法语法：super.方法名(参数列表);
总结:
- super 语句必须是子类构造方法的第一条语句。
- 不能在子类中使用父类构造方法名来调用父类构造方法，必须用super()来调用。
- 父类的构造方法不被子类继承。调用父类的构造方法的唯一途径是使用 super 关键字，如果子类中没显式调用，则编译器自动将 super()，作为子类构造方法的第一条语句，如果父类中没有空的构造方法，则子类必须使用super()给父类的构造方法传参，否则会编译错误。super();
- 静态方法中不能使用 super 关键字。
- 使用this和super来区分是本类的还是父类的属性与方法。

方法重写：
如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。在Java中，子类可继承父类中的方法，而不需要重新编写相同的方法。
- 但有时子类并不想原封不动地继承父类的方法，而是想作一定的修改，这就需要采用方法的重写。
- 方法重写又称方法覆盖。

重写的特点：
1. 若子类中的方法与父类中的某一方法具有相同的方法名、返回类型和参数表，则新方法将覆盖原有的方法。如需父类中原有的方法，可使用super关键字，该关键字引用了当前类的父类。
2. 重写的方法中子类函数的访问修饰权限不能少于父类的。

1.Overload和Override有什么区别？Overloaded的方法是否可
以改变返回值类型？
重载：发生在同一个类中，类名相同，参数类型不同，个数不同
重写：发生在继承体系下，子类实例指向父类引用，子类方法会覆盖父类方法
可以改变与返回值无关
2.final的特性？
类不可继承，方法不可重写，变量为常量

和类名一样的方法且没有返回值叫构造
一个类中有多个方法重名但形参不一样的叫重载
在继承父类的情况下子类重写了一个和父类一样的方法叫重写

重载：
java允许同一个类里定义多个同名方法，只要形参列表不同就行。如果同一个类中包含了两个或两个以上方法的方法名相同，但形参列表不同，则被称为方法重载。

作用：
方法重载是让类以统一的方式处理不同类型数据的一种手方法段

重载的特点：

1. 方法名相同
   2. 参数列表不同
   3. 与返回值无关
   4. 不能将功能不同的方法进行重载
   5. 与访问权限无关
   重载中参数不同的几种形式：
2. 参数类型不同
3. 参数数量不同
   3.参数类型顺序不同
   重载时需要注意事项：
   方法名相同的方法才叫重载
   无论是否有返回值，不影响方法的重载
   不能将不同功能的方法进行重载

对象类型转换：类似于基本数据类型之间的类型转换。 存在继承关系的父类对象和子类对象之间也可以在一定条件之下相互转换。
向上转型（也可称为：父类的引用指向子类的对象）Car BMW = new BMW();
向下转型（如果要调用子类中具体的方法就要将一个汽车类转换成其具体的子类，这种转换叫做向下转型）Car car = new BMW(); BMW BMW = (BMW) car;

重载与重写的区别：
区别点 重载 重写
参数列表 必须修改 一定不能修改
返回类型 可以修改 一定不能修改
访问权限 可以修改 一定不能做更严格的限制
（可以降低限制）

十七、抽象类：
Object类：在Java中，所有的类都直接或者间接的继承了java.lang.Object类。Object是一个比较特殊的类，它是所有类的父类，是Java类层中的最高层。当创建一个类时，总是在继承，除非这个类已经指定要从其他类继承，否则它就是从java.lang.Object类继承而来。

toString()方法:
toString()方法的功能是将一个对象返回为字符串形式
它会返回一个String实例。实际应用中通常重写toString()方法。

equals()方法与==的区别：
equals()比较的是内容是否相等，==比较的是内存地址是否相等，即是否是同一个对象。

clone()方法
clone()方法的作用：clone()可以产生一个相同的类并且返回给调用者。
clone()是如何工作的：Object将clone()作为一个本地方法来实现，这意味着它的代码存放在本地的库中。当代码执行的时候，将会检查调用对象的类(或者父类)是否实现了java.lang.Cloneable接口(Object类不实现Cloneable)。如果没有实现这个接口，clone()将会抛出一个检查异常()——java.lang.CloneNotSupportedException,如果实现了这个接口，clone()会创建一个新的对象，并将原来对象的内容复制到新对象，最后返回这个新对象的引用。
怎样调用clone()来克隆一个对象：用想要克隆的对象来调用clone()，将返回的对象从Object类转换到克隆的对象所属的类，赋给对象的引用。
对象类型判断（instanceof）：
为什么要判断对象类型：
当向下转型时，如果父类的引用不是子类的实例，即两个对象之间不存在继承关系时就会出现异常。所以在转型时要事先判断父类是否为子类对象的实例。
语法：某类对象的引用 instanceof 某个类
十八、多态和final关键字
什么是多态：
多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。因为在程序运行时才确定具体的类，这样，不用修改源程序代码，就可以让引用变量绑定到各种不同的类实现上，从而导致该引用调用的具体方法随之改变，即不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性

满足多态的条件(必须)：
只有满足了以下三个条件，我们才能够在同一个继承结构中使用统一的逻辑实现代码处理不同的对象，从而达到执行不同的行为。

1. 继承：在多态中必须存在有继承关系的子类和父类。
2. 重写：子类对父类中某些方法进行重新定义，在调用这些方法时就会调用子类的方法。
3. 向上转型：在多态中需要父类的引用指向子类的对象，只有这样该引用才能够具备技能调用父类的方法和子类的方法。

多态的利弊：
好处：提高了程序的扩展性。
弊端：当父类引用指向子类对象时，虽然提高了扩展性，但是只能访问父类中具备的方法，不可以访问子类中特有的方法。(前期不能使用后期产生的功能，即访问的局限性)

final关键字：
什么是final关键字：
final在Java中是一个保留的关键字，可以声明成员变量、方法、类以及局部变量。一旦你将引用声明作final，你将不能改变这个引用了，编译器会检查代码，如果你试图将变量再次初始化的话，编译器会报编译错误。
final变量：
凡是对成员变量或者本地变量(在方法中的或者代码块中的变量称为本地变量，又叫局部变量)声明为final的都叫作final变量。final变量经常和static关键字一起使用，作为常量。

注意点：定义的时候不赋值，一定不能加static关键字

final方法：
final也可以声明方法。方法前面加上final关键字，代表这个方法不可以被子类的方法重写。如果你认为一个方法的功能已经足够完整了，子类中不需要改变的话，你可以声明此方法为final。final方法比非final方法要快，因为在编译的时候已经静态绑定了，不需要在运行时再动态绑定。

final类：
使用final来修饰的类叫作final类。final类中的所有方法都被隐式的设置为final形式，但是成员变量可以定义为final类型和非final类型。final类通常功能是完整的，它们不能被继承。Java中有许多类是final的，譬如String, Interger以及其他包装类。
语法：final 类名{}

final总结：

1. final关键字可以用于成员变量、本地变量、方法以及类。
   2. final成员变量必须在声明的时候初始化或者在构造器中初始化，否则就会报编译错误。
   3. 本地变量必须在声明时赋值。
   4. final变量不能再次赋值。
   5. final方法不能被重写。
   6. final类不能被继承。
   7. 将类、方法、变量声明为final能够提高性能，这样JVM就有机会进行估计，然后优化。
   8. 按照Java代码惯例，final变量就是常量，而且通常常量名要大写。多个单词之间用下划线连接‘_’。

十九、抽象类与接口
为什么使用抽象类：我们一般会将父类定义为抽象类，比如有汽车类，汽车中有开车方法，但是具体开什么车是不知道的，即在汽车类中这个方法是没有什么具体意义的。所以这个汽车类就是一个抽象的类。又比如让你去买电脑，肯定不会让你去买电脑类，因为电脑种类有很多。
定义抽象类语法：public abstract class 类名{}
抽象方法
使用abstract定义的类称为抽象类，而使用这个关键字定义的方法称为抽象方法。抽象方法没有方法体，这个方法本身没有任何意义，除非它被重写，而承载这个抽象方法的抽象类必须被继承，实际上抽象类除了被继承外没有任何意义。
抽象方法的特点：
1. 没有方法的实体，必须要用子类来重写的方法。
2. 如果类中有一个方法为抽象方法，那么这个类就是抽象类。
3. 抽象方法和抽象类必须要加上abstract。
4. 抽象类不能被实例化，即不能被new出来，只能被继承。
5. 抽象类中可以写实体方法。

• 举例：

  //定义一个抽象类
  public abstract class Person {
  //定义一个抽象方法，抽象方法必须加入abstract关键字
  public abstract void run();
  //定义一个实体方法
  public void eat(){
  System.out.println(“人吃饭”);
  }
  }
  //测试类
  public class Test {
  public static void main(String[] args) {
  //这是错误的，抽象方法不能被实例化
  Person person = new Person();
  }
  }

  什么是接口：接口是抽象类的延伸，可以将它看作是存粹的抽象类，接口中所有的方法都没有实体，但是可以写静态方法**（JDK1.8以后可以）**，但是静态方法必须有实体。
  为什么使用接口：在继承中可以发现一个问题，就是单继承。一个子类只能继承一个父类，但是有这么个情况：比如一个人，他既是学生，又是党员，又是一个儿子，这么多身份要继承，那要怎么办呢？那就要用到接口。
  定义一个接口的语法：public interface 类名{}
  接口的特点：

  1. 接口中所有的方法都是抽象方法，所以可以省略abstract关键字。但是可以写静态方法**（JDK1.8以后可以）**，但是静态方法必须有实体。
  2. 子类与父类的关系叫：继承，接口与继承接口的关系叫：实现。实现接口的关键字为：implememnts。
  3. 接口中的定义的属性都是public static final类型的。一般接口中不会定义属性。
  4. 一个类可以实现多个接口，语法为：public class 类名 implememnts 接口1，接口2…{}
  5. 一个类继承父类与实现接口之间不冲突，可同时进行，语法为：public class 类名 extends 父类 implememnts 接口1，接口2…{}，必须先继承，再实现接口。
  6. 接口中没有构造方法，与抽象类类似，无法实例化。

抽象类与接口的区别：
1 语法层面上的区别：

1. 抽象类可以提供成员方法的实现细节，而接口中只能存在public abstract 方法和static静态方法**（JDK1.8以后可以）**，这个静态必须写实体；
2. 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是public static final类型的；
3. 接口中不能含有静态代码块，可以写静态方法**（JDK1.8以后可以）**，但是静态方法必须有实体，只能用接口名.方法名调用。而抽象类可以有静态代码块；
4. 一个类只能继承一个抽象类，而一个类却可以实现多个接口。
   2 设计层面上的区别：
5. 抽象类是对一种事物的抽象，即对类抽象，而接口是对行为的抽象。抽象类是对整个类整体进行抽象，包括属性、行为，但是接口却是对类局部（行为）进行抽象。举个简单的例子，飞机和鸟是不同类的事物，但是它们都有一个共性，就是都会飞。那么在设计的时候，可以将飞机设计为一个类Airplane，将鸟设计为一个类Bird，但是不能将 飞行 这个特性也设计为类，因此它只是一个行为特性，并不是对一类事物的抽象描述。此时可以将 飞行 设计为一个接口Fly，包含方法fly( )，然后Airplane和Bird分别根据自己的需要实现Fly这个接口。然后至于有不同种类的飞机，比如战斗机、民用飞机等直接继承Airplane即可，对于鸟也是类似的，不同种类的鸟直接继承Bird类即可。从这里可以看出，继承是一个 "是不是"的关系，而 接口 实现则是 "有没有"的关系。如果一个类继承了某个抽象类，则子类必定是抽象类的种类，而接口实现则是有没有、具备不具备的关系，比如鸟是否能飞（或者是否具备飞行这个特点），能飞行则可以实现这个接口，不能飞行就不实现这个接口。
6. 设计层面不同，抽象类作为很多子类的父类，它是一种模板式设计。而接口是一种行为规范，它是一种辐射式设计。什么是模板式设计？最简单例子，大家都用过ppt里面的模板，如果用模板A设计了ppt B和ppt C，ppt B和ppt C公共的部分就是模板A了，如果它们的公共部分需要改动，则只需要改动模板A就可以了，不需要重新对ppt B和ppt C进行改动。而辐射式设计，比如某个电梯都装了某种报警器，一旦要更新报警器，就必须全部更新。也就是说对于抽象类，如果需要添加新的方法，可以直接在抽象类中添加具体的实现，子类可以不进行变更；而对于接口则不行，如果接口进行了变更，则所有实现这个接口的类都必须进行相应的改动。
   什么时候使用抽象类和接口：
7. 如果你拥有一些方法并且想让它们中的一些有默认实现，那么使用抽象类吧。
   2. 如果你想实现多重继承，那么你必须使用接口。由于Java不支持多继承，子类不能够继承多个类，但可以实现多个接口。因此你就可以使用接口来解决它。
   3. 如果基本功能在不断改变，那么就需要使用抽象类。如果不断改变基本功能并且使用接口，那么就需要改变所有实现了该接口的类。

本文地址：https://blog.csdn.net/m0_47420737/article/details/107697977

如对本文有疑问， 点击进行留言回复！！