final，权限，内部类（IDEA版）

final关键字

概述：学习继承之后我们知道了子类是可以继承父类的方法（方法重写）和属性，但是java中API是不是可以随便的改写呢？显然是不能，所以就出现了final关键，代表的是最终的不可改变的。

final关键字：
修饰类：不能被继承
修饰方法：不能被重写
修饰变量：不能被重新赋值
使用方法
修饰类
使用方法：final class 类名{}
修饰方法（当重写final的方法的时候，会报错）：
修饰符 final 返回值类型 方法名（参数列表）{
方法体
}
修饰变量：
基本数据类型：基本类型的局部变量被修饰之后，只能够赋值一次，且不能被更改。

p
ublic class FinalDemo1 {
public static void main(String[] args) {
// 声明变量，使用final修饰
final int a;
// 第一次赋值
a = 10;
// 第二次赋值
a = 20; // 报错,不可重新赋值
// 声明变量，直接赋值，使用final修饰
final int b = 10;
// 第二次赋值
b = 20; // 报错,不可重新赋值
}
}

final int c = 0;
for (int i = 0; i < 10; i++) {
c = i;
System.out.println(c);
}

这种方式会报错的

for (int i = 0; i < 10; i++) {
final int c = i;
System.out.println(c);
}

这种写法不会报错，因为每一次循环，都是一个新的变量c所以不会报错

引用类型：
引用类型的局部变量，被final修饰之后，只能指向一个对象，地址不能被修改，但是不会影响内部的成员变量值的修改

public class FinalDemo2 {
public static void main(String[] args) {
// 创建 User 对象
final User u = new User();
// 创建 另一个 User对象
u = new User(); // 报错，指向了新的对象，地址值改变。
// 调用setName方法
u.setName("张三"); // 可以修改
}
}

3.成员变量
成员变量涉及到初始化的问题，初始化的方式有两种，并且只能2选1
（1)显示初始化

public class User {
final String USERNAME = "张三";
private int age;
}

（2）构造方法初始化

public class User {
final String USERNAME ;
private int age;
public User(String username, int age) {
this.USERNAME = username;
this.age = age;
}
}

注意：被final修饰的变量名称一般都有书写规范，所有的字母都要是大写
权限修饰符
概述：
在java中提供了四种权限修饰符，使用不同的权限修饰符的时候，被修饰的内容会有不同的访问权限

public 拥有最大的权限，private则是最小的
编写代码的时候，如果没有特殊的考虑的话建议这样使用权限：
成员变量使用private 隐藏细节
构造方法使用public 方便调用对象
成员方法使用public 方便调用方法
注意当不加修饰符的时候，其访问的能力与default修饰符相同

内部类

概述：
什么是内部类？
将一个类1定义在类2中，里面的类1就是内部类，类2则是外部类
成员内部类
成员内部类定义在方法外面

class 外部类 {
class 内部类{
}
}

在描述事物的时候，若一个事物还包含有其他的事物，就可以使用内部类这种结构，比如汽车含有发动机

class Car { //外部类
class Engine { //内部类
}
}

访问特点：
1.内部类可以直接访问外部类的成员，包括私有成员
2.外部类如果要是要访问内部类中的成员，必须建立内部类的对象
创建内部类对象的格式

外部类名.内部类名 对象名 = new 外部类型().new 内部类型()；

定义类：

public class Person {
private boolean live = true;
class Heart {
public void jump() {
// 直接访问外部类成员
if (live) {
System.out.println("心脏在跳动");
} else {
System.out.println("心脏不跳了");
}
}
} 
public boolean isLive() {
return live;
} 
public void setLive(boolean live) {
this.live = live;
}
}

测试类：

public static void main(String[] args) {
// 创建外部类对象
Person p = new Person();
// 创建内部类对象
Heart heart = p.new Heart();
// 调用内部类方法
heart.jump();
// 调用外部类方法
p.setLive(false);
// 调用内部类方法
heart.jump();
}
}
输出结果:
心脏在跳动
心脏不跳了

