java final类的写法_java.final关键字、权限修饰符、内部类

final关键字

final关键字用于修饰不可改变的内容

final：不可改变。可以用于修饰类、方法和变量

类：被修饰的类不能被继承

方法：被修饰的方法不能被重写

变量：被修饰的变量不能被重新赋值

修饰类

final class 类名{

}

修饰方法

修饰符 final 返回值类型 方法名(参数列表){

//方法体

}

修饰变量

1、局部变量--基本类型

基本类型的局部变量，被final修饰后，只能赋值一次，不能再更改

public class Demo01 {

public static void main(String[] args) {

//声明变量，使用final修饰

final int a;

//第一次赋值

a = 10;

//第二次赋值

//a = 20; //报错，不可重新赋值

//声明变量，直接赋值，使用final修饰

final int b = 10;

//第二次赋值

b = 20;//报错，不可重复赋值

}

}

**2、局部变量--引用类型

引用类型的局部变量，被final修饰后，只能指向一个对象，地址不能再更改，但是不影响对象内部的成员变量值的修改

**

public class Demo02 {

public static void main(String[] args) {

//创建user对象

final User u = new User();

//创建另一个User对象

//u = new User(); // 报错，指向了新对象，地址值改变

//调用setName方法

u.setName("leesin");

}

}

3、成员变量

成员变量设计到初始化问题，初始化方式有两种，只能二选一

显示初始化

public class User{

final String USERNAME = "leesin"

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中提供了四种访问权限，使用不同的访问权限修饰符修饰时，被修饰的内容会有不同的访问权限

public：公共的

protected：受保护的

default：默认的

private：私有的

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 Demo {

public static void main(String[] args) {

// 创建外部类对象

Person p = new Person();

//创建内部类对象

Person.Heart heart = p.new Heart();

//调用内部类方法

heart.jump();

//调用

p.setLive(false);

heart.jump();

}

}

输出结果：

心脏在跳动

心脏不跳了

内部类仍然是一个独立的类，在编译之后会内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号 。

比如，Person$Heart.class

匿名内部类

是内部类的简化写法。他的本职是一个带具体实现的 父类或父类接口的 匿名的 子类对象。

开发中，最常用的内部类就是匿名内部类。以接口举例，当你使用一个接口时，似乎做得如下几步操作

定义子类

重写接口中的方法

创建子类对象

调用重写后的方法

最终目的只是为了调用方法，匿名内部类就是将四步合一

格式：

new 父类名或者接口名(){

//方法重写

@Override

public void method(){

//执行语句

}

}

使用方式

以接口为例，匿名内部类的使用，代码如下：

定义接口：

public abstract class FlyAble{

public abstract void fiy();

}

创建匿名内部类，并调用：

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 sly(){

System.out.println("起飞了);

}

});

}

public static void showFly(FlyAble f){

f.fly();

}

}