Java基础之代码块、final关键字以及方法重写

代码块：

        代码块的概述：
                用 { } 括起来的代码，统称为代码；

  根据其位置以及声明不同：
                分为以下：
        局部代码块：在main( )里面,给变量限定它的生命周期；
        构造代码块：在一个类中的成员位置中,用 { } 括起来；

作用：可以将多个构造方法中的相同的代码放到构造代码块中,对对象进行初始化；
                                  在每次执行构造方法之前,先执行构造代码块；
                静态代码块：在一个类的成员位置,也是用 { } 包起来,但是他被static修饰；

                        作用：一般情况 它的作用给类进行初始化；

        思考：
                构造代码块,构造方法,静态代码的优先级?

                        答案：静态代码块 > 构造代码块 > 构造方法

        注意：
                静态代码:只能执行一次；

                构造代码块在每次执行构造方法之前都会被执行；

        举例：

//定义一个Code类
class Code{
	
	//静态代码块
	static{
		int x = 1000 ;
		System.out.println(x);
	}
	
	//成员位置
	{
		int x = 100 ;
		System.out.println(x);
	}
	//构造方法
	public Code() {
		System.out.println("code");
	}
	
	//构造代码块
	{
		int y = 200 ;
		System.out.println(y);
	}
	
	//有参构造
	public Code(int a) {
		System.out.println("code");
	}
	
	//静态代码块
	static {
		int y = 2000 ;
		System.out.println(y);
	}
}
public class CodeDemo {
        public static void main(String[] args) {
        //局部代码块
        {
                int x = 10 ;
                System.out.println(x);
        }
        //不能访问局部代码块中的这个变量x
        System.out.println(x);
}

        代码块例题：

代码解释：
    //首先先看StudentDemo类，先执行static静态代码块，之后进入main函数，执行输出语句；
    //之后给变量s1分配Student分配单元，首先执行静态代码块，在执行构造代码块，之后再执行构造方法，程序执行完返回main函数；
    //顺序执行函数体，给变量s2分配Student单元，但是静态代码块只能执行一次，所以跳过静态代码块，执行构造代码块，在执行构造方法；
    //返回函数，结束程序；

方法重写：
        由于子类继承父类的时候，提供一摸一样的方法声明，然后会将父类该方法覆盖掉(重写，复写)；

        有时候(具体的需求)，不需要子类重写父类的功能，针对这种情况，Java提供了一个关键字：final   最终的,终态的意思；

        举例：

class Fu{
	public void show() {
		System.out.println("这是一个绝密文件,任何多不能更改...");
	}
}

//Zi类
class  Zi extends Fu{
	public void show() {
		System.out.println("这是一堆垃圾....");
	}
}
//测试类
public class ZiDemo {

	public static void main(String[] args) {
		
		Zi zi =new Zi() ;
		zi.show();
	}
}

//输出结果为：  这是一堆垃圾....   
//也可以理解为：就近原则；
//如果父类的public void show()  ==>  public final void show()  ==>  则在子类不能重写被final修饰的Fu类的方法；

final关键字：表示最终，终态(不能被更改的)；

        它可以修饰类,那么该类不能继承；
        它可以修饰成员方法,成员方法不能被重写；

   它可以修饰变量,此时这个变量是一个常量；

                举例：

                        自定义常量(final修饰的)：    pubic final int num = 100 ;

        final不仅可以修饰基本数据类型，还可以引用类型；
   如果final修饰的是一个基本数据类型：基本数据类型的值不能再改变了；
   如果final习俗的是一个引用类型数据：引用类型的地址值不能再改变了,但是堆内存中的成员变量的值可以变得；
  
        final的初始化时机：
   1)被final只能被赋值一次(final int a = 10 )
   final int a ;

   //在使用之前进行初始化,赋值(在构造方法之前赋值) (非静态的...)

        举例：

class Student{
	int age = 20 ;
}
public class FinalTest {

	public static void main(String[] args) {
		//定一个变量
		int x = 10 ;
		x = 100 ;
		System.out.println(x);
		System.out.println("-----------------");
		final int y = 20 ;
		//y = 200 ;// 不能被赋值了,变量y此时常量...
		System.out.println("-----------------");
		
		//创建Student类对象
		Student s = new Student() ;
		s.age = 56 ;
		System.out.println(s.age);
		System.out.println("-----------------");
		//另一种情况:
		final Student ss = new Student() ;  //开辟一个新的Student对象，堆内存里的值是可以改变的，但是空间的地址是不能改变的；
		ss.age = 70 ;
		System.out.println(ss.age);   
		
		
		//给堆内存开辟一个新的空间，系统会报错，新的Student对象，空间地址是不能改变的；
//		ss = new Student() ;      //the final local variable ss cannot be assigned
	}
}