idea笔记七（final、权限、内部类）

1.final关键字

        （1）final关键字代表最终、不可改变的

                常见的四种用法

                ①可以用来修饰一个类

                ②可以用来修饰一个方法

                ③还可以用来修饰一个局部变量

                ④还可以用来修饰一个成员变量

        （2）当final关键字用来修饰一个类的时候

                格式：

                public final class 类名称{

                        //.......

                }

                含义：当前这个类不能有任何的子类（太监类）

                注意：一个类如果是final的，那么其中所有成员方法都无法进行覆盖重写

        （3）当final关键字用来修饰一个方法的时候 

                这个方法就是最终方法，也就是不能被覆盖重写

                格式：

                修饰符 final 返回值类型 方法名称（参数列表）{

                                //方法体

                }

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

        （4）当final关键字用来修饰一个局部变量时

                一旦使用final用来修饰局部变量，那么这个变量就不能改变

                ①对于基本类型：不可变说的是变量当中的数据不可改变

                ②对于引用类型：不可变说的是变量当中的地址值不可改变

        （5）当final关键字用来修饰一个成员变量时

                这个成员变量也不可变

                ①由于成员变量具有默认值，所以用了final之后必须手动赋值，不会再给默认值了

                ②对于final的成员变量，要么直接赋值，要么通过构造方法赋值，二者选其一

                ③必须保证类当中的所有重载构造方法，都最终会对final成员变量进行赋值

2.四种权限修饰符

        （1）四种权限修饰符：public  >  protected   > （default）>  private

                同一个类                 yes            yes               yes             yes

                同一个包                 yes            yes               yes              no

                不同包子类              yes            yes               no               no

                不同包非子类           yes            no                no               no

                注意：（default）并不是关键字“default”，而是根本不写 

3.内部类

        （1）一个类内部包含另一个类

                分类：

                ①成员内部类

                ②局部内部类（包含匿名内部类）

        （2）成员内部类的定义格式

                修饰符 class 外部类名称 {

                        修饰符 class 内部类名称{

                                //...

                        }

                        //....

                }

                注意：内用外，随意访问；外用内，需要内部类对象

        （3）如何使用成员内部类

                两种方式：

                ①间接方式：在外部类的方法当中，使用内部类；然后main只是调用外部类的方法

                ②直接方式：公式：

                   【外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();】

        （4）内部类的同名变量访问

                如果出现了重名现象，那么格式是：外部类.this.外部类成员变量名

        （5）局部内部类

                局部内部类定义在方法的内部

                “局部”：只有当前所属的方法才能使用他它，出了这个方法外面就不能用了

                局部内部类定义格式：

                修饰符 class 外部类名称 {

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

                                class 局部内部类名称{

                                        //....

                                }

                        }

                }

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

                ①外部类：public /（default）

                ②成员内部类：public / protected /（default）/ private

                ③局部内部类：什么都不能写

        （6）局部内部的final问题

                局部内部类，如果希望访问所在方法的局部变量，那么这个局部变量必须是有效final的

                原因：

               ① new出来的对象在堆内存中

               ② 局部变量是跟着方法走的，在栈内存当中

               ③ 方法运行结束之后立刻出栈，局部变量就会立刻消失

               ④ new出来的对象会在堆当中持续存在，直到垃圾回收消失

4.匿名内部类

        （1）如果接口的实现类（或者父类的子类）需要使用唯一的一次

                那么这种情况下就可以省略掉该类的定义，而改为【匿名内部类】

        （2）匿名内部类的格式： 

                接口名称 对象名 =  new 接口名称(){

                        //覆盖重写所以抽象方法

                };

        （3）对“new 接口名称(){....}”进行解析：

                ①new代表创建对象的动作

                ②接口名称就是匿名内部类需要实现哪个接口

                ③{....}这才是匿名内部类的内容

                注意事项:

                ①匿名内部类在【创建对象】的时候，只能使用唯一的一次

                ②匿名对象，在【调用对象】的时候，只能调用唯一的一次

                        如果希望同一个对象，调用多次方法，那么必须给对象起个名字

                ③匿名内部类是省略了【实现类/子类】，但是匿名对象省略了【对象名称 】

                强调：匿名内部类和匿名对象不是一回事!!!

        （4）成员变量

                类可以作为成员变量

                接口可以作为成员变量

                接口可以作为方法的参数和返回值