本文已参与「新人创作礼」活动，一起开启掘金创作之路。
抽象类与接口
抽象类 abstract
抽象类的概述
程序，是用来描述现实世界，解决现实问题的。
不可被实例化
可以没有抽象方法，但有 抽象方法的 必须 为抽象类。
抽象类有构造器，子类调用
抽象类 都 作为 父类使用
抽象类有 属性 和 方法
抽象类的子类 必须 实现抽象方法或者把自己设为抽象类。
// 定义一个抽象类
package com.laity.basicSyntax.day4.abstractUsage;
/**
* @author : Laity
* @Project: JavaLaity
* @Package com.laity.basicSyntax.day4.abstractUsage
* @date Date : 2021年11月29日 21:41
* @Description: abstract 抽象类的定义
*
* 抽象类是没有对象的(子类是可以继承到的)
* 抽象类不能实例化对象，只是为了给所以的子类进行公共部分的定义
*/
public abstract class Animal { // abstract
// 抽象类可以定义属性
public String name;
public int age;
// 也可以定义方法，行为
public void sleep(){}
public void eat(){}
// 也可以定义构造方法
}
抽象方法
被abstract修饰的方法被称为抽象方法。
抽象方法只能定义在抽象类中。
抽象方法只能声明，没有实现。
抽象方法只能包含在抽象类中。
抽象方法的定义
public abstract class Animal { // abstract
// 抽象类可以定义属性
public String name;
public int age;
// 也可以定义方法，行为
// 如果有个方法，所有的子类都在重写，那么这个方法在父类中没有必要的
public void sleep(){}
public void eat(){}
// 也可以定义构造方法
// 实现抽象方法(被abstract修饰的方法被称为抽象方法。)
// 只能包含在抽象类中
public abstract void bark();
}
抽象类的实现方法
非抽象类在继承中来自一个抽象父类的同时，必须重写实现父类中所有的抽象方法。因此，抽象类可以用来做一些简单的规则指定。
在抽象类中制定一些规则，要求所有的子类必须实现，约束所有的子类的行为。
场景：就是指定一些简单的规则(因为类是单继承的，所有由局限性)
接口 Interface
宏观上来讲，接口是一种标准。例如，我们生活中常见的USB接口。电脑通过USB接口连接各种外设的设备，每一个接口不用关心连接的外设设备是什么，只要
这个外设的设备实现了USB的标准，就可以使用接口进行这样的复杂的规则指定。
微观上来讲，接口是一种能力和约定
- 接口的定义：代表了某种能力。(类似于生活中的合同)
- 方法的定义：能力的具体要求。(类似于合同中的条款)
从程序上讲，接口代表了某种能力，类似于生活中的合同。而在接口中定义的各种方法，表示这个能力的具体要求，类似于合同中的条款。
（一个类可以实现多个接口，同样不能创建对象，但是也可以引用，具备object所具有的方法）
接口中没有构造方法、构造代码段、静态代码段。
（class改成interface一样的效果）
属性默认 public static final
方法默认 public abstract
实现接口使用implements
接口可以多继承
类可以同时继承和实现接口，继承在前。
接口的定义
package com.laity.basicSyntax.day4.InterfaceUsafe;
/**
* @author : Laity
* @Project: JavaLaity
* @Package com.laity.basicSyntax.day4.InterfaceUsafe
* @date Date : 2021年11月29日 23:32
* @Description: 第一个接口
*
* 方法：接口中的方法默认的修饰符是 public abstract（可写可不写）
* 属性: 接口中的属性默认的修饰符是 public static final
*/
public interface MyFirstInterface {
// 接口中可以定义:
// 1.方法
void myInterfaceMethod();
// 2.属性
int a = 10;
}
抽象类和接口的区别
// 基本区别
抽象类中可以有抽象方法，而接口中所有的方法必须是抽象的
一个类可以实现（implements）多个接口，但只能继承一个抽象类（extends）
抽象类可以有构造方法，而接口内不能有构造方法
抽象类中的抽象方法除了private都可以，而接口中的默认public abstract
抽象类中可以包含静态方法，接口中不能。
抽象类中的属性可以是任意类型的修饰符，接口中只能是public static final
// 应用区别
抽象类：在代码实现方面发挥作用，可以实现代码的重用。（抽象工厂模式）
接口：更多的是在系统框架设计方法发挥作用。（多态）
接口的实现 implements
package com.laity.basicSyntax.day4.InterfaceUsafe;
/**
* @author : Laity
* @Project: JavaLaity
* @Package com.laity.basicSyntax.day4.InterfaceUsafe
* @date Date : 2021年11月29日 23:51
* @Description: 调用接口的类
*/
public class MyInterfaceImpl implements MyFirstInterface{ // alt + enter
@Override
public void myInterfaceMethod() {
}
}
接口的实现增强
package com.laity.basicSyntax.day4.InterfaceUsafe;
/**
* @author : Laity
* @Project: JavaLaity
* @Package com.laity.basicSyntax.day4.InterfaceUsafe
* @date Date : 2021年11月29日 23:52
* @Description:
*/
public interface MyInterface {
void method1();
void method2();
void method3();
String toString();
}
class Superclass {
}
class Subclass extends Superclass implements MyInterface{
// 一个接口的实现和继承是可行的
@Override
public void method1() {
}
@Override
public void method2() {
}
@Override
public void method3() {
}
}
多个接口的实现
一个类收到多种条件的限制
package com.laity.basicSyntax.day4.Interfaced;
/**
* @author : Laity
* @Project: JavaLaity
* @Package com.laity.basicSyntax.day4.Interfaced
* @date Date : 2021年11月30日 0:05
* @Description:
*/
public interface MyInterface {
void method1();
void method2();
void method3();
}
interface MyInterface1 {
void method4();
void method5();
}
interface MyInterface2 {
void method6();
}
/**
* 一个类可以实现多个接口，只需要将实现的所有的接口以逗号进行分割即可，接口之间的先后顺序没影响
* 如果一个类实现了多个接口，则必须要所有的接口中的所有的抽象方法都重写实现
* 注意事项:
* 1.如果多个接口中有相同的方法: 则在实现类中只实现一次即可
* 2.如果多个接口中有同名，参数也相同，返回值不同的方法：此时这两个接口是不能同时实现的
* 3.
*/
class MyInterfaceImpl implements MyInterface,MyInterface1,MyInterface2 {
@Override
public void method1() {
}
@Override
public void method2() {
}
@Override
public void method3() {
}
@Override
public void method4() {
}
@Override
public void method5() {
}
@Override
public void method6() {
}
}
接口的继承
类是单继承，而接口是多继承的。(一个接口可以有多个父接口。而子接口可以继承到所有的父接口中的成员。)
package com.laity.basicSyntax.day4.Interfaced1;
/**
* @author : Laity
* @Project: JavaLaity
* @Package com.laity.basicSyntax.day4.Interfaced1
* @date Date : 2021年11月30日 0:17
* @Description:
*/
public interface Cooker { // 厨师
void cook(); // 会做饭
void buy(); // 会买菜
void clean(); // 会刷碗
}
interface HouseKeeping{ // 家政人员
void wash(); // 洗衣服
void saodi(); // 会扫地
}
interface GirlFriend extends Cooker,HouseKeeping{}
class Person implements GirlFriend{
@Override
public void cook() {
}
@Override
public void buy() {
}
@Override
public void clean() {
}
@Override
public void wash() {
}
@Override
public void saodi() {
}
}
接口的多态
接口的引用，也是可以指向实现类的对象。与类的多态相似，同样存在向上转型和向下转型。
- 向上转型：实现类类型 转成为 接口类型。(类转接口)
- 是一个隐示转换，不需要任何的修饰
- 向上转型后的接口引用，只能访问接口中的成员。
- 向下转型：接口类型 转成为 实现类类型 (接口转类)
- 是一个现实转换，需要强制类型转换。
- 向下转型后的实现类引用，将可以访问实现类中的成员。
接口的新特性
在java8中，为接口添加了两个新特性
-
static方法:可以在接口中定义静态方法，静态方法不是抽象方法，是有实现部分的。同时这个静态方法，只能由当前的接口调用，实现类是不能
使用的。
interface Myinterface{
public static void method{
System.out.println("接口中静态方法的实现");
}
}
-
default方法:修饰接口中的方法，default修饰的方法可以添加默认的实现部分。此时实现类在实现接口的时候，对于这些方法可以重写，也可以不
重写。(不重写按照原来的执行，重写了按照重写的执行)
interface Myinterface{
public default void method{
System.out.println("接口中的方法默认实现方式");
}
}
