Java入门——final关键字

最新推荐文章于 2022-11-14 15:33:51 发布

脑袋不灵光的小白羊

最新推荐文章于 2022-11-14 15:33:51 发布

阅读量296

点赞数

分类专栏： Java 文章标签： java

本文链接：https://blog.csdn.net/qq_42588990/article/details/109562228

版权

Java 专栏收录该内容

113 篇文章 8 订阅

订阅专栏

关于Java语言中的final关键字：

final是一个关键字，表示最终的，不变的
final修饰的类无法被类继承
final修饰的方法无法被覆盖
final修饰的变量“一旦”赋值之后不可重新赋值【只能赋值一次】
final修饰的引用一旦指向某个对象之后，不能让它去指向其他对象，那么被指向的对象永远不能被垃圾回收器回收

final修饰的引用虽然指向某个对象后不能指向其他对象，但是所指向的对象内部的内存是可以更改的
final修饰的实例变量，（万变不离其宗）final修饰的变量只能赋值一次（这句话到哪里都好使）
你是否记得，实例变量如果没有手动赋值的话，系统会赋默认值。

结论：
final修饰的实例变量，系统不管赋默认值，要求程序员必须手动赋值
Java程序设计不背锅！！甩锅甩的很好！！

实例变量在什么时候赋值（初始化）？？？
构造方法执行的过程中赋值，（new的时候赋值）

终级结论：
final修饰的实例变量，系统不负责赋默认值，要求程序员必须手动赋值
这个手动赋值，在变量后面赋值可以，在构造方法中赋值也可以
final修饰的实例变量一般添加static修饰
结论：
final修饰的实例变量一般和static联合使用，称为“常量”，常量名建议全部大写，每个单词之间采用下划线衔接。
常量：实际上常量和静态变量一样，区别在于:
常量的值不能变，常量和静态变量，都是储存在方法区，并且都是在类加载时初始化

常量一般都是公开的：public的
提示：final控制不了能不能调用的问题，final管的是啥？
final修饰的表示最后的，不能变的，不能改的

/*
final修饰的类无法继承
*/

final class A{//A没有子孙

}
//B类继承A类，相当于对A类的功能进行扩展，如果你不希望别人对A类型进行扩展
//你可以给A类加上final关键字，这样的话A类就无法继承了
//错误：无法从最终A进行继承
/*
class B extends A {

}
*/

/*
final修饰的方法无法覆盖
*/

class C{
	public final void doSome(){
			System.out.println("C is doSome");
		}
}

class D extends C{
		/*
		public void doSome(){
			System.out.println("D is doSome");
		}
		*/
}

/*
final 修饰的变量不能再赋值
*/
public class FinalTest {

	public static void main(String[] args) {
		//局部变量
		int i=10;
		System.out.println(i);
		//重新赋值
		i=20;
		System.out.println(i);
		
		//局部变量
		final int k=100;
		//编译错误，无法为最终变量k分配值
		//重新赋值
		//k=200;
		
		final int m;
		m=200;
		//编译错误，无法为最终变量m分配值
		//m=300;
		
		
	}
}

/*
final修饰的实例变量，必须程序员手动赋值
*/

public class FinalTest02 {

	//成员变量之实例变量
	int i;
	
	//实例变量有默认值，final修饰的变量一旦赋值不能重新赋值
	//综上考虑，java语言最终规定实例变量一旦被final修饰必须手动赋值，不能采用系统默认值
	//final int age;//编译报错
	
	//第一种解决方案
	
	final int age=10;
	
	//以下这一堆代码全部联合起来，num变量也是赋值了一次
	//第二种解决方案
	
	final int num;
	//构造方法
	public FinalTest02() {
	    System.out.println("Hello");
		this.num=200;//只要是赶在系统赋默认值之前赋值就行
		//this.num = 300;//这个可以吗？？不行
		//系统赋默认值是在这个时候
		//num = 0；
	}
	
	
	//其实，本质上来说这两种解决方案都是一种解决方案，都是在构造方法执行过程当中给实例变量赋值
	
	public static void main(String[] args) {

	}

}

/*
final修饰的引用只能指向一个对象，不可再变，但是所指向的对象内存中的所存储的内容依然是可以改变的，
因为引用存储的只是该对象的内存地址，与内容无关！！
*/
public class FinalTest03 {

	public static void main(String[] args) {

		//创建用户对象
		User u=new User(100);//User u=0x1234;
		
		//又创建了一个新的对象
		//程序执行到这里，表示上面的对象已变成垃圾数据，等待垃圾回收器回收
		u=new User(200);//u=0x2589;
		
		
		//创建用户对象
		//代码不管怎么变化，user也是一个变量（只不过这里它有一个特殊的名字：引用）
		final User user=new User(30);
         //final修饰的引用一旦指向某个对象之后，不能让它去指向其他对象，那么被指向的对象永远不能被垃圾回收器回收
		//user=new User(50);
		
		//user=null;
		
		System.out.println(user.id);
		
		user.id=50;//final修饰的引用虽然指向某个对象后不能指向其他对象，但是所指向的对象内部的内存是可以更改的
		
		System.out.println(user.id);
		
	}

}

