Day06_重写和重载、抽象类、接口

1.重写和重载

1.重要知识点

重写（Override）：方法的名称一样，参数列表【也一样】。覆盖、覆写。
重载（Overload）：方法的名称一样，参数列表【不一样】。

方法覆盖重写的注意事项：
1. 必须保证父子类之间方法的名称相同，参数列表也相同。
@Override：写在方法前面，用来检测是不是有效的正确覆盖重写。

2. 子类方法的返回值必须【小于等于】父类方法的返回值范围。
小扩展提示：java.lang.Object类是所有类的公共最高父类（祖宗类），比如你学习的java.lang.String就是Object的子类。

3. 子类方法的权限必须【大于等于】父类方法的权限修饰符。
小扩展提示：public > protected > (default) > private

1.@Override：写在方法前面，用来检测是不是有效的正确覆盖重写。

2.java.lang.Object类是所有类的公共最高父类（祖宗类），比如你学习的java.lang.String就是Object的子类。

父类你写了一个method方法（父类的返回值是Object）
public Object method() {
    
    
        return null;
    }
子类你重写了父类的method方法（子类的返回值是String）
@Override
public String method() {
    
    
        return null;
    }
这是正确的，因为子类的返回值小于等于父类



父类你写了一个method方法（父类的返回值是Sting）
public String method() {
    
    
        return null;
    }
子类你重写了父类的method方法（子类的返回值是Object）
@Override
public Object method() {
    
    
        return null;
    }
这是错误的，因为子类的返回值是Object意味着就可以是int可以是string，远大于父类给的范围

3. 子类方法的权限必须【大于等于】父类方法的权限修饰符。
小扩展提示：public > protected > (default) > private

父类你写了一个method方法（父类的权限是public）
public String method() {
    
    
        return null;
    }
子类你重写了父类的method方法（子类的权限是private）
@Override
private String method() {
    
    
        return null;
    }
这是错误的，因为子类权限缩小了


父类不写权限（default），那么子类可以写成public
String method() {
    
    
        return null;
    }
子类
public String method() {
    
    
        return null;
    }

绝大多数的，良好的编程习惯就是子类和父类的返回值和权限是相等关系

2.例题

// 本来的老款手机
public class Phone {
    
    

    public void call() {
    
    
        System.out.println("打电话");
    }

    public void send() {
    
    
        System.out.println("发短信");
    }

    public void show() {
    
    
        System.out.println("显示号码");
    }

}

// 定义一个新手机，使用老手机作为父类
public class NewPhone extends Phone {
    
    
    @Override
    public void show() {
    
    
        super.show(); // 把父类的show方法拿过来重复利用
        // 自己子类再来添加更多内容
        System.out.println("显示姓名");
        System.out.println("显示头像");
    }
}

public class Demo01Phone {
    
    
    public static void main(String[] args) {
    
    
        Phone phone = new Phone();
        phone.call();
        phone.send();
        phone.show();
        System.out.println("==========");

        NewPhone newPhone = new NewPhone();
        newPhone.call();
        newPhone.send();
        newPhone.show();
    }
}

2.抽象类

1.知识点

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

1.不能直接创建new抽象类对象。

public abstract class Animal {
    
    

    public abstract void eat();
    
}

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

}

public class DemoMain {
    
    
    public static void main(String[] args) {
    
    
//        Animal animal = new Animal(); // 错误写法！不能直接创建抽象类对象

        Cat cat = new Cat();
        cat.eat();
    }

}

2.子类必须覆盖重写抽象父类当中所有的抽象方法。
（和接口一样，必须覆盖重写接口当中所有的抽象方法）

3.一个抽象类不一定含有抽象方法，
只要保证抽象方法所在的类是抽象类，即可。

public abstract class Animal {
    
    

    // 这是一个抽象方法，代表吃东西，但是具体吃什么（大括号的内容）不确定。
    public abstract void eat();

    // 这是普通的成员方法
    public void normalMethod() {
    
    
		System.out.println("我不是抽象方法但我可以在抽象类中");
    }
}

public class Animal {
    
    

    // 错误，这是一个抽象方法，但这个类却不是抽象类
    public abstract void eat();

    // 这是普通的成员方法
    public void normalMethod() {
    
    
		System.out.println("123");
    }
}

2.例题

发红包的方法：
要把一分钱分成几个小份，那就需要一个ArrayList<Integer>
定义一个方法，输入的参数是（总共发多少钱，分成几份），返回值是ArrayList<Integer>
即public ArrayList<Integer> send(int totalMoney,int count){
    
       }


