超牛牪犇Java之适配器设计模式&字符串类的一些常见方法

一.适配器模式

1.类适配器

可以让没有关系的类和接口产生联系,可以扩展功能,增加已有代码的复用性

example:

中国人:说中国话

美国人:说英语 ----需要翻译来交流

public class Demo {
	public static void main(String[] args) {
		Target chinese = new Chinese();
		chinese.communicate();
		//使用适配器的类
		Target american = new Translator();
		american.communicate();
	}
}
class American{
	//说话方法
	public void speak() {
		System.out.println("说英语");
	}
}
//目标接口
interface Target{
	//耳机连接的抽象方法
	public abstract void communicate();
}
class Chinese implements Target{

	@Override
	public void communicate() {
		System.out.println("说中文");
	}
}
//使用继承来实现 让类和接口发生关系
//使用一个适配器类 (相当于一个第三方的类) 通过这个类让类和接口产生联系
//提高接口的兼容性
class Translator extends American implements Target{
	//实现抽象方法
	@Override
	public void communicate() {
		System.out.println("翻译官进行翻译");
		super.speak();
	}
}

2.对象适配器(IO 适用对象进行连接来扩展功能)

3.缺省适配器

简单举个栗子:

这个社会中有很多职业,但是每个人只可能会从事其中一种或几种工作,把职业类型设成一个接口,难道每次给人设置职业的时候要全部实现吗?在这里就要有一个缺省适配器,缺省适配器是个抽象类,仅仅implements而不写实现方法(空实现),然后直接使用adapter即可选择需要实现的方法,而不用实现全部

example:

放假了学校布置了很多作业,假期必须要完成:语文 数学 英语

但是全部都写的话就没时间玩了 所以只选择其中一种作业来写

//作业接口
interface Homwork{
	//写语文作业方法
	public abstract void language();
	//写数学作业方法
	public abstract void math();
	//写英语作业方法
	public abstract void english();
}
//使用一个类作为桥梁 来连接接口与类
//让适配器的类 来实现接口 			方法里面什么都没写---空实现
//适配器类只是对接口方法的空实现 具体怎么实现 不管
//不希望 这个适配器类直接被使用
abstract class MyAdapter implements Homwork{
	@Override
	public void language() {
		
	}
	@Override
	public void math() {
		
	}
	@Override
	public void english() {
		
	}	
}
//这时就可以直接继承适配器类

class Me extends MyAdapter{
	//重写适配器类的方法
	@Override
	public void language() {
		System.out.println("认真写语文作业 写完就去玩");
	}
}

二.字符串类

字符串类是系统类 提供了一些方法

注意:字符串是常量 字符串常量(程序运行当中不能修改,修改的是地址不是字符串本身)

学习系统类的目的:学习系统的方法 如何使用

看方法时需要知道:

1.关键字 有没有static修饰(看方法的调用方式)

2.返回值类型(返回一个什么结果)

3.方法名(见名知意)

4.参数列表(方法需要什么)

public class Demo {
	public static void main(String[] args) {
		//修改的是 字符串引用(地址)
		//指向不同地址 而不是字符串本身被修改了
		//看系统方法时 拼接 截取等操作字符串的一类方法
		//都是返回一个 新的字符串
		String bt = "狗子";
		bt = "狗子昂";
		System.out.println(bt);
		//s2的创建方式 相当于在方法区的常量池中创建一个字符串
		String s2 = "Taylor";
		//s3是在堆内存中开辟一块空间
		String s3 = new String("Taylor");
		String s4 = "Taylor";
		//== 对象比的是 地址
		//不是对象 比的是值
		System.out.println(s2 == s4);
		//equals 把两个字符串 变成字符数组 一位一位的进行比较
		System.out.println(s2.equals(s4));
		System.out.println(s2 == s3);
		//s2 和 s3 有什么区别
		//s2是一个对象
		//s3是两个对象 : "Taylor" 和 new出来的对象
	}
}

1.获取

根据索引获取字符串中字符 char charAt(int index)

根据字符获取在字符串中的位置 int indexOf(int ch)

整数和字符之间可以相互转换(按照ASCII码)

private static void fun() {
		String string = "TaylorSwift";
		//注意:角标不要越界
		char c = string.charAt(5);
		System.out.println(c);
		//获取索引
		String s1 = "TaylorSwift";
		int index = s1.indexOf('r');
		System.out.println(index);
		//从传入的索引这一位开始查找 包括这一位
		//留头不留尾
		int index1 = s1.indexOf('y', 3);
		System.out.println(index1);
		//传入字符串 查找对应的角标
		int index2 = s1.indexOf("Swift");
		System.out.println(index2);
	}

