JAVA基础

String类、static、final关键字

String类

String是一个不可变的字符序列，一旦定义好，则无法再修改其内容，所谓修改，实际是修改了引用变量指向的字符串对象地址

###常用方法

public class StringTest {

	public static void main(String[] args) {
		
		String s1 = "helloworld";
		s1 = "你好世界";
		
		s1 = "d:/test/music/小苹果.mP3";
		
		//将当前字符串转换为小写并返回
		System.out.println(s1.toLowerCase());
		//将当前字符串转换为大写并返回
		System.out.println(s1.toUpperCase());
		//判断当前字符串是否以指定后缀结尾
		System.out.println(s1.toLowerCase().endsWith(".mp3"));
		
		String a = "helloworld";
		String b = "HelloWorld";
		//比较两个字符串对象是否一致
		System.out.println(a.equals(b));
		//忽略大小写的情况下比较两个对象是否一致
		System.out.println(a.equalsIgnoreCase(b));
		
		//将字符串转换为字节数组
		byte[] byt = a.getBytes();
		System.out.println(byt.length);
		//遍历获取数组中每一个元素(就是一个字符的ascii码)
		for (int i = 0; i < byt.length; i++) {
			System.out.print((char)byt[i]+" ");
		}
		System.out.println();
		
		//使用字节数组构建一个String对象
		a = new String(byt);
		System.out.println(a);
		
		System.out.println(a.indexOf(101));
		
		System.out.println(b.intern());
		
		// "" != null
		a = ""; 
		//获取字符串的长度(字符的个数)
		System.out.println(a.length());
		//判断当前字符串是否为空(length是否为0)
		System.out.println(a.isEmpty());
		
		//使用指定的分隔符将后续所有的字符串对象进行拼接成为一个整个字符串对象
		System.out.println(String.join("/", "hello","world","softem","你好世界")); 
		
		a = "src/a.txt";
		//字符串截取
		System.out.println(a.substring(4));
		//获取指定字符串在目标字符串中最后一次出现的位置
		System.out.println(a.lastIndexOf("t"));
		
		String phone = "13876543218";
		//判断当前字符串是否匹配给定正则表达式
		System.out.println(phone.matches("^1\\d{10}")); 
		
		//将字符串中指定的字符替换为目标字符
		System.out.println("helloworld".replace('o','O'));
		
		//将字符串中指定的子串替换为目标字符串
		System.out.println("helloworldhelloworld".replace("hello", "你好"));
		//将字符串中匹配指定正则表达式规则的子串替换为目标字符串
		System.out.println("132876543212world13287653122world".replaceAll("1\\d{10}", "手机号"));
		
		//你小子真是个**，**的
		System.out.println("你小子真是个狗蛋,你妹的！");
		
		String str = "GET /~minift/epretty/pretty.zip HTTP/1.1";
		String[] ss = str.split(" ");
		for (String s : ss) {
			System.out.println(s);
		}
		
		String fileName = "你从哪里来.mp3";
		System.out.println(fileName.split("\\.")[0]);
		//输入学生的学号，姓名，性别，年龄，专业
		//判断指定字符串是否以某一个子串开头
		System.out.println("softeem123".startsWith("softeem"));
		
		//去除字符串前后空格
		System.out.println("       你好     世界         ".trim()); 
		
		//将其他类型数据转换为字符串
		System.out.println(String.valueOf(10) + 10);
	}

}

String，StringBuffer与StringBuilder区别

​ 以上三个类都是位于java.lang包，String是一个不可变的字符序列，在每一次做字符串拼接时实际都是在创建新的字符串对象，因此在做大量字符串拼接时会不断创建新的对象，在效率上非常差；StringBuffer跟String都是从CharSequence接口实现，StringBuffer是一个可变长的字符序列，每次在进行字符串拼接(追加)时只是向原来序列中新增数据，并未反复创建新对象，所以在拼接效率方面远远高于String,并且StringBuffer是线程安全的实现；StringBuilder跟StringBuffer共享相同的API(相同的方法)，但是StringBuilder是线程不安全的实现，在多线程运行时效率比StringBuffer要高，但是对于字符串的安全性没有保障。

static&final关键字

static关键字

​ static关键字可以用于修饰一个类中属性，方法，以及内部类，被static修饰的以上元素称之为:静态属性，静态方法，静态内部类；被static修饰的元素与对象无关(在使用时无需创建对象，使用对象调用)，他们直接与类相关，在调用时只需要通过“类名.*”即可调用。

public class StaticTest {

	//静态属性(类属性)
	static String name = "狗蛋";
	
	//静态方法
	public static void showMsg(String msg){
		System.out.println(msg);
	}
	
	public static void main(String[] args) {
//		传统调用方式		
//		StaticTest st = new StaticTest();
//		st.name  = "催化";
//		st.showMsg("hellworld"); 
        
//		静态元素的调用方式		
		name = "hello";   //StaticTest.name
		showMsg("helloworld"); //StaticTest.showMsg
	}

}

