【java】初阶总结(干货)--持续更新

末蓝、 2023-02-11 10:22 58阅读 0赞

# Java总结（持续更新） #

## 一、方法重载（overload）总结 ##

*  应用：在同一个类中，多个功能一样的方法可考虑将他们方法名一致
 *  优点：代码美观，减少代码重复量，提高代码效率
 *  重载条件：同时满足3个条件  
    **1.位于同一个类中  
    2.方法名相同  
    3.参数列表不同（参数个数/参数类型/参数顺序）**  
    注意：  
    只有返回值不同----->不算是重载，算是重复，因为JVM无法区别，因为返回值可以不再main函数里面接受。  
    只有修饰符不同----->不算是重载，算是重复修饰符（public、static…）。
 *  返回值要求  
    主数据类型：必须一致  
    引用数据类型：可以变成子类

## 二、构造函数总结 ##

1.构造方法可以在给对象初始化的时候给对象属性赋值，完成对象的初始化  
2.使用new运算符时调用构造函数  
3.为防止**缺省构造器**丢失，需手动写出缺省构造方法  
4.实例变量的初始化不是**类加载时**完成，而是在产生对象进行

## 三、JVM内存结构总结 ##

JVM中主要的三块内存空间：  
1.栈内存：局部变量+方法空间  
2.堆内存：存放对象  
3.方法区内存：字节码文件（classloader将字节码文件装载到JVM中）  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTQzNzAyMg_size_16_color_FFFFFF_t_70]![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTQzNzAyMg_size_16_color_FFFFFF_t_70 1]

## 四、封装总结 ##

*  面向对象的三大特征：有了封装才有继承，有了继承才有多态：**封装->继承-> 多态**
 *  封装定义：通过访问权限控制外部对其内部的访问控制，以保证内部的安全性，内部的复杂不对外部显露，外部只能通过预留的接口对内部进行操作。
 *  封装作用：  
    1.保证内部结构的安全。  
    2.屏蔽复杂（内部结构），暴露简单（接口）  
    对于代码调用者来说，无需care代码如何实现，只需要找到代码接口，便可调用这个代码，实现其功能。
 *  封装步骤：  
    1.属性私有化（private私有权限：出了本类，无法被访问）  
    2.留下公有接口  
    接口：留给外部访问私有属性的间接方法，在此方法中可以检测出外部访问者的操作是否合法。

## 五、static总结 ##

*  修饰变量->静态变量
 *  修饰方法->静态方法
 *  修饰类->静态方法
 *  **可通过但不依赖**对象调用静态变量和静态方法
 *  类中的静态成员变量在内存中只有一份，无论实例化多少个对象，全部共享这一份静态成员变量
 *  static方法能调用static方法，能通过对象调用非static方法  
    static方法中不能有非static变量
 *  在类被加载时运行且只运行一次
 *  static关键字不能修饰方法中的局部变量  
    静态变量类加载时初始化，静态变量的内存位于方法区
 *  变量：局部变量+成员变量(实例变量+静态变量)
 *  实例的：对象相关的，只能采用“引用.”去访问，需要先new对象，可能会出现空指针异常，例：实例方法、实例变量
 *  静态的：类相关的，建议采用“类名.”去访问，不需要new对象，不会出现空指针异常，例：静态方法、静态变量
 *  空指针异常：只有在“空引用”访问“实例”相关的，都会出现NullPointerException
 *  静态代码块：  
    1.格式：static\{Java语句; java语句；\}  
    2.一个类中可以有多个代码块  
    3.静态代码块在类加载时执行，并且只执行一次，在main方法之前执行  
    4.作用：可以记录类加载的日志记录----->写在静态代码块中  
    5.静态代码块和静态变量都在类加载时执行，时间相同，根据代码先后判断执行顺序  
    6.静态变量的内存图解：方法的代码块位于方法区中，但是方法执行就会压栈，静态方法也是如此  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTQzNzAyMg_size_16_color_FFFFFF_t_70 2]

## 六、this总结： ##

