Java-final、权限、内部类

final常见四种用法

final关键字代表最终的，不可改变的

1. 用来修饰一个类

   格式：public final class 类名称 { }

   利用final修饰的类不能有任何的子类，不能继续往下

2. 用来修饰一个方法

   格式：public final void 方法名()

   当final用来修饰一个方法时，这个方法就不能被子类覆盖重写

3. 用来修饰一个局部变量

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

   • 对于基本类型来说，不能被改变就是变量当中的数据不能被改变；而对于引用类型来说，是地址值不能改变，但是内容可以改变

4. 用来修饰一个成员变量

   被final修饰后，同样不能够改变

   • 由于成员变量是具有默认值的，为了不将默认值放入，所以被final修饰的成员变量就必须要进行手动赋值
   • 对于修饰的成员变量，要么直接赋值，要么就通过构造方法赋值
   • 必须保证当中所有重载的构造方法，都会对final修饰的成员变量进行赋值

四种不同的权限修饰符

范围： public > protected > (default) > private

(default)的意思是不写

	public	protected	(default)	private
同一个类	Yes	Yes	Yes	Yes
同一个包	Yes	Yes	Yes	No
不同包子类	Yes	Yes	No	No
不同包非子类	Yes	No	No	No

内部类

1. 成员内部类：一个定义在类中的类
2. 局部内部类：一个定义在方法中的类，就是一个局部内部类

成员内部类：

例如：人体和心脏、汽车和发动机

内部类使用外部类可以随便使用，但是外部内使用内部类时需要借助内部类的对象

（内用外，随便用；外用内，需要借助内部类对象）

package Demo02;

public class outer {
    private String name;

    public String getName() {
        return name;
    }

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

    public void method(){
        System.out.println("外部类的成员方法");
    }

    public void useinner(){
        new inner().method();
    }

    public class inner {
        public void method() {
            System.out.println("内部类的成员方法");
            System.out.println("我是" + name);
        }
    }
}

========================================================
package Demo02;

public class innermain {
    public static void main(String[] args) {
        outer out = new outer();
        out.setName("郭忠宇");
        out.useinner();
    }
}

========================================================
package Demo02;

public class innermain {
    public static void main(String[] args) {
        outer.inner use = new outer().new inner();
        use.method();
    }
}

利用内部类的两种不同方式：

1. 间接方式：在外部类中创建一个函数去调用内部类，当调用外部内的该方法时就可以通过外部类去用内部类

   例如：上面useinner()方法

2. 直接方式：外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称；

内部类的同名变量访问

package Demo02;

public class outer {
    int num = 10;
    
    public void method() {
        System.out.println("外部类的method成员方法");
    }

    public class inner {
        int num = 20;
        public void method() {
            int num = 30;
            System.out.println("内部类的method成员方法");
            System.out.println(num);    //30
            System.out.println(this.num);  //20
            System.out.println(outer.this.num);  //10
        }
    }
}

==============================================================
package Demo02;

public class innermain {
    public static void main(String[] args) {
        outer.inner use = new outer().new inner();
        use.method();
    }
}

局部内部类：

只有当前所属的方法才能使用，出了这个方法就不能用了

局部内部类的final方法使用：局部内部类，如果希望能够访问所在方法的局部变量，那么这个局部变量就必须是有效final的；即int num；或者final int num；

package Demo02;

public class Jubuinner {
    public void outmethod(){
        class inner{   //局部内部类，什么都不能写，权限修饰符一个都不能写
            public void innermethod(){
                System.out.println("我是局部内部类中的method方法");
            }
        }

        inner inn = new inner();
        inn.innermethod();
    }
}
==========================================================================
package Demo02;

public class innermain {
    public static void main(String[] args) {
        Jubuinner Jubu = new Jubuinner();
        Jubu.outmethod();
    }
}

注意事项：

权限修饰符：public > protected > (default) > private

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

1. 外部类：public / (default)
2. 成员内部类：public / protected / (default) / private
3. 局部内部类：什么都不能写

匿名内部类

匿名内部类是属于局部内部类

如果接口的实现类（或者父类的子类），只需要使用唯一的一次，这个时候就可以使用匿名内部类

定义格式：

接口名称 对象名 = new 接口名称（）{

//覆盖重写所有的抽象方法

}

package Demo02;

public class innermain {
    public static void main(String[] args) {
        Noname no = new Noname() {   //接口名称 对象名 = new 接口名称（）
            @Override
            public void method() {
                System.out.println("实现类覆盖重写了方法！");
            }
        };
        no.method();    //这个匿名内部类有名字，名字就是no
    }
    
/*    new Noname() {   //接口名称 对象名 = new 接口名称（）
            @Override
            public void method() {
                System.out.println("实现类覆盖重写了方法！");
            }
      }.method();   //让这个方式，没有名字，既是匿名内部类，又是匿名对象
*/
}

注意事项：

1. 匿名内部类在创建对象时，就只能使用唯一的一次
2. 如果希望重复使用，那就需要单独定义实现类

类和接口均可作为成员变量类型