​ 通过以上方式可以得知，在调用属性，调用方法时使用static方式会更简单，但是如果元素被static修饰之后，这些元素的生命周期会延长；并且在初始化时也会早于对象的创建，因为在类加载时(不是对象)所有的static元素会被首先初始化，并且这些static元素不会跟随对象的创建次数执行，而是永远只会初始化一次。因此一般被static修饰的主要为一些反复被使用，而不需要反复创建的元素，比如一些工具类中的方法。

参考以下代码:

public class StaticTest2 {

	//静态块在当前类被初始化时执行，并且只会执行一次
	static{
		System.out.println("静态初始化块(静态块)");
	}
	
    //游离快在当前类中创建对象执行构造器之前执行，执行次数跟对象创建次数保持一致
	{
		System.out.println("初始化块（游离块）");
	}
	
	public StaticTest2() {
		System.out.println("构造器被执行");
	}
	
	public static void m(){
		System.out.println("hello");
	}
	
	public static void main(String[] args) {
		
		new StaticTest2();
		new StaticTest2();
		new StaticTest2();
		
	}
}

关于static的注意事项

1. 不允许在static语句块中调用非static的元素(因为static元素初始化时对象还不存在)
2. 构造器不允许使用static

###设计模式之-单例模式

​ 设计模式是软件工程方法迭代多年的研究成果，java中常用设计模式主要包含23中，包括:单例，观察者，适配器，工厂方法，抽象工厂，代理模式，装饰模式，模板方法等；

​ 其中单例模式是一种开发中非常常见模式，指的是在程序运行中对象的获取永远是同一个，比如说一些资源池(常量池，连接池，线程池)一般都是基于单例模式实现，单例模式的实现原理为：

1. 类中构造器必须使用private修饰
2. 类中必须提供一个用户返回当前对象实例的静态方法
3. 类中存在一个静态的变量，类型为当前类型

java中单例模式又分为两种:

####1. 饿汉模式

饿汉模式即在类被初始化时就创建一个实例，后续的返回永远是当前实例对象

public class Singleton {
	
	//饿汉模式(以空间换时间)
	private static Singleton instance = new Singleton();

	private Singleton(){
		
	}
	
	public static Singleton getInstance(){
		return instance;
	}
}

饿汉模式是一种以空间换取时间的设计，在类初始化时即创建对象，后续无需在耗时创建。

####2.懒汉模式

懒汉模式指的是在类初始化时不创建任何实例，在提供的静态方法中判断对象是否存在，若不存在则创建:

public class Singleton2 {
	
	private static Singleton2 instance = null;

	private Singleton2(){
		
	}
	
	//懒汉模式(以时间换空间)
	public static Singleton2 getInstance(){
		if(instance == null){
			instance = new Singleton2();
		}
		return instance;
	}
}

懒汉模式是一种以时间换取空间的设计

设计模式参考书籍

《设计模式之禅》

《设计模式》GOF

final关键字

final表示最终的，终极的；final关键字可以用于修饰类，属性，方法:

• 被final修饰类不允许被继承（断子绝孙类）
• 被final修饰变量不予许修改（但是被final修饰的变量必须初始化,也可以在构造器初始化）
• 被final修饰的方法不允许被重写

//final修饰的类不允许被继承
public final class FinalTest {
	
    //final属性一旦初始化则不可修改
	final String msg;
	//常量
	static final int TYPE = 1;
	
    //可以在构造器中初始化final属性
	public FinalTest(){
		msg = "hello";
	}
	
	public FinalTest(String msg){
		this.msg = msg;
	}
	//final方法不允许被重写
	public final void m(){
		final int i = 10;
    }

}

final关键字在定义变量时通常跟static组合为常量

public class Test{
   public static final String STATUS_OFF = "off";
   public static final String STATUS_ON = "on";
   
   public static final int ORDER_UNSINGE =0；
}

abstract关键字与抽象类

abstract（抽象）可以用于修饰一个类，方法；被abstract修饰类成为抽象类，被abstract修饰方法，称之为抽象方法。抽象方法只能出现在抽象类或者接口中。

public abstract class Animal {
	
	private String name;
	private int age;
	
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

    //抽象方法(只有方法的声明，没有具体实现)
	public abstract void bark();
	
	public abstract void eat();
	
	public abstract void sleep();

}

###为什么需要抽象类

​ 在实际开发中，对于某些需求具体的实现不确定时，可以将这些需求对应的功能定义为抽象方法，等待后期子类进行实现，从而提高程序的扩展性。

抽象类特点

1. 抽象类中可以包含普通类的一些特性(属性，方法，构造器)
2. 抽象类中除了包含一些已实现的方法外还包含抽象方法(未实现)
3. 抽象类存在构造器，但是不允许被实例化
4. 抽象类一般由子类继承，但是子类继承了抽象类之后就必须实现抽象方法(除非子类也是抽象类)
5. 抽象类也可以继承其他抽象类
6. 如果子类继承了多个抽象类(多重继承) 则子类必须实现所有抽象类中未实现的方法