Java基础 day15笔记

最新推荐文章于 2024-06-09 23:35:14 发布

zey-惟愿

最新推荐文章于 2024-06-09 23:35:14 发布

阅读量120

点赞数

本文链接：https://blog.csdn.net/weixin_47649943/article/details/106605154

版权

今日内容介绍
1、Object
2、String
3、StringBuilder

###01API概念

* A:API(Application Programming Interface) 
	* 应用程序编程接口
* B:Java API
	* 就是Java提供给我们使用的类，这些类将底层的实现封装了起来，
	* 我们不需要关心这些类是如何实现的，只需要学习这些类如何使用。
* C: 演示查看Object类中的相关方法

###02Object类概述
* A:Object类概述
* 类层次结构的根类
* 所有类都直接或者间接的继承自该类
* Object中描述的所有方法子类都可以使用
* 所有类在创建对象的时候，最终找的父类就是Object。
* B:构造方法
* public Object()
* 回想面向对象中为什么说：
* 子类的构造方法默认访问的是父类的无参构造方法

###03equals方法比较内存地址
* A:equals方法比较内存地址
* a: Object类中的equals方法
* 用于比较两个对象是否相同，Object类中就是使用两个对象的内存地址在比较。
* Object类中的equals方法内部使用的就是==比较运算符。

	* b: 案例代码
	
		public class Person extends Object{
			private String name;
			private int age;
			
			public Person(){}
			
			public Person(String name, int age) {
				this.name = name;
				this.age = age;
			}
			/*
			 * 将父类的equals方法写过来,重写父类的方法
			 * 但是,不改变父类方法的源代码, 方法equals 比较两个对象的内存地址
			 * 				
			 */
			public boolean equals(Object obj){					
				return this == obj;
			}		
			
			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 class TestEquals {
			public static void main(String[] args) {
				//Person类继承Object类,继承下来了父类的方法equals
				Person p1 = new Person("李四",20);
				Person p2 = new Person("张三",20);

//Person对象p1,调用父类的方法equals,进行对象的比较
boolean b = p1.equals(p1);
System.out.println(b);

}
}

###04重写equals方法
* A: 重写equals方法
* a: 开发中要比较两个对象是否相同，经常会根据对象中的属性值进行比较
* b: 在开发经常需要子类重写equals方法根据对象的属性值进行比较。
* c: ==号和equals方法的区别
* 是一个比较运算符号,既可以比较基本数据类型,也可以比较引用数据类型,基本数据类型比较的是值,引用数据类型比较的是地址值
* equals方法是一个方法,只能比较引用数据类型,所有的对象都会继承Object类中的方法,如果没有重写Object类中的equals方法,
equals方法和号比较引用数据类型无区别,重写后的equals方法比较的是对象中的属性
* d: 案例代码
public class Person extends Object{
private String name;
private int age;

			public Person(){}
			
			public Person(String name, int age) {
				this.name = name;
				this.age = age;
			}
			/*
			 * 重写父类的方法toString()
			 * 没有必要让调用者看到内存地址
			 * 要求: 方法中,返回类中所有成员变量的值
			 */
			public String toString(){
				return name + age;
			}

/*
* 将父类的equals方法写过来,重写父类的方法
* 但是,不改变父类方法的源代码, 方法equals 比较两个对象的内存地址
*
* 两个对象,比较地址,没有意义
* 比较两个对象的成员变量,age
* 两个对象变量age相同,返回true,不同返回false
*
* 重写父类的equals,自己定义自己对象的比较方式
*/
public boolean equals(Object obj){
if( this == obj){
return true;
}

//对参数obj,非null判断
if( obj == null){
return false;
}

				if( obj instanceof Person){
					// 参数obj接受到是Person对象,才能转型
					// 对obj参数进行类型的向下转型,obj转成Person类型
					Person p = (Person)obj;
					return this.age ==  p.age;
				}
				return false;
			}				
			
			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 class TestEquals {
			public static void main(String[] args) {
				//Person类继承Object类,继承下来了父类的方法equals
				Person p1 = new Person("李四",20);
				Person p2 = new Person("张三",20);

//Person对象p1,调用父类的方法equals,进行对象的比较
boolean b = p1.equals(p1);
System.out.println(b);

}
}

###05重写toString方法
* A: 重写toString方法
* a: 为什么要重写toString方法
* toString方法返回该对象的字符串表示，其实该字符串内容就是对象的类型+@+内存地址值。
* 由于toString方法返回的结果是内存地址，而在开发中，经常需要按照对象的属性得到相应的字符串表现形式，因此也需要重写它。
* Object类中的toString的核心代码
getClass().getName() + “@” + Integer.toHexString(hashCode())
* 由于默认情况下的数据对我们来说没有意义，一般建议重写该方法。
* b: 案例核心代码(重写Person类中的toString方法)
/*
* 重写父类的方法toString()
* 没有必要让调用者看到内存地址
* 要求: 方法中,返回类中所有成员变量的值
/
public String toString(){
return name + age;
}
//Eclipse中自动生成的toString
@Override
public String toString() {
return “Person [name=” + name + “, age=” + age + “]”;
}
//测试代码
public class TestToString {
public static void main(String[] args) {
//调用Person类的方法toString()
//输出语句中,写的是一个对象,默认调用对象的toString方法
Person p = new Person(“张三”,20);
String s = p.toString();
System.out.println§;
System.out.println(s);
/
* System.out.println§;
* System.out.println(p.toString());
*/

				/*Random r = new Random();
				System.out.println(r.toString());
				
				Scanner sc = new Scanner(System.in);
				System.out.println(sc.toString());*/
			}
		}

