包装类

包装类是针对八种基本数据类型定义相应的引用类型。

基本数据类型 包装类
byte Byte
short Short
int Lnteger
long Long
float Float
double Double
boolean Boolean
char Character

其中Byte Short Lnteger Long Float Double拥有一个父类Number。

包装类的出现，使得基本数据类型可以封装起来，作为一个类使用，完善了Java面向对象的特性。

包装类、基本数据类型、String相互转换

使用构造器将基本数据类型装箱

1
2
3
4
5
6
7
8
Integer i1 = new Integer(1);
System.out.println(i1.toString());//out:1
Integer i2 = new Integer("1");
System.out.println(i2.toString());//out:1
Boolean b2 = new Boolean("true123");
System.out.println(b2.toString());//out:false
//Java在将布尔类型装箱时，如果不是null或者true，一律均未false
//布尔作为基本数据类型的时候，初值为false，作为包装类的时候，初值为null

使用包装类内置方法转换为基本数据类型

包装类拥有一个xxxValue的方法，xxx是指要转换的类型。

1
2
3
Integer i = new Integer(1);
int i1 = i.intValue();
System.out.println(i1);

自动装箱与自动拆箱

这是包装类与基本数据类型之间最常用的转换方式。

1
2
3
4
5
6
7
public static void main(String[] args) {
   int i1 = 114514;
   Test(i1);//自动装箱
   Integer i2 = i1;//自动装箱
   int i3 = i2;//自动拆箱
}
public static void Test(Object obj){}

包装类、基本数据类型与String之间的转换

包装类、基本数据类型–>String

1
2
3
int i1 = 114514;
String str1 = i1 + "";//方式一
String str2 = String.valueOf(i1);//方式二

String–>包装类、基本数据类型

1
2
String str1 = "114514";
int num1 = Integer.parseInt(str1);//包装类的parseXxx方法

单例设计模式

单例的设计模式就是让某一个类只能存在一个对象实例，并且这个类只提供一个取得其对象实例的方法。

具体就是将类的构造器访问权限设置为private，这样类的外部就无法访问到类的构造器，但我们可以在类的内部产生类的对象。由于在类的外部，我们无法得到类的对象，只能通过该类的某个静态方法返回类内部构建的对象，由于静态方法只能访问静态成员变量，所以，指向类内部产生的对象的变量也必须是静态的。

单例有两种实现的方式——饿汉式与懒汉式。

饿汉式实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Demo {
   public static void main(String[] args) {
      Singleton singleton = Singleton.getInstance();
   }
}
class Singleton {
   //1.私有化类的构造器
   private Singleton(){}
   //2.内部创建类的对象，并将其设置为静态
   private static Singleton instance = new Singleton();
   //3.提供公共的静态的方法，返回类的对象
   public static Singleton getInstance(){
      return instance;
   }
}

懒汉式实现

1
2
3
4
5
6
7
8
9
10
11
12
13
class Singleton {
   //1.初始化类的构造器
   private Singleton(){}
   //2.声明一个静态类对象，但不进行初始化
   private static Singleton instance = null;
   //3.声明一个公共、静态的方法，返回当前类的对象
   public static Singleton getInstance(){
      if (instance == null){//防止创建多个对象
         instance = new Singleton();
      }
      return instance;
   }
}

单例的使用

当一个实例生成需要使用大量资源的时候，使用单例可以节约系统性能的开销。单例模式应用场景其实挺常见的：

  • 应用程序的日志
  • 网站计数器
  • 数据库连接池
  • 读取配置文件的类
  • Windows的回收站
  • …

代码块

代码块在Java中指的是使用{}包围起来的代码集合。代码块分为四种，普通代码块，静态代码块，同步代码块，构造代码块。后面三种代码块均为类的成员之一。由于同步的内容还未学习，所以同步代码块的内容暂时不写。

普通代码块

普通代码块就是在方法体内定义的代码块，普通代码块和一般代码的执行顺序与书写顺序一致。

1
2
3
4
5
public static void main(String[] args) {
   {
      System.out.println("普通代码块");
   }
}

静态代码块

1
2
3
4
5
public class Demo {
	static {
		System.out.println("静态代码块");
	}
}

静态代码块在类被加载的时候会被执行，而且只执行一次，并且优先于各种代码块以及构造函数。如果类中含有多个代码块，则会按照代码顺序执行。

由于静态代码块的加载是优先于类的其他成员的，所以他既不能存在任何方法体中，也不能访问任何普通变量。

静态代码块用于某些代码需要启动时就执行，例如启动时加载配置文件等。

构造代码块

1
2
3
4
5
public class Demo {
	{
		System.out.println("构造代码块");
	}
}

构造代码块与静态代码块在外观上差距了一个static关键词。

构造代码块在创建对象时会被调用，每次创建对象时都会调用依次，且执行顺序是优先于构造函数的。实际上，构造代码块是依托于构造函数的，在编译后，构造代码块就是将里面的代码置入构造函数的最前端。

由于构造代码块每次创建对象都会执行，而构造函数不一定每个对象构造的时候都执行（多个构造函数情况下，建立对象时传入的参数不同则初始化使用对应的构造函数），利用这个特性，我们可以做统计对象创建次数等功能。