2.判断

返回值都是布尔类型的

1️⃣是否包含这个字符串

2️⃣是否以这个前缀开头

3️⃣是否以这个后缀结尾

public static void main(String[] args) {
		String string = "www.baidu.com";
		//判断包含
		boolean rell = string.contains("baidu");
		System.out.println(rell);
		//判断前缀
		boolean rel = string.startsWith("www");
		System.out.println(rel);
		//判断后缀
		boolean rel1 = string.endsWith("com");
		System.out.println(rel1);
		//判断两个字符串相等
		boolean rel2 = string .equals("haha");
		System.out.println(rel2);
		//判断两个字符串忽略大小写相等
		boolean rel3 = string.equalsIgnoreCase("Baidu");
		System.out.println(rel3);
		//字符串转小写
		String s1 = string.toLowerCase();
		System.out.println(s1);
		//字符串转大写
		String s2 = string .toUpperCase();
		System.out.println(s2);
	}

替换:

private static void fun() {
		//替换
		String string = "TaylorSwift";
		String s1 = string.replace("T", "L");
		System.out.println(s1);
		//替换字符串
		String s2 = string.replace("Swift", "May");
		System.out.println(s2);
	}

字符串分割:

返回值是字符串类型的数组

private static void fun() {
		String string = "TaylorSwift,MayDay,SunYanZi";
		String[] strings = string.split(",");
		//使用转义符
		System.out.println(Arrays.toString(strings));
		//增强for循环(专门用来遍历的)
//		for (容器中数据类型 名字:遍历的容器) {
//			
//		}
		for (String s : strings) {
			//String s 相当于表示容器中每一个元素
			System.out.println(s);
		}
	}

获取子字符串:

private static void fun() {
		//获取子字符串
		String string = "TaylorSwift";
		//从传入的索引这一位开始截取(包括3)
		String s1 = string.substring(3);
		System.out.println(s1);
		//实际截取的是0,1,2 不包括3
		String s2 = string.substring(0, 3);
		System.out.println(s2);
	}

去掉字符串中的空格:

(只去掉头和尾部的 内部的空格不去)

字符一样返回0

返回正值就说明前面大

返回负值就说明前面小

字符不一样的时候 按照ASCII码表返回两个字符差值 前减后 

长度不一样的时候 返回的是位数的差值

一位一位进行比较 字符不一样就做差值 

private static void fun() {
		//去空格
		String string = "    abc def  ";
		String s1 = string.trim();
		System.out.println(s1);
		//字符串比较
		String s2 = "abcAB";
		String s3 = "Ab";
		//字符一样返回0
		//返回正值就说明前面大
		//返回负值就说明前面小
		//字符不一样的时候 按照ASCII码表返回两个字符差值 前减后
		//长度不一样的时候 返回的是位数的差值
		//一位一位进行比较 字符不一样就做差值
		int num = s2.compareTo(s3);
		System.out.println(num);
	}

字符串和字符数组的转换:

private static void fun() {
		//把字符数组转换成字符串
		char[] array = {'T','a','y','l','o','r'};
		//使用构造方法转化
		String string = new String(array);
		System.out.println(string);
		//字符串转化成字符数组
		String s1 = "TaylorSwift";
		char[] charArray = s1.toCharArray();
		for (char c : charArray) {
			System.out.println(c);
		}
	}

判断字符串是否为空:

private static void fun() {
		//判断字符串是否为空
		String string = "";
		boolean b = string.isEmpty();
		System.out.println(b);
		//字符串拼接
		String s1 = "Taylor";
		String s2 = "Swift";
		String s3 = s1.concat(s2);
		System.out.println(s3);
	}

exercise:

打印出下面两个字符串中相同的 最大子字符串

字符串一:asakjfahellosdlmkasklhk

字符串二:mcnvbsehellolssphkp

public class Demo{
	public static void main(String[] args) {
		String str1 = "asakjfahellosdlmkasklhka";
		String str2 = "mcnvbsehellolssphkp";
		int i = 0;
		while (i < str2.length()) {
			int start = 0;
			int end = str2.length() - i;
			while (end < str2.length()) {
				String string = str2.substring(start, end + 1);
				System.out.println(string);
				if (str1.contains(string)) {
					//因为是从长度最大开始到最小进行比较的 所以第一个找到的相同子字符串就是最大的子字符串
					System.out.println(string);
					return;
				}
				start++;
				end++;
			}
			i++;
		}
	}
}