java基础---代码块、final修饰符、单例设计模式、工具类设计

时间：2022-05-31 21:08:12

一、代码块

  1. 代码块的定义：在类或者方法中，直接使用“{}”括起来的一段代码，表示一块代码区域。
  2. 代码块的分类：根据代码块的定义位置不同，可以分为三类：

             1）局部代码块：直接定义在 方法内部，在调用该方法时，局部代码块按照代码块申明的顺序依次执行；
           2）初始化代码块（又称构造代码块）：直接定义在 类中（无static修饰）,每次创建对象都会执行初始化代码块，因为在底层，初始化代码   块中的语句，会作为构造器的最初语句，因此又称为构造代码块。
            3）静态代码块：使用static修饰的初始化代码块，在main方法执行之前执行，且只执行一次
                 问题：main方法是程序的入口,为什么静态代码块优先于main方法执行？                            静态成员随着字节码的加载也加载进JVM,此时main方法还没执行,因为方法需要JVM调用.
            先把字节码加载进JVM,  而后JVM再调用main方法. 
 

//初始化代码块
class InitialCodeBlock
{
	//初始化代码块：直接定义在类中,每次创建对象都会执行初始化代码块，因为在底层，初始化代码块中的语句，会作为构造器的最初语句，因此又称为构造代码块。
	//我们一般不使用初始化代码块的,难看,即使要做初始化操作,我们一般在构造器中做即可,如果做初始化操作的代码比较多,此时构造器的结构比较混乱,此时专门定义一个方法做初始化操作,再在构造器中调用即可.
	{
		{
			System.out.println("初始化代码块");
		}
	}

	
}

//演示代码块的相关知识：局部代码块、初始化代码块、静态代码块
class CodeBlockDemo 
{
	//静态代码块：使用static修饰的初始化代码块，在main方法执行之前执行，且只执行一次
	static
	{
		System.out.println("静态代码块");
	}

	public static void main(String[] args) 
	{
		System.out.println("main方法的入口");
			
		//局部代码块：直接定义在方法内部，在调用该方法时，局部代码块按照代码块申明的顺序依次执行
		{
			System.out.println("局部代码块1");
		}

		{
			System.out.println("局部代码块2");
		}
		
		new InitialCodeBlock();
		new InitialCodeBlock();
		new InitialCodeBlock();
		
	}
}

 





  结果如下： 
 


 

---------- Java ----------
静态代码块
main方法的入口
局部代码块1
局部代码块2
初始化代码块
初始化代码块
初始化代码块

输出完成 (耗时 0 秒) - 正常终止
 

二、final关键字


 

 


          1.为什么要使用final关键字？ 

 

 

 


              继承关系最大弊端是破坏封装: 
 子类能访问父类的实现细节,而且可以通过方法覆盖的形式修改实现细节 
 . 

 

 
         2.final定义： 
 
 
 
 
              本身的含义是“最终的 
  ,不可改变的 
  ”，它可以修饰非抽象类，非抽象方法和变量。 
  注意：构造方法不能使用final修饰，因为构造方法不能被继承，肯定是最终的 
  。 
 
 
 
 
          3.final修饰的类:表示最终的类,该类不能再有子类（无法被继承）。 
 
 
 
 
               
  
            只要满足以下条件就可以把一个类设计成final类：
 
  
                ①　某类不是专门为继承而设计。
 
  
                ②　出于安全考虑，类的实现细节不许改动,不准修改源代码。
 
  
                ③　确信该类不会再被拓展。
 
  
        面试题:列举5个Java中内置的使用final修饰的类.
 
  
 
  
 
           java里final修饰的类有很多，比如八大基本数据类型包装 
   类和String等。 
  
 
  
 
           4.final修饰的方法:  最终的方法,该方法不能被子类覆盖. 
  
 
  
 
                
   
           什么时候的方法需要使用final修饰.
 
   
                  1):在父类中提供的统一的算法骨架,不准子类通过方法覆盖来修改. 此时使用final修饰.模板方法设计模式.
 
   
                  2):在构造器中调用的方法(初始化方法),此时一般使用final修饰.
 
   
 
   
 
                注意: 
    final修饰的方法, 
    子类可以调用 
    ,但是不能覆盖. 
   
 
   

            5. 
    final修饰的变量 
    :最终的变量 
    ,常量 
    ,该变量只能赋值一次, 
    不能再赋值.（final是唯一可以修饰局部变量的修饰符）。 
   
 
   
 
                 
    
                    1):final变量必须显示地指定初始值，系统不会为final字段初始化。
 
    
                    2):final变量一旦赋予初始值，就不能被重新赋值。
 
    
                    3):常量名规范：常量名符合标识符，单词全部使用大写字母，如果是多个单词组成,单词间使用下划线隔开。
 
    
            int类型的最大值: final int MAX_VALUE =....;
 
    
 
    

                  补充概念 
     :全局静态常量: 
     public  static  final 
     修饰的变量 
     ,直接使用类名调用即可. 
    
 
    
 
     


 
    
 
     
            面试题:final修饰的引用类型变量到底表示引用的地址不能改变,还是引用空间中的数据不能改变.
 
    
 
    
 
     
            1）final修饰基本类型变量：表示该变量的值不能改变，即不能用“=”号重新赋值。
 
    
 
    
 
     
            2）final修饰引用类型变量：表示该变量的引用的地址不能变，而不是引用地址里的内容不能变。
 
    
 
    
 
     
