1.finally
1.1 概述
学习了继承后，我们知道，子类可以在父类的基础上改写父类内容，比如，方法重写。那么我们能不能随意的继承
API中提供的类，改写其内容呢？显然这是不合适的。为了避免这种随意改写的情况，Java提供了 final 关键字，
用于修饰不可改变内容。
final： 不可改变。可以用于修饰类、方法和变量。
类：被修饰的类，不能被继承。
方法：被修饰的方法，不能被重写。
变量：被修饰的变量，不能被重新赋值。
1.1 修饰类
package cn.itcast.day11.demo01;/*
当final关键字用来修饰一个类的时候，格式：
public final class 类名称 {// ...
}*/
public final class MyClass /*extends Object*/ {public void method() {System.out.println("方法执行！");}}含义：当前这个类不能有任何的子类。（太监类）
注意：一个类如果是final的，那么其中所有的成员方法都无法进行覆盖重写（因为没儿子。）
1.2修饰方法
package cn.itcast.day11.demo01;/*格式：
修饰符 final 返回值类型 方法名称(参数列表) {// 方法体
}注意事项：*/
public abstract class Fu {public final void method() {System.out.println("父类方法执行！");}public abstract /*final*/ void methodAbs() ;}当final关键字用来修饰一个方法的时候，这个方法就是最终方法，也就是不能被覆盖重写。
对于类、方法来说，abstract关键字和final关键字不能同时使用，因为矛盾。
1.3修饰局部变量
package cn.itcast.day11.demo01;/* final关键字代表最终、不可改变的。常见四种用法： 1. 可以用来修饰一个类 2. 可以用来修饰一个方法 3. 还可以用来修饰一个局部变量 4. 还可以用来修饰一个成员变量*/
public class Demo01Final {
public static void main(String[] args) {
int num1 = 10;System.out.println(num1); // 10num1 = 20;System.out.println(num1); // 20// 一旦使用final用来修饰局部变量，那么这个变量就不能进行更改。// “一次赋值，终生不变”final int num2 = 200;System.out.println(num2); // 200// num2 = 250; // 错误写法！不能改变！
// num2 = 200; // 错误写法！// 正确写法！只要保证有唯一一次赋值即可final int num3;num3 = 30;// 对于基本类型来说，不可变说的是变量当中的数据不可改变// 对于引用类型来说，不可变说的是变量当中的地址值不可改变Student stu1 = new Student("赵丽颖");System.out.println(stu1);System.out.println(stu1.getName()); // 赵丽颖stu1 = new Student("霍建华");System.out.println(stu1);System.out.println(stu1.getName()); // 霍建华System.out.println("===============");final Student stu2 = new Student("高圆圆");// 错误写法！final的引用类型变量，其中的地址不可改变
// stu2 = new Student("赵又廷");System.out.println(stu2.getName()); // 高圆圆stu2.setName("高圆圆圆圆圆圆");System.out.println(stu2.getName()); // 高圆圆圆圆圆圆}}// 一旦使用final用来修饰局部变量，那么这个变量就不能进行更改。
// “一次赋值，终生不变”
== // 对于基本类型来说，不可变说的是变量当中的数据不可改变
// 对于引用类型来说，不可变说的是变量当中的地址值不可改变==
引用类型的局部变量，被final修饰后，只能指向一个对象，地址不能再更改。但是不影响对象内部的成员变量值的
修改，代码如下：
1.4修饰成员变量
package cn.itcast.day11.demo01;/* 对于成员变量来说，如果使用final关键字修饰，那么这个变量也照样是不可变。1. 由于成员变量具有默认值，所以用了final之后必须手动赋值，不会再给默认值了。 2. 对于final的成员变量，要么使用直接赋值，要么通过构造方法赋值。二者选其一。 3. 必须保证类当中所有重载的构造方法，都最终会对final的成员变量进行赋值。*/
public class Person {
private final String name/* = "鹿晗"*/;public Person() {
name = "关晓彤";}public Person(String name) {
this.name = name;}public String getName() {
return name;}// public void setName(String name) {
// this.name = name;
// }
}成员变量涉及到初始化的问题，初始化方式有两种，只能二选一：
------------------------------------------------------————
2.权限修饰符
package cn.itcast.day11.demo02;/* Java中有四种权限修饰符：public > protected > (default) > private 同一个类（我自己） YES YES YES YES 同一个包（我邻居） YES YES YES NO 不同包子类（我儿子） YES YES NO NO 不同包非子类（陌生人） YES NO NO NO注意事项：(default)并不是关键字“default”，而是根本不写。*/
public class Demo01Main {
}3.内部类
3.1 概述
什么是内部类
将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类。
3。2 成员内部类
package cn.itcast.day11.demo03;public class Body {
// 外部类public class Heart {
// 成员内部类// 内部类的方法public void beat() {
System.out.println("心脏跳动：蹦蹦蹦！");System.out.println("我叫：" + name); // 正确写法！}}// 外部类的成员变量private String name;// 外部类的方法public void methodBody() {
System.out.println("外部类的方法");new Heart().beat();}public String getName() {
return name;}public void setName(String name) {
this.name = name;}
}package cn.itcast.day11.demo03;/* 如果一个事物的内部包含另一个事物，那么这就是一个类内部包含另一个类。 例如：身体和心脏的关系。又如：汽车和发动机的关系。分类： 1. 成员内部类 2. 局部内部类（包含匿名内部类）成员内部类的定义格式： 修饰符 class 外部类名称 {修饰符 class 内部类名称 {// ...}// ... }注意：内用外，随意访问；外用内，需要内部类对象。========================== 如何使用成员内部类？有两种方式： 1. 间接方式：在外部类的方法当中，使用内部类；然后main只是调用外部类的方法。 2. 直接方式，公式： 类名称 对象名 = new 类名称(); 【外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();】*/
public class Demo01InnerClass {
public static void main(String[] args) {
Body body = new Body(); // 外部类的对象// 通过外部类的对象，调用外部类的方法，里面间接在使用内部类Heartbody.methodBody();System.out.println("=====================");// 按照公式写：Body.Heart heart = new Body().new Heart();heart.beat();}}内部类重名
package cn.itcast.day11.demo03;// 如果出现了重名现象，那么格式是：外部类名称.this.外部类成员变量名
public class Outer {
int num = 10; // 外部类的成员变量public class Inner /*extends Object*/ {
int num = 20; // 内部类的成员变量public void methodInner() {
int num = 30; // 内部类方法的局部变量System.out.println(num); // 局部变量，就近原则System.out.println(this.num); // 内部类的成员变量System.out.println(Outer.this.num); // 外部类的成员变量}}}package cn.itcast.day11.demo03;public class Demo02InnerClass {
public static void main(String[] args) {
// 外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();Outer.Inner obj = new Outer().new Inner();obj.methodInner();}}3.3 局部内部类
package cn.itcast.day11.demo04;/* 如果一个类是定义在一个方法内部的，那么这就是一个局部内部类。 “局部”：只有当前所属的方法才能使用它，出了这个方法外面就不能用了。定义格式： 修饰符 class 外部类名称 {修饰符 返回值类型 外部类方法名称(参数列表) {class 局部内部类名称 {// ...}} }小节一下类的权限修饰符： public > protected > (default) > private 定义一个类的时候，权限修饰符规则： 1. 外部类：public / (default) 2. 成员内部类：public / protected / (default) / private 3. 局部内部类：什么都不能写*/
class Outer {
public void methodOuter() {
class Inner {
// 局部内部类int num = 10;public void methodInner() {
System.out.println(num); // 10}}Inner inner = new Inner();inner.methodInner();}}package cn.itcast.day11.demo04;public class DemoMain {
public static void main(String[] args) {
Outer obj = new Outer();obj.methodOuter();}}局部内部类中的finally
package cn.itcast.day11.demo04;/* 局部内部类，如果希望访问所在方法的局部变量，那么这个局部变量必须是【有效final的】。备注：从Java 8+开始，只要局部变量事实不变，那么final关键字可以省略。原因： 1. new出来的对象在堆内存当中。 2. 局部变量是跟着方法走的，在栈内存当中。 3. 方法运行结束之后，立刻出栈，局部变量就会立刻消失。 4. 但是new出来的对象会在堆当中持续存在，直到垃圾回收消失。*/
public class MyOuter {
public void methodOuter() {
int num = 10; // 所在方法的局部变量class MyInner {
public void methodInner() {
System.out.println(num);}}}}匿名内部类（重点）
package cn.itcast.day11.demo05;/* 如果接口的实现类（或者是父类的子类）只需要使用唯一的一次， 那么这种情况下就可以省略掉该类的定义，而改为使用【匿名内部类】。匿名内部类的定义格式： 接口名称 对象名 = new 接口名称() {// 覆盖重写所有抽象方法 };对格式“new 接口名称() {...}”进行解析： 1. new代表创建对象的动作 2. 接口名称就是匿名内部类需要实现哪个接口 3. {...}这才是匿名内部类的内容另外还要注意几点问题： 1. 匿名内部类，在【创建对象】的时候，只能使用唯一一次。 如果希望多次创建对象，而且类的内容一样的话，那么就需要使用单独定义的实现类了。 2. 匿名对象，在【调用方法】的时候，只能调用唯一一次。 如果希望同一个对象，调用多次方法，那么必须给对象起个名字。 3. 匿名内部类是省略了【实现类/子类名称】，但是匿名对象是省略了【对象名称】 强调：匿名内部类和匿名对象不是一回事！！！*/
public class DemoMain {
public static void main(String[] args) {
// MyInterface obj = new MyInterfaceImpl();
// obj.method();// MyInterface some = new MyInterface(); // 错误写法！// 使用匿名内部类，但不是匿名对象，对象名称就叫objAMyInterface objA = new MyInterface() {
@Overridepublic void method1() {
System.out.println("匿名内部类实现了方法！111-A");}@Overridepublic void method2() {
System.out.println("匿名内部类实现了方法！222-A");}};objA.method1();objA.method2();System.out.println("=================");// 使用了匿名内部类，而且省略了对象名称，也是匿名对象new MyInterface() {
@Overridepublic void method1() {
System.out.println("匿名内部类实现了方法！111-B");}@Overridepublic void method2() {
System.out.println("匿名内部类实现了方法！222-B");}}.method1();// 因为匿名对象无法调用第二次方法，所以需要再创建一个匿名内部类的匿名对象new MyInterface() {
@Overridepublic void method1() {
System.out.println("匿名内部类实现了方法！111-B");}@Overridepublic void method2() {
System.out.println("匿名内部类实现了方法！222-B");}}.method2();}}4.引用类型
4.1 类作为成员变量
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());
}
}
public 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
4.2 接口作为成员变量
// 法术攻击
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();
}
}
输出结果:
发动法术攻击:纵横天下
攻击完毕
发动法术攻击:逆转乾坤
攻击完毕
4.3 接口作为方法的参数或者返回值类型
package cn.itcast.day11.demo07;import java.util.ArrayList;
import java.util.List;/* java.util.List正是ArrayList所实现的接口。*/
public class DemoInterface {
public static void main(String[] args) {
// 左边是接口名称，右边是实现类名称，这就是多态写法List<String> list = new ArrayList<>();List<String> result = addNames(list);for (int i = 0; i < result.size(); i++) {
System.out.println(result.get(i));}}public static List<String> addNames(List<String> list) {
list.add("迪丽热巴");list.add("古力娜扎");list.add("玛尔扎哈");list.add("沙扬娜拉");return list;}}接口作为参数时，传递它的子类对象。
接口作为返回值类型时，返回它的子类对象。
5.综合案例
public class Lucky implements OpenMode {
@Override
public ArrayList<Integer> divide(int totalMoney, int count) {
// 创建保存各个红包金额的集合
ArrayList<Integer> list = new ArrayList<>();
// 定义循环次数,总个数‐1次
int time = count ‐ 1;
// 创建随机数对象
Random random = new Random();
// 循环分配
for (int i = 0; i < time; i++) {
/* * 每次重新计算,生成随机金额 * 随机范围: totalMoney / count * 2,totalMoney不断的减少, * count也不断的减少,所以这是一个可变化的范围. */
int money = random.nextInt(totalMoney / count * 2) + 1;
// 金额添加到集合
list.add(money);
// 总金额扣除已分配金额
totalMoney ‐= money;
// 红包个数‐1
count‐‐;
}
// 剩余的金额,为最后一个红包
list.add(totalMoney);
return list;
}
}