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
	}
}



阅读更多

扫码向博主提问

Future_LL

非学,无以致疑;非问,无以广识
去开通我的Chat快问

没有更多推荐了,返回首页