java day11【final、权限、内部类、引用类型】

第一章 final关键字

1.1 概述

学习了继承后，咱们知道，子类能够在父类的基础上改写父类内容，好比，方法重写。那么咱们能不能随意的继承 API中提供的类，改写其内容呢？显然这是不合适的。为了不这种随意改写的状况，Java提供了 final 关键字， 用于修饰不可改变内容。

final： 不可改变。能够用于修饰类、方法和变量。

类：被修饰的类，不能被继承。

方法：被修饰的方法，不能被重写。

变量：被修饰的变量，不能被从新赋值。

1.2 使用方式

修饰类

格式以下：

final class 类名 {

}

查询API发现像 public final class String 、 public final class Math 、 public final class Scanner 等，不少咱们学习过的类，都是被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;

}

构造方法初始化。

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：默认的

private：私有的

2.2 不一样权限的访问能力

可见，public具备最大权限。private则是最小权限。

编写代码时，若是没有特殊的考虑，建议这样使用权限：

成员变量使用 private ，隐藏细节。

构造方法使用 public ，方便建立对象。

成员方法使用 public ，方便调用方法。

小贴士：不加权限修饰符，其访问能力与default修饰符相同

第三章 内部类

1.1 概述

什么是内部类

将一个类A定义在另外一个类B里面，里面的那个类A就称为内部类，B则称为外部类。

成员内部类

成员内部类 ：定义在类中方法外的类。

定义格式：

class 外部类 {

class 内部类{

}

}

在描述事物时，若一个事物内部还包含其余事物，就可使用内部类这种结构。好比，汽车类 Car 中包含发动机 类 Engine ，这时， Engine 就可使用内部类来描述，定义在成员位置。

代码举例：

class Car { //外部类

class Engine { //内部类

}

}

访问特色

内部类能够直接访问外部类的成员，包括私有成员。

外部类要访问内部类的成员，必需要创建内部类的对象。

建立内部类对象格式：

外部类名.内部类名 对象名 = 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 class InnerDemo {

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 匿名内部类【重点】

匿名内部类 ：是内部类的简化写法。它的本质是一个 带具体实现的 父类或者父接口的 匿名的 子类对象。 开发中，最经常使用到的内部类就是匿名内部类了。以接口举例，当你使用一个接口时，彷佛得作以下几步操做

1. 定义子类

2. 重写接口中的方法

3. 建立子类对象

4. 调用重写后的方法

咱们的目的，最终只是为了调用方法，那么能不能简化一下，把以上四步合成一步呢？匿名内部类就是作这样的快 捷方式。

前提

匿名内部类必须继承一个父类或者实现一个父接口。

格式

new 父类名或者接口名(){

// 方法重写

@Override

public void method() {

// 执行语句

}

};

使用方式

以接口为例，匿名内部类的使用，代码以下：

定义接口：

public abstract class FlyAble{

public abstract void fly();

}

建立匿名内部类，并调用：

public class InnerDemo {

public static void main(String[] args) {

/*

1.等号右边:是匿名内部类，定义并建立该接口的子类对象

2.等号左边:是多态赋值,接口类型引用指向子类对象

*/

FlyAble f = new FlyAble(){

public void fly() {

System.out.println("我飞了~~~");

}

};

//调用 fly方法,执行重写后的方法

f.fly();

}

}

一般在方法的形式参数是接口或者抽象类时，也能够将匿名内部类做为参数传递。代码以下：

public class InnerDemo2 {

public static void main(String[] args) {

/*

1.等号右边:定义并建立该接口的子类对象

2.等号左边:是多态,接口类型引用指向子类对象

*/

FlyAble f = new FlyAble(){

public void fly() {

System.out.println("我飞了~~~");

}

};

// 将f传递给showFly方法中

showFly(f);

}

public static void showFly(FlyAble f) {

f.fly();

}

}

以上两步，也能够简化为一步，代码以下：

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 的对象进行传递或返回。

请观察以下方法：获取某集合中全部的偶数。

定义方法：

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中的手气红包，红包做为一种独特的中华文化传承至今。以前 的课程中，咱们也编写过程序，模拟发普通红包。那么今天，咱们将整合基础班课程中全部的技术和知识，编写一 个带界面版的 发红包 案例。

目前，咱们还没有学习过任何与界面相关的类。因此，界面相关代码，已经给出。请运用所学技术分析并使用。

案例需求

分析并使用已给出的类，编写程序，设置红包类型。

小贴士

红包类型：

1. 普通红包：金额均分。不能整除的，余额添加到最后一份红包中

2. 手气红包：金额随机。各个红包金额累和与总金额相等。

红包场景：

此案例是模拟群主给群成员发红包，群主本身打开最后一个红包的场景。

案例分析

已知的类：

1. 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;

}

}

2. OpenMode ：一个接口，包含一个分配方法，用来指定红包类型。

public interface OpenMode {

/** * @param totalMoney 总金额,单位是"分"。总金额为方便计算,已经转换为整数,单位为分。

* @param count 红包个数

* @return ArrayList<Integer> 元素为各个红包的金额值,全部元素的值累和等于总金额.

*

* 请将totalMoney,分红count分,保存到ArrayList<Integer>中,返回便可.

*/

public abstract ArrayList<Integer> divide(int totalMoney, int count);

}