this指针就是一个指向本对象的指针  
this.属性 访问的是自己的属性、  
this() 调用自己的无参构造方法  
1.this是一个关键字，是一个引用，保存内存地址并指向自身。  
2.this可以使用在实例方法中，也可以使用在构造方法中。  
3.this出现在实力方法中代表的是当前对象。  
4.this不能出现在静态方法中。  
5.this. 大部分可以省略，但是用来区分局部变量和实例变量时不能省略  
6.this()这种语法只能出现在构造方法第一行，在无参构造方法中可以用this(参数)来调用有参构造函数，这样节省了重复代码。this()---->作用：代码复用  
7.this内存图解：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTQzNzAyMg_size_16_color_FFFFFF_t_70 3]![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTQzNzAyMg_size_16_color_FFFFFF_t_70 4]

## 七、extends总结 ##

*  作用：  
    1.子类继承父类，代码得到复用  
    2.因为继承关系，才有方法覆盖和多态机制
 *  相关特性：  
    1.B类继承A类，  
    则称A类为超类（superclass）、父类、基类  
    则称B类为子类（subclass）、派生类、扩展类  
    2.java只支持单继承，不支持多继承（多重继承），但是可以多层继承  
    3.子类继承父类，除了构造方法不能继承之外，剩下都可以继承，但是私有属性无法在子类中直接访问。  
    4.java中所有的类都继承Object类，Object类是根类  
    5.继承缺点是增加类间耦合性，父类改变影响子类  
    6.子类拥有父类的非private的属性和方法，同时可以覆盖(方法)，或扩展(新增成员)

## 八、方法覆盖总结 ##

1.方法覆盖：方法重写（Overrider、Overwrite）  
2.子类对父类继承过来的方法进行方法覆盖之后，子类对象调用该方法时，一定执行覆盖之后的方法  
3.形成**方法覆盖条件**：  
(1)两个类有继承关系  
(2)重写方法必须与之前方法具有相同的(返回值类型、方法名、形参列表)  
(3)访问权限不能更低，可以更高  
(4)重写之后的方法不可以抛出更多的异常，可以更少  
4.注意事项：  
(1)方法覆盖针对方法，和属性无关  
(2)私有方法无法覆盖  
(3)构造方法无法被继承，所以无从谈起方法覆盖  
(4)方法覆盖只针对“实例方法”，“静态方法覆盖”不存在（静态方法执行与对象无关，子类“覆盖”之后还是会执行父类的静态方法）  
5.Object类中**toString()方法覆盖**  
(1)toString作用：将“java对象”转换成“字符串形式”  
(2)toString原默认方法体：

public String toString() { 
            return getClass().getName() + "@" + Integer.toHexString(hashCode());
        }

(3)toString方法覆盖(重写一定要复制粘贴)

public String toString() { 
            return year + "年" + month + "月" + day + "日";
        }

6.方法重载和方法覆盖的异同  
(1)方法重载发生在同一个类中；方法覆盖发生在两个有继承关系的类中  
(2)方法重载是方法名相同，参数列表不同；方法覆盖是方法名相同，参数列表相同

## 九、多态总结 ##

一、基础语法  
1.两个重要概念  
向上转型(upcasting)：子—>父 (自动类型转换) 向下转型(downcasting)：父—>子 (强制类型转换)  
无论是向上转型还是向下转型，两个类型之间必须有继承关系  
2.允许父类型引用指向子类型对象  
Animal animal = new Cat();  
3.多态解释：编译时一种形态，运行时一种形态  
java程序分为编译阶段和运行阶段  
编译阶段：对于编译器来说只知道animal的类型是Animal，所以编译器在检查语法时会去Animal.class文件里寻找方法，字节码文件中若找到方法，便会绑定方法，编译通过，静态绑定成功。（编译阶段属于静态绑定）  
运行阶段：堆内存中创建的对象时Cat对象，所以执行方法时，真正参与方法执行的是子类对象，所以运行阶段会动态执行子类对象的方法，这个过程属于运行阶段绑定。（运行阶段绑定属于动态绑定）  
若执行的方法是子类特有的方法则无法通过编译阶段（在父类的class文件中找不到该方法—>语法不合法）  
向下转型(强转)就可访问子类特有的方法  
Cat cat = (Cat)animal;  
4.运行时异常：java.lang.ClassCastException---->类转换异常（向下转型的风险）  
二、开发中的作用  
1.降低程序耦合度，提高程序扩展力：面向父类型编程、面向抽象编程  
软件开发原则：对扩展开放，对修改关闭—>目的是降低耦合度提高扩展力

## 十、instanceof运算符总结 ##

