【final、权限、内部类、引用类型】
今日内容
- final关键字
- 权限
- 内部类
- 引用类型
教学目标
-
描述final修饰的类的特点
- 类不能被继承
-
描述final修饰的方法的特点
- 方法不能被子类重写
-
能够说出权限修饰符作用范围
- public ＞ protected > defualt(什么都不写) > private
-
说出内部类的概念
- 类中类
- 成员内部类
- 访问问外部类的成员变量： 类名.this.外部类的成员变量
- 局部内部类型
- 局部内部类访问方法中的局部变量的时候，这个局部变量需要final修饰，在1.8以后默认就有final
- 成员内部类
匿名内部类格式：
new 父类或者父接口(){
//重写方法
}
有个一个匿名对象，是这个类或者是接口的匿名子类对象
- 类中类
-
能够理解引用类型作为成员变量
-
能够理解引用类型作为方法参数
-
能够理解引用类型作为方法返回值类型
-
引用数据类型传递的就是地址
第一章 final关键字
1.1 概述
学习了继承后，我们知道，子类可以在父类的基础上改写父类内容，比如，方法重写。那么我们能不能随意的继承API中提供的类，改写其内容呢？显然这是不合适的。为了避免这种随意改写的情况，Java提供了final 关键字，用于修饰不可改变内容。
final： 不可改变。可以用 于修饰类、方法和变量。
-
类：被修饰的类，不能被继承。
-
方法：被修饰的方法，不能被重写。
-
变量：被修饰的变量，不能被重新赋值。
1.2 使用方式
修饰类
格式如下：
public final class 类名 {
}
查询API发现像 public final class String 、public final class Math 、public final class Scanner 等，很多我们学习过的类，都是被final修饰的，目的就是供我们使用，而不让我们所以改变其内容。
修饰方法
格式如下：
修饰符 final 返回值类型 方法名(参数列表){
//方法体
}
重写被 final修饰的方法，编译时就会报错。
修饰变量
final 修饰的变量不能二次赋值 (只能赋值一次)
1) 局部变量——基本类型
基本类型的局部变量，被final修饰后，只能赋值一次，不能再更改。代码如下：
public class FinalDemo1 {
public static void main(String[] args) {
// 声明变量，使用final修饰
final int a;
// 第一次赋值
a = 10;
// 第二次赋值
a = 20; // 报错,不可重新赋值
// 声明变量，直接赋值，使用final修饰
final int b = 10;
// 第二次赋值
b = 20; // 报错,不可重新赋值
}
}
思考，如下两种写法，哪种可以通过编译通过？
写法1：
final int c = 0;
for (int i = 0; i < 10; i++) {
c = i;
System.out.println(c);
}
写法2：
for (int i = 0; i < 10; i++) {
final int c = i;
System.out.println(c);
}
根据 final 的定义，写法1报错！写法2，为什么通过编译呢？因为每次循环，都是一次新的变量c。这也是大家需要注意的地方。
2) 局部变量——引用类型
引用类型的局部变量，被final修饰后，只能指向一个对象，地址不能再更改。
但是不影响对象内部的成员变量值的修改，代码如下：
public class FinalDemo2 {
public static void main(String[] args) {
// 创建 User 对象
final User u = new User();
// 创建 另一个 User对象
u = new User(); // 报错，指向了新的对象，地址值改变。
// 调用setName方法
u.setName("张三"); // 可以修改
}
}
3) 成员变量
成员变量涉及到初始化的问题，初始化方式有两种，只能二选一：
- 显示初始化；
public class User {
final String USERNAME = "张三";
private int age;
}
- 构造方法初始化。(set方法都不行)
public class User {
final String USERNAME ;
private int age;
public User(String username, int age) {
this.USERNAME = username;
this.age = age;
}
}
被final修饰的常量名称，一般都有书写规范，所有字母都大写。多个单词之间,使用下划线进行分割
第二章 权限修饰符
2.1 概述
在Java中提供了四种访问权限，使用不同的访问权限修饰符修饰时，被修饰的内容会有不同的访问权限，
-
public：公共的。
-
protected：受保护的
-
default：默认的 (在这里是权限而接口中的default是指默认的意思)
要与接口中的默认方法的default关键字区别开来. -
private：私有的
2.2 不同权限的访问能力
| 位置 | public | protected | default（空的） | private |
|---|---|---|---|---|
| 同一类中 | √ | √ | √ | √ |
| 同一包中子类 | √ | √ | √ | |
| 同一包中无关类 | √ | √ | √ | |
| 不同包的子类 | √ | √ | ||
| 不同包中的无关类 | √ |
可见，public具有最大权限。private则是最小权限。default权限是不写的.
public > protected >default>private
编写代码时，如果没有特殊的考虑，建议这样使用权限：
-
成员变量使用
private，隐藏细节。 //封装 -
构造方法使用
public，方便创建对象。//private 单例模式 把构造方法私有化 -
成员方法使用
public，方便调用方法。 -
类的修饰实践证明 只能用public default
小贴士：不加权限修饰符，其访问能力就是default权限
第三章 内部类的定义和使用
3.1 什么是内部类
类中类 : 将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类。
3.2 成员内部类
成员内部类 定义在类中方法外的类。和成员变量及成员方法同级别位置.
3.2.1 定义格式
public class OuterClass {//外部类
//其他成员变量
//其他成员方法
class InnerClass{//成员内部类
}
}
在描述事物时，若一个事物内部还包含其他事物，就可以使用内部类这种结构。比如，汽车类Car 中包含发动机类Engine ，这时，Engine就可以使用内部类来描述，定义在成员位置。
代码举例：
class Car { //外部类
class Engine { //内部类
}
}
3.2.2 访问特点
外部类和内部类都有其各自的成员变量及成员方法, 那么内部类和外部类之间成员的访问有啥特点呢?
1 ) 在外部类范围内访问( 同一个类范围中的访问)
-
从内到外的访问: 内部类可以直接访问外部类的成员，包括私有成员。
辅助理解: 汽车的发动机访问汽车的汽油 (汽车是外部类, 含有私有属性 汽油. 发动机是内部类) 注意: 如果存在重名情况“就近原则”访问 内部类局部变量 < 内部类成员变量 < 外部类成员变量 直接访问 | this.变量名 | 外部类名.this.变量名 -
从外到内的访问: ** 外部类访问内部类的成员，必须要先建立内部类的对象后访问**
不管是内部类还是外部类,其成员的访问都是基于对象访问的
代码示例
public class Outer {//外部类
private int num = 100; //外部类成员变量
private void method() { //外部类成员方法
System.out.println("Outer method()");
}
class Inner {//内部类
private int num = 200;//内部类成员变量
private void method() {//内部类成员私有方法
int num=300;//局部变量
System.out.println("Inner private method");
System.out.println(num); //本局部变量 300
System.out.println(this.num);//内部类成员变量 200
System.out.println(Outer.this.num); //外部类成员变量
}
public void method2() {//内部类成员公有方法
method();
}
}
}
2) 在其他类中的访问, 遵循访问权限的控制
其他类中, 创建内部类对象格式：
//以下Outter表示外部类,Inner表示内部类
格式一: 先创建外部类对象, 后创建内部类对象.
Outer outer = new Outter();
Outer.Inner inner =outer.new Inter();
格式二: 格式一步骤的合并
Outer.Inner inner =new Outter().new Inner();
代码示例
创建Demo类, 访问 1) 中的Outer 类及其 内部类.
public class Demo02 {
public static void main(String[] args) {
//格式一: 先创建外部类对象, 后创建内部类对象.
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();
// inner.method();//不能调用私有方法
inner.method2();
System.out.println("===================");
//格式二: 格式一步骤的合并
Outer.Inner inner2 = new Outer().new Inner();
inner2.method2();
System.out.println("===================");
Outer outer2= new Outer(); //访问外部类方法
//outer2.method2();//不能够直接访问内部类的成员方法
}
}
成员的访问一定是基于对象
小贴士:
内部类仍然是一个独立的类，在编译之后会内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号 。
比如，Person$Heart.class
3.3 局部内部类
在方法中也可以定义类, 这个类称为局部内部类. 和变量一样理解, 在方法中的变量为局部变量.
1) 定义格式
class 外部类 {
修饰符 返回值类型 外部类方法() {
class 局部内部类 {
// ...
}
}
}
2) 访问特点
只能在局部内部类所在方法中访问.
从外到内: 局部内部类只能在其所在方法范围内访问, 和局部变量一样. 而且同样需要创建对象.
从内到外: 局部内部类如果要使用所在方法的局部变量，那么这个局部变量必须是【有效final的】。从JDK 1.8+开始，只要局部变量事实不变，那么可以省略其final关键字。
代码示例如下
public class Outer { // 外部类
public void methodOuter() { // 外部类的方法
final int num = 100; // 外部类方法的局部变量
// num = 2;
class LocalInner { // 局部内部类
public void methodInner() { // 局部内部类方法
System.out.println("内部类的方法执行！");
System.out.println(num);
System.out.println(100);
}
}
new LocalInner().methodInner();
} // methodOuter
public void methodOuterAnother() {
// new LocalInner(); // 错误写法！局部内部类不能在它所在方法外访问.
}
}
3.4 匿名内部类【重点】
1) 什么是匿名内部类
最暴力直接的理解就是没有名字的内部类. 那好使么? 什么场景使用? 格式怎么写? 怎么创建对象 …
开发中，最常用到的内部类就是匿名内部类了。以接口举例，当你要使用一个接口时，似乎得做如下几步操作，
-
定义子类 重写接口中的方法
-
创建子类对象
-
调用重写后的方法
我们的目的，最终只是为了调用方法，那么能不能简化一下，把以上四步合成一步呢？匿名内部类可以实现 !!
2) 前提
匿名内部类必须继承一个父类或者实现一个父接口。
3) 格式
new 父类名或者接口名 () {
// 方法重写
@Override
public void method() {
// 执行语句
}
};
这个格式中包含了一个对象, 和一个匿名子类, 这个匿名子类实现了父类/父接口的方法.
这个对象就是这个匿名子类的对象.
思考: 区分有名类, 匿名类 有名对象, 匿名对象
4) 匿名内部类结合匿名对象的使用方式
以接口为例，匿名内部类的使用，代码如下：
定义接口：
public abstract interface FlyAble{
public abstract void fly();
}
匿名子对象本质上就是在堆内存中没有变量名指向的对象. 只能在创建的时候使用到一次.
1. 一次性使用的子类对象
开发中, 实现的子类只在当前使用, 其他地方不要使用的情况下, 使用匿名内部类是一个很不错的方案.
创建匿名内部类，并调用：
public class InnerDemo {
public static void main(String[] args) {
/*
1.等号右边:是匿名内部类，定义并创建该接口的子类对象
2.等号左边:是多态赋值,接口类型引用指向子类对象
*/
new FlyAble(){
public void fly() {
System.out.println("我飞了~~~");
}
}.fly();
}
}
2. 一次性使用的方法实参
通常在方法的形式参数是接口或者抽象类时，也可以将匿名内部类对象作为参数传递。代码如下：
public class InnerDemo3 {
public static void main(String[] args) {
/*
创建匿名内部类,直接传递给showFly(FlyAble f)
*/
showFly( new FlyAble(){
public void fly() {
System.out.println("我飞了~~~");
}
});
}
public static void showFly(FlyAble f) {
f.fly();
}
}
第四章 引用类型用法总结
实际的开发中，引用类型的使用非常重要，也是非常普遍的。我们可以在理解基本类型的使用方式基础上，进一步去掌握引用类型的使用方式。基本类型可以作为成员变量、作为方法的参数、作为方法的返回值，那么当然引用类型也是可以的。
基本数据类型: 在方法中进行传递 值得传递.
引用数据类型:在方法中的传递 地址的传递. 只要是同一个地址,不管在哪里修改引用数据类型的值其他地方也会改变.
4.1 class 作为成员变量
在定义一个类Role（游戏角色）时，代码如下：
class Role {
int id; // 角色id
int blood; // 生命值
String name; // 角色名称
}
使用int 类型表示 角色id和生命值，使用String 类型表示姓名。此时，String本身就是引用类型，由于使用的方式类似常量，所以往往忽略了它是引用类型的存在。如果我们继续丰富这个类的定义，给Role 增加武器，穿戴装备等属性，我们将如何编写呢？
定义武器类，将增加攻击能力：
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 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();
}
}
输出结果:
发动法术攻击:纵横天下
攻击完毕
发动法术攻击:逆转乾坤
攻击完毕
我们使用一个接口，作为成员变量，以便随时更换技能，这样的设计更为灵活，增强了程序的扩展性。
接口作为成员变量时，对它进行赋值的操作，实际上，是赋给它该接口的一个子类对象。
4.3 interface作为方法参数和返回值类型
当接口作为方法的参数时,需要传递什么呢？当接口作为方法的返回值类型时，需要返回什么呢？对，其实都是它的子类对象。
ArrayList类我们并不陌生，查看API我们发现，实际上，它是 java.util.List 接口的实现类。所以，当我们看见List 接口作为参数或者返回值类型时，当然可以将ArrayList的对象进行传递或返回。
List list= new ArrayList(); //多态格式体现
其实这里就有多态的体现., 父接口 接收 子实现类的对象.
请观察如下方法：获取某集合中所有的偶数。
定义方法：
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);
}
}
接口作为参数时，传递它的子类对象。
接口作为返回值类型时，返回它的子类对象。
第五章 综合案例——发红包【界面版】
红包文化源远流长。从古时的红色纸包，到手机App中的手气红包，红包作为一种独特的中华文化传承至今。之前的课程中，我们也编写过程序，模拟发普通红包。那么今天，我们将整合基础班课程中所有的技术和知识，编写一个带界面版的 发红包 案例。
目前，我们尚未学习过任何与界面相关的类。所以，界面相关代码，已经给出。请运用所学技术分析并使用。
案例需求
分析并使用已给出的类，编写程序，设置红包类型。
小贴士
红包类型：
- 普通红包：金额均分。
- 手气红包：金额随机。各个红包金额累和与总金额相等。
红包场景：
此案例是模拟群主给群成员发红包，群主自己打开最后一个红包的场景。
案例分析
已知的类：
RedPacketFrame：一个抽象类，包含了一些属性，是红包案例的页面。
public abstract class RedPacketFrame extends JFrame {
/* ownerName : 群主名称 */
public String ownerName = "谁谁谁谁";
/* openMode : 红包的类型 [普通红包/手气红包]*/
public OpenMode openMode = null;
/**
* 构造方法:生成红包界面.
* @param title 页面的标题.
*/
public RedPacketFrame(String title) {
super(title);
init();// 页面相关的初始化操作
}
/* set方法 */
public void setOwnerName(String ownerName) {
this.ownerName = ownerName;
}
public void setOpenMode(OpenMode openMode) {
this.openMode = openMode;
}
}
OpenMode：一个接口，包含一个分配方法，用来指定红包类型。
public interface OpenMode {
/**
* @param totalMoney 总金额,单位是"分"。总金额为方便计算,已经转换为整数,单位为分。
* @param count 红包个数
* @return ArrayList<Integer> 元素为各个红包的金额值,所有元素的值累和等于总金额.
*
* 请将totalMoney,分成count分,保存到ArrayList<Integer>中,返回即可.
*/
public abstract ArrayList<Integer> divide(int totalMoney, int count);
}
案例实现
环境搭建：
- 创建项目：名称自定义，建议为
RedPacketDemo。 - 导入图片：将
pic目录，导入项目中，与src目录平级。 - 导入已知类：在
src下创建一个包，名字自定义，建议为known，将类RedPacketFrame、接口OpenMode拷入。
代码实现：
- 定义
RedPacket类，继承RedPacketFrame，代码如下：
public class RedPacket extends RedPacketFrame {
public RedPacket(String title) {
super(title);
}
}
- 定义测试类，创建
RedPacket对象，代码如下：
public class RedPacketTest {
public static void main(String[] args) {
RedPacket rp = new RedPacket("大红包");
}
}
运行代码，打开一个发红包的页面。可以输入总金额，红包个数，留言信息。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9EyVhWSk-1575624261461)(img/1_input.jpg)]
点击塞钱进红包按钮，跳转到下一页面。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DzHptRw9-1575624261463)(img/2_open.jpg)]
点击谁谁谁谁和開，两个区域，发现可以设置两项内容：
谁谁谁谁：表示群主在发红包，可设置群主名称。通过此方法，熟悉类结构，直接调用父类的方法。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LysYdC2W-1575624261466)(img/3_setName.jpg)]
開：表示打开红包，跳转到下一页面。但是开启之前，必须先设置红包的类型，否则无法开启。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-orETuL0r-1575624261469)(img/4_setMode.jpg)]
-
RedPacket对象，设置群主名称。setOwnerName（String ownerName），是字符串作为参数。我们只需要传递一个字符串即可。
public class RedPacketTest {
public static void main(String[] args) {
// 创建红包对象
RedPacket rp = new RedPacket("大红包");
// 设置群主名称
rp.setOwnerName("我是群大大");
}
}
-
RedPacket对象，设置红包类型。setOpenMode(OpenMode openMode)，是接口作为参数。我们必须定义接口的实现类，重写接口中方法，并传递实现类对象到setOpenMode方法中，方可设置完成。再观察接口：
public interface OpenMode {
/**
* @param money 金额,单位是"分"。总金额为方便计算,已经转换为整数,单位为分。
* @param count 红包个数
* @return ArrayList<Integer> 元素为各个红包的金额值,所有元素的值累和等于总金额.
*
* 如果为手气红包 money为总金额 如果为普通红包money为单个红包金额
*/
public abstract ArrayList<Integer> getRedPacket(int money, int count);
}
- 普通红包，打开方式
Common，代码如下：
public class Common implements OpenMode {
@Override
public ArrayList<Integer> getRedPacket(int money, int count) {
// 创建保存各个红包金额的集合
ArrayList<Integer> list = new ArrayList<>();
for(int i=0; i<count ; i++){
list.add(money);
}
return list;
}
}
- 发普通红包，代码如下：
public class RedPacketTest {
public static void main(String[] args) {
// 创建红包对象
RedPacket rp = new RedPacket("大红包");
// 设置群主名称
rp.setOwnerName("我是群大大");
// 设置红包类型
rp.setOpenMode(new Common()); // 普通红包
}
}
- 手气红包
本质上，手气红包就是把设置的金额money 随机分成指定的count份，所以必须规定每一份金额的取值范围。如果范围太小，可能导致后分配红包金额特别大。反之范围太大，可能导致后分配红包金额为0，不够分。可见，取值范围的定义规则，是手气红包的关键所在。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CYZpzqtq-1575624261470)(assets/手气红包原理图.png)]
以上分析以 单位 分进行计算. 这样更方便处理.
手气红包，打开方式Lucky ，代码如下：
public class Lucky implements OpenMode {
@Override
public ArrayList<Integer> getRedPacket(int money, int count) {
if (count > money) {
System.out.println("不好意思,我分不了呀");
return new ArrayList<>();
}
// 创建保存各个红包金额的集合
ArrayList<Integer> list = new ArrayList<>();
// 定义循环次数,总个数-1次
int time = count - 1;
//创建一个集合存储 随机获取的节点数
ArrayList<Integer> nums = new ArrayList<>();
// 创建随机数对象. 随机获取 time 个 (0,money) 之间的随机数: 不包含0 和money
Random rd = new Random();
//开始随机获取节点
while (true) {
//获取[1,money-1] 的随机数
int n = rd.nextInt(money - 1) + 1;
if (nums.contains(n)) {
//如果nums中含有这个数,继续随机生成
continue;
} else {
//如果不包含,随机数有效
nums.add(n);
}
if (nums.size() == time) {
//节点个数好了,退出循环
break;
}
}
//nums 集合排序, 借助工具类 Collections.sort()
Collections.sort(nums);
System.out.println("随机生成的节点数:" + nums);
// 根据之前分析的原理 循环分配
for (int i = 0; i < time; i++) {
//获取当前红包大小
int m;
if (i == 0) {
//第一个红包大小
m = nums.get(i) - 0;
} else {
//其他红包大小
m = nums.get(i) - nums.get(i - 1);
}
//将红包放进集合中
list.add(m);
}
//最后一个红包: 总额减去最大节点数
list.add(money - nums.get(nums.size() - 1));
return list;
}
}
- 发手气红包，代码如下：
public class RedPacketTest {
public static void main(String[] args) {
// 创建红包对象
RedPacket rp = new RedPacket("大红包");
// 设置群主名称
rp.setOwnerName("我是群大大");
// 设置红包类型,二选一
// rp.setOpenMode(new Common()); // 普通红包
rp.setOpenMode(new Lucky()); // 手气红包
}
}
案例总结
通过发红包 案例，你都学到了什么呢？请你思考如下问题：
- 基础语法，你是否清晰？
- 一些基本的类的方法，你是否能够调用？
- 案例中哪里体现了继承，继承的作用是什么？
- 接口作为参数，如何使用？
- 接口作为成员变量，如何使用？
- 如何简化接口的使用方式？匿名内部类
相信每位学员，都会有自己的思考和答案。也相信大家，随着开发经验的丰富，对于技术的理解会更加深入，对技术的运用会更加纯熟。通过对大量案例的不断积累，最终写出属于你自己的程序，成为一名真正的coder。感谢大家参与学习JavaSE 基础班课程，技术的道路上，这只是一个开始！谢谢大家！
228
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