###06String类的概念和不变性
* A: String类的概念和不变性
* a:String类
* API中的String类的描述，发现String 类代表字符串
* Java 程序中的所有字符串字面值（如 “abc” ）都作为此类的实例实现。
* 字符串是常量,在创建之后不能更改
* 其实就是说一旦这个字符串确定了，那么就会在内存区域中就生成了这个字符串。字符串本身不能改变，但str变量中记录的地址值是可以改变的。
* 源码分析,String类底层采用的是字符数组:
private final char value[]
private 修饰说明value只能在String类内部使用,而且又没有提供get方法,所以外部无法获取value数组,就无法改变数组中元素的值
final修饰说明value是常量,一旦创建,就不能被改变,value一旦被初始化成某个数组,将永远指向这个数组,不可能再指向其它的数组了

	* b: 案例代码
		/*
		 *   String类特点:
		 *     一切都是对象,字符串事物 "" 也是对象
		 *     类是描述事物,String类,描述字符串对象的类
		 *     所有的 "" 都是String类的对象
		 *     
		 *     字符串是一个常量,一旦创建,不能改变
		 */
		public class StringDemo {
			public static void main(String[] args) {
				//引用变量str执行内存变化
				//定义好的字符串对象,不变
				String str = "itcast";
				System.out.println(str);
				str = "itheima";
				System.out.println(str);

}
}

###07String类创建方式和比较
* A: String类创建方式和比较
* a: 创建对象的数量比较
* String s3 = “abc”;
* 在内存中只有一个对象。这个对象在字符串常量池中
 * String s4 = new String(“abc”);
* 在内存中有两个对象。一个new的对象在堆中，一个字符串本身对象，在字符串常量池中
* b: 案例代码
public class StringDemo2 {
public static void main(String[] args) {
//字符串定义方式2个, 直接= 使用String类的构造方法
String str1 = new String(“abc”);
String str2 = “abc”;
System.out.println(str1);
System.out.println(str2);

				System.out.println(str1==str2);//引用数据类型,比较对象的地址 false
				System.out.println(str1.equals(str2));//true
			}
		}

###08String类构造方法
* A: String类构造方法
* a: 常见构造方法
* public String():空构造
* public String(byte[] bytes):把字节数组转成字符串
* public String(byte[] bytes,int index,int length):把字节数组的一部分转成字符串
* public String(String original):把字符串常量值转成字符串
* b: 案例代码
public class StringDemo3 {
public static void main(String[] args) {
function_1();
}
/*
* 定义方法,String类的构造方法
* String(byte[] bytes) 传递字节数组
* 字节数组转成字符串
* 通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。
* 平台 : 机器操作系统
* 默认字符集: 操作系统中的默认编码表, 默认编码表GBK
* 将字节数组中的每个字节,查询了编码表,得到的结果
* 字节是负数,汉字的字节编码就是负数, 默认编码表 ,一个汉字采用2个字节表示
*
* String(byte[] bytes, int offset, int length) 传递字节数组
* 字节数组的一部分转成字符串
* offset 数组的起始的索引
* length 个数,转几个 , 不是结束的索引
*/
public static void function(){
byte[] bytes = {97,98,99,100};
//调用String类的构造方法,传递字节数组
String s = new String(bytes);
System.out.println(s);

				byte[] bytes1 ={65,66,67,68,69};
				//调用String构造方法,传递数组,传递2个int值
				String s1 = new String(bytes1,1,3);
				System.out.println(s1);
			}
		}