注意：内部类仍然是一个独立的类，在编译之后内部类会被编译为独立的.class类但是前面冠上了外部类的类名和$符号比如，Person$Heart.class
匿名内部类：
匿名内部类： 是内部类的简化写法。他的本质是一个带 具体实现的父类或者是父接口的匿名子类对象
以接口为例：当你使用一个接口的时候，似乎得做如下的几步操作
1.定义子类
2.重写接口中的方法
3.创建子类对象
4.调用重写后的方法
我们的目的只是为了调用方法。能不能简化一下呢？匿名对象就是这个作用
**前提：**匿名内部类必须继承一个父类或者是父接口
格式：

new 父类名或者接口名(){
// 方法重写
@Override
public void method() {
// 执行语句
}
};

使用方式：（接口）
定义接口：

public interface MyInterface {

    void method1(); // 抽象方法

    void method2();

}

创建接口的实现类，并调用：

public class MyInterfaceImpl implements MyInterface {
    @Override
    public void method1() {
        System.out.println("实现类覆盖重写了方法！111");
    }

    @Override
    public void method2() {
        System.out.println("实现类覆盖重写了方法！222");
    }
}

测试类：

public class DemoMain {

    public static void main(String[] args) {
//        MyInterface obj = new MyInterfaceImpl();
//        obj.method();

//        MyInterface some = new MyInterface(); // 错误写法！

        // 使用匿名内部类，但不是匿名对象，对象名称就叫objA
        MyInterface objA = new MyInterface() {
            @Override
            public void method1() {
                System.out.println("匿名内部类实现了方法！111-A");
            }

            @Override
            public void method2() {
                System.out.println("匿名内部类实现了方法！222-A");
            }
        };
        objA.method1();
        objA.method2();
        System.out.println("=================");

        // 使用了匿名内部类，而且省略了对象名称，也是匿名对象
        new MyInterface() {
            @Override
            public void method1() {
                System.out.println("匿名内部类实现了方法！111-B");
            }

            @Override
            public void method2() {
                System.out.println("匿名内部类实现了方法！222-B");
            }
        }.method1();
        // 因为匿名对象无法调用第二次方法，所以需要再创建一个匿名内部类的匿名对象
        new MyInterface() {
            @Override
            public void method1() {
                System.out.println("匿名内部类实现了方法！111-B");
            }

            @Override
            public void method2() {
                System.out.println("匿名内部类实现了方法！222-B");
            }
        }.method2();
    }

使用匿名对象的两种方法
注意：
另外还要注意几点问题：

1. 匿名内部类，在【创建对象】的时候，只能使用唯一一次。
   如果希望多次创建对象，而且类的内容一样的话，那么就需要使用单独定义的实现类了。
2. 匿名对象，在【调用方法】的时候，只能调用唯一一次。
   如果希望同一个对象，调用多次方法，那么必须给对象起个名字。
3. 匿名内部类是省略了【实现类/子类名称】，但是匿名对象是省略了【对象名称】
   强调：匿名内部类和匿名对象不是一回事！！！

引用变量用法用法总结

1.class作为成员变量

class Role {
int id; // 角色id
int blood; // 生命值
String name; // 角色名称
}

当我们使用int类型表示角色id和生命值，String类型表示姓名，此时String本身就是引用数据类型，由于使用的方式类似于常量，所以往往忽略。
定义武器类：

class Weapon {
String name； // 武器名称
int hurt； // 伤害值
}

定义盔甲类，将增加防御能力，也就是提升生命值

class Armour {
String name；// 装备名称
int protect；// 防御值
}

定义角色类：

class Role {
int id；
int blood；
String name；
// 添加武器属性
Weapon wp；
// 添加盔甲属性
Armour ar；
// 提供get/set方法
public Weapon getWp() {
return wp;
} 
public void setWeapon(Weapon wp) {
this.wp = wp;
} 
public Armour getArmour() {
return ar;
} 
public void setArmour(Armour ar) {
this.ar = ar;
} /
/ 攻击方法
public void attack(){
System.out.println("使用"+ wp.getName() +", 造成"+wp.getHurt()+"点伤害");
} /
/ 穿戴盔甲
public void wear(){
// 增加防御,就是增加blood值
this.blood += ar.getProtect();
System.out.println("穿上"+ar.getName()+", 生命值增加"+ar.getProtect());
}
}

测试类：

p
ublic class Test {
public static void main(String[] args) {
// 创建Weapon 对象
Weapon wp = new Weapon("屠龙刀" , 999999);
// 创建Armour 对象
Armour ar = new Armour("麒麟甲",10000);
// 创建Role 对象
Role r = new Role();
// 设置武器属性
r.setWeapon(wp);
// 设置盔甲属性
r.setArmour(ar);
// 攻击
r.attack();
// 穿戴盔甲
r.wear();
}
} 
输出结果:
使用屠龙刀,造成999999点伤害
穿上麒麟甲 ,生命值增加10000

类作为成员变量的时候，对它进行赋值操作，实际上，是赋给它该类的一个对象
使用interface作为成员变量
接口是对方法的封装，对应游戏当中，可以看作是扩展游戏角色的技能，所以，要是想扩展更强大的技能的话，我们可以在role中，可以增加接口作为成员变量，来设置不同的技能
定义接口：

// 法术攻击
public interface FaShuSkill {
public abstract void faShuAttack();
}

定义角色类：

public class Role {
FaShuSkill fs;
public void setFaShuSkill(FaShuSkill fs) {
this.fs = fs;
} /
/ 法术攻击
public void faShuSkillAttack(){
System.out.print("发动法术攻击:");
fs.faShuAttack();
System.out.println("攻击完毕");
}
}

定义测试类：

public class Test {
public static void main(String[] args) {
// 创建游戏角色
Role role = new Role();
// 设置角色法术技能
role.setFaShuSkill(new FaShuSkill() {
@Override
public void faShuAttack() {
System.out.println("纵横天下");
}
});
// 发动法术攻击
role.faShuSkillAttack();
// 更换技能
role.setFaShuSkill(new FaShuSkill() {
@Override
public void faShuAttack() {
System.out.println("逆转乾坤");
}
});
// 发动法术攻击
role.faShuSkillAttack();
}
} 
输出结果:
发动法术攻击:纵横天下
攻击完毕
发动法术攻击:逆转乾坤
攻击完毕

我们使用一个接口，作为成员变量，以便随时可以更换技能，这样的设计更为灵活，增强了程序的扩展性，接口作为成员变量的时候，对他进行赋值的操作，实际上是赋值给该接口的一个子类对象
interface作为方法的参数或者是返回值类型
获取某集合中所有的偶数
定义方法：

public static List<Integer> getEvenNum(List<Integer> list) {
// 创建保存偶数的集合
ArrayList<Integer> evenList = new ArrayList<>();
// 遍历集合list,判断元素为偶数,就添加到evenList中
for (int i = 0; i < list.size(); i++) {
Integer integer = list.get(i);
if (integer % 2 == 0) {
evenList.add(integer);
}
} /
* 返回偶数集合
* 因为getEvenNum方法的返回值类型是List,而ArrayList是List的子类,
所以evenList可以返回
*/
return evenList;
}

调用方法：

public class Test {
public static void main(String[] args) {
// 创建ArrayList集合,并添加数字
ArrayList<Integer> srcList = new ArrayList<>();
for (int i = 0; i < 10; i++) {
srcList.add(i);
} /
* 
* 获取偶数集合
因为getEvenNum方法的参数是List,而ArrayList是List的子类,
所以srcList可以传递
*/
List list = getEvenNum(srcList);
System.out.println(list);
}
}

接口作为参数的时候，传递它的子类对象
接口作为返回值类型的时候，返回它的子类对象

发红包案例

红包类型：

1. 普通红包：金额均分。不能整除的，余额添加到最后一份红包中。
2. 手气红包：金额随机。各个红包金额累和与总金额相等。
   红包场景：此案例是模拟群主给群成员发红包，群主自己打开最后一个红包的场景