class SuperClass
{
	final int NUM = 5;
	Integer NUM1 = new Integer(124);
	
	//name = name.valueOf("ohoh.oho");
	//name = "ehhhh";
	public void doWork()
	{
		System.out.println("doWork");
	}
}

class SubClass extends SuperClass
{
	public void doWork()
	{
		System.out.println("doWork");
	}
}

//演示final相关知识
class FinalDemo 
{
	public static void main(String[] args) 
	{
		Person p = new Person();
		p = new Person();
		p.info = "修改值";
		System.out.println(p.info);
		final String name = "wxm";
		//name = "123";
		System.out.println(name);

	}
}

class Person
{
	public String info = "最初值";
}


 
    
 
    
三、单例设计模式
 
   
 
  
 
 
 




 

 

 


  1.设计模式的概念： 

 


          是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。毫无疑问，设计模式于己于他人于系统都是多赢的；设计模式使代码编制真正工程化；设计模式是软件工程的基石脉络，如同大厦的结构一样。 

 


  2.单例设计模式 

 

 

 

 

 
 需求: 
 定义一个数组的工具类( 
 ArrayUtil), 
 使用单例模式解决. 

 


  目的：保证某一个在整个应用中某一个类 
 有且只有一个实例 
 (一个类在堆 
 内存只存在一个对象)，即所有指向该类型实例的引用都指向同一块内存空间。    

 

 

写单例模式的步骤：单讲饿汉式.
 

      1):必须在该类中,自己先创建出一个对象.
 

      2):私有化自身的构造器,防止外界通过构造器创建新的对象.
 

      3):想外暴露一个公共的静态方法用于获取自身的对象.
 

//演示单例设计模式
class ArrayUtil
{
	//1）创建一个工具类对象
	private static ArrayUtil instance = new ArrayUtil();
	//2)私有化构造器，防止外界通过构造器创建对象以此来调用
	private ArrayUtil(){}
	//3)提供一个公共的静态方法（通过类名调用），来获取对象
	public static ArrayUtil getInstnce()
	{
		return instance;
	}

	public void swap()
	{
		System.out.println("执行交换操作");
	}

}
class SingletonDemo 
{
	public static void main(String[] args) 
	{
		//需要进行交换
		ArrayUtil.getInstnce().swap();
		//需要进行交换
		ArrayUtil.getInstnce().swap();
		//需要进行交换
		ArrayUtil.getInstnce().swap();
		//需要进行交换
		ArrayUtil.getInstnce().swap();
	}
}





四、工具类的设计


 

            工具类:存放了某一类事物的工具方法的类.
 

            工具类存放的包:工具包(util,utils,tool/tools,helper,helpers),存放工具类.
 

            工具类起名: XxxUtil/XxxUtils/XxxXTool/XxxTools.Xxx表示一类事物,
 

                    比如ArrayUtil,StringUtil,JdbcUtil.
 

----------------------------------------------------------------------
 

        工具类如何设计: 工具在开发中其实只需要存在一份即可.
 

               1):如果工具方法没有使用static修饰,说明工具方法得使用工具类的对象来调用.
 

                   此时把工具类设计为单例的.
 

              2):如果工具方法全部使用static修饰,说明工具方法只需要使用工具类名调用即可.
 

                  此时必须把工具类的构造器私有化(防止创建工具类对象调用静态方法).
 

----------------------------------------------------------------------
 

一般的,首选第二种,简单. 在JDK中提供的工具类都是第二种. 如java.util.Arrays类.
 

 

标签：
相关文章