###09String类构造方法_2
* A: String类构造方法
* a: 常见构造方法
* public String(char[] value):把字符数组转成字符串
* public String(char[] value,int index,int count):把字符数组的一部分转成字符串
* B: 案例代码
/*
* String类构造方法
* String类的构造方法,重载形式
*
/
public class StringDemo3 {
public static void main(String[] args) {
function_1();
}
/
* String(char[] value) 传递字符数组
* 将字符数组,转成字符串, 字符数组的参数,不查询编码表
*
* String(char[] value, int offset, int count) 传递字符数组
* 将字符数组的一部分转成字符串
* offset 数组开始索引
* count 个数
*/
public static void function_1(){
char[] ch = {‘a’,‘b’,‘c’,‘d’,‘e’,‘f’};
//调用String构造方法,传递字符数组
String s = new String(ch);
System.out.println(s);

			String s1 = new String(ch,1,4);
			System.out.println(s1);
		}
	}

###10String类的其他方法
* A：String类的其他方法
* a: 方法介绍
* int length(): 返回字符串的长度
* String substring(int beginIndex,int endIndex): 获取字符串的一部分
* String substring(int beginIndex): 获取字符串的一部分
* boolean startsWith(String prefix): 判断一个字符串是不是另一个字符串的前缀,开头
* boolean endsWith(String prefix): 判断一个字符串是不是另一个字符串的后缀,结尾
* boolean contains (String s): 判断一个字符串中,是否包含另一个字符串
* int indexOf(char ch): 查找一个字符,在字符串中第一次出现的索引,被查找的字符不存在,返回-1
* byte[] getBytes(): 将字符串转成字节数组,此功能和String构造方法相反,byte数组相关的功能,查询编码表
* char[] toCharArray(): 将字符串转成字符数组,功能和构造方法相反
* boolean equals(Object obj): 方法传递字符串,判断字符串中的字符是否完全相同,如果完全相同返回true
* boolean equalsIgnoreCase(String s): 传递字符串,判断字符串中的字符是否相同,忽略大小写

* b: 案例代码

public class StringDemo4 {
public static void main(String[] args) {
function_9();
}
/*
* boolean equals(Object obj)
* 方法传递字符串,判断字符串中的字符是否完全相同,如果完全相同返回true
*
* boolean equalsIgnoreCase(String s)
* 传递字符串,判断字符串中的字符是否相同,忽略大小写
*/
public static void function_9(){
String str1 = “Abc”;
String str2 = “abc”;
//分别调用equals和equalsIgnoreCase
boolean b1 = str1.equals(str2);
boolean b2 = str1.equalsIgnoreCase(str2);
System.out.println(b1);
System.out.println(b2);
}

			/*
			 * char[] toCharArray() 将字符串转成字符数组
			 * 功能和构造方法相反
			 */
			public static void function_8(){
				String str = "itcast";
				//调用String类的方法toCharArray()
				char[] ch = str.toCharArray();
				for(int i = 0 ; i < ch.length ; i++){
					System.out.println(ch[i]);
				}
			}
			
			/*
			 *  byte[] getBytes() 将字符串转成字节数组
			 *  此功能和String构造方法相反
			 *  byte数组相关的功能,查询编码表
			 */
			public static void function_7(){
				String str = "abc";
				//调用String类方法getBytes字符串转成字节数组
				byte[] bytes = str.getBytes();
				for(int i = 0 ; i < bytes.length ; i++){
					System.out.println(bytes[i]);
				}
			}
			
			/*
			 *  int indexOf(char ch)
			 *  查找一个字符,在字符串中第一次出现的索引
			 *  被查找的字符不存在,返回-1
			 */
			public static void function_6(){
				String str = "itcast.cn";
				//调用String类的方法indexOf
				int index = str.indexOf('x');
				System.out.println(index);
			}
			
			/*
			 *  boolean contains (String s)
			 *  判断一个字符串中,是否包含另一个字符串
			 */
			public static void function_5(){
				String str = "itcast.cn";
				//调用String类的方法contains
				boolean b =str.contains("ac");
				System.out.println(b);
			}
			
			/*
			 * boolean endsWith(String prefix)
			 * 判断一个字符串是不是另一个字符串的后缀,结尾
			 * Demo.java
			 *     .java
			 */
			public static void function_4(){
				String str = "Demo.java";
				//调用String类方法endsWith
				boolean b = str.endsWith(".java");
				System.out.println(b);
			}
			
