2021-03-06:java第十天：抽象类和接口的知识

抽象类的图解：

 

抽象方法和抽象类的使用：

父类：

package Day_10;
/*
抽象方法：就是加上abstract关键字，然后去掉大括号，直接分号结束
抽象类；抽象方法所在的类，必须是抽象类才行。在class之前写上abstract即可
如何使用抽象类和抽象方法：
1.不能直接创建new抽象类对象
2.必须用一个子类来继承抽象父类
3.子类必须覆盖重写抽象父类当中所有的抽象方法
覆盖重写（实现）：子类去掉抽象方法的abstract关键字，然后补上方法体大括号
4.创建子类对象进行使用
*/
public abstract class Animal {
    //这是一个抽象方法，代表吃东西，但是具体吃什么（大括号的内容）不确定
    public abstract void eat();
    //普通的成员方法
    public void normalMethod(){

    }
}

 

子类：

package Day_10;

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

主程序：

package Day_10;

public class demo01 {
    public static void main(String[] args) {
        //Animal animal = new Animal();
        //不能直接创建抽象对象
        Cat cat = new Cat();
        cat.eat();
    }
}

 

抽象方法和抽象类的注意事项：

 

父类：

package Day_10.demo03;

public abstract class Animal {
    public abstract void sleep();
    public abstract void eat();
}

子类：

package Day_10.demo03;
//子类也是一个抽象类
public abstract class Dog extends Animal{

    public abstract void sleep();

    @Override
    public void eat() {
        System.out.println("狗吃东西");
    }
}

孙子类：1.金毛

package Day_10.demo03;

public class DogGolden extends Dog{

    @Override
    public void sleep() {
        System.out.println("呼呼呼");
    }
}

2.二哈

package Day_10.demo03;

public class Dong2Ha extends Dog{
    @Override
    public void sleep() {
        System.out.println("嘿嘿嘿");
    }
}

主方法类：

package Day_10.demo03;

public class demomain {
    public static void main(String[] args) {
        //Animal animal = new Animal();
        //Dog dog = new Dog();
        //错误，两个都是抽象类
        Dong2Ha ha = new Dong2Ha();//普通类，可以直接new对象
        ha.sleep();
        ha.eat();
        DogGolden golden = new DogGolden();
        golden.sleep();
        golden.eat();
    }
}

 

发红包实例：

父类：

package Day_10.demo04;

public class User {
    private String name;
    private int money;

    public User() {
    }

    public User(String name, int money) {
        this.name = name;
        this.money = money;
    }
    public void show(){
        System.out.println("我叫："+getName()+"有多少钱："+getMoney());
    }
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }
}

子类群主；

package Day_10.demo04;

import java.util.ArrayList;
//群主的类
public class Manager extends User{
    public Manager(){
    }

    public Manager(String name, int money) {
        super(name, money);
    }
    public ArrayList send(int totalMoney, int count){
        //首先需要一个集合，存储若干个红包的金额
        ArrayList redList = new ArrayList<>();
        //看看群主有多少钱
        int leftMoney = super.getMoney();//群主余额
        if(totalMoney > leftMoney){
            System.out.println("余额不足");
            return redList; //返回空集合
        }
        //扣钱，其实就是重新设置余额
        super.setMoney(leftMoney - totalMoney);
        //发红包需要平均拆分成count份；
        int avg = totalMoney/count;
        int mod = totalMoney%count;//零头
        //零头包在最后一个红包里
        for (int i = 0; i < count-1; i++) {
            redList.add(avg);
        }
        redList.add(avg+mod);
        return redList;
    }
}

子类成员：

package Day_10.demo04;

import java.util.ArrayList;
import java.util.Random;

public class Member extends User{
    public Member() {
    }

    public Member(String name, int money) {
        super(name, money);
    }
    public void receive(ArrayList list){
        //从多个红包当中抽取一个
        //获取一个List的索引编号
        int index = new Random().nextInt(list.size());
        //根据索引从集合当中删除，得到被删除的红包给我自己
        Integer delta = list.remove(index);
        //当前成员本来有多少钱
        int money = super.getMoney();
        super.setMoney(money+delta);
    }
}

主程序类：

package Day_10.demo04;

import java.util.ArrayList;

