一、final关键字
1.概述
Java提供了 final 关键字， 用于修饰不可改变内容。
final: 不可改变。可以用于修饰类、方法和变量。
类:被修饰的类，不能被继承。
方法:被修饰的方法，不能被重写。
变量:被修饰的变量，不能被重新赋值。
2.使用方式
#修饰类：
final class 类名 {
}//如 public final class String
#修饰方法：
修饰符 final 返回值类型 方法名(参数列表){
//方法体
}
- 局部变量——基本类型
基本类型的局部变量，被final修饰后，只能赋值一次，不能再更改
public class FinalDemo1 {
public static void main(String[] args) {
final int a;// 声明变量，使用final修饰
a = 10;// 第一次赋值
a = 20;// 第二次赋值 // 报错,不可重新赋值
final int b = 10;// 声明变量，直接赋值，使用final修饰
b = 20; // 第二次赋值// 报错,不可重新赋值
} }
- 局部变量——引用类型
引用类型的局部变量，被final修饰后，只能指向一个对象，地址不能再更改。但是不影响对象内部的成员变量值的修改。
public class FinalDemo2 {
public static void main(String[] args) {
final User u = new User();// 创建 User 对象
u = new User(); // 创建另一个对象//报错指向了新的对象，地址值改变。
u.setName("张三"); // 调用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修饰的常量名称，一般都有书写规范，所有字母都大写。
二、权限修饰符
1.概述
在Java中提供了四种访问权限，使用不同的访问权限修饰符修饰时，被修饰的内容会有不同的访问权限，
public:公共的。
protected:受保护的
default:默认的
private:私有的
2.不同权限的访问能力
可见，public具有最大权限。private则是最小权限。
编写代码时，如果没有特殊的考虑，建议这样使用权限:
成员变量使用 private ，隐藏细节。
构造方法使用 public ，方便创建对象。
成员方法使用 public ，方便调用方法。
小贴士:不加权限修饰符，其访问能力与default修饰符相同
三、内部类
概念：将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类。
1.成员内部类
成员内部类 :定义在类中方法外的类。
比如，汽车类 Car 中包含发动机 类 Engine ，这时， Engine 就可以使用内部类来描述，定义在成员位置。
定义格式:
class 外部类 {
class 内部类{
}
}
访问特点
内部类可以直接访问外部类的成员，包括私有成员。
外部类要访问内部类的成员，必须要建立内部类的对象。
创建内部类对象格式:
外部类名.内部类名 对象名 = 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$Heart.class
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("我飞了~~~");
}
};
f.fly(); //调用 fly方法,执行重写后的方法}
}
通常在方法的形式参数是接口或者抽象类时，也可以将匿名内部类作为参数传递。代码如下:
public class InnerDemo2 {
public static void main(String[] args) {
/*
1.等号右边:定义并创建该接口的子类对象
2.等号左边:是多态,接口类型引用指向子类对象
*/
FlyAble f = new FlyAble(){
public void fly() {
System.out.println("我飞了~~~"); }
};
showFly(f); }// 将f传递给showFly方法中
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作为成员变量
4.2 interface作为成员变量
4.3 interface作为方法参数和返回值类型