案例实现

环境搭建：

1. 建立项目：名称自定义，建议为 RedPacketDemo 。

2. 导入图片：将 pic 目录，导入项目中，与 src 目录平级

3. 导入已知类：在 src 下建立一个包，名字自定义，建议为 known ，将类 RedPacketFrame 、接口 OpenMode 拷入。

代码实现：

1. 定义 RedPacket 类，继承 RedPacketFrame ，代码以下：

public class RedPacket extends RedPacketFrame {

public RedPacket(String title) {

super(title);

}

}

2. 定义测试类，建立 RedPacket 对象，代码以下

public class RedPacketTest {

public static void main(String[] args) {

RedPacket rp = new RedPacket("大红包");

}

}

运行代码，打开一个发红包的页面。能够输入总金额，红包个数，留言信息。

点击 塞钱进红包 按钮，跳转到下一页面。

           

点击 谁谁谁谁 和 開 ，两个区域，发现能够设置两项内容：

谁谁谁谁 ：表示群主在发红包，可设置群主名称。经过此方法，熟悉类结构，直接调用父类的方法。

開 ：表示打开红包，跳转到下一页面。可是开启以前，必须先设置红包的类型，不然没法开启。

3. RedPacket 对象，设置群主名称。

setOwnerName（String ownerName） ，是字符串做为参数。咱们只须要传递一个字符串便可。

public class RedPacketTest {

public static void main(String[] args) {

// 建立红包对象

RedPacket rp = new RedPacket("大红包");

// 设置群主名称

rp.setOwnerName("我是群大大");

}

}

4. RedPacket 对象，设置红包类型。

setOpenMode(OpenMode openMode) ，是接口做为参数。咱们必须定义接口的实现类，重写接口中方法，并传 递实现类对象到 setOpenMode 方法中，方可设置完成。再观察接口：

public interface OpenMode {

/** * @param totalMoney 总金额,单位是"分"。总金额为方便计算,已经转换为整数,单位为分。

* @param count 红包个数

* @return ArrayList<Integer> 元素为各个红包的金额值,全部元素的值累和等于总金额. *

* 请将totalMoney,分红count分,保存到ArrayList<Integer>中,返回便可.

*/

public abstract ArrayList<Integer> divide(int totalMoney, int count);

}

5. 普通红包，打开方式 Common ，代码以下：

public class Common implements OpenMode {

@Override

public ArrayList<Integer> divide(int totalMoney, int count) {

// 建立保存各个红包金额的集合

ArrayList<Integer> list = new ArrayList<>();

// 定义循环次数,总个数‐1次

int time = count ‐ 1;

// 一次计算,生成平均金额

int money = totalMoney / count;

// 循环分配

for (int i = 0; i < time; i++) {

// 添加到集合中

list.add(money);

// 总金额扣除已分配金额 

totalMoney ‐= money;

}

// 剩余的金额,为最后一个红包

list.add(totalMoney);

System.out.println("普通红包金额:" + list);

// 返回集合

return list;

}

}

6. 发普通红包，代码以下：

public class RedPacketTest {

public static void main(String[] args) {

// 建立红包对象

RedPacket rp = new RedPacket("大红包");

// 设置群主名称

rp.setOwnerName("我是群大大");

// 设置红包类型

rp.setOpenMode(new Common());// 普通红包

}

}

7. 手气红包【重点】

本质上，手气红包就是把总金额 totalMoney 随机分红指定的 count 份，因此必须规定每一份金额的取值范围。如 果范围过小，可能致使后分配红包金额特别大。反之范围太大，可能致使后分配红包金额为0，不够分。可见，取 值范围的定义规则，是手气红包的关键所在。

咱们规定：每一份随机金额范围（除最后一份），最小值为1，最大值为当前剩余平均金额的2倍 ，单位为"分"。

计算公式：

当前剩余平均金额 = 剩余总金额 / 剩余红包个数

举例：总额为50元，发5个红包。

小贴士：为方便表格中进行运算，此处，单位为"元"。程序中，建议换算为"分"进行运算。

手气红包，打开方式 Lucky ，代码以下：

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;

}

}

8. 发手气红包，代码以下：

public class RedPacketTest {

public static void main(String[] args) {

// 建立红包对象

RedPacket rp = new RedPacket("大红包");

// 设置群主名称

rp.setOwnerName("我是群大大");

// 设置红包类型,二选一

// rp.setOpenMode(new Common()); // 普通红包

rp.setOpenMode(new Lucky()); // 手气红包

}

}

案例总结

经过 发红包 案例，你都学到了什么呢？请你思考以下问题：

1. 基础语法，你是否清晰？

2. 一些基本的类的方法，你是否可以调用？

3. 案例中哪里体现了继承，继承的做用是什么？ 

4. 接口做为参数，如何使用？

5. 接口做为成员变量，如何使用？

6. 如何简化接口的使用方式？