Java面向对象编程——抽象类和接口
定义类的过程就是抽象和封装的过程，而抽象类与接口则是对实体类进行更高层次的抽象，进定义公共行为和特征。
抽象类：
如果一个类没有足够的信息去描述一个具体的对象，那我们就称之为抽象类。
语法格式:
public abstract class 类名{}
案例代码:
package Demo01;/*** @version 1.0* @author: weimengjie* @date: -05-13 10:31*/public class Demo01 {// 定义动物抽象类public abstract class Animal{}}
抽象方法：
有了抽象类，类中就要有与之对应的抽象方法。抽象发发就是用abstract修饰的方法，这种方法值声明返回的数据类型，方法名称和所需要的参数，没有方法体。也就是说在抽响雷中声明抽象方法时，值需要声明方法，不需要定义方法体。子类在继承父类时，必须重写父类的抽象方法，这也是抽象方法存在的意义。
语法格式:
public abstract 返回值类型 方法名（参数列表）；
案例代码：
package Demo01;/*** @version 1.0* @author: weimengjie* @date: -05-13 10:31*/public class Demo01 {// 定义动物抽象类public abstract class Animal{public abstract void go(); // 名为go的抽象方法，注意方法没有大括号}}
抽象类和抽象方法具体该怎么使用？ 抽象方法的作用是 什么？
案例代码:
package Demo01;/*** @version 1.0* @author: weimengjie* @date: -05-13 10:31*/public class Demo01 {// 定义动物抽象类public abstract class Animal{public abstract void go(); // 名为go的抽象方法，注意方法没有大括号}public class Demo02 extends Demo01 {public void go(){System.out.println("鸟飞的块");}}public class Demo03 extends Demo01{public void go(){System.out.println("狗跑的块");}}}
测试类：
package Demo01;/*** @version 1.0* @author: weimengjie* @date: -05-13 10:42*/public class Demo04 {public static void main(String[] args) {Demo02 d = new Demo02();d.go();Demo03 demo03 = new Demo03();demo03.go();}}
通过上面的代码我们可以总结：
定义抽象类就是用于继承的。和一般类的继承相比，子类继承抽象类必然会实现抽象方法。由于抽象方法都是没有方法体的，也就是说，抽象方法并没有写死，我么可以根据自己的需求去写
抽象类是一种模板式设计，通常是对同类事物相对具体的抽象。抽象类通常包含抽象方法、实体方法、属性变量。。我们在使用抽象方法和抽象类时，需要注意以下几点。
（1）包含抽象方法的类一定时抽象类。
（2）抽象类中的方法不一定都是抽象方法。抽象类也可以没有抽象方法
（3）构造方法不能声明为抽象方法
（4）abstract 不能与private 、static、final、native并修饰同一个方法
final修饰符
使用：
显示生活中，我们的身份证一经确定，身份证号就不能在此修改了。那我们Java中某些数据是定值，为了保证计算的正确性，不能在被修改，应该怎末办呢？这时候就用到了final修饰符，表示最终的。
final使用有以下几种情况。
（1）修饰类
（2）修饰方法
（3）修饰对象和变量
修饰类：
被final修饰过的类不能被继承
.因为不能被继承，所以此类中的所有方法默认都是final修饰
该类如果不需要子类，不需要被扩展，类中的方法不允许被重写，就是用final
修饰方法：
被final修饰的方法可以被继承，不能被覆盖重写
修饰对象和变量：
final修饰一个对象，那么这个对象的引用不能变，但是值是可以变的。如果是基础类型，那么值不可变。
案例代码：
package Demo02;;/*** @version 1.0* @author: weimengjie* @date: -05-13 10:31*/public class Demo01 {public String name;public Demo01(String name) {super();this.name = name;}public String getName() {return name;}public void setName(String name) {this.name = name;}@Overridepublic String toString() {return "Demo01{" +"name='" + name + '\'' +'}';}}
测试类：
package Demo02;/*** @version 1.0* @author: weimengjie* @date: -05-13 10:31*/public class Demo02 {public static void main(String[] args) {// final 修饰的是李斯特这个对象final Demo01 list = new Demo01("李四");// 李四对象中name 属性并没有被final修饰list.setName("张三");//最终输出内容：Demo01{name='张三'}System.out.println(list.toString());}}
接口
在生活中，接口时一套规范，满足这个规范的设备，就可以组装在一起。
接口就像插座一样，一种插孔可以插很多种电器，这个插孔就是我们像外卖呢提供的接口，所有的电器都要实现这个接口
为什么需要接口？
和抽象类对同类事物进行抽象不同，接口不是类，而是一组对类的需求描述（可以看成只有抽象方法的抽象类）。这要求接口采用锲约式、开放式对需求进行设计，这样才能满足不同事物的相同要求。
接口的使用
在软件中，接口同样是一种规范和标准，他们可以约束类的行为，是一些方法特征的集合，但没有方法的实现，需要类对接口进行实现。
Java中接口的定义语法：
[修饰符] interface 接口名 extends 父接口1，父接口2 ..{// 常量定义// 方法定义}
类实现接口的语法如下:
class 类名 extends父类名 implement 接口1 ，接口2 ，，，{//类成员}
interface 之中可以定义变量和方法，变量必须是public static final的，方法必须是public 、abstract的
说明：
（1）接口的命名规则与类相同。如果修饰符是public，则该接口在整个项目中可见；如果省略修饰符，则该接口只在当前包可见。
（2） 接口中可以定义常量，不能定义变量。接口中的属性都会自动用public static final 修饰
（3）接口中的所有方法都是抽象方法。接口中方法都会自动用 public abstract修饰，即接口中只有全局抽象方法
（4）和抽象类一样，接口也不能实例化，接口中不饿能有构造方法
（5）接口之间可以通过extends来实现继承关系，一个接口可以继承多个接口，但接口不能继承类。
(6)实现接口的类必须实现接口的全部方法，否则必须定义为抽象类
（7）一个类只能有一个直接父类，但可以通过implements是西安多个接口。当类在继承父类的同时有实现了多个接口时，extends关键字必须位于implements 关键字之前
案例代码：
（1）约定Usb接口标准
（2）制作符合Usb接口约定的各种具体设备
（3）将Usb设备插到Usb接口上进行工作
package Demo03;/***@author: weimengjie*@date: -05-14 09:08*@version 1.0*/public abstract class Demo01 {public interface Usb{public void run();}static class UsbPrinter implements Usb{@Overridepublic void run(){System.out.println("Usb连接中，打印机连接中，开始工作");}}static class UsbMouse implements Usb{@Overridepublic void run(){System.out.println("Usb 连接中 ，鼠标连接中，开始工作");} }static class Test{public static void main(String[] args){Usb a = new UsbPrinter();Usb B = new UsbMouse();a.run();B.run();}}}
接口是一种能力使用
接口是一种能力，一个类实现了某个接口，就表示这个类具备了某种能力。
案例代码：
package Demo03;import org.w3c.dom.ls.LSOutput;/*** @version 1.0* @author:weimengjie* @date: -05-14 09:24*/public class Demo02 {static public abstract class Venicle {public abstract void run();public abstract void stop();}static interface Lock {void lock();void open();}static class Car extends Venicle implements Lock{@Overridepublic void run() {System.out.println("开完锁，发动引擎，驾驶员驾驶者汽车开始行驶");}@Overridepublic void stop() {System.out.println("驾驶员将发动机熄火，准备锁上汽车");}@Overridepublic void lock() {System.out.println("插进钥匙，向左旋转三圈，拔出钥匙");}@Overridepublic void open() {System.out.println("插进钥匙，向右旋转三圈，所打开了，拔出钥匙");}}}
测试类：
package Demo03;/*** @version 1.0* @author:weimengjie* @date: -05-14 09:41*/public class TestDemo02 {public static void main(String[] args){Demo02.Car car = new Demo02.Car();car.lock();car.open();car.run();car.stop();}}
既然接口代表一种能力，那么我i们在开车和停车的基础上，扩展行车记录仪记录功能，需要增加一种能力
代码：
package Demo03;/*** @version 1.0* @author:weimengjie* @date: -05-14 09:24*/public class Demo03 {static public abstract class Venicle {public abstract void run();public abstract void stop();}interface Lock {void lock();void open();}interface TripREC{void record();}static class Car extends Venicle implements Lock{@Overridepublic void run() {System.out.println("开完锁，发动引擎，驾驶员驾驶者汽车开始行驶");}@Overridepublic void stop() {System.out.println("驾驶员将发动机熄火，准备锁上汽车");}@Overridepublic void lock() {System.out.println("插进钥匙，向左旋转三圈，拔出钥匙");}@Overridepublic void open() {System.out.println("插进钥匙，向右旋转三圈，所打开了，拔出钥匙");}public void record(){System.out.println("行车记录仪开始录像");}}}
测试类:
package Demo03;/*** @version 1.0* @author:weimengjie* @date: -05-14 09:41*/public class TestDemo03 {public static void main(String[] args){Demo03.Car car = new Demo03.Car();car.lock();car.open();car.run();car.stop();car.record();}}
从结果中可以看出：
接口在代码的扩展和维护方面十分方柏霓。接口类似于一个组件，需要时可以自由组装。从使用角度来讲，接口和抽象类的区别在于：抽象类利于代码复用，接口利于代码维护
接口是一种约定
接口其实就是一种约定，实现接口的类就必须遵守这个接口的约定
Java8中接口的变化
在 JDK 8及以后，允许我们在接口中定义static方法和default方法，这两种方法可以有方法体
default方法属于实例，static方法属于接口或类。要注意的是 default方法可以被继承，static方法不能被继承
如果一个类实现了多个接口，并且这些接口之间没有相互继承关系，同时存在相同的default方法时会报错，不过可以在实现类中重写default方法并通过“<接口>.super.<方法名>();"
静态方法：
在接口中增加静态方法。理论上讲。没有任何理由认为这是不合法的。只是这有违将接口作为抽象规范的初衷
案例代码：
package Demo04;/*** @version 1.0* @author:weimengjie* @date: -05-14 10:02*/public class Demo01 {public static void main(String[] args) {//静态方法不会被继承TestInter.staticMethh();TestInter2.staticMethh2();}}interface TestInter{static void staticMethh(){System.out.println("TestInter中的静态方法");}}interface TestInter2{static void staticMethh2(){System.out.println("TestInter2中的静态方法");}}
默认方法：
default关键字修饰接口的方法，使其称为默认方法。目的时减少子类实现接口的工作量。
案例代码：
先看没有使用默认方法的方式：
package Demo04;/*** @version 1.0* @author: weimengjie* @date: -05-14 10:18*/public class Demo02 {public interface Log {void login(String name);}class Emp implements Log{@Overridepublic void login(String name){System.out.println("用户"+name+":登陆系统");}}class Student implements Log{@Overridepublic void login(String name){System.out.println("用户"+name+";登陆系统");}}}
再看使用默认方法之后的代码：
package Demo04;/*** @version 1.0* @author:weimengjie* @date: -05-14 10:21*/public class Demo03 {public interface Log{default void login(String name){System.out.println("用户"+name+":登陆系统");}}static class Emp implements Log{}static class Student implements Log{}static class DefaultMethodTest{public static void main(String[] args) {Emp emp = new Emp();emp.login("张三");Student student = new Student();student.login("李四");}}}
结论：
如果多个子类实现某个接口方法，方法体都是一样的，这就导致后期维护上的困难，如果在接口中定义了默认的实现，那么即减少了子类实现的接口的工作量，也为后期的维护提供了方便（只需要更改接口中的默认实现即可）
总结
面向接口编程可以实现接口和现实的分离，这样做最大的好处就是能够在客户端位置的情况下修改是西安代码，那么怎样抽象出接口呢？一种时用在层与层的调用。层与层之间最机会耦合度过高或修改过于频繁。设计优秀的接口能够解决这个问题，
另一种时是使用在那些不稳定的部分上。如果某些需求的变化性很大，那么定义接口也是一种解决方法，设计良好的接口就像日常使用的万能插座，不论插头如何变化，都可以使用
当纠结定义接口还是抽象类时，优先推荐定义为接口，遵循接口隔离原则，按某个维度划分成多个接口，然后在用抽象类去是实现某些接口，这样做可方柏霓后续的扩展和重构。
