目录
String是最常用的类
-
String类又称作不可变字符序列
-
String类位于java.lang包中，Java程序默认导入java.lang包下的所有类
-
Java字符串就是Unicode字符序列，例如"Java"就是4个Unicode字符"J"、"a"、"v"、"a"组成的
-
Java没有内置的字符串类型，而是在标准Java类库中提供了一个预定义的类String，每个用双引号括起来的字符串都是String类的一个实例
public class TestString {
public static void main(String[] args) {
// String s0 = null;
String s = "";
String s1 = "Java";
String s2 = new String("Java");
// System.out.println(s0.length()); // 报NullPointerException(空指针异常)的错
System.out.println(s.length()); // 0
System.out.println(s1.length()); // 4
System.out.println(s2.length()); // 4
}
}
常量池
-
全局字符串常量池
-
class文件常量池
-
运行时常量池(Runtime Constant Pool)
每个class运行时都有一个运行时常量池
System.out.println("--------------字符串相等问题---------------");
String s3 = "张三";
String s4 = "张三";
String s5 = new String("张三");
System.out.println(s3 == s4); // true
System.out.println(s3 == s5); // false
System.out.println(s5.equals(s3)); // true
API文档如何阅读
-
下载API文档地址：
Java Development Kit 8 Documentation (oracle.com)
String类常用的方法
| 方法 | 解释说明 |
|---|---|
| char charAt(int index) | 返回字符串中方第index个字符 |
| boolean equals(String other) | 如果字符串与other相等，返回ture；否则，返回false |
| boolean equalsIgnoreCase(String other) | 如果字符串与other相等(忽略大小写)，则返回true；否则返回false |
| int indexOf(String str) | 返回从头开始查找第一个子字符串str在字符串中的索引位置。如果未找到子字符串str，返回-1 |
| lastIndex(Of) | 返回从末尾开始查找第一个子字符串str在字符串中的索引位置。如果未找到子字符串str，返回-1 |
| int length() | 返回字符串的长度 |
| String replace(char oldChar，char newChar) | 返回一个新串，它是通过用newChar替换此字符串中出现的所有oldChar而生成的 |
| boolean startWith(String prefix) | 如果字符串以prefix开始，则返回true |
| boolean endsWith(String prefix) | 如果字符串以prefix结尾，则返回true |
| String subString(int beginIndex) | 返回一个新字符串，该串包含从原始字符串beginIndex到串尾 |
| String subString(int beginIndex,int endIndex) | 返回一个新字符串，该串包含从原始字符串beginIndex到串尾或endIndex - 1的所有字符 |
| String toLowerCase() | 返回一个新字符串，该串将原始字符串中的所有大写字母改成小写字母 |
| String toUpperCase() | 返回一个新字符串，该串将原始字符串中的所有小写字母改成大写字母 |
| String trim() | 返回一个新字符串，该串删除了原始字符串头部和尾部的空格 |
示例
public class TestString02 {
public static void main(String[] args) {
String s = "HELLO EVERYONE!";
String s1 = "hello everyone!";
System.out.println(s.charAt(4)); // 提取下标为4的字符 O
System.out.println(s.length()); // 返回字符串s的长度 15
System.out.println(s.equals(s1)); // 判断s与s1是否相等 false
System.out.println(s.equalsIgnoreCase(s1)); // 同上，但忽略大小写 true
System.out.println(s.indexOf("HELLO")); // 查找s中是否有Hello并返回位置 0
System.out.println(s1.indexOf("Pink")); // 查找s1中是否有Pink -1
String s2 = s.replace("E","A"); // 将s1中的E换成A
System.out.println(s2); // 打印s2，一个全新的字符串: HALLO AVARYONA!
System.out.println(s); // HELLO EVERYONE! String是不可变序列
String s3 = "Hi,beautiful girl~ do you love me? girl ?";
System.out.println(s3.lastIndexOf("girl")); // 从后往前找girl,找到了从前往后数位置并返回 35
System.out.println(s3.indexOf("girl")); // 从前往后找girl并返回位置 13
}
}
public class TestString03 {
public static void main(String[] args) {
String s = "";
String s1 = "Hi Zhangsan Hello~";
System.out.println(s1.startsWith("Hi")); // 判断是否以Hi开头 true
System.out.println(s1.startsWith("Hello")); // 判断是否以hello开头 false
System.out.println(s1.endsWith("~")); // 判断是否以~结尾 true
s = s1.substring(5); // 提取字符串从5开始到字符串结尾
System.out.println(s); // 打印s angsan Hello~
s = s1.substring(3,8); // 提取3-8的字符串，不包括8
System.out.println(s); // Zhang
s = s1.toLowerCase(); // 转小写
System.out.println(s); // hi zhangsan hello~
s = s1.toUpperCase(); // 转大写 HI ZHANGSAN HELLO~
System.out.println(s); //
String s2 = " How are you ~~~ ";
s = s2.trim(); // 去除首尾字符串，但不能去掉中间的
System.out.println(s); // How are you ~~~
System.out.println(s2.toLowerCase()); // String是不可变字符，s2不变 How are you ~~~
}
}
内部类
把一个类放在另一个类的内部定义，称为内部类(inner class)
特点
-
内部类提供了更好的封装，只能让外部类直接访问，不允许同一个包中的其他类直接访问
-
内部类可以直接访问外部类的私有属性，内部类被当成其他外部类放入成员，但外部类不能访问内部类的内部属性
-
接口只是解决了多重继承的部分问题，而内部类使得多重继承的解决方案变得更加完整
-
它只是一个编译时的概念，一旦编译成功，就会变成完全不同的两个类。是相对独立的一种存在，其成员变量/方法名可以和外部类相同
成员内部类
非静态内部类
-
对象必须寄存在一个外部类对象里，因此，如果有一个非静态内部类对象，那么一定存在对应的外部内对象
-
可以直接访问外部类的成员，但不能直接访问非静态类内部类成员
-
不能有静态方法，静态属性和静态初始化块
-
外部类的静态方法，静态代码块不能访问非静态内部类，包括不能使用非静态内部类定义变量，创建实例
成员变量访问要点
-
内部类属性：this.变量名
-
外部类属性：外部类名.this.变量名
内部类的访问
-
外部类中定义内部类：new Inner()
-
外部类以外的地方使用非静态内部类
-
Outer.Inner varname = new Outer().new Inner()
-
示例
package InnerClassTest;
public class Outer {
public static void main(String[] args) {
Outer o = new Outer();
o.show();
Outer.Inter i = new Outer().new Inter();
i.show();
}
private int age = 18;
private String name = "张三";
public void show(){
System.out.println("Outer.show");
System.out.println(age);
System.out.println(name);
}
public class Inter {
int age = 19;
String name = "李四";
public void show(){
System.out.println("Inter.show");
System.out.println(age);
System.out.println(Outer.this.age);
Outer.this.show();
}
}
}
在别的类中调用
package InnerClassTest;
public class TestInner {
public static void main(String[] args) {
Outer o = new Outer();
// Inner i = new Inner(); 错误的调用
Outer.Inter i = new Outer().new Inter(); /*正确调用*/
o.show();
i.show();
}
}
静态内部类
定义方式
static class ClassName{
// 类体
}
使用要点
-
看作外部类的一个静态成员
-
当一个静态内部类对象存在，并不一定存在对应得外部类对象。因此，静态内部类得实例方法不能直接访问外部类的实例方法
示例
package InnerClassTest;
class Outer2 {
private int a = 56;
static private int b = 33;
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 i2 = new Outer2.Inner2();
i2.test(); // 33
}
}
匿名内部类
-
适合只需要使用一次的类，eg：键盘监听操作等等，在安卓开发、awt、swing开发中常见
-
里面没有访问修饰符
-
没有构造方法
语法：
new 父类构造器(实参列表) \ 实现接口(){
// 匿名内部类类体
}
示例
package InnerClassTest;
import javax.swing.plaf.synth.SynthOptionPaneUI;
public class TestAnonymousInnerClass {
public void test(A a){
a.run();
}
public static void main(String[] args) {
TestAnonymousInnerClass t = new TestAnonymousInnerClass();
// t.test(new AImpl()); // 之前的做法
// 匿名类的做法--只用这一次
t.test(new A() { // new的不是接口，是一个没有名字的A的实现类
@Override
public void run() {
System.out.println("run");
}
});
t.test(new A(){ // 完全可以与上面的共存
@Override
public void run(){
System.out.println("run2");
}
});
}
}
// 之前的做法
//class AImpl implements A{
// @Override
// public void run(){
// System.out.println("run");
// }
//}
interface A{
void run();
}
局部内部类
开发中用的极少
-
定义在方法内部，作用域只限于本方法，称为局部内部类
-
作用域仅限于所在方法
package InnerClassTest;
public class TestLocalInnerClass {
public void show(){
class Inner3{
public void fun(){
System.out.println("hahaha");
}
}
new Inner3().fun();
}
public static void main(String[] args) {
new TestLocalInnerClass().show();
}
}
面向对象知识总结思维导图：
链接：知犀思维导图 - 免费思维导图 - 知犀 密码：3797
2553
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