1.避免运行时异常：类转换异常  
2.运行阶段动态判断：引用指向的对象的类型  
3.返回值为Boolean(true/false)  
4.animal instanceof Animal ----> true  
5.用法：对类型向下转型时，使用instanceof运算符进行判断，可以避免ClassCastException

## 十一、super和this总结 ##

**super与this关键字的比较**

*  this关键字  
    1.指向自己的引用  
    2.this()调用本类中构造方法时，放在程序首行  
    3.this能出现在实例方法和构造方法中，不能出现在静态方法中  
    4.this的语法有：“this.”、“this()”  
    5.this大部分情况下可以省略，但是在区分局部变量和实例变量时不能省略  
    public void setName(String name)\{  
    this.name = name;  
    \}
 *  super关键字  
    1.用来引用当前对象的直接父类。  
    2.super()调用父类中构造方法时，放在程序首行,先初始化父类特征（有子先有父）  
    3.super能出现在实例方法和构造方法中，不能出现在静态方法中  
    4.super的语法：“super.”、“super()”  
    5.super大部分情况下可以省略，但是父类和子类中有同名的属性或方法，想要在子类中访问父类的同名属性或方法，需要"super."  
    6.super在构造函数中默认存在  
    7.使用方法：  
    super(实参列表)—>调用父类有参构造函数---->由于父类属性为private，无法在子类直接赋值构造  
    super.属性名—>访问父类的方法  
    super.方法名(实参)—>调用父类方法

## 十二、final总结 ##

1.final是关键字，代表"最终的，不可变的"  
2.修饰变量—>只能赋值一次  
修饰方法—>无法被方法覆盖or方法重写  
修饰类—>该类无法被继承  
修饰对象引用—>其指向不可修改，但是对象内部数据可以修改  
3.final修饰的实例变量一般添加static修饰并且访问权限都是public—>public static final联合修饰称为"常量"  
4.常量和静态变量一样都是存储在方法区，都是在类加载时初始化，区别在于常量不可变，静态变量可变

## 十三、抽象类总结 ##

1.概念：类与类之间具有共同特征，将这些共同特征提取出来，形成的就是抽象类，抽象类本身并不存在，所以无法创建对象进行实例化  
2.抽象类属于引用数据类型  
3.语法:  
\[修饰符列表\] abstract class 类名\{  
类体;  
\}  
4.final与abstract是对立的，无法同时使用  
5.抽象类必须被继承，其子类也可以是抽象类，也可以是非抽象类  
6.抽象类可以有构造方法供给子类使用  
7.抽象方法：没有方法体的方法  
例：public abstract void doSome();  
8.抽象类中不一定有抽象方法，但是抽象方法必须位于抽象类中  
9.抽象类的子类必须对抽象类中的抽象方法进行覆盖/重写/实现  
**面试题**：java语言中凡是没有方法体的方法都是抽象方法？  
答：错误的，native关键字修饰的方法就是底层调用C++写的动态链接库程序  
例如：public native int hashCode();  
10.抽象类并不完全抽象

## 十四、接口总结 ##

1.接口是一种"引用数据类型"  
2.接口是完全抽象的  
3.接口定义语法：  
\[修饰符列表\] interface 接口名\{…\}  
4.接口可以继承，并且支持多继承，弥补了java中的类只支持单继承的缺陷  
5.接口中只有：**常量、抽象方法**(不能有方法体)  
6.接口中的所有元素**都是public修饰**  
7.常量的public static final可以省略  
抽象方法的public abstract可以省略  
8.类与类之间称作继承(extends)，类与接口之间称作实现(implements)  
非抽象类实现接口时，必须将接口中的所有方法实现  
9.一个类可以实现多个接口  
10.extends和implements可以共存，extends在前  
11.使用多态：接口类型引用指向子类型对象  
12.接口A和接口B之间无继承关系，但是可以强制转换，编译可通过，但是运行可能会出现ClassCastException  
13.接口在开发中的作用：  
java中要求：面向抽象编程—>面向接口编程  
接口使实现者与调用者解耦合

## 十五、抽象类与接口的区别总结 ##

1.抽象类是半抽象的，接口是完全抽象的  
2.抽象类中可有构造方法，接口中不可有构造方法  
3.抽象类只能单继承，接口可以多继承  
4.一个类只能继承一个抽象类，一个类可以实现多个接口

## 十六、类中的接口： ##

1.私有属性的set和get方法  
set方法：在set中设立关卡可以防止用户的非法输入

