java学习笔记19

final关键字

final关键字代表最终的，不可改变的
常用四种用法
1 可以用来修饰一个类
2 可以用来修饰一个方法
3 可以用来修饰一个局部变量
4 可以用来修饰一个成员变量
修饰一个类

/*
final 修饰一个类
public final class 类名称
{
  //...
}
不能有子类但有父类,其中成员方法不能被覆盖重写
*/
public final class Demo
{
   public void method()
   {
      System.out.println("方法执行");
   }
}

修饰一个方法

/*
  当用final关键字修饰一个方法时，这个方法就是最终方法，不能被覆盖重写
  修饰符 final 返回值类型 方法名称(参数列表)
  {
    //方法体。。
  }
  注意 abstract关键字和fianl关键字不能同时出现
*/
public class Fu
{
    public final void method()
    {
       System.out.println("父类方法");
       
    }
}

修饰一个局部变量

public class Demo
{
    public static void main(String[] args)
    {
    //一旦使用final用来修饰局部变量，那么这个变量就不会进行修改
       final int num2=1000;
       final int num1;
       num1=1000;
       //对于基本类型来说，不可变说的是变量当中的数据不可变
       //对于引用变量来说，不可边说的是地址值不可变
    }
}

修饰一个成员变量

public class Person
{
/*
   对于成员变量来说，如果使用了final关键字修饰，那么这个变量也照样不可变
   1 由于成员变量具有默认值，所以使用了final之后必需手动赋值，不会再给默认值
   2 对于final的成员变量，要么使用直接赋值要么使用构造方法赋值,二者选其一
*/
   private final String name="aaaa";
   public Person(String name)
   {
      name="ssss";
   }
}

四种权限修饰符

内部类

一个类包含另一个类
例如 汽车和发动机
分类：
1 成员内部类
2 局部内部类（包含匿名内部类）
成员内部类
定义格式
修饰符 class 类名称
{
修饰符 class 内部类名称
{

 }

}
注意 内用外，可以随意访问，外用内，要有内部类对象

package cn.itcast.day11.demo03;

public class Body { // 外部类

    public class Heart { // 成员内部类

        // 内部类的方法
        public void beat() {
            System.out.println("心脏跳动：蹦蹦蹦！");
            System.out.println("我叫：" + name); // 正确写法！
        }

    }

    // 外部类的成员变量
    private String name;

    // 外部类的方法
    public void methodBody() {
        System.out.println("外部类的方法");
        new Heart().beat();
    }

    public String getName() {
        return name;
    }

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

使用成员内部类
1 间接方式，在外部类的方法中，使用内部类，然后main只是调用外部类的方法
2 直接方式，公式：外部类名称.内部类名称=new 外部类名称().new 内部类名称（）;

内部类的同名变量的访问

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

    int num = 10; // 外部类的成员变量

    public class Inner /*extends Object*/ {

        int num = 20; // 内部类的成员变量

        public void methodInner() {
            int num = 30; // 内部类方法的局部变量
            System.out.println(num); // 局部变量，就近原则
            System.out.println(this.num); // 内部类的成员变量
            System.out.println(Outer.this.num); // 外部类的成员变量
        }

    }

}

局部内部类

/*
   定义在一个方法内部的，那么这就是一个局部内部类
   “局部”：只有当前所属的方法才能使用他，除了这个方法就不能使用
   定义格式
   修饰符 class 外部类名称
   {
      修饰符 返回值类型 外部类方法名称(参数列表)
      {
          class 局部内部类
          {
          
          }
      }
   }
   定义一个类的时候，权限修饰符规则：
   1 外部类：public/(default)
   2 成员内部类:public/protected/(default)/private
   3 局部内部类 什么都不写
*/
public class Outer
{
    public void methodOuter()
    {
        class Inner
        {
           int num=10;
           public void methodInner()
           {
               System.out.println(num);
           }
        }
        Inner inner=new Inner();
        inner.methodInner();
    }
}
public class Demn
{
    public static void main(String[] args)
    {
       Outer obj=new Outer();
       obj.methodOuter();
    }
}

final问题

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

备注：从Java 8+开始，只要局部变量事实不变，那么final关键字可以省略。

原因：
1. new出来的对象在堆内存当中。
2. 局部变量是跟着方法走的，在栈内存当中。
3. 方法运行结束之后，立刻出栈，局部变量就会立刻消失。
4. 但是new出来的对象会在堆当中持续存在，直到垃圾回收消失。
*/
public class NyOuter
{
   public void methodOuter(){
      int num=10;//所在方法的局部变量
      class MyInner
      {
           public void methodInner()
           {
               System.out.println()
           }
      }
   }
}