JAVA入门——lesson 8

String： 就是把一堆字符串起来， 统一使用。

口 String 类又称作不可变字符序列。
口 String 位于 java.lang 包中， Java 程序默认导入 java.lang 包下的所有类。
口 Java 字符串就是 Unicode 字符序列， 例如字符串“Java”就是 4 个 Unicode 字 符’J’、 ’a’、’v’、 ’a’组成的。
口 Java 没有内置的字符串类型， 而是在标准 Java 类库中提供了一个预定义的类 String， 每个用双引号括起来的字符串都是 String 类的一个实例。

【示例】 String 类的简单使用

String e = ""   ; // 空字符串
String greeting = " Hello World ";

【示例】 " +"连接符

int age = 18;
String str = "age is" + age;   //str 赋值为"age is 18"
//这种特性通常被用在输出语句中：
System.out.println("age   is" + age);

【示例】字符串相等判断（以后一般判断字符串值是否相等，使用 equals()）

String g1 = "小雅工作室"; 
String g2 = "小雅工作室"; 
String g3 = new String("小雅工作室"); 
System.out.println(g1 == g2); // true 
System.out.println(g1 == g3); // false 
System.out.println(g1.equals(g3)); //true

· 如何下载 API 文档

下载地址，点击进入： https://www.oracle.com/java/technologies/javase-jdk8-doc-downloads.html

查看 API 文档

下载成功后，解压下载的压缩文件，点击进入 docs/api 下的 index.html 文件即可。 ·

API 文档如何阅读

【示例】String 类常用方法一

public class StringTest1 { 
	public static void main(String[ ] args) { 
		String s1 = "core Java"; 
		String s2 = "Core Java"; 
		System.out.println(s1.charAt(3));//提取下标为 3 的字符 	
		System.out.println(s2.length());//字符串的长度 
		System.out.println(s1.equals(s2));//比较两个字符串是否相等 
		System.out.println(s1.equalsIgnoreCase(s2));//比较两个字符串（忽略大小 写） 
		System.out.println(s1.indexOf("Java"));//字符串 s1 中是否包含 Java 
		System.out.println(s1.indexOf("apple"));//字符串 s1 中是否包含 apple 
		String s = s1.replace(' ', '&');//将 s1 中的空格替换成& 
		System.out.println("result is :" + s); 
	} 
}

运行结果：

【示例】String 类常用方法二

public class StringTest2 { 
	public static void main(String[ ] args) { 
		String s = ""; String s1 = "How are you?"; 
		System.out.println(s1.startsWith("How"));//是否以 How 开头 
		System.out.println(s1.endsWith("you"));//是否以 you 结尾 
		s = s1.substring(4);//提取子字符串：从下标为 4 的开始到字符串结尾为止 
		System.out.println(s); 
		s = s1.substring(4, 7);//提取子字符串：下标[4, 7) 不包括 7 
		System.out.println(s); 
		s = s1.toLowerCase();//转小写 
		System.out.println(s); 
		s = s1.toUpperCase();//转大写 
		System.out.println(s); 
		String s2 = " How old are you!! "; 
		s = s2.trim();//去除字符串首尾的空格。注意：中间的空格不能去除 
		System.out.println(s); 
		System.out.println(s2);//因为 String 是不可变字符串，所以 s2 不变 
	} 
}

运行结果：

 equals 方法用来检测两个字符串内容是否相等。如果字符串 s 和 t 内容相等，则 s.equals(t)返回 true，否则返回 false。
 要测试两个字符串除了大小写区别外是否是相等的，需要使用 equalsIgnoreCase
方法。
 判断字符串是否相等不要使用"=="

【示例】忽略大小写的字符串比较

"Hello".equalsIgnoreCase("hellO");//true

【示例】字符串的比较："= ="与 equals()方法

public class TestStringEquals { 
	public static void main(String[ ] args) { 
		String g1 = "嗲嗲"; 
		String g2 = "嗲嗲"; 
		String g3 = new String("嗲嗲"); 
		System.out.println(g1 == g2); // true 指向同样的字符串常量对象 
		System.out.println(g1 == g3); // false g3 是新创建的对象 
		System.out.println(g1.equals(g3)); // true g1 和 g3 里面的字符串内容是一样的 
	} 
}

运行结果：

