[size=medium][color=gray]Java面向对象编程
一、基本成员
1.类
语法：修饰符 class 类名｛
//类成员
｝
类修饰符：public protected 缺省 private static abstract final
*final 和 abstract不能同时修饰一个类。
final表示不能被继承,abstract表示只能用于继承.
类成员：属性，方法，构造方法，类，接口，枚举类
成员分类：类相关(使用类名直接调用)
对象相关(创建对象，才能通过对象调用)
2.封装
把类的状态信息隐藏在类内部，不允许外部程序直接调用，只能通过该类提供特定的方法来操作和访问
访问权限：private 类内部范围
缺省 同包里的类访问
protected 同包中的类访问,同项目中不同包中的了类访问.
public 可以被同项目中所有类访问
实现：a:将内部状态信息(属性)用private修饰
b:提供相关方法让外部调用
优点：安全性,完整性,复用率.
3.继承
语法：subclass extends superclass{
//类定义部分
}
*Java只支持单继承，每个类只能有一个直接父类
子类可以继承父类的哪些财产：
public 和 protected 修饰的属性和方法，是否同包都能继承
缺省修饰的属性和方法，但子类和父类必须同包
子类无法继承父类的财产：
private修饰的属性和方法.
父类的构造方法.
4.接口
语法：修饰符 interface 接口名｛
//成员
｝
彻底的抽象类。
@接口中的成员：属性(必须为常量)，方法(必须为抽象方法)，接口，类，枚举类
@非接口成员:构造方法，普通方法，普通属性，语句块.
@接口和抽象类都不能被实例化，只能用来被子类实现.
@接口中的实现类必须实现(重写)接口中所有方法.
*实现类的写法：
public class 类名 implements 接口1，接口2｛
//实现接口的方法
｝
接口思想：
作为程序外部交互的窗口，体现一种规范。
5.多态
同一个实现接口，使用不同的实例而执行不同的操作。
实现多态的条件：
1.继承的存在(继承是多态的基础，没有继承就没有多态)。
2.子类重写父类的方法(多态后调用子类重写后的方法)。
3.父类引用变量指向子类对象(子类到父类的类型转换)。
多态代码层面：
1.把父类作为方法的参数
public class Method(父类名 定义名){
定义名.方法名();
}
2.根据对象的引用来调用方法
public static main(String[] args){
//创建实例
Method zoa = new Method();
//传入需要调用的对象
zoa.方法名(new 对象());
}
instanceof
用于判断一个对象是否属于一个类或实现了一个接口。
重载与重写的区别
重载(Overloading) 方法名相同，参数类型不同，返回值类型可同可不同。
重写(Overriding) 子类重写父类的方法，相同的名称与参数。
二、类与类的关系
1.继承：类与类之间的关系，子类自动继承父类的成员。
优点：减少代码量 重用性 扩展性 维护性
2.实现：类与接口的关系
语法：类 Implements 接口1，接口2
优点：约束实现类具备某些行为，弥补Java单继承的不足，可以更好的实现多态。
3.依赖
指一个类的某个方法无法独立完成某个功能需要其它类协助完成。
体现依赖的形式：
Class A{
方法(B object){...}
}
//把类B作为类A方法的参数来调用。
依赖指程度较弱的依赖的关系，有偶然性。
例：人要过河，借助于桥或船。
4.关联
强依赖关系，长期性的依赖。
体现形式：将一个类作为另一个类的属性存在这个类中。
优势：得到一个类的对象就可以拿到另一个类的对象成员。
例：老师类 学生类
老师可以调用学生类对象的成员，学生类也可以调用老师类成员。
5.聚合
强依赖，关联的一种特例。
体现形式：整体和部分的关系，可以分离，有独立的生命周期。
例：公司 员工
Class 公司{
list<员工> 集合名 = new ArrayList<>(员工);
}
6.组合
强依赖，依赖程度比聚合更强。
体现形式：整体和部分的关系，不可以被分离，没有独立的生命周期，一个对象生命周期 结束，另一个也随这结束。
例：人 大脑
内聚
一个方法内部实现过程尽量独立，外界的改变，尽可能少地去影响这个方法。
耦合
一个类依赖于其它类的程度，依赖程度越高，耦合就越高。
三、设计原则
1.单一职责
每个类中只定义相关职责的方法。
2.里氏替代
在父类出现的地方都可以用子类进行无损替换。
3.开闭原则
对扩展开放，对修改关闭。
4.依赖倒置
面向接口编程，要求依赖抽象面不要依赖具体实现类。
5.接口隔离
将多个方法隔离在不同的接口中，不强迫实现类去实现其不需要的方法，只提供该类需要的方法。
四、集合框架
Collection 集合的顶集接口;存放的数据无序,可重复.
Collection<--List<--ArrayList，Likedlist，Vector(实现都是单个元素) --有序,允许重复.
Map<--HashMap,HashTable(实现类的元素为成对出现)
Collection<--Set<--HashSet(基于Map来实现)
常用类的区别
1．ArrayList: 效率高，多用于查询
2．Vector: 线程安全，多用于查询
存储数据方式同ArrayList一样,但它支持线程同步.
3．LinkedList:多用于插入和删除
存储本身数据外,还额外存储下个数据的存储地址.
4．HashMap: 元素可为空.
5．HashTable: 线程安全，元素不可为空.
6. HashSet: 存储数据无序,不允许重复.
从集合中提取数据的方法：
for循环 for(int i=0;i<集合名.size();i++){
//转换数据类型并输出
对象 对象名 = (对象)集合名.get(i);
system.out.println(对象名.数据或值);
}
遍历 for(对象 对象名:集合名){
system.out.prinln(对象名.数据或值);
}
迭代器 Iterator<对象名> 迭代名 = 集合名.Iterator();
while(迭代名.hasNext()){
对象名 自定义名 = 迭代名.next();
system.out.println(自定义名.get(值));
}
判断集合中是否存在的对象信息
if(集合名.contains(对象信息)){
system.out.println(判断值);
}
Map接口的用法
map<key,value> 集合名 = new HashMap<>(key,value);
//添加数据
集合名.put("key","数据");
获取键值的方法
key
for(key类型 key:集合名.key){
system.out.println(key);
}
value
for(值类型 value:集合名.value){
system.out.println(value);
}
key 和 value
for(key类型 key:集合名.keyset()){
//获得值与key
string value = 集合名.get(key);
system.out.println("key"+"value");
}
迭代器取数据
Iterator<数据类型> 迭代名 = 集合名.key和value.iterator();
while(迭代名.hasnext()){
数据类型 自定名= 迭代名.next();
system.out.println(自定名);
}
五、java语言来操作数据库(jdbc)
Class.forName("数据库驱动");//加载驱动
Concection con = DriverManager.getconnection("连接地址","用户名","密码");// 获得连接
statement stmt = con.createstatement(sql);//创建语句对象,处理sql语句
Resultset rs = stmt.excutequery(sql);//执行sql语句,并返回结果集
while(rs.next()){
String 字段名 = rs.getString("字段");//处理结果集
system.out.println("语句"+rs.getString("匹配字段名"));
}
rs.close();//按顺序关闭资源(结果集-语句对象-数据库连接)
stmt.close();
con.close();
语句对象安全用法
preparedStatement pstmt = con.preparedStatement(sql);
pstemt.excuteupdate();
pstemt.setstring(1,"参数");
String sql="增、删、改里面的字段都用 ？作为点位符";
六、LogciJava
1.java工作原理
.java-->字节码文件.class-->显示结果
Hello.java通过javac Hello.java编译成Hello.class，通过java Hello显示运行后的结果
2.数据类型
a.基本数据类型
byte short int long float double char boolean
b.引用数据类型
数组 类 接口
3.变量:代表内存中所放的数据
int a = 5;
变量三要素：
数据类型 变量名=值
4.运算符：
a.算术运算符 + - * / %
b.关系运算符 > 、>=、 <、 <=、 == 、!=
c.逻辑运算符 && 、 || 、 !
d.赋值运算符 =
5.自动类型转换和强制类型转换
a.自动类型转换
int i = 10;
double d = i;
float f = 5.5F;
double d = f;
b.强制类型转换
double num = 5.2;
int i = (int)num;
自动类型转换条件: a.目标类型大于源类型 b.数据类型要兼容
3、选择结构
a.单分支
b.双分支
c.多分支
if(条件1){
代码块1
}...
else if(条件n){
代码块n
}else{
//以上条件均不成立，则运行此处代码
}
Switch语句
switch-case
switch(表达式){
case 常量1:
代码块1
break;
case 常量2:
代码块2
break;
...
case 常量n:
代码块n
break;
default:
代码块
}
值匹配成功就执行该case语句直到break语句为止,如果没有,则执行default后面的若干个语句。
在switch同一个语句中，case后的常量值必须互不相同。
4.循环结构
循环四要素：
a.循环变量的初始值
b.循环条件
c.循环操作
d.迭代部分
4.1.
for(循环变量的初始值;循环条件;迭代部分){
循环操作
}
4.2.
while(循环条件){
循环体(循环操作，迭代部分)
}
特点：先判断再执行
4.3.
do{
循环体(循环操作，迭代部分)
}while(循环条件);
循点：先执行，再判断
5.输入与输出
Scanner input = new Scanner(System.in);
input.nextInt(); //获得整数
input.next();或input.nextLine();//获得字符串
input.nextDouble(); //获得小数
input.next().charAt(0); //获得char
....
输出：
System.out.println();或 System.out.print();
6.break和continue区别
a.使用场合不同
break用于循环结构和switch-case结构
continue用于循环结构
b.意义不同
break用于循环结构表示终止循环或叫退出循环,用于switch-case结构表示跳出该结构
continue用于循环结构表示中止本次循环，继续进入下一轮循环
7.return表示结束方法
a.用于方法中表示结束该方法，后续代码不执行
b.用于方法中表示该方法的有返回值
8.数组
特点：a.存储一组相同数据类型的数据
b.内存空间连续
c.长度固定
使用数组的步骤：
a.声明数组
int[] a;
b.分配空间
a = new int[5];
两步合为一步：int[] a = new int[5];
c.赋值
a[0] = 2;
a[1] = 2;
a[2] = 2;
a[3] = 2;
d.使用
例如：
int num = a[3]*10;
数组的赋值分为：
a.静态初始化
String [] str ={"aa","bb","cc"};
String [] str =new String[]{"aa","bb","cc"};
b.动态初始化
int[] a = new int[5];
a[0] = 2;
a[1] = 2;
a[2] = 2;
a[3] = 2;
Arrays.sort(数组);//将指定数组进行升序排序
9.什么是对象
局限的定义：客观存在的事物，可以看得见摸得着的东西
特点：属性和行为或功能
10.什么是类
具有相同属性特征和行为的对象的集合
特点：属性和方法
11.对象与类的关系
对象是具体的，类是抽象的
关系： 对象抽象出类,类实例化出对象
12.如何定义类?
class 类名{
属性1;
属性2;
...
属性n;
public 返回值的类型 方法1(参数列表){}
public 返回值的类型 方法2(参数列表){}
...
public 返回值的类型 方法n(参数列表){}
}
13.如何使用对象?
a.创建类的对象
类 对象名 = new 类();
b.调用对象的属性和方法
对象名 .属性
对象名 .方法
注意：属性是每个对象所独有，方法是同一个类的所有对象共用的
Person p1 = new Person();
p1.name = "zhangsan";
p1.age = 20;
p1.show();
Person p2 = new Person();
p2.name = "lisi";
p2.age = 18;
p2.show();
14.如何定义方法？
语法：
访问修饰符 返回值的类型 方法名(参数列表){
方法体
}
例如：
public int add(int num1,int num2){
return num1+num2;
}
15.方法什么时候要带参？
当要完成该方法的功能时，需要外部给它数据时，就需要带参
16.方法什么时候要返回值？
当我们很关心该方法执行后的结果的时候，该方法需要设计返回值
17.String常用方法:
length(); //获得字符串的长度
trim();//去掉字符串前后空格
indexOf(String ch);//在源始字符串中查找ch这个字符串第一次出现的位置，找到返回其位置,找不到返回-1
lastIndexOf(String ch)在源始字符串中查找ch这个字符串最后一次出现的位置，找到返回其位置,找不到返回-1
subString(int index)//从index处开始往后取所有的字符
subString(int index1,int index2) //取[index1,index2)之间的字符串
split(String s) //按照指定分隔符分割字符串，返回一个String[]
equals(String s); //比较两个字符串的内容是否相同
equalsIgnorecase(); //忽略大小写比较两个字符串的内容是否相同
toLowerCase(); //将字符串的内容全都转成小写
toUpperCase(); //将字符串的内容全都转成大写
[/color][/size]
一、基本成员
1.类
语法：修饰符 class 类名｛
//类成员
｝
类修饰符：public protected 缺省 private static abstract final
*final 和 abstract不能同时修饰一个类。
final表示不能被继承,abstract表示只能用于继承.
类成员：属性，方法，构造方法，类，接口，枚举类
成员分类：类相关(使用类名直接调用)
对象相关(创建对象，才能通过对象调用)
2.封装
把类的状态信息隐藏在类内部，不允许外部程序直接调用，只能通过该类提供特定的方法来操作和访问
访问权限：private 类内部范围
缺省 同包里的类访问
protected 同包中的类访问,同项目中不同包中的了类访问.
public 可以被同项目中所有类访问
实现：a:将内部状态信息(属性)用private修饰
b:提供相关方法让外部调用
优点：安全性,完整性,复用率.
3.继承
语法：subclass extends superclass{
//类定义部分
}
*Java只支持单继承，每个类只能有一个直接父类
子类可以继承父类的哪些财产：
public 和 protected 修饰的属性和方法，是否同包都能继承
缺省修饰的属性和方法，但子类和父类必须同包
子类无法继承父类的财产：
private修饰的属性和方法.
父类的构造方法.
4.接口
语法：修饰符 interface 接口名｛
//成员
｝
彻底的抽象类。
@接口中的成员：属性(必须为常量)，方法(必须为抽象方法)，接口，类，枚举类
@非接口成员:构造方法，普通方法，普通属性，语句块.
@接口和抽象类都不能被实例化，只能用来被子类实现.
@接口中的实现类必须实现(重写)接口中所有方法.
*实现类的写法：
public class 类名 implements 接口1，接口2｛
//实现接口的方法
｝
接口思想：
作为程序外部交互的窗口，体现一种规范。
5.多态
同一个实现接口，使用不同的实例而执行不同的操作。
实现多态的条件：
1.继承的存在(继承是多态的基础，没有继承就没有多态)。
2.子类重写父类的方法(多态后调用子类重写后的方法)。
3.父类引用变量指向子类对象(子类到父类的类型转换)。
多态代码层面：
1.把父类作为方法的参数
public class Method(父类名 定义名){
定义名.方法名();
}
2.根据对象的引用来调用方法
public static main(String[] args){
//创建实例
Method zoa = new Method();
//传入需要调用的对象
zoa.方法名(new 对象());
}
instanceof
用于判断一个对象是否属于一个类或实现了一个接口。
重载与重写的区别
重载(Overloading) 方法名相同，参数类型不同，返回值类型可同可不同。
重写(Overriding) 子类重写父类的方法，相同的名称与参数。
二、类与类的关系
1.继承：类与类之间的关系，子类自动继承父类的成员。
优点：减少代码量 重用性 扩展性 维护性
2.实现：类与接口的关系
语法：类 Implements 接口1，接口2
优点：约束实现类具备某些行为，弥补Java单继承的不足，可以更好的实现多态。
3.依赖
指一个类的某个方法无法独立完成某个功能需要其它类协助完成。
体现依赖的形式：
Class A{
方法(B object){...}
}
//把类B作为类A方法的参数来调用。
依赖指程度较弱的依赖的关系，有偶然性。
例：人要过河，借助于桥或船。
4.关联
强依赖关系，长期性的依赖。
体现形式：将一个类作为另一个类的属性存在这个类中。
优势：得到一个类的对象就可以拿到另一个类的对象成员。
例：老师类 学生类
老师可以调用学生类对象的成员，学生类也可以调用老师类成员。
5.聚合
强依赖，关联的一种特例。
体现形式：整体和部分的关系，可以分离，有独立的生命周期。
例：公司 员工
Class 公司{
list<员工> 集合名 = new ArrayList<>(员工);
}
6.组合
强依赖，依赖程度比聚合更强。
体现形式：整体和部分的关系，不可以被分离，没有独立的生命周期，一个对象生命周期 结束，另一个也随这结束。
例：人 大脑
内聚
一个方法内部实现过程尽量独立，外界的改变，尽可能少地去影响这个方法。
耦合
一个类依赖于其它类的程度，依赖程度越高，耦合就越高。
三、设计原则
1.单一职责
每个类中只定义相关职责的方法。
2.里氏替代
在父类出现的地方都可以用子类进行无损替换。
3.开闭原则
对扩展开放，对修改关闭。
4.依赖倒置
面向接口编程，要求依赖抽象面不要依赖具体实现类。
5.接口隔离
将多个方法隔离在不同的接口中，不强迫实现类去实现其不需要的方法，只提供该类需要的方法。
四、集合框架
Collection 集合的顶集接口;存放的数据无序,可重复.
Collection<--List<--ArrayList，Likedlist，Vector(实现都是单个元素) --有序,允许重复.
Map<--HashMap,HashTable(实现类的元素为成对出现)
Collection<--Set<--HashSet(基于Map来实现)
常用类的区别
1．ArrayList: 效率高，多用于查询
2．Vector: 线程安全，多用于查询
存储数据方式同ArrayList一样,但它支持线程同步.
3．LinkedList:多用于插入和删除
存储本身数据外,还额外存储下个数据的存储地址.
4．HashMap: 元素可为空.
5．HashTable: 线程安全，元素不可为空.
6. HashSet: 存储数据无序,不允许重复.
从集合中提取数据的方法：
for循环 for(int i=0;i<集合名.size();i++){
//转换数据类型并输出
对象 对象名 = (对象)集合名.get(i);
system.out.println(对象名.数据或值);
}
遍历 for(对象 对象名:集合名){
system.out.prinln(对象名.数据或值);
}
迭代器 Iterator<对象名> 迭代名 = 集合名.Iterator();
while(迭代名.hasNext()){
对象名 自定义名 = 迭代名.next();
system.out.println(自定义名.get(值));
}
判断集合中是否存在的对象信息
if(集合名.contains(对象信息)){
system.out.println(判断值);
}
Map接口的用法
map<key,value> 集合名 = new HashMap<>(key,value);
//添加数据
集合名.put("key","数据");
获取键值的方法
key
for(key类型 key:集合名.key){
system.out.println(key);
}
value
for(值类型 value:集合名.value){
system.out.println(value);
}
key 和 value
for(key类型 key:集合名.keyset()){
//获得值与key
string value = 集合名.get(key);
system.out.println("key"+"value");
}
迭代器取数据
Iterator<数据类型> 迭代名 = 集合名.key和value.iterator();
while(迭代名.hasnext()){
数据类型 自定名= 迭代名.next();
system.out.println(自定名);
}
五、java语言来操作数据库(jdbc)
Class.forName("数据库驱动");//加载驱动
Concection con = DriverManager.getconnection("连接地址","用户名","密码");// 获得连接
statement stmt = con.createstatement(sql);//创建语句对象,处理sql语句
Resultset rs = stmt.excutequery(sql);//执行sql语句,并返回结果集
while(rs.next()){
String 字段名 = rs.getString("字段");//处理结果集
system.out.println("语句"+rs.getString("匹配字段名"));
}
rs.close();//按顺序关闭资源(结果集-语句对象-数据库连接)
stmt.close();
con.close();
语句对象安全用法
preparedStatement pstmt = con.preparedStatement(sql);
pstemt.excuteupdate();
pstemt.setstring(1,"参数");
String sql="增、删、改里面的字段都用 ？作为点位符";
六、LogciJava
1.java工作原理
.java-->字节码文件.class-->显示结果
Hello.java通过javac Hello.java编译成Hello.class，通过java Hello显示运行后的结果
2.数据类型
a.基本数据类型
byte short int long float double char boolean
b.引用数据类型
数组 类 接口
3.变量:代表内存中所放的数据
int a = 5;
变量三要素：
数据类型 变量名=值
4.运算符：
a.算术运算符 + - * / %
b.关系运算符 > 、>=、 <、 <=、 == 、!=
c.逻辑运算符 && 、 || 、 !
d.赋值运算符 =
5.自动类型转换和强制类型转换
a.自动类型转换
int i = 10;
double d = i;
float f = 5.5F;
double d = f;
b.强制类型转换
double num = 5.2;
int i = (int)num;
自动类型转换条件: a.目标类型大于源类型 b.数据类型要兼容
3、选择结构
a.单分支
b.双分支
c.多分支
if(条件1){
代码块1
}...
else if(条件n){
代码块n
}else{
//以上条件均不成立，则运行此处代码
}
Switch语句
switch-case
switch(表达式){
case 常量1:
代码块1
break;
case 常量2:
代码块2
break;
...
case 常量n:
代码块n
break;
default:
代码块
}
值匹配成功就执行该case语句直到break语句为止,如果没有,则执行default后面的若干个语句。
在switch同一个语句中，case后的常量值必须互不相同。
4.循环结构
循环四要素：
a.循环变量的初始值
b.循环条件
c.循环操作
d.迭代部分
4.1.
for(循环变量的初始值;循环条件;迭代部分){
循环操作
}
4.2.
while(循环条件){
循环体(循环操作，迭代部分)
}
特点：先判断再执行
4.3.
do{
循环体(循环操作，迭代部分)
}while(循环条件);
循点：先执行，再判断
5.输入与输出
Scanner input = new Scanner(System.in);
input.nextInt(); //获得整数
input.next();或input.nextLine();//获得字符串
input.nextDouble(); //获得小数
input.next().charAt(0); //获得char
....
输出：
System.out.println();或 System.out.print();
6.break和continue区别
a.使用场合不同
break用于循环结构和switch-case结构
continue用于循环结构
b.意义不同
break用于循环结构表示终止循环或叫退出循环,用于switch-case结构表示跳出该结构
continue用于循环结构表示中止本次循环，继续进入下一轮循环
7.return表示结束方法
a.用于方法中表示结束该方法，后续代码不执行
b.用于方法中表示该方法的有返回值
8.数组
特点：a.存储一组相同数据类型的数据
b.内存空间连续
c.长度固定
使用数组的步骤：
a.声明数组
int[] a;
b.分配空间
a = new int[5];
两步合为一步：int[] a = new int[5];
c.赋值
a[0] = 2;
a[1] = 2;
a[2] = 2;
a[3] = 2;
d.使用
例如：
int num = a[3]*10;
数组的赋值分为：
a.静态初始化
String [] str ={"aa","bb","cc"};
String [] str =new String[]{"aa","bb","cc"};
b.动态初始化
int[] a = new int[5];
a[0] = 2;
a[1] = 2;
a[2] = 2;
a[3] = 2;
Arrays.sort(数组);//将指定数组进行升序排序
9.什么是对象
局限的定义：客观存在的事物，可以看得见摸得着的东西
特点：属性和行为或功能
10.什么是类
具有相同属性特征和行为的对象的集合
特点：属性和方法
11.对象与类的关系
对象是具体的，类是抽象的
关系： 对象抽象出类,类实例化出对象
12.如何定义类?
class 类名{
属性1;
属性2;
...
属性n;
public 返回值的类型 方法1(参数列表){}
public 返回值的类型 方法2(参数列表){}
...
public 返回值的类型 方法n(参数列表){}
}
13.如何使用对象?
a.创建类的对象
类 对象名 = new 类();
b.调用对象的属性和方法
对象名 .属性
对象名 .方法
注意：属性是每个对象所独有，方法是同一个类的所有对象共用的
Person p1 = new Person();
p1.name = "zhangsan";
p1.age = 20;
p1.show();
Person p2 = new Person();
p2.name = "lisi";
p2.age = 18;
p2.show();
14.如何定义方法？
语法：
访问修饰符 返回值的类型 方法名(参数列表){
方法体
}
例如：
public int add(int num1,int num2){
return num1+num2;
}
15.方法什么时候要带参？
当要完成该方法的功能时，需要外部给它数据时，就需要带参
16.方法什么时候要返回值？
当我们很关心该方法执行后的结果的时候，该方法需要设计返回值
17.String常用方法:
length(); //获得字符串的长度
trim();//去掉字符串前后空格
indexOf(String ch);//在源始字符串中查找ch这个字符串第一次出现的位置，找到返回其位置,找不到返回-1
lastIndexOf(String ch)在源始字符串中查找ch这个字符串最后一次出现的位置，找到返回其位置,找不到返回-1
subString(int index)//从index处开始往后取所有的字符
subString(int index1,int index2) //取[index1,index2)之间的字符串
split(String s) //按照指定分隔符分割字符串，返回一个String[]
equals(String s); //比较两个字符串的内容是否相同
equalsIgnorecase(); //忽略大小写比较两个字符串的内容是否相同
toLowerCase(); //将字符串的内容全都转成小写
toUpperCase(); //将字符串的内容全都转成大写
[/color][/size]
扫一扫
7236
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