收红包的方法：
你要从ArrayList<Integer>中随机选一个金额
参数就是这个ArrayList<Integer>，返回值是空
public void receive(ArrayList<Integer>){
    
        }

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("我叫：" + name + "，我有多少钱：" + money);
    }

    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;
    }
}

import java.util.ArrayList;

// 群主的类
public class Manager extends User {
    
    

    public Manager() {
    
    
    }

    public Manager(String name, int money) {
    
    
        super(name, money);
    }

    public ArrayList<Integer> send(int totalMoney, int count) {
    
    
        // 首先需要一个集合，用来存储若干个红包的金额
        ArrayList<Integer> 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);
        }

        // 最后一个红包
        int last = avg + mod;
        redList.add(last);

        return redList;
    }
}

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<Integer> list) {
    
    
        // 从多个红包当中随便抽取一个，给我自己。
        // 随机获取一个集合当中的索引编号
        int index = new Random().nextInt(list.size());
        // 根据索引，从集合当中删除，并且得到被删除的红包，给我自己
        int delta = list.remove(index);
        // 当前成员自己本来有多少钱：
        int money = super.getMoney();
        // 加法，并且重新设置回去
        super.setMoney(money + delta);
    }
}

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);

        manager.show(); // 100
        one.show(); // 0
        two.show(); // 0
        three.show(); // 0
        System.out.println("===============");

        // 群主总共发20块钱，分成3个红包
        ArrayList<Integer> redList = manager.send(20, 3);
        // 三个普通成员收红包
        one.receive(redList);
        two.receive(redList);
        three.receive(redList);

        manager.show(); // 100-20=80
        // 6、6、8，随机分给三个人
        one.show();
        two.show();
        three.show();
    }

}

3.接口

1.关于接口的名字

接口的名字是MyInterAbstract，那么实现了这个接口的类名应该是MyInterAbstractImpl（即“接口名+Impl”）。

---

2.如何定义一个接口

public interface 接口名称 {
    
    
    // 接口内容
}

接口内容可以写什么呢？

• 可以写抽象方法
  • 可以写抽象方法。接口当中的抽象方法，修饰符必须是两个固定的关键字：public abstract，当然，可以省略。
  • 也就是说public abstract void methodAbs1();等价于abstract void methodAbs2();也等价于public void methodAbs3();还等价于void methodAbs4();
  • 你在接口里面见到的void methodAbs4();就是public abstract void methodAbs1();就是抽象方法
• 也可以写默认方法（见5.接口的默认方法）
• 也可以写静态方法（见6.接口的静态方法）
• 也可以写私有方法（见7.接口的私有方法）
• 也可以写常量（见8.接口的常量）

---

3.接口的实现类必须覆盖重写（实现）接口中所有的抽象方法。

• 如果实现类并没有覆盖重写接口中所有的抽象方法，那么这个实现类自己就必须是抽象类。
• 接口的快捷键Alt+Enter你不会不知道吧？见IDEA的使用

public interface MyInterfaceAbstract {
    
    
    
    public abstract void methodAbs1();
    public abstract void methodAbs2();
    public abstract void methodAbs3();
    public abstract void methodAbs4();
    
}

public class MyInterfaceAbstractImpl implements MyInterfaceAbstract {
    
    
    @Override
    public void methodAbs1() {
    
    
        System.out.println("这是第一个方法！");
    }

    @Override
    public void methodAbs2() {
    
    
        System.out.println("这是第二个方法！");
    }

    @Override
    public void methodAbs3() {
    
    
        System.out.println("这是第三个方法！");
    }

    @Override
    public void methodAbs4() {
    
    
        System.out.println("这是第四个方法！");
    }
}

4.不能直接创建new接口对象，只能new已经实现了的接口方法

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

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

}

5.接口的默认方法

public interface MyInterfaceDefault {
    
    

    // 抽象方法
    public abstract void methodAbs();
}

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

public class MyInterfaceDefaultB implements MyInterfaceDefault {
    
    
    @Override
    public void methodAbs() {
    
    
        System.out.println("实现了抽象方法，BBB");
    }
}

如上面的代码所示，接口MyInterfaceDefault只有一个抽象方法，然后MyInterfaceDefaultA和MyInterfaceDefaultB分别实现了该接口，

如果此时接口升级了，他多了一个功能，多了一个抽象方法methodAbs2();如下：
public interface MyInterfaceDefault {
    
    