public class MainRedPacket {
    public static void main(String[] args) {
        Manager manager = new Manager("群主",100);
        Member one = new Member("A",0);
        Member two = new Member("B",0);
        Member three = new Member("C",0);
        //群主发70块钱，3个红包
        ArrayList red = manager.send(70,3);
        one.receive(red);
        two.receive(red);
        three.receive(red);
        //看看每个人有多少钱
        one.show();
        two.show();
        three.show();
        manager.show();
    }
}

接口概述与生活举例：

接口的抽象方法定义：

 

接口：

package Day_10.demo05;
/*
接口中的抽象方法：
在任何版本的java中，接口都能定义抽象方法：
格式
public abstract 返回值类型 方法名称（参数列表）;
注意事项：
1.接口当中的抽象方法，修饰符必须是两个固定的关键字：public abstract
2.这两个关键字修饰符，可以选择性地省略
3.方法的三要素，可以随意定义
 */
public interface MyInterfaceAbstract {
    //这是一个抽象方法
    public abstract void methodAbs();
    void methodAbs1();
}

接口实现：

package Day_10.demo05;
//实现该接口，接口名字+Impl
public class MyInterfaceAbstractImpl implements MyInterfaceAbstract{

    @Override
    public void methodAbs() {
        System.out.println("第一个方法");
    }

    @Override
    public void methodAbs1() {
        System.out.println("第二个方法");
    }
}

Main方法：

package Day_10.demo05;
/*
接口就是多个类的公共规范
接口十一红引用数据类型，最重要的内容就是其中的抽象方法

如何定义一个接口的格式：
public interface 接口名称{
    //接口内容
}
备注：换成了关键字interface之后，编译生成的字节码文件仍然是: .java --> .class
如果是java 7,那么接口中可以包含的内容有
1.常量
2.抽象方法

如果是Java8，还可以额外包含有
3.默认方法
4.静态方法

如果是Java9,还可以额外包含有
5.私有方法

接口使用步骤：
1.接口不能直接使用，必须有一个”实现类“来实现该接口
格式：
//public class 子类 extends 父类
相似：
public class 实现类名称 implements 接口名称{
//...
}
2.接口的实现类必须覆盖重写接口中所有的抽象方法
去掉abstract关键字，加上方法体大括号
3.创建实现类的对象，进行使用

注意事项：
如果实现类并没有覆盖重写接口中所有的抽象方法，那么这个实现类自己就必须是抽象类
 */
public class demo05Interface {
    public static void main(String[] args) {
        //MyInterfaceAbstract inter = new MyInterfaceAbstract();
        MyInterfaceAbstractImpl impl = new MyInterfaceAbstractImpl();
        impl.methodAbs();
        impl.methodAbs1();
    }
}

如果Interface,接口升级了，接口实现除了Override,还可以用default在Interface里使用

 

package Day_10.demo05;
/*
从Java 8开始，接口里允许定义默认方法。
格式：
public default 返回值类型 方法名称(参数列表){
    方法体
}
备注：接口当中的默认方法，可以解决接口升级的问题
 */
public interface MyInterfaceDefault {
    public abstract void methodAbs();
    //public abstract void methodAbs2();
    //新添加的方法，改成默认方法。这里的public也能省略
    public default void methodDefault(){
        System.out.println("这是新添加的默认方法");
    }
}

package Day_10.demo05;

public class MyInterfaceDefaultA implements MyInterfaceDefault{

    @Override
    public void methodAbs() {
        System.out.println("实现了抽象方法，AAA");
    }
}

package Day_10.demo05;

public class MyInterfaceDefaultB implements MyInterfaceDefault{

    @Override
    public void methodAbs() {
        System.out.println("实现了抽象方法，BBB");
    }
    @Override
    public void methodDefault(){
        System.out.println("实现类B覆盖重写了接口的默认方法");
    }
}

主程序：

package Day_10.demo05;
/*
1.接口的默认方法，可以通过接口实现类对象，直接调用
2.接口的默认方法，也可以被接口实现类进行覆盖重写。
 */