public void set 属性名首字母大写(1个参数){ 
       XXX = 参数；
    }
    get方法：
    public int get 属性名首字母大写(){ 
        return XXX;
    }

2.接口都有调用者和实现者：面向接口调用、面向接口写实现类，这都属于面向接口编程  
为什么要面向接口编程？  
解耦合：降低程序耦合度，提高程序可扩展性  
多态机制就是非常典型的面向抽象编程（不要面向具体编程）

建议：
    Animal a = new Cat();
    Animal b = new Dog();
    //喂养方法
    public void feed(Animal a){ //面向父类型编程
    }
    
    不建议：
    Dog d = new Dog();
    Cat c = new Cat();

## 十七、is-a、has-a、like-a关系 ##

is-a: 继承关系(继承)----->Cat is a animal ---->A extends B  
has-a: 属性关系(属性)—>I has a pen ---->A\{B b;\}  
like-a： 实现关系(接口)—>Cooker like a FoodMenu ----> A implements B

## 十八、package和import总结 ##

*  package：  
    1.package是java中的包机制，作用是为了方便程序的管理，不同功能的类分别放在不同包下  
    2.用法：package+包名  
    出现在程序第一行  
    3.命名规范：采用公司域名倒叙（公司域名具有全球唯一性）  
    公司域名倒叙 + 项目名 + 模块名 + 功能名  
    4.带有package的程序运行与编译  
    运行：javac -d . HelloWorld.java  
    \-d带包编译  
    .编译之后的东西放入当前目录  
    编译：java com.bjpowernode.javase.chapter17.HelloWord
 *  import  
    1.将程序中需要且不存在于当前目录下的类导入，可以正常使用  
    2.import语句位于package与class之间

## 十九、访问控制权限总结 ##

public--------->表示公开的，在任何位置都可以访问  
protected----->表示受保护，只能在本类、同包、子类中访问  
default-------->表示默认的，只能在本类、同包中访问  
private-------->表示私有的，只能在本类中访问

## 二十、内部类总结 ##

1.内部类：在类的内部又定义一个新的类，被称为内部类  
2.分类：  
静态内部类：类似于静态变量  
实例内部类：类似于实例变量  
局部内部类：类似与局部变量  
3.内部类编写的代码可读性很差

## 二十一、数组总结 ##

1.数组是一种引用数据类型，父类是Object  
2.数组中可以存储基本数据类型（内容），也可以存储引用数据类型（对象地址）  
3.数组对象处于堆当中  
4.数组一旦创建，在Java中规定：数组长度不可变  
5.数组自带length属性，可以求数组长度  
6.数组的优点、缺点、注意：  
**优点：检索效率高  
缺点：随机增删效率较低，数据无法存储大数据量。  
注意：数组最后一个元素的增删效率不受影响**  
7.数组是什么？（面试这样回答）  
**第一、空间存储上，内存地址是连续的  
第二、每个元素占用的空间大小相同  
第三、知道首元素的内存地址  
第四、通过下标可以计算出偏移量  
通过数组下标和数据类型可以计算出某一个元素的内存地址，效率很高**  
8.一、二维数组的静态初始化、动态初始化  
**静态初始化：**  
**一维**：

int[] arr = { 1, 2, 3};
    Object[] objs = {  new Object(), new Object(), new Object() };

**二维**：

int[][] arr = { 
        { 1, 2, 3},
        { 1, 2, 2, 5},
        { 2, 5, 9, 6, 3}
    };
    Object[][] objs = { 
        { new Object(), new Object(), new Object() },
        { new Object(), new Object()},
        { new Object()}
    };

**动态初始化：**  
**一维**：

int[] arr = new int[4];    //4个长度，每个元素默认为0
    Object[] objs = new Object[4];    //4个长度，每个元素默认值为null

**二维**：

int[][] arr =new int[3][4];
    Object[][] arr = new Object[4][4];
    Animal[][] animal = new Animal[3][4];    
    //既可以存储Animal对象，也可以存储Animal的子类对象

9.一维数组的遍历:  
**一维：**

for( int i = 0; i < arr.length; i++){ 
        System.out.println( arr[i] );
    	}

**二维：**

for(int i = 0; i < arr.length; i++){ 
    	for(int j = 0; j < arr[i].length; j++){ 
    		System.out.print(arr[i][j]);
    	}
    	System.out.println();
    }

