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符号
比如,Person符号比如,PersonHeart.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.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);
}
}
接口作为参数的时候,传递它的子类对象
接口作为返回值类型的时候,返回它的子类对象
发红包案例
红包类型:
- 普通红包:金额均分。不能整除的,余额添加到最后一份红包中。
- 手气红包:金额随机。各个红包金额累和与总金额相等。
红包场景:此案例是模拟群主给群成员发红包,群主自己打开最后一个红包的场景