抽象

抽象

抽象方法：就是加上abstract关键字，然后去掉大括号，直接分号结束。 抽象类：抽象方法所在的类，必须是抽象类才行。在class之前写上abstract即可。

如何使用抽象类和抽象方法：

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

2. 必须用一个子类来继承抽象父类。

3. 子类必须覆盖重写抽象父类当中所有的抽象方法。 覆盖重写（实现）：子类去掉抽象方法的abstract关键字，然后补上方法体大括号。

4. 创建子类对象进行使用。

package cn.itcast.day09.demo11;
public abstract class Animal {
​
   // 这是一个抽象方法，代表吃东西，但是具体吃什么（大括号的内容）不确定。
   public abstract void eat();
​
   // 这是普通的成员方法
//   public void normalMethod() {
//   }
​
}

package cn.itcast.day09.demo11;
​
public class Cat extends Animal {
​
   @Override
   public void eat() {
       System.out.println("猫吃鱼");
  }
​
}

package cn.itcast.day09.demo11;
​
public class DemoMain {
​
   public static void main(String[] args) {
//       Animal animal = new Animal(); // 错误写法！不能直接创建抽象类对象
​
       Cat cat = new Cat();
       cat.eat();
  }
​
}

抽象方法和抽象类

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

这样没有抽象方法的抽象类，也不能直接创建对象，在一些特殊场景下有用途。

package cn.itcast.day09.demo12;
​
public class DemoMain {
​
   public static void main(String[] args) {
       Zi zi = new Zi();
       zi.eat();
  }
​
}

package cn.itcast.day09.demo12;
​
public abstract class Fu {
​
   public Fu() {
       System.out.println("抽象父类构造方法执行！");
  }
​
   public abstract void eat();
​
}

package cn.itcast.day09.demo12;
public abstract class MyAbstract {
}

package cn.itcast.day09.demo12;
​
public class Zi extends Fu {
​
   public Zi() {
       // super();
       System.out.println("子类构造方法执行");
  }
​
   @Override
   public void eat() {
       System.out.println("吃饭饭");
  }
}

 

 

package cn.itcast.day09.demo13;
​
// 最高的抽象父类
public abstract class Animal {
​
   public abstract void eat();
​
   public abstract void sleep();
​
}

package cn.itcast.day09.demo13;
​
public class DemoMain {
​
   public static void main(String[] args) {
//       Animal animal = new Animal(); // 错误！
​
//       Dog dog = new Dog(); // 错误，这也是抽象类
​
       Dog2Ha ha = new Dog2Ha(); // 这是普通类，可以直接new对象。
       ha.eat();
       ha.sleep();
       System.out.println("==========");
​
       DogGolden golden = new DogGolden();
       golden.eat();
       golden.sleep();
  }
​
​
}

package cn.itcast.day09.demo13;
​
// 子类也是一个抽象类
public abstract class Dog extends Animal {
​
   @Override
   public void eat() {
       System.out.println("狗吃骨头");
  }
​
   // public abstract void sleep();
}

package cn.itcast.day09.demo13;
​
public class Dog2Ha extends Dog {
   @Override
   public void sleep() {
       System.out.println("嘿嘿嘿……");
  }
}

package cn.itcast.day09.demo13;
​
public class DogGolden extends Dog {
   @Override
   public void sleep() {
       System.out.println("呼呼呼……");
  }
}

package cn.itcast.day09.demo13;
​
public class DogGolden extends Dog {
   @Override
   public void sleep() {
       System.out.println("呼呼呼……");
  }
}

发红包项目

package cn.itcast.day09.demo14;
​
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();
  }
​
}

package cn.itcast.day09.demo14;
​
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;
  }
}

package cn.itcast.day09.demo14;
​
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);
  }
}

package cn.itcast.day09.demo14;
​
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;
  }
}