final关键字
final：不可改变，用于修饰类方法和变量
修饰类：被修饰的类不能被继承
修饰方法：被修饰的方法，不能被重写
变量：被修饰的变量，不能被重新赋值
使用格式：
修饰类：
final class 类名{
}
修饰方法：
修饰符 final 返回值类型 方法名（参数列表）{
//方法体
}
修饰变量：
局部变量–基本类型
基本类型的局部变量，被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;
// 报错,不可重新赋值
}
}
局部变量–引用类型
引用类型的局部变量，被final修饰后，只能指向一个对象，地址不能再更改。但是不影响对象内部的成员变量值的 修改，代码如下：
public class FinalDemo2 {
public static void main(String[] args) {
// 创建 User 对象
final User u = new User();
// 创建 另一个 User对象
u = new User(); // 报错，指向了新的对象，地址值改
变。
// 调用setName方法
u.setName("张三");
// 可以修改
}
}
成员变量：
成员变量涉及到初始化的问题，初始化方式有两种，只能二选一：
显示初始化
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修饰的常量名称，一般都有书写规范，所有字母都大写。
权限修饰符
java中提供了4中访问权限：
public ：公共的
protected ： 受保护的
default ： 默认的
private ： 私有的
public具有最大权限，private是最小的权限
编写代码时，建议这样使用权限
成员变量使用 private ，隐藏细节。
构造方法使用 public ，方便创建对象。
成员方法使用 public ，方便调用方法
内部类
定义：讲一个类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. 重写接口中的方法 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();
}
}