class User{
   int id;
   public User(){
   }
   public User(int id){
   		this.id = id;
   	}
}

在这里插入图片描述

/*
常量
*/

public class FinalTest04 {

	public static final double PI=3.1415926535;
	
	public static void main(String[] args) {
		
		System.out.println(Chinese.GUO_JI);
		
		System.out.println(PI);
		
		
	}
}


class Chinese{
	//国籍：中国
	
	//需求：每一个中国人都是中国，恒定不变，防止国际被修改，加final关键字
	//final修饰的实例变量不可变的，这种变量一般和static联合使用，成为“常量”。
	//常量定义的语法格式
	//                              public static final 类型 变量名 =值;
	//java规范中，常量名全部大写，单词之间用下划线链接
	//static final String country="中国";
	
	//国家的值是一个固定值：“中国”
	//实例变量在堆中，一个对象一份，100个对象100份
	//实例变量既然使用final修饰了，说明该实例变量值不会随着对象的变化而变化
	//该实例变量前面应该添加：static关键字，变为静态的，存储在方法区
	public static final String GUO_JI="中国";//常量是无法重新赋值的

	//i永远都是10，创建100个对象，i也是10
	//i是10是永远不会发生改变的，既然这样，没必要声明为实例变量，最好是静态的，节省内存空间
	static final int i =10;
	
	
}

访问控制权限修饰符

访问控制权限修饰符来控制元素的访问范围
访问控制权限修饰符包括：

public 【表示公开的，任何位置都能访问】
protected 【同包，子类】
default（缺省）【同包】
private 【私有的，只能在本类中访问】
访问控制权限修饰符可以修饰类、方法、变量…
当某个数据孩只能希望子类使用，使用protected进行修饰
修饰范围：

private<缺省<protected<public
类只能采用public和缺省来进行修饰，内部类除外

public class Test01 {

	public static void main(String[] args) {

		//创建User对象，访问i和j
		User u=new User();
		
		System.out.println(u.i);
		
		System.out.println(u.j);
		
	}

}


public class User {

	//受保护的
	protected int i=10;
	
	//缺省的
	int j=20;
	
	private void m1() {
		
	}
	
    void m2() {
		
	}
	
	protected void m3() {
		
	}
	
	public void m4() {
		
	}
	
	
}

import com.bjpowernode.javase.test005.User;

public class Driver extends User {
		
	    public void m() {

	    	System.out.println(this.i);
			
			//System.out.println(this.j);
	    }
	   

}

import com.bjpowernode.javase.test005.User;

public class UserTest {

	public static void main(String[] args) {

		User u=new User();
		//System.out.println(u.i);
		//System.out.println(u.j);
		
		
	}

}

public class ExerciseTest {

	public static void main(String[] args) {

		/**
		 * 需求：向控制台输出“Hello World！”
		 */

		System.out.println("Hello World!");

		/**
		 * 需求：计算1~100之间所有素数的和
		 */

		// 判断一个数是否是素数
		// 是，输出，累加

		/*
		int sum = 0;

		for1: for (int i = 2; i <= 100; i++) {
			for2: for (int j = 2; j < i; j++) {
				if (i % j == 0) {
					continue for1;
				}
			}

			sum += i;

		}

		System.out.println("最后结果为：" + sum);
		*/

		int sum = 0;

		for (int i = 2; i <= 100; i++) {
			boolean flag = true;
			for (int j = 2; j < i; j++) {
				if (i % j == 0) {
					flag = false;
					break;
				}
			}
			if (flag) {
				sum += i;
			}
		}

		System.out.println("最后结果为：" + sum);

		/**
		 * 需求：打印九九乘法表
		 */

		for (int i = 1; i <= 9; i++) {
			for (int j = 1; j <= i; j++) {
				System.out.print(i + "*" + j + "=" + (i * j) + "\t");
			}
			System.out.print("\n");
		}

		/**
		 * 输出1~100所有数字，每8个数字换一行
		 */

		int count = 0;

		for (int i = 1; i <= 100; i++) {

			System.out.print(i + "\t");
			count++;
			/*
			 * if (count % 8 == 0) { System.out.print("\n"); }
			 */
			if (count == 8) {
				System.out.print("\n");
				count = 0;
			}

		}

	}

}

/**
 * 类只能采用public和缺省来进行修饰，内部类除外
 *
 */
public class Customer {

}

/**
 * 类只能采用public和缺省来进行修饰，内部类除外
 *
 */
class Student {

}

下一篇：抽象类

脑袋不灵光的小白羊

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java入门——final关键字

关于Java语言中的final关键字：final是一个关键字，表示最终的，不变的final修饰的类无法被类继承final修饰的方法无法被覆盖final修饰的变量“一旦”赋值之后不可重新赋值【不可二次赋值】final修饰的实例变量，必须手动赋值，不能采用系统默认值final修饰的引用一旦指向某个对象之后，不能让它去指向其他对象，那么被指向的对象永远不能被垃圾回收器回收final修饰的引用虽然指向某个对象后不能指向其他对象，但是所指向的对象内部的内存是可以更改的final修饰的实例变量一般和s
复制链接

扫一扫

专栏目录