public class demo06Interface {
    public static void main(String[] args) {
        //默认方法会被实现类继承下去
        MyInterfaceDefaultA a = new MyInterfaceDefaultA();
        a.methodAbs();//调用抽象方法，实际运行的是右侧实现类
        //调用默认方法，如果实现类当中没有，会向上找接口的
        a.methodDefault();

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

接口的静态方法：

package Day_10.demo05;
/*
从Java 8开始，接口当中允许定义静态方法。
格式：
public static 返回值类型 方法名称(参数列表){
    方法体
}
提示：就是将abstract或者default换成static即可，带上方法体
 */
public interface MyInterfaceStatic {
    public static void methodStatic(){
        System.out.println("这是接口的静态方法");
    }
}

package Day_10.demo05;

public class MyInterfaceStaticImpl implements MyInterfaceStatic{

}

package Day_10.demo05;
/*
注意：不能通过接口实现类的对象来调用接口当中的静态方法
原因：一个类可以继承多个接口。多个接口当中的静态方法有可能会产生冲突
正确用法：通过接口名称，直接调用其中的静态方法
格式：
接口名称.静态方法名(参数);

静态跟对象无关，仅跟类有关
 */
public class demo07Interface {
    public static void main(String[] args) {
        //创建了实现类对象
        MyInterfaceStaticImpl impl = new MyInterfaceStaticImpl();
        // impl.methodStatic(); 错误写法

        //正确写法应该直接通过接口名称调用静态方法
        MyInterfaceStatic.methodStatic();
    }
}

 

接口的私有(静态)方法使用：

package Day_10.demo05;
/*
问题描述：
我们需要抽取一个公共方法，用来解决两个默认方法之间重复代码的问题
但是这个共有方法不应该让实现类使用，应该是私有化的

解决方法：
从Java 9开始，接口当中允许定义私有方法
1.普通私有方法，解决多个默认方法之间重复代码问题
private 返回值类型 方法名称(参数列表){}
2.静态私有方法，解决多个静态方法之间重复代码问题
private static 返回值类型 方法名称(参数列表){}
 */
public interface MyInterfacePrivateA {
    public default void methodDefault1(){
        System.out.println("默认方法1");
        methodCommon();
    }
    public default void methodDefault2(){
        System.out.println("默认方法2");
        methodCommon();
    }
    private void methodCommon(){
        System.out.println("AAA");
        System.out.println("BBB");
        System.out.println("CCC");
    }
}

 

package Day_10.demo05;

public interface MyInterfacePrivateB {
    public static void methodDeafault1(){
        System.out.println("默认方法1");
        methodStaticCommon();
    }
    public static void methodDefault2(){
        System.out.println("默认方法2");
        methodStaticCommon();
    }
    private static void methodStaticCommon(){
        System.out.println("AAA");
        System.out.println("BBB");
        System.out.println("CCC");
    }
}

package Day_10.demo05;
/*
注意：不能通过接口实现类的对象来调用接口当中的静态方法
原因：一个类可以继承多个接口。多个接口当中的静态方法有可能会产生冲突
正确用法：通过接口名称，直接调用其中的静态方法
格式：
接口名称.静态方法名(参数);

静态跟对象无关，仅跟类有关
 */
public class demo07Interface {
    public static void main(String[] args) {
        //创建了实现类对象
        MyInterfaceStaticImpl impl = new MyInterfaceStaticImpl();
        // impl.methodStatic(); 错误写法

        //正确写法应该直接通过接口名称调用静态方法
        MyInterfaceStatic.methodStatic();
    }
}

接口中的常量：

package Day_10.demo05;
/*
接口当中也可以定义”成员变量“，但是必须使用public static final三个关键字进行修饰
从效果上看，这其实就是接口的常量
格式：
public static final 数据类型 常量名称 = 数据值;
备注：
注意：一旦使用final进行修饰，说明不可改变
注意事项：
1.接口当中的常量，可以省略 public static final，注意，不写也照样是这样
2.接口当中的常量，必须进行赋值，不能不赋值
3.接口中常量的名称，使用完全大写的字母，用下划线进行分隔。(推荐命名规则)
 */
public class MyInterfaceConst {
    //这其实就是一个常量，一旦赋值，不可以修改
    public static final int NUM_OF_MY_CLASS = 10;
}

 

package Day_10.demo05;

public class demo08Interface {
    public static void main(String[] args) {
        System.out.println(MyInterfaceConst.NUM_OF_MY_CLASS);
    }
}

 

默认方法就是实现类已经写好，但接口想要更新。加default不用改变实现类

静态方法用接口进行调用

私有方法的原因是减少接口里的重复代码，又不想被实现类所调用

 

继承父类并实现多个接口：

 

接口实现可以继承两个不同接口，但如果接口的默认方法在Interface里重复了，在接口实现里面必须覆盖重写

package Day_11;

public interface MyInterfaceA {
    //错误写法，接口不能有静态代码块
    //static {}
    //接口不能有构造方法
    //public MyInterface{}
    public abstract void methodA();
    public abstract void methodAbs();
    public default void methodDefault(){
        System.out.println("默认方法AAA");
    }
}

package Day_11;

public interface MyInterfaceB {
    //错误写法，接口不能有静态代码块
    //static {}
    //接口不能有构造方法
    //public MyInterface{}
    public abstract void methodB();
    public abstract void methodAbs();
    public default void methodDefault(){
        System.out.println("默认方法BBB");
    }
}

package Day_11;

public class MyInterfaceImpl implements MyInterfaceA, MyInterfaceB{
    @Override
    public void methodA() {
        System.out.println("覆盖重写A方法");
    }

    @Override
    public void methodB() {
        System.out.println("覆盖重写B方法");
    }
    @Override
    public void methodAbs(){
        System.out.println("覆盖重写AB都有的抽象方法");
    }

    @Override
    public void methodDefault() {
        System.out.println("对多个接口当中冲突的默认方法进行覆盖重写");
    }
}

 

如果没有实现接口里的所有抽象方法，那么这个接口实现类只能是抽象类

 

package Day_11;

public abstract class MyInterfaceAbstract implements MyInterfaceA,MyInterfaceB{
    @Override
    public void methodA() {

    }



    @Override
    public void methodAbs() {

    }

    @Override
    public void methodDefault() {

    }
}

如果一个类又继承了父类又继承了接口，且父类方法中和接口方法重复， 那么先用父类里的方法

package Day_11;

public interface MyInterface {
    public default void method(){
        System.out.println("接口的默认方法");
    }
}

package Day_11;

public class Fu {
    public void method(){
        System.out.println("Fu方法");
    }
}
package Day_11;

public class Zi extends Fu implements MyInterface{
    //优先Fu类的同名方法

 }

package Day_11;
/*
使用接口的时候，需要注意：
1.接口是没有静态代码块或者构造方法的
2.一个类的直接父类是唯一的，但是一个类可以同时实现多个接口
格式：
public class MyInterfaceImpl implements MyInterfaceA,MyInterfaceB{}
//覆盖重写所有抽象方法
3.如果实现类所实现的多个接口当中，存在重复的抽象方法，那么只需要覆盖重写一次即可。
4.如果实现类没有覆盖重写所有接口当中的所有抽象方法，那么实现类必须是抽象类
5.如果实现类实现的多个接口当中，存在重复的默认方法，那么实现类一定要对冲突的默认方法进行覆盖重写
6.一个类如果直接父类当中的方法，和接口当中的默认方法产生了冲突，优先用父类当中的方法
 */

public class demo01Interface {
    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.method();//父类方法 （接口其次）
    }

}

接口与接口之间的多继承关系：

package Day_11.demo02;

public interface MyInterfaceA {
    public abstract void methodA();

