一继承

1.1概念

继承就是子类（派生类）继承父类（基类）的属性和行为，使得子类对象具有父类相同的属性(成员变量)和行为（成员方法），子类还可以访问父类中非私有的属性和行为。

class 父类{}
class 子类 entends 父类{}

1.2 继承的特点

1.Java只支持单继承，不是多继承（C++，Python),一个类只有一个父类
2.Java支持多层继承，顶级父类是Object类，所有的类默认都继承Object类，作为父类
3.子类和父类是一种相对的概念

继承可以提高代码的复用性

案例一：发红包

// 用户类
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("我叫" + this.name + "，我有" + this.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;
    }
}

// 成员类
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 receiveMoney = list.get(index);
//        list.remove(index);
        int delMoney = list.remove(index);
        // 查看当前会员有多少前
        int money = super.getMoney();
        // 重新设置一个余额
        super.setMoney(money+delMoney);
    }
}

// 群主类
public class Manager extends User{
    public Manager(){

    }
    public Manager(String name, int money){
        super(name, money);
    }
    //定义发红包
    public ArrayList<Integer> send(int totalMoney, int count){
        int lastRedBag = 0;
        ArrayList<Integer> list = new ArrayList<>();
        //查看群主有多少钱，余额不足要告诉一下
        int leftMoney = super.getMoney();
        if(totalMoney > leftMoney){
            System.out.println("您的余额不足");
            return list;
        }
        //扣钱
        super.setMoney(this.getMoney() - totalMoney);
        //发红包将红包分成count份
        int oneRedBag = totalMoney/count;
        //如果除不开，将零头放到最后一个红包里
        if(totalMoney % count != 0){
            lastRedBag = totalMoney - (count - 1) * oneRedBag;
        }else{
            lastRedBag = oneRedBag;
        }
        //将余额一个一个放到集合中
        for (int i = 0; i < count; i++) {
            if(i != count-1){
                list.add((int)oneRedBag);
            }else{
                list.add(lastRedBag);
            }
        }
        return list;
    }
}

测试类
public class MainRedPacket {
    public static void main(String[] args) {
        System.out.println("============");
        System.out.println("当前显示群里所有人的余额");
        // 一个群主100，三个成员0，0，0
        Manager manager = new Manager("群主", 100);
        Member member1 = new Member("一号成员", 0);
        Member member2 = new Member("二号成员", 0);
        Member member3 = new Member("三号成员", 0);
        manager.show();
        member1.show();
        member2.show();
        member3.show();
        System.out.println("============");
        System.out.println("请群主输入要发红包的金额"); //20  //8，6，6
        int money = new Scanner(System.in).nextInt();
        //发红包
        ArrayList<Integer> list = manager.send(money, 3);
        //收红包
        member1.receive(list);
        member2.receive(list);
        member3.receive(list);
        //显示余额
        manager.show();
        member1.show();
        member2.show();
        member3.show();
    }
}

1.3 子类中访问父类的内容

语法结构：
1: super(当前类名称,self).你要调的父类的属性或方法
2： super().你要调的父类的属性或方法
3: 你要调的父类的属性或方法(self)

1.4 继承后子类和父类的变化

继承相关图示

成员变量不重名：
如果子类父类中出现不重名的成员变量，访问时没有影响的
成员变量重名:
有影响，new子类时候调用的是子类的成员变量，想要调用父类的，要用super关键字，就像本类使用this一样。（父类中成员变量私有，我们可以通过get，set方法访问父类的成员变量）

案例二：

// 父类
public class Fu {
     int num = 5;
     }
}

// 子类
public class Zi extends Fu {
    int num = 6;
    public void show(){
        //想调用父类的成员变量，需要在前面加 super，不加super的话num = 6
        System.out.println("Fu num =" + num); //num = 6  , super.num = 5
        System.out.println("Zi num =" + num); // num = 6  , this.num = 6
    }
}

// 测试类
public class ExtendDemoTest02 {
    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.show();
    }
}

此时子类和父类的成员变量重名，调用show（）方法，输出的num都是子类的成员变量。想要调用父类的，要用super关键字，例 super.num。

成员方法不重名没影响，对象在调用方法时，会在子类中查找有没有对应的方法。没有就会去父类中找相应的方法去执行
成员方法重名子类中出现与父类一模一样的方法（返回值类型，方法名，参数列表都相同）---》会出现覆盖效果（也叫复写）----》声明不变，重新实现。

案例一：

// 父类
public class Fu {
     int num = 5;
     public void show(){
         System.out.println("父类的show方法执行");
     }
}

// 子类
public class Zi extends Fu {
    int num = 6;
    //重写 父类的方法建议使用该注解进行标识
    @Override
    public void show(){
        //想调用父类的成员变量，需要在前面加 super，不加super的话num = 6
        System.out.println("子类show方法被执行");
    }
}

// 测试类
public class ExtendDemoTest04 {
    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.show(); //子类show方法被执行
    }
}

案例二：新手机添加来电显示功能和头像显示功能

// 手机类
public class Phone {
    public void sendMessage(){
        System.out.println("发短信");
    }
    public void call(){
        System.out.println("打电话");
    }
    public void showNum(){
        System.out.println("来电显示");
    }
}

// 新型手机
public class NewPhone extends Phone{
    //重写父类的来电显示功能，并且增加自己的的显示姓名和图片功能
    @Override
    public void showNum(){
        //调用父类已经存在的功能使用super
        super.showNum();
        System.out.println("显示来电姓名");
        System.out.println("显示头像");
    }
}