    // 抽象方法
    public abstract void methodAbs();

    // 新添加了一个抽象方法
    public abstract void methodAbs2();
}
此时MyInterfaceDefaultA和MyInterfaceDefaultB也必须实现该接口中的抽象方法methodAbs2()，而这两个已经投入使用了，你要是改写它们你将付出巨大的代价

为了解决上述问题，引进了接口的默认方法，默认的方法会被实现该接口的类继承下去

public default 返回值类型 方法名称(参数列表) {
    
    
    方法体
}

备注：接口当中的默认方法，可以解决接口升级的问题。

public interface MyInterfaceDefault {
    
    

    // 抽象方法
    public abstract void methodAbs();

    // 新添加的方法，改成默认方法，默认的方法会被实现该接口的类继承下去
    public default void methodDefault() {
    
    
        System.out.println("这是新添加的默认方法");
    }
}

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

public class MyInterfaceDefaultB implements MyInterfaceDefault {
    
    
    @Override
    public void methodAbs() {
    
    
        System.out.println("实现了抽象方法，BBB");
    }
}

public class Demo02Interface {
    
    

    public static void main(String[] args) {
    
    

        // 创建了实现类对象
        MyInterfaceDefaultA a = new MyInterfaceDefaultA();
        a.methodAbs(); 

        // 尽管MyInterfaceDefaultA没有实现该methodDefault()方法，但它会向上找
        a.methodDefault(); // 这是新添加的默认方法
        System.out.println("==========");

        MyInterfaceDefaultB b = new MyInterfaceDefaultB();
        b.methodAbs();
        b.methodDefault(); // 实现类B覆盖重写了接口的默认方法
    }

}

接口的默认方法，也可以被接口实现类进行覆盖重写。

public interface MyInterfaceDefault {
    
    

    // 抽象方法
    public abstract void methodAbs();

    // 接口的默认方法
    public default void methodDefault() {
    
    
        System.out.println("这是新添加的默认方法");
    }
}


public class MyInterfaceDefaultB implements MyInterfaceDefault {
    
    
    @Override
    public void methodAbs() {
    
    
        System.out.println("实现了抽象方法，BBB");
    }

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

6.接口的静态方法

public static 返回值类型 方法名称(参数列表) {
    
    
    方法体
}

注意事项：不能通过接口实现类的对象来调用接口当中的静态方法。
正确用法：通过接口名称，直接调用其中的静态方法。[接口名称.静态方法名(参数);]

public interface MyInterfaceStatic {
    
    

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

}

public class MyInterfaceStaticImpl implements MyInterfaceStatic {
    
    
		//接口的静态方法可以不覆盖重写
}


public class Demo03Interface {
    
    
    public static void main(String[] args) {
    
    
        // 创建了实现类对象
        MyInterfaceStaticImpl impl = new MyInterfaceStaticImpl();

        // 错误写法！，不能通过接口实现类的对象来调用接口当中的静态方法。
        impl.methodStatic();

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

}

7.接口的私有方法

1. 普通私有方法，解决多个默认方法之间重复代码问题
格式：
private 返回值类型 方法名称(参数列表) {
    
    
    方法体
}

2. 静态私有方法，解决多个静态方法之间重复代码问题
格式：
private static 返回值类型 方法名称(参数列表) {
    
    
    方法体
}

看一下下面的啰嗦代码

public interface MyInterfacePrivateA {
    
    

    public default void methodDefault1() {
    
    
        System.out.println("默认方法1");
        System.out.println("AAA");
        System.out.println("BBB");
        System.out.println("CCC");
    }

    public default void methodDefault2() {
    
    
        System.out.println("默认方法2");
        System.out.println("AAA");
        System.out.println("BBB");
        System.out.println("CCC");
    }
}

改良后

public interface MyInterfacePrivateA {
    
    

    public default void methodDefault1() {
    
    
        System.out.println("默认方法1");
        methodCommon();
    }

    public default void methodDefault2() {
    
    
        System.out.println("默认方法2");
        methodCommon();
    }

    public default void methodCommon() {
    
    
        System.out.println("AAA");
        System.out.println("BBB");
        System.out.println("CCC");
    }

}

上述代码也有问题，你有三个public default，而public default子类是可以访问的，第三个没有必要让子类知道啊，它应该私有化

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");
    }

}

当然，default也可以换成static

public interface MyInterfacePrivateB {
    
    