			/*
			 * boolean startsWith(String prefix)  
			 * 判断一个字符串是不是另一个字符串的前缀,开头
			 * howareyou
			 * hOw
			 */
			  public static void function_3(){
				  String str = "howareyou";
				  //调用String类的方法startsWith
				  boolean b = str.startsWith("hOw");
				  System.out.println(b);
			  }
			
			/*
			 *  String substring(int beginIndex,int endIndex) 获取字符串的一部分
			 *  返回新的字符串
			 *  包含头,不包含尾巴
			 *  
			 *  String substring(int beginIndex)获取字符串的一部分
			 *  包含头,后面的字符全要
			 */
			public static void function_2(){
				String str = "howareyou";
				//调用String类方法substring获取字符串一部分
				str= str.substring(1, 5);
				System.out.println(str);
				
				String str2 = "HelloWorld";
				str2 = str2.substring(1);
				System.out.println(str2);
			}
			
			/*
			 *  int length() 返回字符串的长度
			 *  包含多少个字符
			 */
			public static void function(){
				String str = "cfxdf#$REFewfrt54GT";
				//调用String类方法length,获取字符串长度
				int length = str.length();
				System.out.println(length);
			}
		}

###11String类练习
* A: 获取指定字符串中，大写字母、小写字母、数字的个数
* a: 题目分析
* 为了统计大写字母、小写字母、数字的个数。创建3个计数的变量。
* 为了获取到字符串中的每个字符，进行字符串的遍历，得到每个字符。
* 对得到的字符进行判断，如果该字符为大写字母，则大写字母个数+1；如果该字符为小写字母，则小写字母个数+1；如果该字符为数字，则数字个数+1。
* 显示大写字母、小写字母、数字的个数

	* b: 解题步骤
		* 略
	* 案例代码
		public class StringTest {
			public static void main(String[] args) {
				getCount("A%A3eBr1FFy");					
			}
			
			/*
			 * 获取指定字符串中，大写字母、小写字母、数字的个数。
			 * 思想:
			 *   1. 计数器,就是int变量,满足一个条件 ++
			 *   2. 遍历字符串, 长度方法length() + charAt() 遍历
			 *   3. 字符判断是大写,是小写,还是数字
			 */
			public static void getCount(String str){
				//定义三个变量,计数
				int upper = 0;
				int lower = 0;
				int digit = 0;
				//对字符串遍历
				for(int i = 0 ; i < str.length() ; i++){
					//String方法charAt,索引,获取字符
					char c = str.charAt(i);
					//利用编码表 65-90  97-122  48-57
					if(c >='A' && c <=90){
						upper++;
					}else if( c >= 97 && c <= 122){
						lower++;
					}else if( c >= 48 && c <='9'){
						digit++;
					}
				}
				System.out.println(upper);
				System.out.println(lower);
				System.out.println(digit);
			}
		}

###12String类练习_2
* A: 将字符串中，第一个字母转换成大写，其他字母转换成小写，并打印改变后的字符串。
* a: 题目分析
* 把字符串分为两个部分，第一部分为字符串中第一个字母，第二部分为剩下的字符串。
* 把第一部分字符串转换成大写字母，把第二部分字符串转换成小写字母
* 把两部分字符串连接在一起，得到一个完整的字符串
* b: 解题步骤
* 略
* C: 案例代码
public class StringTest {
public static void main(String[] args) {

				System.out.println(toConvert("aBc5%4dEF"));
				
			}
			
			/*
			 *  将字符串的首字母转成大写,其他内容转成小写
			 *  思想:
			 *    获取首字母, charAt(0)  substring(0,1)
			 *    转成大写 toUpperCase()
			 *    
			 *    获取剩余字符串, substring(1)  toLowerCase()
			 */
			public static String toConvert(String str){
				//定义变量,保存首字母,和剩余字符
				String first = str.substring(0,1);
				String after = str.substring(1);
				//调用String类方法,大写,小写转换
				first = first.toUpperCase();
				after = after.toLowerCase();
				return first+after;
			}
		}