    public abstract void methodcommon();
    public default void methodDefault(){
        System.out.println("AAA");
    }
}

package Day_11.demo02;

public interface MyInterfaceB {
    public abstract void methodB();

    public abstract void methodcommon();

    public default void methodDefault(){
        System.out.println("BBB");
    }
}

//同时继承接口AB：

package Day_11.demo02;
/*
这个子接口当中有几个方法？
4个：
methodA 接口A
methodB 接口B
methodcommon 同时类源于接口A和B
method 来源于我自己

 */
public interface MyInterface extends MyInterfaceA,MyInterfaceB{
    public abstract void method();

    @Override
    public default void methodDefault() {
        //这里的default不能删掉
    }
}


//对应的接口实现类：

package Day_11.demo02;

public class MyInterfaceImpl implements MyInterface{

    @Override
    public void method() {

    }

    @Override
    public void methodA() {

    }

    @Override
    public void methodB() {

    }

    @Override
    public void methodcommon() {

    }
}

package Day_11.demo02;
/*
1.类与类之间是单继承的，直接父类只有一个
2.类与接口之间是多实现的，一个类可以实现多个接口
3.接口与接口之间是多继承的

注意事项：
1.多个父接口当中的抽象方法如果重复，没关系
2.多个父接口当中的默认方法如果重复，就有问题
那么子接口必须进行默认方法的覆盖重写，而却带着default关键字
 */
public class demo01Relations {
}