权限修饰符-抽象类-接口

权限修饰符

名称	public	protected	（default）	private
同一个类	yes	yes	yes	yes
同一个包	yes	yes	yes	no
不同包子类	yes	yes	no	no
不同包非子类	yes	no	no	no
注意事项：（default）并不是关键字“default”，而是根本不写

抽象类概念

如果父类当中的方法不确定如何进行{}方法体实现，那么这就应该是一个抽象方法

抽象方法和抽象类的格式

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

public abstract class Animal {

    //抽象方法，代表吃东西，具体吃什么不确定
    public abstract void eat();

    //这是普通的成员方法
    public void normalMethod(){

    }
}

抽象方法和抽象类的使用

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

主方法

public class DemoMain {

    public static void main(String[] args) {
        //Animal animal = new Animal() 错误写法，不能直接创建抽象类对象
        Cat cat = new Cat();
        cat.eat();
    }
}

抽象类

public abstract class Animal {

    //抽象方法，代表吃东西，具体吃什么不确定
    public abstract void eat();

    //这是普通的成员方法
    public void normalMethod(){

    }
}

子类

public class Cat extends Animal{

    @Override
    public void eat() {
        System.out.println("猫吃鱼！");//实现
    }
}

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

1、抽象类不能创建对象，如果创建编译无法通过而报错，只能创建其非抽象子类的对象（假设创建了抽象类的对象，调用抽象方法，而抽象方法没有具体的方法体，没有意义）
2、抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员用的（子类的构造方法中，有默认的super（），需要访问父类构造方法）
3、抽象类中，不一定包含抽象方法，但是有抽象方法的类必须是抽象类（未包含抽象方法的抽象类，目的就是不想让调用者创建该对象，通常用于某些特殊的类结构设计）
4、抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象类。（假设不重写所有抽象方法，则类中可能包含抽象方法，那么创建对象后，调用抽象的方法，没有意义）

发红包案例

群主发普通红包。某群有多名成员，群主给成员发普通红包。普通红包的规则:
1.群主的一笔金额，从群主余额中扣除，平均分成n等份，让成员领取。
2.成员领取红包后，保存到成员余额中。
请根据描述，完成案例中所有类的定义以及指定类之间的继承关系，并完成发红包的操作。

用户类

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

群主类

//群主的类
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();//80
        //6、6、8，随机分给三个人
        one.show();//
        two.show();//
        three.show();//
    }
}

final关键字的概念和四种用法

final关键字代表最终的、不可改变的
常见四种用法
1、可以用来修饰一个类
2、可以用来修饰一个方法
3、还可以用来修饰一个局部变量
4、还可以用来修饰一个成员变量

final关键字用来修饰类

当final关键字用来修饰一个类的时候，格式
public final class 类名称{
//
}
含义：当前这个类不能有任何的子类。（公公类）
注意：一个类如果是final的，那么其中所有的成员方法都无法进行覆盖重写

public final class MyClass {
    public void method(){
        System.out.println("方法执行！");
    }

}

final关键字用来修饰方法

当final关键字用来修饰一个方法的时候，这个方法就是最终方法，也就是不能被覆盖重写
格式：
修饰符 final 返回值类型 方法名称 （参数列表）
//方法体
}
注意事项：
对于类、方法来说，abstract关键字和final关键字不能同时使用，因为矛盾
父类

public abstract  class Fu {
    public final void method(){
        System.out.println("父类方法执行！");
    }
    public abstract void methodAbs();
}

子类

public class Zi extends Fu{
    @Override
    public void methodAbs() {

    }
   /* @Override
    public void method() {
        System.out.println("子类重写父类的方法！");
    }*/

}

final关键字用来修饰局部变量

对于一个普通的内容来说它的内容是可变的
一旦使用final用来修饰局部变量，那么这个变量就不能进行更改）（一次赋值，终生不变）

对于基本类型来说，不可改变的是变量当中的数据不可改变
对于引用类型来说，不可改变的是变量当中的地址值不可改变
主方法

public class Demo01Final {
    public static void main(String[] args) {
        int num1 = 10;
        System.out.println(num1);//10
        num1 = 20;
        System.out.println(num1);//20

        //一旦使用final用来修饰局部变量，那么这个变量就不能进行更改
        //一次赋值，终生不变
        final int num2 = 300;
        //正确写法，只要保证有唯一次赋值即可
        final int num3;
        num3 = 30;
        //对于基本类型来说，不可改变的是变量当中的数据不可改变
        //对于引用类型来说，不可改变的是变量当中的地址值不可改变
        Student stu1 = new Student("刘辣子！");
        System.out.println(stu1.getName());
        System.out.println(stu1);
        stu1 = new Student("小甜甜");
        System.out.println(stu1.getName());
        System.out.println(stu1);
        System.out.println("=============");

        final Student stu2 = new Student("甜品大师");
        System.out.println(stu2.getName());//甜品大师
        //错误写法！final的引用类型变量，其中的地址不可改变
        //stu2 = new Student("啊哈哈！");
        stu2.setName("很甜很甜！");
        System.out.println(stu2.getName());//很甜很甜！
    }

}

学生类

public class Student {
    private  String name;

    public Student(){

    }

    public Student(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

final用来修饰成员变量

对于成员变量来说，如果使用final关键字来修饰，那么这个变量也照样是不可变
1、由于成员变量具有默认值，所以用了final之后必须手动赋值，不会再给默认值了
2、对于final的成员变量，要么使用直接赋值，要么通过构造方法赋值，二者选其一
3、必须保证类当中所有重载的构造方法，都最终会对final的成员变量进行赋值

常量

常量是使用public static final修饰的成员变量，而且执行的过程中其值不能被改变
常量的作用和好处：可以用于做系统的配置信息，方便程序的维护，同时也能提高可读性。

public class Constant{
	public static final String SCHOOL_NAME = "哈哈哈",

常量命名规范：英文单词全部大写，多个单词下划线连接起来。

常量的执行原理

在编译阶段会进行“宏替换”，把使用常量的地方全部替换成真是的字面量
这样做的好处是让使用常量的程序的执行性能与直接使用字面量是一致的。

枚举的特征：

枚举类都是继承了枚举类型，java.lang.Enum
枚举都是最终类，不可以被继承
构造器都是私有的，枚举对外不能创建对象
枚举类的第一行默认都是罗列枚举对象的名称的
枚举类相当于是多例模型。

final和abstract是什么关系？

互斥关系：abstract定义的抽象类作为模板让子类继承，final定义的类不能被继承
抽象方法定义通过功能让子类重写，final定义的方法子类不能重写。