第一章 final关键字

1.概述

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

• final： 不可改变。可以用于修饰类、方法和变量。
  • 类：被修饰的类，不能被继承。
  • 方法：被修饰的方法，不能被重写。
  • 变量：被修饰的变量，不能被重新赋值。

2.使用

final关键字代表最终、不可改变的。常见四种用法：
1. 可以用来修饰一个类
2. 可以用来修饰一个方法
3. 还可以用来修饰一个局部变量
4. 还可以用来修饰一个成员变量

final修饰的类

当final关键字用来修饰一个类的时候，格式：
public final class 类名称 {// ...
}含义：当前这个类不能有任何的子类。（太监类）
注意：一个类如果是final的，那么其中所有的成员方法都无法进行覆盖重写（因为没儿子。）

public final class MyClass /*extends Object*/ {public void method() {System.out.println("方法执行！");}}

实现上边的final类：

// 不能使用一个final类来作为父类
public class MySubClass /*extends MyClass*/ {//报错！
}

final修饰方法

当final关键字用来修饰一个方法的时候，这个方法就是最终方法，也就是不能被覆盖重写。
格式：
修饰符 final 返回值类型 方法名称(参数列表) {// 方法体
}注意事项：
对于类、方法来说，abstract关键字和final关键字不能同时使用，因为矛盾。

public abstract class Fu {public final void method() {System.out.println("父类方法执行！");}public abstract /*final*/ void methodAbs() ;}

public class Zi extends Fu {@Overridepublic void methodAbs() {}// 错误写法！不能覆盖重写父类当中final的方法
//    @Override
//    public void method() {//        System.out.println("子类覆盖重写父类的方法！");
//    }
}

final修饰局部变量

一旦使用final用来修饰局部变量，那么这个变量就不能进行更改。
“一次赋值，终生不变”

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. 由于成员变量具有默认值，所以用了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;
//    }
}

第二章 权限修饰符

在Java中提供了四种访问权限，使用不同的访问权限修饰符修饰时，被修饰的内容会有不同的访问权限，

• public：公共的。
• protected：受保护的
• default：默认的
• private：私有的
  

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

• 成员变量使用 private ，隐藏细节。
• 构造方法使用 public ，方便创建对象。
• 成员方法使用 public ，方便调用方法。
  小贴士：不加权限修饰符，其访问能力与default修饰符相同

第三章 内部类

1.概述

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

如果一个事物的内部包含另一个事物，那么这就是一个类内部包含另一个类。
例如：身体和心脏的关系。又如：汽车和发动机的关系。分类：
1. 成员内部类
2. 局部内部类（包含匿名内部类）成员内部类的定义格式：
修饰符 class 外部类名称 {修饰符 class 内部类名称 {// ...}// ...
}注意：内用外，随意访问；外用内，需要内部类对象。==========================
如何使用成员内部类？有两种方式：
1. 间接方式：在外部类的方法当中，使用内部类；然后main只是调用外部类的方法。
2. 直接方式，公式：
类名称 对象名 = new 类名称();
【外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();】

2.成员内部类的实现

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;}
}

注意：定义类名称的的时候不使用$，原因是编译文件：

1.使用成员内部类

1）间接方式
在外部类的方法当中，使用内部类；然后main只是调用外部类的方法。
如上边的：

public void methodBody() {System.out.println("外部类的方法");new Heart().beat();//在外部类中间接使用了内部类}

2）直接方式
外部类名称.内部类名称 对象名 = 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();}}

2.内部类中的同名变量的访问

// 如果出现了重名现象，那么格式是：外部类名称.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); // 外部类的成员变量}}}

3.局部内部类

如果一个类是定义在一个方法内部的，那么这就是一个局部内部类。
“局部”：只有当前所属的方法才能使用它，出了这个方法外面就不能用了。定义格式：
修饰符 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();}}

使用：