构造方法
因为构造方法的名字和类名一致，所以子类无法继承父类的构造方法。构造方法的作用是初始化成员变量，所以子类初始化的过程中，必须先执行父类的初始化动作，子类的构造方法默认有一个super()，表示调用父类的构造方法，父类成员变量初始化后，才可以给子类使用。

案例一：

// 父类
public class FuGou {
    private int n;
    FuGou(){
        System.out.println("FuGou()");
    }
}

// 子类
public class ZiGou extends FuGou {
    ZiGou(){
        // 子类构造方法默认调用父类构造方法
//        super();
        System.out.println("ZiGou()");
    }
}

测试类
public class ExtendDemoTest07 {
    public static void main(String[] args) {
        FuGou fuGou = new FuGou(); // FuGou()
        ZiGou ziGou = new ZiGou(); // FuGou() ZiGou()
    }
}

案例二：

// 父类
public class Animal {
    Animal(){
        System.out.println("Animal()");
    }
    public void eat(){
        System.out.println("animal:eat");
    }
}

// 子类
public class Cat extends Animal{
    private String name;
    //无参构造函数
    Cat(){
        super();
        System.out.println("Cat()");
    }
    Cat(String name){
        // super();子类中每个均右super()，用来调用父类空参构造
        //手动调用父类的super()，会覆盖默认的super()
        //super()和this()都必须在构造方法的第一行
        super();
        //调用本来的构造方法
        // this()
        this.name = name;
        System.out.println("Cat" + name);
    }
    @Override
    public void eat(){
        System.out.println("cat:eat");
    }
    public void eatTest(){
        this.eat(); // this 调用本类的方法
        super.eat();
    }
}

// 测试类
public class ExtendDemoTest08 {
    public static void main(String[] args) {
//        Animal animal = new Animal();
//        animal.eat();
        Cat cat1 = new Cat("淘气猫"); //Animal()  Cat淘气猫
//        cat.eatTest();
    }
}

子类中每个均有super()，用来调用父类空参构造
手动调用父类的super()，会覆盖默认的super()
super()和this()都必须在构造方法的第一行，所以两者不能同时出现

1.5 抽象类

定义

1.抽象方法：没有方法主体的方法（没有{}
2.抽象方法的格式：使用abstract修饰的方法，就成了抽象方法，抽象方法只包含一个方法名，而没有方法体。
3.格式：修饰符 abstract 返回值类型方法名（参数列表）;

public abstract void run();

抽象类： 如果一个类包含抽象方法，那么该类必须是抽象类

public abstract class AnimalAb {
    //定义格式
    public abstract void run();
}

抽象类的使用： 继承抽象类的子类必须重写父类的所有抽象方法，否则该子类也必须是抽象类。最终必须有子类实现父类的抽象方法，否则从最初的父类到最终的子类都不能被new（创建），失去了意义。

二接口（Interface）

概述： Java中的一种引用类型，是方法的集合
接口主要封装了方法

1.JDK1.7及以前包含抽象方法
2.JDK8 默认方法和静态方法
3.JDK9 私有方法

定义

1.与类定义相似，使用interface修饰，也会编译成.class文件，但是接口不是类，而是另外一种引用数据类型
2.使用：不能被创建，但是可以被实现（implements,类似于extends）一个接口可以多实现
3.一个实现接口的子类需要实现接口所有的抽象方法，否则它就必须是一个抽象类

类与接口的实现关系

类实现接口，该类成为接口的实现类，也可以称为接口的子类，使用implements关键字

public class B implements A {
    //重写所有的抽象方法【必须】
    ///重写默认方法【可选】
}

接口格式

public interface 接口名{
  //抽象方法
 //默认方法
 //静态方法
 //私有方法
}

public interface A {
    //抽象方法
      public abstract void method();

    //默认方法 使用default修饰，不可以省略
    //功能是供子类调用或者子类重写
      public default void method(){
          //执行语句
     }

     //静态方法 使用static修饰，供接口直接调用
   public static void method2(){
        //执行语句
    }

    //私有方法
//含有私有方法和私有静态方法 ： 使用private修饰，供接口中的默认方法或者静态方法调用
    private void method(){
    }

}

案例一：

public interface Livable {
    //定义抽象方法
    public abstract void eat();
    public void sleep();
}

public class AnimalLivable implements Livable{
    @Override
    public void eat() {
        System.out.println("吃");
    }

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

public class InterfaceDemoTest {
    public static void main(String[] args) {
        AnimalLivable animalLivable = new AnimalLivable();
        animalLivable.eat();
        animalLivable.sleep();
    }
}

案例二：

public interface Livable1 {
    public default void fly(){
        System.out.println("天上飞");
    }
}

public class AnimalLivable1 implements Livable1{
    @Override
    public void fly(){
        System.out.println("骄傲的飞飞飞");
    }
}

public class InterfaceDemoTest01 {
    public static void main(String[] args) {
        AnimalLivable1 animalLivable1 = new AnimalLivable1();
        animalLivable1.fly();
    }
}

Java七（继承，接口，抽象类）

Java七（继承，接口，抽象类）

一继承

1.1概念

1.2 继承的特点

1.3 子类中访问父类的内容

1.4 继承后子类和父类的变化

1.5 抽象类

二接口（Interface）

Java七（继承，接口，抽象类）

一 继承

1.1概念

1.2 继承的特点

1.3 子类中访问父类的内容

1.4 继承后子类和父类的变化

1.5 抽象类

二 接口（Interface）

一继承

二接口（Interface）