###13String类练习_3
* A: 查询大字符串中，出现指定小字符串的次数
* a: 题目分析
* 在大串中，查找小串出现的位置，出现了就次数+1
* 在上次小串出现位置的后面继续查找，需要更改大串的内容为上次未查询到的字符串。
* 回到第一步，继续查找小串出现的位置，直到大串中查询不到小串为止
* b: 解题步骤
* 略
* C: 案例代码
package cn.itcast.demo02;

		public class StringTest {
			public static void main(String[] args) {		
				System.out.println(getStringCount("hellojava,nijavahaojava,javazhenbang", "java"));
			}
			/*
			 *  获取一个字符串中,另一个字符串出现的次数
			 *  思想:
			 *    1. indexOf到字符串中到第一次出现的索引
			 *    2. 找到的索引+被找字符串长度,截取字符串
			 *    3. 计数器++
			 */
			public static int getStringCount(String str, String key){
				//定义计数器
				int count = 0;
				//定义变量,保存indexOf查找后的索引的结果
				int index = 0;
				//开始循环找,条件,indexOf==-1 字符串没有了
				while(( index = str.indexOf(key) )!= -1){
					count++;
					//获取到的索引,和字符串长度求和,截取字符串
					str = str.substring(index+key.length());
				}
				return count;
			}
		}

###14StringBuffer特点可变字符数组
* A:StringBuffer类概述
* 通过JDK提供的API，查看StringBuffer类的说明
* 线程安全的可变字符序列
* 底层采用字符数组实现,初始容量为16
* B:StringBuffer和String的区别
* String是一个不可变的字符序列
* StringBuffer是一个可变的字符序列

###15StringBuffer类的方法
* A: StringBuffer类的方法
* a: 方法介绍
* StringBuffer append(), 将任意类型的数据,添加缓冲区
* append 返回值,写return this
* 调用者是谁,返回值就是谁
* delete(int start,int end): 删除缓冲区中字符
* 开始索引包含,结尾索引不包含
* insert(int index, 任意类型): 将任意类型数据,插入到缓冲区的指定索引上
* replace(int start,int end, String str): 将指定的索引范围内的所有字符,替换成新的字符串
* reverse(): 将缓冲区中的字符反转
* String toString(): 继承Object,重写toString()
* 将缓冲区中的所有字符,变成字符串
* b: 案例代码
public class StringBufferDemo {
public static void main(String[] args) {
function_5();
}
/*
* StringBuffer类的方法
* String toString() 继承Object,重写toString()
* 将缓冲区中的所有字符,变成字符串
*/
public static void function_5(){
StringBuffer buffer = new StringBuffer();
buffer.append(“abcdef”);
buffer.append(12345);

				//将可变的字符串缓冲区对象,变成了不可变String对象
				String s = buffer.toString();
				System.out.println(s);
			}
			
			/*
			 *  StringBuffer类的方法
			 *    reverse() 将缓冲区中的字符反转
			 */
			public static void function_4(){
				StringBuffer buffer = new StringBuffer();
				buffer.append("abcdef");
				
				buffer.reverse();
				
				System.out.println(buffer);
			}
			
			/*
			 *  StringBuffer类方法
			 *    replace(int start,int end, String str)
			 *    将指定的索引范围内的所有字符,替换成新的字符串
			 */
			public static void function_3(){
				StringBuffer buffer = new StringBuffer();
				buffer.append("abcdef");
				
				buffer.replace(1, 4, "Q");
				
				System.out.println(buffer);
			}
			
			/*
			 *  StringBuffer类方法 insert
			 *    insert(int index, 任意类型)
			 *  将任意类型数据,插入到缓冲区的指定索引上
			 */
			 public static void function_2(){
				 StringBuffer buffer = new StringBuffer();
				 buffer.append("abcdef");	 
				 
				 buffer.insert(3, 9.5);
				 System.out.println(buffer);
			 }
			
			/*
			 * StringBuffer类方法
			 *   delete(int start,int end) 删除缓冲区中字符
			 *   开始索引包含,结尾索引不包含
			 */
			public static void function_1(){
				StringBuffer buffer = new StringBuffer();
				buffer.append("abcdef");
				
				buffer.delete(1,5);
				System.out.println(buffer);
			}
			
			/*
			 *  StringBuffer类方法
			 *   StringBuffer append, 将任意类型的数据,添加缓冲区
			 *   append 返回值,写return this
			 *   调用者是谁,返回值就是谁
			 */
			public static void function(){
				StringBuffer buffer = new StringBuffer();
				//调用StringBuffer方法append向缓冲区追加内容
				buffer.append(6).append(false).append('a').append(1.5);
				System.out.println(buffer);
			}
		}