public class DemoMain {public static void main(String[] args) {Outer obj = new Outer();obj.methodOuter();}}

局部内部类的final问题

/*
局部内部类，如果希望访问所在方法的局部变量，那么这个局部变量必须是【有效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);}}}}

4.匿名内部类【重点】

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

1. 定义子类
2. 重写接口中的方法
3. 创建子类对象
4. 调用重写后的方法

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

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

如果接口的实现类（或者是父类的子类）只需要使用唯一的一次，
那么这种情况下就可以省略掉该类的定义，而改为使用【匿名内部类】。匿名内部类的定义格式：
接口名称 对象名 = new 接口名称() {// 覆盖重写所有抽象方法
};对格式“new 接口名称() {...}”进行解析：
1. new代表创建对象的动作
2. 接口名称就是匿名内部类需要实现哪个接口
3. {...}这才是匿名内部类的内容，这个类没有名字！所以才叫匿名！另外还要注意几点问题：
4. 匿名内部类，在【创建对象】的时候，只能使用唯一一次。
如果希望多次创建对象，而且类的内容一样的话，那么就需要使用单独定义的实现类了。
5. 匿名对象，在【调用方法】的时候，只能调用唯一一次。
如果希望同一个对象，调用多次方法，那么必须给对象起个名字。
6. 匿名内部类是省略了【实现类/子类名称】，但是匿名对象是省略了【对象名称】
！！！ 强调：匿名内部类和匿名对象不是一回事！！！

定义格式：
先定义一个接口：

public interface MyInterface {void method1(); // 抽象方法void method2();
}

实现：

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.1类作为成员变量类型

Demo：

public class Weapon {private String code; // 武器的代号public Weapon() {}public Weapon(String code) {this.code = code;}public String getCode() {return code;}public void setCode(String code) {this.code = code;}
}

// 游戏当中的英雄角色类
public class Hero {private String name; // 英雄的名字private int age; // 英雄的年龄private Weapon weapon; // 英雄的武器public Hero() {}public Hero(String name, int age, Weapon weapon) {this.name = name;this.age = age;this.weapon = weapon;}public void attack() {System.out.println("年龄为" + age + "的" + name + "用" + weapon.getCode() + "攻击敌方。");}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;}
}

public class DemoMain {public static void main(String[] args) {// 创建一个英雄角色Hero hero = new Hero();// 为英雄起一个名字，并且设置年龄hero.setName("盖伦");hero.setAge(20);// 创建一个武器对象Weapon weapon = new Weapon("AK-47");// 为英雄配备武器hero.setWeapon(weapon);// 年龄为20的盖伦用多兰剑攻击敌方。hero.attack();}}

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 接口作为方法的参数或返回值

当接口作为方法的参数时,需要传递什么呢？当接口作为方法的返回值类型时，需要返回什么呢？对，其实都是它的
子类对象。 ArrayList 类我们并不陌生，查看API我们发现，实际上，它是 java.util.List 接口的实现类。所
以，当我们看见 List 接口作为参数或者返回值类型时，当然可以将 ArrayList 的对象进行传递或返回。
请观察如下方法：获取某集合中所有的偶数。

/*
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;}}

Java基础（9）——final、权限、内部类、引用类型相关推荐

1. java基础(十三)-----详解内部类——Java高级开发必须懂的

   java基础(十三)-----详解内部类--Java高级开发必须懂的 目录 为什么要使用内部类 内部类基础 静态内部类 成员内部类 成员内部类的对象创建 继承成员内部类 局部内部类 推荐博客 匿名内部 ...

2. 【Java基础】final关键字总结

   Java中的final关键字非常重要,它可以应用于类.方法以及变量.这篇文章中我将带你看看什么是final关键字?将变量,方法和类声明为final代表了什么?使用final的好处是什么?最后也有一些使 ...

3. java基础-关键字final

   概述 final是java中一个保留的关键字,也被视为一个修饰符(Modifier),可以修饰一个成员变量.方法参数.方法甚至一个类. final变量(域) 凡是用final关键字修饰的成员变量或本地 ...

4. java网课|final权限修饰符

   P195 final关键字概念 常见的四种用法: 修饰一个类(1): 1.不能有子类 2.它的成员方法不能被覆盖重写 修饰一个方法(2): 不能覆盖重写[父类当中final的方法] 父类中: publ ...

5. Java基础之访问权限（访问限定符）

   1 定义 2 使用方式 3 出现的位置 4 总结 1 定义 访问权限是指定义在类中的方法和属性是否可以在其它类使用. public protected 不写 private 公开的,所有类都能使用 受 ...

6. java基础之final关键字，形式参数和返回值问题

   目录 一:final关键字 二:形式参数和返回值问题 1:形式参数 2:返回值类型 3:例子 一:final关键字 1:final关键字是最终的意思,可以修饰类,成员变量,成员方法. 2:修饰类,类不 ...

7. Java基础复习——访问权限

   1.访问权限由大到小顺序 public-protected-default-private 2.三种对象可能出现的位置 在本类中的对象 在同一个包内,出现在本类外的对象 在包外的对象 3.上面三种情况 ...

8. java基础之final关键字_繁星漫天_新浪博客

   final关键字可以修饰类.变量.方法,它有"这是无法改变的"或者"最终"的含义 因此被final修饰的有以下特性: 1.final修饰的类不能继承 2.fin ...

9. java基础学习--final

   1.final属性的数据 对于基本数据类型:一旦第一次赋值之后,就不允许改变了.(声明的时候可以先不赋值) final int a = 6; // a = 7;会报编译错误,提示已分配变量给a 对于数 ...

10. java 调用关系_【Java基础】几种简单的调用关系与方法

    直接上代码吧. class lesson4AB //同一个类下的public修饰的方法A,B可以相互调用 { public void A() { B();//等价于this.B(); } public ...

最新文章

1. c语言中字符串数组的地址存放以及%s输出单个字符导致程序崩溃的问题
2. Nginx的正向代理与反向代理
3. 网络好不好，ping一下就知道
4. 项目中除了需求外还需要知道的问题
5. 浅谈数据中的偏差问题和推荐系统去偏最新研究进展
6. 操作系统 综合应用题知识点更新【章节考试重点（进程同步、处理机调度与死锁、存储管理、设备管理、文件管理）】
7. （21）Spring Boot过滤器、监听器【从零开始学Spring Boot】
8. windows下C语言多线程编程
9. 零基础带你学习MySQL—多子句查询（十九）
10. java 安卓权限_java – Android运行时权限 – 如何实现
11. mssql数据库基本语句总结（2）
12. 【跳频扩频通信】基于matlab跳频扩频通信【含Matlab源码 1003期】
13. 公司打算使用内网安全管理的软件，看了一下感觉IP-guard和Ping32两个好像不错，有需要的朋友可以参考一下
14. wordpress单独html页面,wordpress独立留言板页面
15. 行测---图形推理思维导图总结
16. 51单片机原理与设计方案（包含原理图与PCB）
17. 关于javaweb中的流媒体
18. shell连接CentOS启动可视化界面startx
19. ps、ai超强辅助类插件，神器一样的存在
20. 关于waitKey()函数按键无反应情况

热门文章

1. 手机可用熵_信息论的熵
2. tkinter如何变成悬浮窗
3. GUITAR PRO8吉他软件好不好用?值不值得下载
4. 基于php的二手车交易网站
5. 误区：初创企业不应该注重网络安全防护
6. 【二】服务器硬件知识
7. RFID医疗耗材管理解决方案-RFID耗材柜管理系统
8. IOS – OpenGL ES 图像水晶球效果 GPUImageGlassSphereFilter
9. 易特鞋店销售管理后台软件（4）
10. 2022年计算机软件水平考试网络规划设计师（高级）练习题及答案