final关键字和内部类
final常见的四种用法：修饰类和方法修饰成员变量和局部变量内部类成员内部类局部内部类匿名内部类
final常见的四种用法：
1.可以用来修饰一个类 2.可以用来修饰一个方法 3.可以用来修饰一个局部变量 4.可以用来修饰一个成员变量
修饰类和方法
当final关键字用来修饰一个类的时候，格式：
public final class 类名称{
//...
}
含义：当前这个类不能有任何的子类。
其中所有的成员方法都无法覆盖重写。
当final关键字用来修饰一个方法的时候，格式
修饰符 final 返回值类型 方法名称（参数列表）{
//方法体
}
对于类、方法来说，abstract关键字和final关键字不能同时使用，因为矛盾。抽象方法需要重写，final关键字不被能重写。
public final class Fu{
public void method(){
System
.out
.println("方法1");
}
}
public class Zi{
public void method(){
System
.out
.println("方法2");
}
}
修饰成员变量和局部变量
对于成员变量来说，如果使用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 class Final {
public static void main(String
[] args
) {
int num1
= 10;
System
.out
.println(num1
);
num1
= 20 ;
System
.out
.println(num1
);
final int num2
= 200;
Student stu1
= new Student("放");
System
.out
.println(stu1
);
stu1
= new Student("稳");
System
.out
.println(stu1
);
final Student stu2
= new Student("wen");
System
.out
.println(stu2
.getName());
}
}
内部类
内部类
分类：
1.成员内部类
2.局部内部类（包含匿名内部类）
成员内部类的定义格式
修饰符 class 类名称{
修饰符 class 类名称{
//....
}
//....
}
注意：内用外，随意访问：外用内，需要内部类对象。
===================================
如何使用成员内部类？有两种方式：
1.间接方式：在外部类的方法当中，使用内部类；然后main只是调用外部类的方法。
2.直接方式，公式：
类名称 对象名 = new 类名称（）；
外部类名称.内部类名称 对象名 = new 外部类名称（）.new 内部类名称（）；
成员内部类
public class Body {
private String name
;
public String
getName() {
return name
;
}
public void setName(String name
) {
this.name
= name
;
}
public class Heart{
public void beat(){
System
.out
.println("心脏跳动");
System
.out
.println("我叫 " + name
);
}
}
public void methodBody(){
System
.out
.println("外部类方法");
new Heart().beat();
}
}
public class Outer {
int num
= 10 ;
public class Inners{
int num
= 20 ;
public void methodInner(){
int num
= 30 ;
System
.out
.println(num
);
System
.out
.println(this.num
);
Outer outer
= new Outer();
System
.out
.println(outer
.num
);
System
.out
.println(new Outer().num
);
System
.out
.println(Outer
.this.num
);
}
}
}
public class OuterClass {
public static void main(String
[] args
) {
Body body
= new Body();
body
.methodBody();
Body
.Heart heart
= new Body().new Heart();
heart
.beat();
Outer
.Inners inner
= new Outer().new Inners();
inner
.methodInner();
}
}
局部内部类
如果一个类是定义在一个方法内部的，那么这就是一个局部内部类。
“局部”：只有当前所属的方法才能使用它，出了这个方法外面就不能用了。
定义格式：
修饰符 class 外部类名称{
修饰符 返回值类型 外部类方法名称（参数列表）{
class 局部内部类名称{
//......
}
}
}
public class Inner {
public void methodOuter(){
class Inner1{
int num
= 10;
public void methodInner(){
System
.out
.println(num
);
}
}
Inner1 inner1
= new Inner1();
inner1
.methodInner();
}
}
匿名内部类
如果接口的实现类（或者是父类的子类）只需要使用唯一的一次
那么这种情况下就可以省略掉该类的定义，而改为使用【匿名内部类】
匿名内部类的定义格式：
接口名称 对象名 = new 接口名称（）{
//覆盖重写接口中所有抽象方法
};
另外还要注意几点问题：
1.匿名内部类在创建对象的时候，只能使用唯一一次。如果希望多次创建对象，而且内容一样的话，
那么就必须使用单独定义的实现类。
2.匿名对象，在【调用方法】的时候，只能调用唯一一次。
如果希望同一个对象，调用多次方法，那么必须给对象起个名字。
3.匿名内部类是省略了【实现类/子类名称】，但是匿名对象是省略了【对象名称】
public interface MyInterFace {
void method();
}
public class MyInterfaceImp implements MyInterFace{
@Override
public void method() {
System
.out
.println("覆盖重写");
}
}
public class ImpMyInterfaceImp {
public static void main(String
[] args
) {
MyInterFace interFace
= new MyInterFace() {
@Override
public void method() {
System
.out
.println("匿名内部类重写方法");
}
};
interFace
.method();
MyInterfaceImp myInterfaceImp
= new MyInterfaceImp(){
public void method(){
System
.out
.println("这里重写了");
}
};
myInterfaceImp
.method();
new MyInterFace(){
@Override
public void method() {
System
.out
.println("匿名对象匿名内部类");
}
}.method();
}
}
