Java中final关键字、权限、内部类

一：final关键字

学习了继承后，我们知道，子类可以在父类的基础上改写父类内容，比如，方法重写。那么我们能不能随意的继承API中提供的类，改写其内容呢？显然这是不合适的。为了避免这种随意改写的情况，Java提供了final 关键字，用于修饰不可改变内容。

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

类：被修饰的类，不能被继承。
方法：被修饰的方法，不能被重写。
变量：被修饰的变量，不

使用方式

修饰类

格式如下：

 final class 类名 {
 
}

修饰方法

格式如下：

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

重写被 final 修饰的方法，编译时就会报错。

被final修饰的方法不可被重写,重写发生在继承或者接口,就是为了扩展功能,而final定义的是不可变的,因此要切记: final 和abstract 不可同时使用.

注意：对于类、方法来说，abstract关键字和final关键字不能同时使用，因为矛盾。

修饰变量

局部变量——基本类型

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

public class FinalTest {
    public static void main(String[] args) {
        // 声明变量，使用final修饰
        final int a;
        // 第一次赋值
        a = 10;
        // 第二次赋值
        a = 20; // 报错,不可重新赋值
        // 声明变量，直接赋值，使用final修饰
        final int b = 10;
        // 第二次赋值
        b = 20; // 报错,不可重新赋值
    }
}

被final修饰的常量名称，一般都有书写规范，所有字母都大写。 

二：权限修饰符

在Java中提供了四种访问权限，使用不同的访问权限修饰符修饰时，被修饰的内容会有不同的访问权限

• public：公共的。

• protected：受保护的

• default：默认的 (在这里是权限而接口中的default是指默认的意思)

• private：私有的

 不同权限的访问能力

	public	protected	default（空的）	private
同一类中	√	√	√	√
同一包中(子类与无关类)	√	√	√
不同包的子类	√	√
不同包中的无关类	√

 可见，public具有最大权限，private则是最小权限。

编写代码时，如果没有特殊的考虑，建议这样使用权限：

成员变量使用 private ，隐藏细节。
构造方法使用 public ，方便创建对象。
成员方法使用 public ，方便调用方法。

 public > protected >default>private

编写代码时，如果没有特殊的考虑，建议这样使用权限：

成员变量使用private ，隐藏细节。 

构造方法使用public ，方便创建对象。

成员方法使用public ，方便调用方法。

 注意：不加权限修饰符，其访问能力与default修饰符相同

三： 内部类的定义和使用

概念：将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类。

成员内部类

成员内部类 ：定义在类中方法外的类。

定义格式：

 class 外部类 {
    class 内部类{
    }
}

 在描述事物时，若一个事物内部还包含其他事物，就可以使用内部类这种结构。

访问特点

内部类可以直接访问外部类的成员，包括私有成员。
外部类要访问内部类的成员，必须要建立内部类的对象。

创建内部类对象格式：

外部类名.内部类名 对象名 = new 外部类型().new 内部类型()；

 

public class Person {
    String name;

    class Student {
        String name;
        int age;
        String sex;

        @Override
        public String toString() {
            return "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    ", sex='" + sex + '\'' +
                    '}';
        }
    }
}


public class PersonTest01 {
    public static void main(String[] args) {
        //内部类的调用
        Person person=new Person();
        Person.Student student=person.new Student();
        student.name="张三";
        student.age=19;
        student.sex="男";
        System.out.println(student);

    }
}

匿名内部类:

匿名内部类:是内部类的简化写法。它的本质是一个带具体实现的父类或者父接口的 匿名的 子类对象。开发中，最常用到的内部类就是匿名内部类了。以接口举例，当你使用一个接口时，似乎得做如下几步操作:

1:定义子类
2:重写接口中的方法
3:创建子类对象
4:调用重写后的方法
我们的目的，最终只是为了调用方法，那么能不能简化一下，把以上四步合成一步呢？匿名内部类就是做这样的快捷方式。

前提
匿名内部类必须继承一个父类或者实现一个父接口。

格式：

new 父类名或者接口名(){
// 方法重写
@Override
public void method() {
// 执行语句
}
};

作用：

1、内部类可以很好的实现隐藏。
非内部类是不可以使用 private和 protected修饰的，但是内部类却可以，从而达到隐藏的作用。
2、间接的实现多继承。
每个内部类都能独立地继承自一个(接口的)实现，所以无论外部类是否已经继承了某个(接口的)实现，对于内部类都没有影响。