Java抽象和接口

抽象 知道有方法 但是不知道具体
比如动物类有吃的方法，但是不具体到猫狗 所以是抽象 要用关键词 abstract 并且删掉括号
猫类吃鱼 狗类吃狗头
注意 抽象方法所在类 必须是抽象类 在class之前写上abstract 即可

1不能直接创建new抽象类对象
2必须用一个子类来继承抽象父类
3 子类必须覆盖重写抽象父类当中的所有抽象方法
覆盖重写（实现）：子类去掉抽象方法的abstract关键字，然后补上方法体大括号
4创建子类对象进行使用

public abstract class Animal{
//这是一个抽象的方法
public abstract void eat();
}

public class Cat extends Animal{
public void eat(){
System.out.println("猫吃鱼")；
}
}

public class Demo{
public static void main(String[] args){
//Animal animal =new Animal();错误写法
Cat cat =new Cat();
cat.eat();
}
}

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

接口(Interface)是一种引用数据类型，是多个类的公共规范
如何定义一个接口
public interface 接口名称{

}
注意
1接口当中的抽象方法 修饰符必须是两个固定的关键字 public abstract
2 这两个关键字修饰符 可以选择性地忽略
3方法的三要素可以随意定义

接口中可以包含的内容
1常量
2抽象方法
3默认方法
4静态方法
5私有方法

接口使用步骤：
1接口不能直接使用，必须有一个“实现类”来实现该接口。
public class 实现类名称 implements 接口名称{
//…
}
2 接口的实现类必须覆盖重写（实现）接口中所有的抽象方法
去掉abstract关键字，加上方法体大括号
3创建实现类的对象，进行使用。
注意
如果实现类 并没有覆盖重写接口中的所有抽象方阿飞，那么这个实现类自己就必须是抽象类

public interface MyInterfaceAbstract{
//这是一个抽象方法
public abstract void methodAbs1();

//这也是抽象方法
abstract void methodAbs2();

// 这也是抽象方法
public void methodAbs3();

// 这也是抽象方法
void methodAbs4();
}

public class MyInterfaceABstractImpl implements MyInterfaceAbstract{
//2 方法重写
public void methodAbs1(){
System.out.println("这是第一个方法！");
}
public void methodAbs2(){
System.out.println("这是第二个方法！");
}
public void methodAbs3(){
System.out.println("这是第三个方法！");
}
public void methodAbs4(){
System.out.println("这是第四个方法！");
}

public class Demo{
public static void main(String[] args){
//错误写法 不能直接new接口对象使用
MyInterfaceABstract inter=new MyINterfaceAbstract();

//创建实现类的对象使用
MyInterfaceAbstractImpl impl=new MyInterfaceAbstractImpl();

impl.methodAbs1();
impl.methodAbs2();
impl.methodAbs3();
impl.methodAbs4();
}
}
}

//从java 8开始 接口里允许定义默认方法。
//格式：
//public default 返回值类型 方法名称 方法名称（参数列表）{
        方法体
}
//备注 接口当中的默认方法 是可以解决接口升级的问题 
1是可以通过接口实现类对象，直接调用
2接口的默认方法，可以不用写进实现类里面 ，实现类必须对所有抽象方法进行覆盖重写，不然会报错，用默认方法就解决了这个问题,也可以被接口实现类进行覆盖重写


public interface MyInterfaceDefault{
//抽象方法
public abstract void methodAbs();
//新添加了一个抽象方法
//public abstract void methodAbs2();
//新添加的方法，改成默认方法
public default void methodDefault(){
System.out.println("这是新添加的默认方法")；
}
}


public class MyInterfaceDefaultA implements MyterfaceDefault{
public void methodAbs(){
System.out.println("实现了抽象方法，AAA")；
}
}


public class MYInterfaceltB implements MyterfaceDefault{
public void methodAbs(){
System.out.println("实现了抽象方法，BBB")
}

public class Demo02Interface{
public static void main(String[] args){
//创建实现类对象
MyInterfaceDefaultA a=new MyInterfaceDefauktA();
a.methodAbs();
//调用抽象方法，实际运行的是右侧的实现类
//调用默认方法 如果是实现类没有 就向上找接口
a.methodDefault();

MyInterfaceDefaultB b=new MyInterfaceDefaultB();
b.methodAbs();
b.methodDefault();
}
}
}

接口的静态方法
定义：
public static 返回值类型 方法名称（参数列表）{
方法体
//就是把abstract或者 default换成statuc 即可 带上方法体
}`
静态方法是直接 接口.方法 进行使用 不用创建对象

public interface MyInterfaceStatic
{
public static void methodStatic(){
System.out.println("这是接口的静态方法")；
}

public class MyInterfaceStaticImpl implements MyInterfaceStatic{

}
//注意//不能通过接口实现类的对象来调用接口当中的静态方法。
//正确用法 通过接口名称直接调用
//接口名称。静态方法名（参数）

public class Demo{
public static void main(sTring [] args){
//创建实现类对象
MyInterfaceStaticImpl impl=new MyInterfaceStaticImpl();
//错误写法！
impl.methodStatic();
//直接通过接口名称调用静态方法
MyInterfaceStatic.methodStatic();
}
//静态方法只跟类有关 直接类.方法名称就可以
//跟对象无关 不需要创建对象

}
}

接口的私有方法定义
我们需要抽取一个共有方法，用来解决两个方法之间的重复代码的问题。
但是这个共有方法不应该让实现类使用，应该是私有化。
1.普通私有方法
2.

public interface MyInterfacePrivateB{

public static void methodStatic1(){
System.out.prinitln("静态方法1")；
//System.out.prinitln("AAA")；
methodDefayltCommon();
}

public static void methodStatic2(){
System.out.prinitln("静态方法2")；
//System.out.prinitln("AAA")；
methodDefayltCommon();
}

private static void methodStaticCommon(){
System.out.prinitln("AAA")；
}


public class Demo {
public static void main(String[] args){
MyInterfaceprivateB.methodStatic1();
MyInterfaceprivateB.methodStatic2();
}
}
}

接口里面用到重复代码 就创建私有方法 把重复代码写进去
接口的使用是 类.方法 与对象无关
接口的定义
public interface MyInterfacePrivateB{
}