Java SE 07（继承、抽象类、接口）

继承

继承的特点：

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

继承：就是子类继承父类的属性和行为，使得子类对象具有父类相同的属性和行为
子类可以直接访问父类中非私有的属性和行为
1.继承的好处，提高代码复用性
2.类与类之间产生了关系，继承是多态的前提
继承格式:

    class 父类 {
    }

    class 子类 extends 父类 {
    }
分为子类、父类（超类或者基类)

注：代码练习请点击
 Employee类
 Teacher类
 Test类

继承后的变化：

一.成员变量：
1.不重名情况：如果子类父类中出现不重名的成员变量，访问是没有影响的
2.重名情况：有影响，new子类时候调用的是子类的成员变量，想要调用父类的，要用super关键字，就像本类使用this一样.(父类中成员变量私有，我们可以通过get,set方法访问父类的成员变量)
父类代码
 子类代码

二.成员方法：
1.不重名情况：没影响，对象在调用方法时，会在子类中查找有没有对应的方法，没有就回去父类中找相应的方法去执行
2.重名(重写Override）情况：子类出现了与父类一模一样的方法（返回值类型，方法名，参数列表都相同）---》会出现覆盖效果（也叫复写）----》声明不变重新实现.
应用-----子类个性化定制自己的方法（注：调用父类的成员方法，super.成员方法）（子覆盖父，保证权限大于等于父类）
Phone
NewPhone
Test
注：重写父类的方法建议使用该注解进行标识 : @Override

三.构造方法:
1.构造方法的名字和类名一致，所以子类无法继承父类构造方法
2.构造方法的作用是初始化成员变量，所以子类初始化的过程中必须先执行父类的初始化动作，子类的构造方法默认有一个super()，表示调用父类的构造方法，父类成员变量初始化后才可以给子类使用
注: super:代表父类的存储空间标识（父类的引用）格式：super.成员方法（）【父类的】； super.成员变量【父类的】
this:调用当前类的对象的引用（谁调用就代表谁）格式：this.成员方法（）【本类的】； this.成员变量【本类的】
FuGou
ZiGou
ExtendDemoTest7
Animal
Cat
Test8

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

发红包案例：

User类：

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

Manger类：

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

    public Manger(String name, int money) {
        super(name, money);
    }
    //定义发红包方法
    public ArrayList<Integer> send(int totalMoney, int count){
        ArrayList<Integer> redList = new ArrayList<>();
        //1.看一下群主有多少钱，余额不足要告诉一下
        int leftmoney = super.getMoney();
        if (leftmoney < totalMoney){
            System.out.println("余额不足");
            return redList;
        }
        //2.扣钱
         super.setMoney(leftmoney - totalMoney);
        //3.发红包，将红包分成count份
        int avg = totalMoney / count;
        int mod = totalMoney % count;//余数，也就是零头部分

//如果除不开，将零头放在最后一个红包中

        //4.将余额一个一个放到集合中
        //放 前count -1
        for (int i = 0; i < count - 1 ; i++) {
            redList.add(avg);
        }
        //放 第count个
        int last = avg + mod;
        redList.add(last);

        return redList;
    }
}

Member类：

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);
        int delMoney = list.remove(index);

        //查看当前会员还有多少钱
        int money = super.getMoney();
        //重新设置一下余额
        super.setMoney(money + receiveMoney);
    }
}

红包测试类：

public class MainRedPacket {
    public static void main(String[] args) {
        System.out.println("===============");
        System.out.println("当前显示群里所有人的余额");
        //一个群主100，3个成员0，0，0
        Manger manger = new Manger("群主",100);
        Member one = new Member("成员A", 0);
        Member two = new Member("成员B", 0);
        Member three = new Member("成员C", 0);
        manger.show();
        one.show();
        two.show();
        three.show();
        System.out.println("=========================");
        System.out.println("请群主要发红包的金额");//20；6，6，8
        int money = new Scanner(System.in).nextInt();
        //发红包
        ArrayList<Integer> redList = manger.send(money, 3);

        //收红包
        one.receive(redList);
        two.receive(redList);
        three.receive(redList);
        //显示所有人当前的余额
        manger.show();
        one.show();
        two.show();
        three.show();
    }
}

抽象类

抽象类：
一.定义：
1.抽象方法：没有方法主体的方法，没有{ }
2.抽象方法格式：使用abstract修饰的方法，就成了抽象方法，抽象方法只包含一个方法名，而没有方法体

格式：修饰符  abstract  返回值类型  方法名（参数列表）；
public abstract class AnimalAb {   
    //定义格式
    public abstract void run();
}

二.抽象类：如果一个类包含抽象方法，那么该类必须是抽象类
三.使用：继承抽象类的子类必须重写父类的所有抽象方法，否则该子类也必须是抽象类，最终必须有子类实现父类的抽象方法，否则从最初的父类到最终的子类都不能被new，失去了意义

小贴士：

类封装了成员变量、成员方法、构造函数

数据类型：

1.引用数据类型:接口、类、数组

2.基本数据类型：byte\short\int\long\float\double\char\boolean

接口（interface）(特点：抽象方法使用abstract修饰，可以省略，没有方法体，该方法供子类实现使用)

一.概述：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 Liveable {
   //定义抽象方法
   public abstract void eat();
   public  void sleep();
}


public class AnimalLiveable implements Liveable {
   //alt+ shift + enter导入所有抽象方法

   @Override
   public void eat() {
       System.out.println("咔咔造");
   }

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

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

接口默认方法实现案例：

public interface Liveable1 {
    //默认方法 ： 可以重写，也可以继承，但是只能通过实现类来调用
    //1.继承默认方法
    public default void fly(){
        System.out.println("天上飞");
    }
}


public class AnimalLiveable1 implements Liveable1{
    //继承什么都可以不用写，直接调用即可
//    @Override
//    public void fly() {
//    }
    //重写
    @Override
    public void fly() {
        System.out.println("骄傲的飞飞飞");
    }
}

public class InterfaceDemoTest1 {
    public static void main(String[] args) {
        AnimalLiveable1 animalLiveable1 = new AnimalLiveable1();
        animalLiveable1.fly();
    }
}

接口静态方法实现案例：

public interface Liveable {
    //静态方法的使用
    public static void run() {
        System.out.println("跑起来");
    }

public abstract class Animal implements Liveable{
   //无法重写静态方法
}

public class InterfaceTest {
    public static void main(String[] args) {
        Animal animal = new Animal();
           Animal.run(); //报错，无法继承方法，也无法调用
           Liveable.run();//通过接口调用
    }
}

接口私有方法实现案例：

public interface Liveable {
 //将func1 和 func2 两个方法封装为默认方法 func中
    default void func() {
        func1();
        func2();
    }

    //私有方法
    private void func1() {
        System.out.println("func1");
    }

    //func2
    private void func2() {
        System.out.println("func1");
    }
}

public abstract class Animal implements Liveable{
    @Override
    public void func() {

    }

    @Override
    public void show() {

    }
}

public class InterfaceTest {
    public static void main(String[] args) {
       Animal animal = new Animal();
       animal.func();
   }
}