10.**main方法上"String\[\] args"参数**：运行程序之前需要输入的字符串，可以用来判断是否具有使用该程序的权限  
11.数组的拷贝：String.arraycopy()方法的使用  
数组有一个特点：长度一旦确定，不可变  
所以数组长度不够时，需要扩容，扩容的机制是：新建一个大数据，将小数组中的数据拷贝到大数组，然后小数组对象被垃圾回收  
12.数组内存结构：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTQzNzAyMg_size_16_color_FFFFFF_t_70 5]

## 二十二、String字符串总结 ##

1.字符串的动态创建、静态创建  
动态创建：String str = new String(" abc "); ----->垃圾回收器会回收  
静态创建：String str = " abc "; ----->垃圾回收器不会回收  
2.字符串的存储位置  
动态创建：字符串引用位于栈中(存储字符串对象的地址)，字符串对象位于堆中(存储字符串内容的地址)，字符串内容位于方法区中的字符串常量池中  
静态创建：字符串引用位于栈中(存储字符串对象的地址)，字符串内容位于方法区中的字符串常量池中  
3.静动态创建相同字符串的异同  
静态创建：str1和str2中存储的地址一模一样，都是位于字符串常量池中"abc"的地址。

String str1 = "abc";
    String str2 = "abc";

动态创建：str1和str2中存储的地址不一样，分别是位于堆上的不同字符串对象

String str1 = new("abc");
    String str2 = new("abc");

4.字符串内容比较使用：equals()方法  
例如：

str1.equals(str2);
    "hello".equals(str1);   --->可以避免空指针异常

5.面试题：

String str1 = new("abc");
    String str2 = new("abc");

一共产生了3个对象：字符串常量池中一个，堆上两个String对象

## 二十三、常用的String构造方法 ##

第一个：String s = new String("");  
第二个：String s = “”;  
第三个：String s = new String(char 数组);  
第四个：String s = new String(char 数组，起始下标，长度);  
第五个：String s = new String(byte数组);  
第六个：String s = new String(byte数组，起始下标，长度);

## 二十四、String类中常用方法 ##

1、（掌握）char charAt( int index )  
**作用：获取指定位置字符**

char c = "中国人".charAt(1);
    System.out.println(c);//国

2、（了解）int compareTo(String anotherString)  
**作用：比较字符串的大小**  
**字符串之间比较大小不能直接使用 “<”">"，需要使用compareTo方法。**

int result = "abc".compareTo("abc");
    System.out.println(result); 
    //0（等于0） 前后一致 10 - 10 = 0
    
    int result2 = "abcd".compareTo("abce");
    System.out.println(result2); 
    //-1（小于0） 前小后大 8 - 9 = -1
    
    int result3 = "abce".compareTo("abcd");
    System.out.println(result3); 
    // 1（大于0） 前大后小 9 - 8 = 1
    
    // 拿着字符串第一个字母和后面字符串的第一个字母比较。能分胜负就不再比较了。
    System.out.println("xyz".compareTo("yxz")); // -1

3、（掌握）boolean contains(CharSequence s)  
**作用：判断前面的字符串中是否包含后面的子字符串。**

System.out.println("HelloWorld.java".contains(".java")); // true
    System.out.println("http://www.baidu.com".contains("https://")); // false

4、（掌握） boolean endsWith(String suffix)  
**作用：判断当前字符串是否以某个子字符串结尾。**

System.out.println("test.txt".endsWith(".java")); // false
    System.out.println("test.txt".endsWith(".txt")); // true
    System.out.println("fdsajklfhdkjlsahfjkdsahjklfdss".endsWith("ss")); // true

5、（掌握）boolean equals(Object anObject)  
**作用：比较两个字符串必须使用equals方法，不能使用“==”  
equals只能看出相等不相等，  
compareTo方法可以看出是否相等，并且同时还可以看出谁大谁小。**

System.out.println("abc".equals("abc")); // true

6、（掌握）boolean equalsIgnoreCase(String anotherString)  
**作用：判断两个字符串是否相等，并且同时忽略大小写。**

System.out.println("ABc".equalsIgnoreCase("abC")); // true

7、（掌握）byte\[\] getBytes()  
**作用：将字符串变成字节数组，数组中存放的是对应字符串中字符的数值，例如，a----97; b----98**

byte[] bytes = "abcdef".getBytes();
            for(int i = 0; i < bytes.length; i++){ 
                System.out.println(bytes[i]);
            }
    //bytes[] = {97,98,99,100,101,102}

