Java基础知识笔记5

final关键字

概述

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

常见四种用法

1.用来修饰一个类。

2.用来修饰一个方法。

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

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

用来修饰一个类

格式：

public final class 类名称{

		//内容

}

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

注意：一个类如果是final的，那么其中所有的成员方法都无法进行覆盖重写。（因为没儿子）

用来修饰一个方法

当final关键字用来修饰一个方法的时候，这个方法就是最终方法，也就是不能被覆盖重写。

格式：

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

//		内容

}

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

用来修饰一个局部变量

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

一次赋值，终生不变。

对于基本类型来说，不可变说的是变量当中的数据不可改变。

对于引用类型来说，不可变说的是变量当中的地址值不可改变。

public class FinalTest {
    public static void main(String[] args) {
        int num1 = 10;
        System.out.println(num1);

        num1 = 20;
        System.out.println(num1);

        final int num2 = 100;
        System.out.println(num2);

//        num2 = 200;   错误，无法再次赋值。

        Student stu1 = new Student("大帅");
        System.out.println(stu1);

        Student stu2 = new Student("二帅");
        System.out.println(stu2);

        final Student stu3 = new Student("三帅");
        System.out.println(stu3.getName());

//        stu3  = new Student("小帅");  错误报错，stu3地址不可再改变。
        stu3.setName("小帅");
        System.out.println(stu3.getName());//这个就可以，因为是在引用类型的地址上进行重新赋值，地址并未改变，
    }
}

用来修饰一个成员变量

对于成员变量，如果使用final关键字，那么这个变量也照样是不可变的，

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

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

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

权限修饰符

Java中有四种权限修饰符

	public	protected	（default）	private
同一个类（我自己）	YES	YES	YES	YES
同一个包（我领居）	YES	YES	YES	NO
不同包子类（我儿子）	YES	YES	NO	NO
不同包非子类（陌生人）	YES	NO	NO	NO

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

内部类

概述

如果一个事务的内部包含另一个事务，那么这就是一个类内部包含另一个类。

例如：身体和心脏的关系，又如：汽车和发动机的关系。

分类：

1.成员内部类

2.局部内部类（包含匿名内部类）

成员内部类

定义格式

修饰符 class 外部类名称 {
	修饰符 class 内部类名称{
        //内容
	}
}

其中，内用外，随意访问；外用内，需要内部对象。

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

使用成员内部类

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

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

成员内部类的同名变量访问

public class Body {
    int num = 10;
    public class Heart{
        int num = 20;
        public void dongdong(){
            int num = 30;
            System.out.println(Body.this.num);
            System.out.println(this.num);
            System.out.println(num);
        }
    }
}

局部内部类

如果一个类是定义在一个方法内部的，那么这就是一个局部内部类。

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

定义格式

修饰符  class  外部类名称{

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

				class  局部内部类名称{

						//内容

				}

		}

}

局部内部类的局部变量

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

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

原因：

1.new出来的对象在堆内存中。

2.局部变量是跟着方法走的，在栈内存中。

3.方法运行结束后立刻出栈，局部变量会立刻消失。

4.但new出来的的对象会在堆内存中持续存在，直到垃圾回收消失。

5.如果之后对象还活着并且想继续使用局部变量，由于之前局部变量已经消失，如果还想使用，可在常量池中取到之前的局部变量的值，因此需要用final关键字修饰变量，使其无法被重新赋值，原值能一直被保存。

小结权限修饰符

public > protected > (default) > private

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

1.外部类：public / (default)

2.成员内部类：public / protected / (default) / private

3.局部内部类：什么都不能写（和default不同）

匿名内部类(重点)

概述

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

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

匿名内部类的定义格式：

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

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

};

解析

对格式“new 接口名称( ){ }”进行解析:

1.new代表创建对象的动作

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

3.{…}这里面是匿名内部类的内容

注意

1. 匿名内部类，在创建对象的时候，只能使用唯一一次。如果希望使用多次，而且类的内容一样的话，那么就必须使用单独定义的实现类了。
2. 匿名对象，在【调用方法】的时候，只能调用唯一一次。如果希望同一个对象调用多种方法，一定要给对象起一个名字。
3. 匿名内部类是省略了【实现类/子类名称】，但是匿名对象是省略了【对象名称】。匿名内部类和匿名对象不是一回事。（理解了基本没问题）

类作为成员变量类型

参见Sum.Demo01

接口作为成员变量类型

参见Sum.Demo02

接口作为方法的参数或返回值

public class demo {

    public static void main(String[] args) {
        List<String> list = new ArrayList<>();//左边是接口名称，右边是类名称，这就是多态写法
        demo.addList(list);
        System.out.println(list);
    }

    public static List<String> addList(List<String> list){
        list.add("你好");
        list.add("你好啊");
        list.add("你好啊啊");
        list.add("你好啊啊啊");

        return list;
    }
}