一、final关键字
1.final概述
final关键字代表最终、不可改变。常见的用法：
1.可以用来修饰一个类
2.可以用来修饰一个方法
3.可以用来修饰一个局部变量
4.可以用来修饰一个成员变量2.final修饰一个类
格式：
public final class 类名称{
// ...
}
含义：
当前这个类不能有任何的子类。（太监类）
即使用final关键字修饰一个类之后，不能再使用一个final类来作为父类
注意事项：
一个类如果是final的，那么其中所有的成员方法都无法进行覆盖重写。（因为是太监类，无法有子类）
因为只有在子类中，才能对父类的方法进行覆盖重写.3.final修饰一个方法
当final关键字用来修饰一个方法的时候，这个方法就是最终方法，也就是不能被覆盖重写。
格式：
修饰符 final 返回值类型 方法名称(参数列表){
方法体
}
注意事项：
对于类、方法来说，abstract关键字和final关键字【不能同时使用】，因为矛盾。
abstract：一定要被覆盖重写
final：一定不能被覆盖重写4.final修饰一个局部变量
对于基本数据类型来说，不可改变指的是变量中的数据不可改变。
对于引用数据类型来说，不可改变指的是变量中的地址值不可改变，但是其中的内容是可以改变的。5.final修饰一个成员变量
对于成员变量来说，如果使用了final关键字修饰，那么这个变量也是不可改变的。
1.由于成员变量具有默认值，所以用了final之后必须手动赋值，不会再给默认值了
2，对于final的成员变量，要么使用直接赋值，要么通过构造方法赋值.【二者选其一】。
3.必须保证类当中所有重载的构造方法，都最终会对final的成员变量进行赋值。通过构造方法进行赋值，就不能写Setter了。二、权限修饰符
一共有四种权限修饰符：public、protected、(default)、private
可以访问到的不同权限修饰的成员变量关系如下：
public > protected > (default) > private
同一个类（自己） Y Y Y Y
同一个包（邻居） Y Y Y N
不同包子类（儿子） Y Y N N
不同包非子类（陌生人） Y N N N
巧记：呈上三角状
注意：(default)并不是关键字default,而是什么都不写上三角矩阵注解：
【在本类中】，由四种权限修饰符修饰的成员变量，都可以访问到；
【在用一个包中】，可以访问到public、protected、（default）修饰的成员变量，
但是，不能访问到private修饰的成员变量。
【不同包子类】，可以访问到public、protected修饰的成员变量，
但是，不能访问到（default）、private修饰的成员变量。
不在同一个类、不是同一个包、也不是不同包子类，而是【不同包非子类】，
可以访问到public修饰的成员变量，但是不能访问到protected、（default）、private修饰的成员变量。三、内部类
1.内部类概述
一个类就是用来模拟一类事物的，如果一个事物的内部包含另一个事物，那么与之对应，一个类内部就包含另一个类。这就是内部类。内部类就相当于身体和心脏的关系，身体是包含心脏的。
2.分类
1.成员内部类
【定义格式】：(直接在外部类下边定义)
修饰符 class 外部类名称{
修饰符 class 内部类名称{
// ...
}
// ...
}
【注意事项】：
内用外，随意访问；外用内，需要内部类对象。
【如何使用成员内部类？】有两种方式：
（1）间接方式：在外部类的方法当中，使用内部类，然后main只是调用外部类的方法
（2）直接方式：【公式】：
普通类：类名称 对象名 = new 类名称();
内部类：外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();(想要用内部类对象，必须要先有外部类对象)
2.局部内部类（包含匿名内部类）
如果一个类是定义在一个方法内部的，那么这就是一个局部的内部类。
3.区别：成员内部类是在【方法外边】，局部内部类是在【方法里面】实例分析：
Body body = new Body(); //外部类对象
//直接使用成员内部类
Body.Heart heart = new Body().new Heart();3.标识符命名和匿名内部类的联系
标识符的命名规则：字母、数字、下划线、符号。
因为在内部类中，编译后生成的.class文件有两个，包含：Body.class和Body符号有特殊意义，所以再给标识符命名的时候，就不推荐用$符号了，否则容易被认为是一个内部类。
4.访问重名的外部类成员变量
格式是：外部类名称.this.外部类成员变量名
this指向的是本类当中。
实例分析：
public class Outer {
int num = 10; // 外部类的成员变量
public class Inner{
int num = 20; // 内部类的成员变量
public void methodInner(){
int num = 30; // 内部类方法的局部变量
System.out.println(num); // 30,局部变量，就近原则
System.out.println(this.num); // 20,内部类的成员变量
System.out.println(Outer.this.num); // 10，外部类的成员变量
}
}}
5.局部内部类
如果一个类是定义在一个【方法内部】的，那么这就是一个局部的内部类。
“局部”：只有当前所属的方法才能使用它，出了这个方法外面就不能用了。
定义格式：
修饰符 class 外部类名称{
修饰符 返回值类型 方法名称(参数列表){
class 局部内部类名称{
// ...
}
}
}小结一下类的修饰符：
public > protected > (default) > private
定义一个类的时候，权限修饰符规则：
1.外部类：public / (default)
2.成员内部类：public / protected / (default) / private
3.局部内部类：什么都不能写（可以理解为只有当前方法自己能用，其他都不能用）注意事项：
局部内部类：如果希望访问所在方法的局部变量，那么这个局部变量必须是【有效final的】。只要局部变量事实不变，那么final关键字可以省略。【为什么要用final修饰】？
1.new出来的对象在堆内存当中
2.局部变量是跟着方法走的，在栈内存当中。
3.方法运行结束之后，立刻出栈，局部变量就会立刻消失。
4.但是new出来的对象会在堆当中持续存在，直到垃圾回收消失。
5.所以局部变量和new的对象的【生命周期】不一样，要想new出来的对象一直能用这个局部变量，这个局部变量的值就要唯一不变，所以用final修饰实例分析：
public class MyOuter {
public void methodOuter(){
/*final*/ int num = 10; // 所在方法的局部变量
class MyInner{
public void methodInner(){
System.out.println(num);
}
}
}
}6.匿名内部类
如果接口的实现类（或者是父类的子类）只需要使用唯一的一次。
那么这种情况下就可以省略掉该类的定义，而改为使用【匿名内部类】。（重点重点重点！！！）
匿名内部类的定义格式：
接口名称 对象名 = new 接口名称(){ // 抽象方法是定义在接口里面的
// 覆盖重写所有的抽象方法
};
备注：大括号包含的部分就是一个类，没有名字，是局部内部类，称为匿名内部类
【不要忘记最后的分号！！！】
定义格式注解：
1.new代表创建对象的动作
2.接口名称就是匿名内部类需要实现哪个接口
3.{...}是匿名内部类的内容注意事项：
1.匿名内部类，在【创建对象】的时候，只能使用【唯一一次】。
如果希望【多次】创建对象，而且类的内容一样的话，那么就必须使用单独定义的实现类了。
2.匿名对象，在【调用方法】的时候，只能调用【唯一一次】。
如果希望同一个对象，调用多次方法，那么必须给对象起个名字。
3.匿名内部类是省略了【实现类/子类名称】，但是匿名对象是省略了【对象名称】。
【强调：匿名内部类和匿名对象是不一样的！！！】实例分析：
//单独定义实现类
//创建实现类对象
MyInterfaceImpl impl = new MyInterfaceImpl();
//使用多态写法也可以，左边是接口，右边是实现类
MyInterface impl1 = new MyInterfaceImpl();
//使用匿名内部类，但不是匿名对象，对象名称是obj
//这样就不需要在单独定义一个实现类
//匿名内部类，创建对象的是时候，只能创建唯一一次
MyInterface obj = new MyInterface() {
@Override
public void method() {
System.out.println("匿名内部类实现了方法！");
}
@Override
public void method2() {
System.out.println("匿名内部类实现了方法2");
}
};
//使用匿名内部类，而且省略了对象的名称，也是匿名对象
//匿名对象，调用方法的时候，只能调用唯一一次
new MyInterface() {
@Override
public void method() {
System.out.println("匿名内部类实现了方法！");
}
@Override
public void method2() {
System.out.println("匿名内部类实现了方法2");
}
}.method();四、成员变量类型
1.类作为成员变量类型
和之前用String类似，String不是基本数据类型，而是一个类，所以成员变量是可以用一个类来作为类型的。
任何一种数据类型都可以作为成员变量类型。
2.接口作为成员变量类型
用法并无区别
3.接口作为成员变量类型
java.util.List正是ArrayList所实现的接口。
//左边是接口名称，右边是实现类名称，这就是多态写法
List<String> list = new ArrayList<>(); // ArrayList集合，即可变数组
//接口作为方法的参数或者返回值
public static List<String> addName(List<String> list){
list.add("张三");
list.add("李四");
list.add("王五");
return list;
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