8、（掌握）.int indexOf(String str)  
**作用：判断某个子字符串在当前字符串中第一次出现处的索引（下标）。**

System.out.println("oraclejavac++.netc#phppythonjavaoraclec++".indexOf("java")); // 6

9、（掌握）boolean isEmpty()  
**作用：判断某个字符串是否为“空字符串”。底层源代码调用的应该是字符串的length()方法。**

String s1 = "";
    String s2 = "a";
    System.out.println(s1.isEmpty());//true
    System.out.println(s2.isEmpty());//false

10、（掌握） int length()  
*面试题：判断数组长度和判断字符串长度不一样  
判断数组长度是length属性，判断字符串长度是length()方法。*

System.out.println("abc".length()); // 3
    System.out.println("".length()); // 0

11、（掌握）int lastIndexOf(String str)  
**作用：判断某个子字符串在当前字符串中最后一次出现的索引（下标）**

System.out.println("oraclejavac++javac#phpjavapython".lastIndexOf("java")); //22

12、（掌握）. String replace(CharSequence target, CharSequence replacement)  
**作用：将某段子字符串替换成另一个字符串替换  
String的父接口就是：CharSequence**

String newString = "http://www.baidu.com".replace("http://", "https://");
    System.out.println(newString); //https://www.baidu.com
    //把以下字符串中的“=”替换成“:”
    String newString2 = "name=zhangsan&password=123&age=20".replace("=", ":");
    System.out.println(newString2);     //name:zhangsan&password:123&age:20

13、（掌握）.String\[\] split(String regex)  
**作用：按照某个字符拆分字符串**

String[] ymd = "1980-10-11".split("-"); //"1980-10-11"以"-"分隔符进行拆分。
    for(int i = 0; i < ymd.length; i++){ 
        System.out.println(ymd[i]);
    }
    String param = "name=zhangsan&password=123&age=20";
    String[] params = param.split("&");
    for(int i = 0; i <params.length; i++){ 
          System.out.println(params[i]);    // 可以继续向下拆分，可以通过“=”拆分。
    }

14、（掌握）、boolean startsWith(String prefix)  
**作用：判断某个字符串是否以某个子字符串开始。**

System.out.println("http://www.baidu.com".startsWith("http")); // true
    System.out.println("http://www.baidu.com".startsWith("https")); // false

==15、（掌握）String substring(int beginIndex) ==  
**参数是起始下标  
作用：从某一个位置开始截取后面字符串**

System.out.println("http://www.baidu.com".substring(7)); //www.baidu.com

16、（掌握）String substring(int beginIndex, int endIndex)  
**作用：将某一段子字符串变变成新字符串  
beginIndex起始位置（包括）  
endIndex结束位置（不包括）**

System.out.println("http://www.baidu.com".substring(7, 10));  //www

17、(掌握)char\[\] toCharArray()  
**作用：将字符串转换成char数组**

char[] chars = "我是中国人".toCharArray();
    for(int i = 0; i < chars.length; i++){ 
        System.out.println(chars[i]);
    }
    //chars[] = {'我','是','中','国','人'}

18、（掌握）String toLowerCase()  
**作用：将字符串全部变成小写**

System.out.println("ABCDefKXyz".toLowerCase());
    //abcdefkxyz

19、（掌握）String toUpperCase();  
**作用：将字符串全部变成大写**

System.out.println("ABCDefKXyz".toUpperCase());
    //ABCDEFKXYZ

20、（掌握）String trim();  
**去除字符串前后空白**

System.out.println(" hello world ".trim());    //hello world

21、（掌握） String中只有一个方法是静态的，不需要new对象  
**这个方法叫做valueOf，作用：将“非字符串”转换成“字符串”**

String s1 = String.valueOf(true);
    String s1 = String.valueOf(100);
    String s1 = String.valueOf(3.14);·

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTQzNzAyMg_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200523095104462.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTQzNzAyMg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTQzNzAyMg_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200523095114746.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTQzNzAyMg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTQzNzAyMg_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200523095558955.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTQzNzAyMg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTQzNzAyMg_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200523095924672.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTQzNzAyMg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTQzNzAyMg_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20200523095930385.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTQzNzAyMg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTQzNzAyMg_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20200523102202835.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTQzNzAyMg==,size_16,color_FFFFFF,t_70