JAVA（8） - Final

一.final关键字

1.常见四种用法

• 修饰一个类
• 修饰一个方法
• 修饰一个局部变量
• 修饰一个成员变量

修饰一个类

public final class finalInClass {
	public finalInClass(String str){
    	name = str;
	}
	private final String name/* = "word"*/;
	public String getName() {
    	return name;
	}
	public void setName(String name) {
    	this.name = name;
	}
}

当用final关键字修饰一个类的时候
格式：

//public final class 类名称{
	//...
//}

含义：当前这个类不能有任何的子类
注意：一个类如果是final的，其中所有的成员方法都无法进行覆盖重写（没有被继承）

修饰成员变量

• 对于成员变量来说，如果使用final关键字进行修饰，那么这个变量也照样是不可变的
• 由于成员变量具有默认值，所以用了final之后必须手动赋值，不会再给赋值
• 对于final的成员变量，要么使用直接赋值，要么通过构造方法赋值
• 必须保证类当中所有重载的构造方法，都最终会对final的成员变量进行赋值

修饰一个方法

public class finalInVoid {
	public final void method(){
    	System.out.println("Final!!!");
	}
}

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

修饰一个局部变量

	final int num = 200;
    //修饰一个局部变量，则不能进行更改
    //即使是再次赋同样的值，也是错误写法
    //可以分开为两句进行赋值
    final int num1;
    num1 = 200;

注意事项：
1.对于基本类型来说，不可变说的是变量当中的数据不可改变
2.对于引用类型来说，不可变说的是变量当中地址值不可改变，内容可以改变

二.四种权限修饰符的比较

三.内部类

分类：

• 成员内部类
• 局部内部类（包含匿名内部类）

成员内部类

1.定义格式

修饰符 class 外部类名称{
	修饰符 class 内部类名称{}
}

注意事项：内部类使用外部类可以随意访问，外部类使用内部类需要内部类对象

2.使用方式

• 间接方式：在外部类的方法当中，使用内部类，然后main方法中调用外部类的方法
• 直接方式：
  格式：外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();
  对比普通类对象创建：类名称 对象名 = new 类名称();

实例：

public class Body {
	int num = 500;
	public String getName() {
    	return name;
	}

	public void setName(String name) {
    	this.name = name;
	}

	//内部类
	public class Heart{ 
	//内部类并不继承外部类
    	int num = 200;
    	//内部类的方法
    	public void beat(){
        	System.out.println("BBB!!!!");
        	System.out.println("my name is " + name);
    	}
    	public void methodInner(){
        	int num =300;
        	System.out.println(num); //局部变量，就近原则
        	System.out.println(this.num);
        	System.out.println(Body.this.num);
        //如果出现了重名现象，那么使用外部类变量格式是：外部类名称.this.外部类成员变量名
    	}
    	//文件名Body$Heart.class
	}
	//外部类的方法
	public void methodBody(){
    	System.out.println("外部类的方法！");
    	Heart heart = new Heart();
    	heart.beat();
	}
	//外部类的变量
	private String name;
}

使用实例：

Body body = new Body();
body.methodBody();
Body.Heart heart1 = new Body().new Heart();
heart1.methodInner();

局部内部类

1.定义：如果一个类是定义在一个方法内部的，那么这就是一个局部内部类
    “局部”定义: 只有当前所属方法的方法才能使用这个类，除了这个方法外面不能使用

2.定义格式：

修饰符 class 外部类名称{
	修饰符 返回值类型 外部类方法名称(参数列表){
    	class 局部内部类名称{
        	//...
    	}
	}
}

实例：

public void methodOuter(){
    /*final*/int num1 = 10;
	//只赋值一次也是有效final,只需要保证事实不变
    class Inner{
        int num = 100;
        public void methodInner(){
            System.out.println(num);
        }
    }
    Inner inner = new Inner();
    inner.methodInner();
}

3.定义一个类的时候，权限修饰符规则：

• 外部类：public/（default)
• 成员内部类：四个都行
• 局部内部类：都不能写

4.如果希望访问所在方法的局部变量，那么这个局部变量必须是有效final的
 原因：

• new出来的对象在堆内存中
• 局部变量是跟着方法走的，在栈内存当中
• 方法运行结束之后，立刻出栈，局部变量就会消失
• 但是new出来的对象会在堆当中持续存在，直到垃圾回收消失

匿名内部类

1.定义：匿名内部类不是匿名对象
如果接口的实现类或者是父类的子类，只需要使用唯一的一次，那么这种情况就可以省略掉该类的定义，而改为匿名内部类

2.定义格式：

接口名称 对象名 = new 接口名称(){
	覆盖重写所有抽象方法
};

实例：

MyInterface obj = new MyInterface(){
	public void show(){}
};

3.注意事项：
1.匿名内部类，在创建对象的时候，只能使用唯一一次，如果希望多次创建对象，而且类的内容一样的话，就必须使用单独定义的实现类
2.匿名内部类的匿名对象：在调用方法的时候，只能调用唯一一次
  如果希望同一个对象调用多次方法，必须给对象起个名字
格式：

new MyInterface(){
  public void show(){}
}.show();

1.匿名内部类，在创建对象的时候，只能使用唯一一次，如果希望多次创建对象，而且类的内容一样的话，就必须使用单独定义的实现类
2.匿名内部类的匿名对象：在调用方法的时候，只能调用唯一一次
  如果希望同一个对象调用多次方法，必须给对象起个名字
格式：

new MyInterface(){
  public void show(){}
}.show();

3.匿名内部类是省略了实现类/子类名称，但是匿名对象是省略了对象名称，有所不同