文章目录
final关键字
final关键字代表最终，不可改变的。
常见四种用法：
1. 可以用来修饰一个类
含义：当前类不能有任何的子类（太监类）
注意：一个类如果是final的，那么其中所有成员方法无法进行覆盖重写（因为没儿子）
public final class MyClass {
public void method(){
System.out.println("方法执行!");
}
}2. 可以用来修饰一个方法
当final关键字用来修饰一个方法时，这个方法就是最终方法，也就是不能覆盖重写
注意事项：对于类、方法来说，abstract关键字和final关键字不能同时使用，因为矛盾。
public class Fu {
public final void method(){
System.out.println("父类方法执行");
}
}3. 可以用来修饰一个局部变量
当final关键字修饰一个局部变量时，该局部变量就永远不能进行更改
public class Demo01Final {
public static void main(String[] args) {
final int num1 = 10;//num1不能进行更改
//正确写法，只要保证唯一一次赋值即可
final int num2;
num2 = 20;
//对于基本类型来说，不可改变变量中的数据不可改变
//对于引用类型来说，不可改变是变量当中的地址值不可改变
final Student stu2 = new Student("高圆圆");
// 错误写法!final的引用类型变量，其中的地址不可改变
// stu2 = new Student("赵又廷");
// 正确写法，内容可以改变
stu2.setName("赵又廷");
}
}4. 可以用来修饰一个成员变量
成员变量用final修饰后也不可变
注意：
a. 由于成员变量有默认值，所以用了final之后必须手动赋值
b. 对于final的成员变量，要么使用直接赋值，要么通过构造方法赋值。（二者选其一）
c. 必须保证类当中所有重载的构造方法，都最终会对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;
// }
}Java中四种权限修饰符
/*
Java中有四种权限修饰符
public > protected > (default) > private
同一个类(我自己) YES YES YES YES
同一个包(我邻居) YES YES YES NO
不同包子类(我儿子) YES YES NO NO
不同包非子类(陌生人) YES NO NO NO
(default)是根本不写
*/内部类
如果一个事物的内部包含另一个事物，那么这就是一个类内部包含另一个类
例如：身体和心脏的关系
分类：
- 成员内部类
- 局部内部类（包含匿名内部类）
成员内部类
Body类
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;
}
}main方法
/*
成员内部类的定义格式：
修饰符 class 外部类名称{
修饰符 class 内部类名称）{
// ...
}
// ...
}
注意：内用外，随意访问；外用内，需要借助内部类对象
=====================
如何使用成员内部类？有两种方法:
1. 间接方式：再外部类的方法中，使用内部类，然后main只是调用外部类的方法
2. 直接方式：公式：
外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();
*/
public class Demo01InnerClass {
public static void main(String[] args) {
Body body = new Body();
//间接方式：再外部类的方法中，使用内部类，然后main只是调用外部类的方法
body.methodBody();
System.out.println("================");
// 直接方式
Body.Heart heart = new Body().new Heart();
heart.beat();
}
}内部类的同名变量访问
public class Outer {
int num = 10;
public class Inner{
int num = 20;
public void methodInner(){
int num = 30;
System.out.println(num);//局部变量，就近原则
System.out.println(this.num);//内部类的成员变量
System.out.println(Outer.this.num);//外部类的成员变量
}
}
}局部内部类
/*
如果一个类是定义在一个方法内部的，那么这就是一个局部内部类
“局部”：只有当前所属的方法才能使用它，出了这个方法就不能用了
定义格式：
修饰符 class 外部类名称{
修饰符 返回值类型 外部类方法名称（参数列表）{
class 局部内部类名称{
// ...
}
}
}
定义一个类的时候，权限修饰符规则：
1. 外部类：public / (default)
2. 成员内部类：public / protected / (default) / private
3. 局部内部类：什么都不能写
*/
public class Outer {
public void methodOuter(){
class Inner{
int num = 10;
public void methodInner(){
System.out.println(num);
}
}
Inner inner = new Inner();
inner.methodInner();
}
}局部内部类的final问题
局部内部类：如果希望访问所在方法的局部变量，那么这个局部变量必须是【有效final的】
备注：从java8开始，只要局部变量事实不变，那么final关键字可以省略
原因：
- new出来的对象在堆内存中
- 局部变量是跟着方法走的，在栈内存中
- 方法运行结束后，立即出栈，局部变量就会立刻消失
- 但是new出来的对象会在堆当中持续存在，知道垃圾回收为止
匿名内部类（重点）
/*
如果接口的实现类，或父类的子类，只需使用唯一的一次，
那么这种情况下就可以省略掉该类的定义，而改为使用【匿名内部类】
匿名内部类的定义格式
接口名称 对象名 = new 接口名称(){
// 覆盖重写所有抽象方法
};
对格式“new 接口名称(){...}”进行解析
1. new代表创建对象的动作
2. 接口名称就是匿名内部类需要实现哪个接口
3. {...}则才是匿名内部类的内容
另外还需要注意几点问题：
1. 匿名内部类，在创建对象的时候，只能使用唯一一次。
如果希望多次创建对象且类的内容一样，就必须使用单独定义的实现类
2. 匿名对象，在【调用方法】的时候，只能调用唯一一次
如果希望同一个对象，调用多次方法，那么必须给对象七个名字
3. 匿名内部类是省略了【实现类/子类名称】，但是匿名对象是省略了【对象名称】
强调：匿名内部类和匿名对象不是一回事
*/
public class DemoMain {
public static void main(String[] args) {
// 使用匿名内部类
MyInterface obj = new MyInterface() {
@Override
public void method() {
System.out.println("匿名内部类实现了方法");
}
};
//既是匿名内部类，也是匿名对象
obj.method();//匿名内部类实现了方法
new MyInterface() {
@Override
public void method() {
System.out.println("匿名内部类实现了方法");
}
}.method();
}
}类作为成员变量类型
public class Hero {
private String name; //英雄姓名
private int age; //英雄年龄
// 类做成员变量
private Weapon weapon; //武器
public void attack(){
System.out.println(age+"岁的"+name+"在用"+weapon.code+"攻击敌人");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Weapon getWeapon() {
return weapon;
}
public void setWeapon(Weapon weapon) {
this.weapon = weapon;
}
}weapon类做hero类的成员变量
public class Weapon {
public String code;//武器代号
public Weapon(String code) {
this.code = code;
}
public String getCode() {
return code;
}
public void setCode(String code) {
this.code = code;
}
}public class DemoMain {
public static void main(String[] args) {
Hero hero = new Hero();
Weapon weapon = new Weapon("AK-47");
hero.setName("亚瑟");
hero.setAge(20);
hero.setWeapon(weapon);
hero.attack();//20岁的亚瑟在用AK-47攻击敌人
}
}接口做成员变量
public class Hero {
private String name; //英雄姓名
private Skill skill;
public void attack(){
System.out.println("我叫"+name+",开始施放技能");
skill.use();
System.out.println("施放技能完成");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Skill getSkill() {
return skill;
}
public void setSkill(Skill skill) {
this.skill = skill;
}
}接口
public interface Skill {
void use();
}接口实现类
public class SkillImpl implements Skill {
@Override
public void use() {
System.out.println("biu~biu~biu");
}
}main方法
public class DemoMain {
public static void main(String[] args) {
Hero hero = new Hero();
hero.setName("亚瑟");
// 设置英雄技能
hero.setSkill(new SkillImpl());
hero.attack();
// 还可以改成使用匿名内部类
Skill skill = new SkillImpl(){
@Override
public void use() {
System.out.println("pia~biu~pia~biu");
}
};
hero.setSkill(skill);
hero.attack();
// 进一步简化，同时使用匿名内部类和匿名对象
hero.setSkill(new SkillImpl(){
@Override
public void use() {
System.out.println("pia~pia~pia");
}
});
hero.attack();
}
}接口作为方法的参数或返回值
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 = addName(list);
for (int i = 0; i < result.size(); i++) {
System.out.println(result.get(i));
}
}
public static List<String> addName(List<String> list){
list.add("1");
list.add("2");
list.add("3");
list.add("4");
return list;
}
}
扫一扫
275
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