    public static void methodStatic1() {
    
    
        System.out.println("静态方法1");
        methodStaticCommon();
    }

    public static void methodStatic2() {
    
    
        System.out.println("静态方法2");
        methodStaticCommon();
    }

    private static void methodStaticCommon() {
    
    
        System.out.println("AAA");
        System.out.println("BBB");
        System.out.println("CCC");
    }

}

总之就一句话，多个static重复了那就用private，多个默认重复了那就用private

8.接口的常量

接口的【常量】必须使用public static final三个关键字进行修饰,一旦使用final关键字进行修饰，说明不可改变。
public static final 数据类型 常量名称 = 数据值;

注意事项：
1. 接口当中的常量，可以省略public static final，注意：不写也照样是这样。换句话说接口中只有常量没有变量。
2. 接口中常量的名称，使用完全大写的字母，用下划线进行分隔。（推荐命名规则）
3. 接口中的常量必须进行赋值，一旦赋值就不能再变了。

public interface MyInterfaceConst {
    
    

    // 这其实就是一个常量，一旦赋值，不可以修改
    public static final int NUM_OF_MY_CLASS = 12;

}

9.一个类可以同时实现多个接口

1. 一个类的直接父类是唯一的，但是一个类可以同时实现多个接口。
   格式：

public class MyInterfaceImpl implements MyInterfaceA, MyInterfaceB {
    
    
    // 覆盖重写所有抽象方法
}

2. 如果实现类所实现的多个接口当中，存在重复的抽象方法，那么只需要覆盖重写一次即可。
3. 如果实现类没有覆盖重写所有接口当中的所有抽象方法，那么实现类就必须是一个抽象类。
4. 如果实现类锁实现的多个接口当中，存在重复的默认方法，那么实现类一定要对冲突的默认方法进行覆盖重写。
5. 一个类如果直接父类当中的方法，和接口当中的默认方法产生了冲突，优先用父类当中的方法。

public interface MyInterfaceA {
    
    

    public abstract void methodA();

    public abstract void methodAbs();

    public default void methodDefault() {
    
    
        System.out.println("默认方法AAA");
    }
}

public interface MyInterfaceB {
    
    

    public abstract void methodB();

    public abstract void methodAbs();

    public default void methodDefault() {
    
    
        System.out.println("默认方法BBB");
    }

}

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("对多个接口当中冲突的默认方法进行了覆盖重写");
    }
}

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

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

public class Zi extends Fu implements MyInterface {
    
    
}

public class Demo01Interface {
    
    
    public static void main(String[] args) {
    
    
        Zi zi = new Zi();
        zi.method();//会优先使用了父类方法
    }
}

9.有好几个父亲的接口

1. 类与类之间是单继承的。直接父类只有一个。
2. 类与接口之间是多实现的。一个类可以实现多个接口。
3. 接口与接口之间是多继承的。

注意事项：
1. 多个父接口当中的抽象方法如果重复，没关系。
2. 多个父接口当中的默认方法如果重复，那么子接口必须进行默认方法的覆盖重写，【而且带着default关键字】。

public interface MyInterfaceA {
    
    

    public abstract void methodA();

    public abstract void methodCommon();

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

}

public interface MyInterfaceB {
    
    

    public abstract void methodB();

    public abstract void methodCommon();

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

}

public interface MyInterface extends MyInterfaceA, MyInterfaceB {
    
    

    public abstract void method();

    @Override
    public default void methodDefault() {
    
    
 		//多个父接口当中的默认方法如果重复，那么子接口必须进行默认方法的覆盖重写
    }
}

10.一个接口也可以作为方法的参数或返回值

所以我们写了如下的代码：

import java.util.ArrayList;
import java.util.List;


public class DemoInterface {
    
    

    public static void main(String[] args) {
    
    
    
        // 左边是接口名称，右边是实现类名称，这就是多态写法
        List<String> list = new ArrayList<>();//这是典型的多态啊

        List<String> result = addNames(list);
        for (int i = 0; i < result.size(); i++) {
    
    
            System.out.println(result.get(i));
        }
    }

	//返回值是List<String>输入的参数也是List<String>，没什么不可以吧？，同时List<String>是一个接口，它作为了参数又作为了返回值
    public static List<String> addNames(List<String> list) {
    
    
        list.add("迪丽热巴");
        list.add("古力娜扎");
        list.add("玛尔扎哈");
        list.add("沙扬娜拉");
        return list;
    }

}