###16StringBuilder类
* A:StringBuilder的概述
* 通过查看API了解一下StringBuilder类
* B:面试题
* String,StringBuffer,StringBuilder的区别
* StringBuffer和StringBuilder的区别
* StringBuffer是jdk1.0版本的,是线程安全的,效率低
* StringBuilder是jdk1.5版本的,是线程不安全的,效率高

		* String和StringBuffer,StringBuilder的区别
			* String是一个不可变的字符序列
			* StringBuffer,StringBuilder是可变的字符序列

###17StringBuffer类案例拼接数组
* A: StringBuffer类案例拼接数组
* a: 题目分析
* 定义StringBuffer对象
* 遍历数组,按照格式要求拼接处新的字符串,追加到StringBuffer容器中
* 将StringBuffer中的内容以String的形式返回
* b: 解题步骤
* 略
* C: 案例代码
public class StringBufferTest {
public static void main(String[] args) {
int[] arr = {4,1,4,56,7,8,76};
System.out.println(toString(arr));
}
/*
* int[] arr = {34,12,89,68};将一个int[]中元素转成字符串
* 格式 [34,12,89,68]
* String s = “[”
* 数组遍历
* s+= arr[i];
* s+"]"
* StringBuffer实现,节约内存空间, String + 在缓冲区中,append方法
*/
public static String toString(int[] arr){
//创建字符串缓冲区
StringBuffer buffer = new StringBuffer();
buffer.append("[");
//数组遍历
for(int i = 0 ; i < arr.length;i++){
//判断是不是数组的最后一个元素
if(i == arr.length-1){
buffer.append(arr[i]).append("]");
}else{
buffer.append(arr[i]).append(",");
}
}
return buffer.toString();
}
}

API

api的概述： 就是java替我们写好的一些类，他封装了一些功能，我们仅仅只需要知道如何使用即可

Object

object的概述：
   A、 object是所有的类父类
   B、 object中的所有方法，子类都能使用（接口不是object的子类）

Object 类中常用方法

 A、equals()  
    底层调用其实就是== 方法
    == 方法：
       基本数据类： 比较的是内容(值)
       引用数据类型：比较的是内存地址值
  String 的equals比较的是内容  

 B、String toString()
    问题：为什么要重写toString()方法
     
    答：打印时默认会调用toString()方法
     因为toString()方法来源于object中，object中getClass.getName()+"@" +Integer.toHexString(hasCode() ) --->打印就是内存地址值
    很多时候，我们不想看见内存地址值，想看到的是子类的特有属性值，这时就需要重写toString()方法

String

 在String 中认为都是对象，String str = "...";
 所以str 是对象，""也是对象
  String 是一个常量，其本质就是private final 修饰的字符数组     

String的构造方法:
 new String(byte [] bytes, int offset,int length);
 offset: 数据解锁起始位置
 length:需要解锁的位数
  
substring(int start ,int end );   包含头，不包含尾。 截取一段字符
substring(int start);             从某一位到尾
startsWith(String str)            判断以什么开头
endsWith(String str)                        判断以什么结尾    
contains(String str)               判断是否包含
indexOf（String str）      
charAt(int index)
equals()                           注意：要区分大小写
equalsIgnoreCase                   不区分大小写
getBytes（）    
toCharArray()

###StringBuilder && StringBuffer

1、 StringBuilder 是字符串缓冲对象，底层是一个没有用final修饰的数组，并且长度默认为16,底层是一个"可变数组"

注意：是底层自动帮我们创建新数组，数组一旦创建，是不可变的

面试题

  object类有哪些方法

###　final

A、修饰类：不能被继承
　　　B、修饰方法：不能被重写
C、修饰变量：基本数据类型：值不能改变
引用数据类型：地址值不能改变

重写和重载

   重写：子类中出现和父类方法声明一模一样的方法,重写
   重载：本类中出现方法名相同，但参数列表不同，注意：与返回值类型无关

封装

  封装好处：
   A、提高了代码的复用性
   B、提高了代码的安全性
   C、隐藏了对象实现的细节，仅仅对外提供方法

继承

  A、提高了代码的复用性
  B、提高了代码的可维护性
  C、是类和类之间耦合起来了，这是多态的前提
  继承的弊端：
  开发的原则：高内聚，低耦合
  内聚：完成一个功能的能力
  耦合：类和类之间的关系   继承的注意事项：
   
   1、 子类继承父类，只能继承父类中非private修饰的成员变量和方法
   2、 简单说：子类有，父类有，找子类，子类没有，父类有，找父类