我们把一个类放在另一个类的内部定义，称为内部类(inner class）

内部类的两个要点：
 内部类提供了更好的封装。只能让外部类直接访问，不允许同一个包中的其他类直 接访问。
内部类可以直接访问外部类的私有属性，内部类被当成其外部类的成员。但外部类 不能访问内部类的内部属性。

注意
内部类只是一个编译时概念，一旦我们编译成功，就会成为完全不同的两个类。对于一 个名为 Outer 的外部类和其内部定义的名为 Inner 的内部类。编译完成后会出现 Outer.class 和 Outer$Inner.class 两个类的字节码文件。所以内部类是相对独立的一种存在，其成员变 量/方法名可以和外部类的相同

【示例】内部类的定义和使用

 
class Outer { 
	private int age = 10; 
	public void show(){ 
		System.out.println(age);//10 
	}
	 
	public class Inner { 
		//内部类中可以声明与外部类同名的属性与方法 
		private int age = 20; 
		public void show(){ 
			System.out.println(age);//20 	
		} 
	}
}

编译后会产生两个不同的字节码文件，如图所示：

非静态内部类（外部类里使用非静态内部类和平时使用其他类没什么不同）

非静态内部类对象必须寄存在一个外部类对象里。因此，如果有一个非静态内部类 对象那么一定存在对应的外部类对象。非静态内部类对象单独属于外部类的某个对 象。非静态内部类可以直接访问外部类的成员，但是外部类不能直接访问非静态内部类 成员。非静态内部类不能有静态方法、静态属性和静态初始化块。成员变量访问要点：内部类属性：this.变量名。外部类属性：外部类名.this.变量名。

【示例】内部类中访问成员变量

 
class Outer1 { 
	private int age = 10; 
	public void show(){ 
		System.out.println(age);//10 
	}
	
	public class Inner1 { 
		//内部类中可以声明与外部类同名的属性与方法 
		private int age = 20; 
		public void show(){ 
			System.out.println(age);//20 
			System.out.println(Outer1.this.age); //10 访问外部类 的普通属性} 
		} 
	}
}

内部类的访问：

外部类中定义内部类：new Inner()。外部类以外的地方使用非静态内部类： Outer.Inner varname = new Outer().new Inner()。

【示例】内部类的访问

 
public class TestInnerClass1 { 
	public static void main(String[ ] args) { 
		//先创建外部类实例，然后使用该外部类实例创建内部类实例 
		Outer1.Inner1 inner = new Outer1().new Inner1(); 
		inner.show(); 
	} 
}

定义方式：

static class ClassName { 
	//类体 
	}

使用要点：

静态内部类可以访问外部类的静态成员，不能访问外部类的普通成员。静态内部类看做外部类的一个静态成员。

【示例】静态内部类的访问

 
class Outer2{ 
	private int a = 10; 
	private static int b = 20; 
	//相当于外部类的一个静态成员 
	static class Inner2{ 
		public void test(){ 
	 // System.out.println(a); //静态内部类不能访问外部类的普 通属性 
		System.out.println(b); //静态内部类可以访问外部类的静态 属性 
		} 
	} 
}
public class TestStaticInnerClass { 		
	public static void main(String[ ] args) { 
	//通过 new 外部类名.内部类名() 来创建内部类对象 
	Outer2.Inner2 inner =new Outer2.Inner2(); 
	inner.test(); 
	} 
}

适合那种只需要使用一次的类。比如：键盘监听操作等等。在安卓开发、awt、swing 开发中常见。
语法：

new 父类构造器(实参类表) 实现接口 () { 
	//匿名内部类类体！ 
}

【示例】匿名内部类的使用

 
public class TestAnonymousInnerClass {
	public void test1(A a) {
		 a.run(); 
	}
	public static void main(String[] args) { 
		TestAnonymousInnerClass tac = new TestAnonymousInnerClass(); 	
		tac.test1(new A() { 
			@Override 
			public void run() { 	
				System.out.println("匿名内部类测试! 我是新定义的 第一个匿名内部类！"); 
			} 
		}); 
		
		tac.test1(new A() { 
			@Override
			public void run() { 
				System.out.println("我是新定义的第二个匿名内部类 "); 
			} 
		}); 
	} 
}
interface A {
	 void run(); 
}

注意
 匿名内部类没有访问修饰符。
 匿名内部类没有构造方法。因为它连名字都没有那又何来构造方法呢。

定义在方法内部的，作用域只限于本方法，称为局部内部类。 局部内部类在实际开发中应用很少。

【示例】方法中的内部类

 
public class TestLocalInnerClass { 	
	public void show() { 
		//作用域仅限于该方法 
		class Inner3 { 
			public void fun() { 
				System.out.println("helloworld"); 
			} 
		}
		new Inner3().fun(); 
	}
	public static void main(String[ ] args) { 
	new TestLocalInnerClass().show(); 
	} 
}