JAVA笔记（二），java笔记
JAVA笔记（二），java笔记
1第一章 初识Java
1Java简介
（1）Java是于1995年由Sun公司推出的一种极富创造力的面向对象的程序设计语言，它是由有Java之父之称的Sun研究院院长詹姆斯·格士林博士亲手设计而成的，并完成了Java技术的原始编译器和虚拟机。Java最初的名字是OAK，在1995年被重命名为Java，正式发布。
（2）Java SE（基本核心）
Java SE是Java的标准版，主要用于桌面应用程序的开发，同时也是Java的基础，它包含Java语言基础、JDBC（Java数据库连接性）操作、I/O（输入/输出）、网络通信、多线程等技术。
（3）Java EE
Java EE是Java企业版，主要用于开发企业级分布式的网络程序，如电子商务网站和ERP（企业资源规划）系统，其核心为EJB（企业Java组件模型）。
（4）java ME
Java ME主要应用于嵌入式系统开发，如掌上电脑、手机等移动通信电子设备，现在大部分手机厂商所生产的手机都支持Java技术。
2.Java语言的特性
Java语言的语法简单明了，容易掌握，而且是纯面向对象的语言。
（1）面向对象【面向对象是Java语言的基础，也是Java语言的重要特性，它本身就是一种纯面向对象的程序设计语言。Java提倡万物皆对象，语法中不能在类外面定义单独的数据和函数，也就是说，Java语言最外部的数据类型是对象，所以的元素都是通过类和对象来访问。】
（2）分布式【Java的分布性包括操作分布和数据分布，其中操作分布是指在多个不同的主机上布置相关操作而数据分布是将数据分别存放在不同的主机上，这些主机是网络中的不同成员。Java可以凭借URL（统一资源定位符）对象访问网络对象，访问方式与访问本地系统相同。】
（3）可移植性【Java程序具有与体系结构无关的特性，可以方便地移植到网络上的不同计算机中。同时，Java的类库中也实现了针对不同平台的接口，使这些类库可以移植。】
（4）解释性【运行Java程序需要解释器。任何移植了Java解释器的计算机或其他设备都可以用Java字节码进行解释执行。字节码独立于平台，它本身携带了许多编译时的信息，使得连接过程更加简单，开发过程更加迅速更具探索性。】
（5）安全性【Java语言删除了类似C语言中的指针和内存释放等语法，有效地避免了非法操作内存。Java程序代码要经过代码校验、指针校验等很多测试步骤才能够运行，所以未经允许的Java程序不可能出现损害系统平台的行为，而且使用Java可以编写防病毒和放修改的系统。】
（6）健壮性【Java程序的设计目标之一，是编写多方面的、可靠的应用程序，Java将检查程序在编译和运行时的错误，并消除错误。类型检查能帮助用户检查出许多在开发早期出现的错误。集成开发工具（如Eclipse、net Beans）的出现也是编译和运行Java程序更加容易。】
（7）多线程【多线程机制能使应用程序在同一时间并行执行多项任务，而且相应的同步机制可以保证不同线程能够正确地共享数据。使用多线程，可以带来更好的交互能力和实时行为。】
（8）高性能【Java编译后的字节码实在解释器中运行的，所以它的速度较多数交互式应用程序提高了很多。另外，字节码可以在程序运行时被翻译成特定平台的机器指令，从而进一步提高运行速度。】
（9）动态【Java在很多方面比C和C++更能够适应发展的环境，可以动态调整库中方法和增加变量，而客户端却不需要任何更改。在Java中进行动态调整是非常简单和直接的。】······································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································
第二章 熟悉Eclipse开发工具············································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································································
1．注释
单行注释：// CTRL+/
多行注释：// CTRL+shift+/
文档注释： /**
* /**回车
*/
第三章 Java语言基础
数值型 ‘long 长整型 64位
‘float 单精度 32位 boolean 布尔型
‘double 双精度 64位
浮点型
8.常量 （constant） 通常也被称为“final 变量”
常量在整个程序中只能被赋值一次。在为所有的对象共享值时，常量是非常有用的。
优点：比较安全
‘ final 最终的
‘ final 数据类型 常量名称【=值】
9.变量命名规则： 建名之意+驼峰命名
Java语言中，变量名要符合一定规则：
首字母 其余部分
任意多的：
1.数字
变 1.字母 2.字母
量 2.下划线““ 3.下划线““
名 3.‘‘符号
★变量命名规范：
简短且能清楚地表明变量的作用，通常第一个单词的首字母小写，其后单词的首字母大写。例如：myScore.
10.
变量名
//键盘输入
Scanner input = new Scanner(System.in); ‘’只需new一次就可以使用内容
扫描
System .out.println(“~~~”); 快捷键：Alt+/
Int scroceJava = input.nextlnt();
注： * 表示全部
11.赋值运算符： =
功能：将右方操作数所含的值赋给左方的操作数。
由于赋值运算符“=”处理时会先取得右方表达式处理后的结果，因此一个表达式中若含有两个以上的“=”运算符，会从最右方的“=”开始处理。
12.算术运算符
Java算术运算符
运算符 说明 实例 结果
- 加 12.45f+15 27.45
- 减 1.56-0.16 4.4
- 乘 5L*12.45f 62.25
/ 除 7/2 3
% 取余数（摸除） 12%10 2
注：小的数摸除大的数等于小的数
自动类型转换规则：
规则1：如果一个操作数为double型，则整个表达式可提升为double型。
规则2：
满足自动类型转换的条件：
◇两种类型要兼容
＞数值类型（整型和浮点型）互相兼容
◇目标类型大于源类型
＞例如：double型大于int型
强制类型转换：
（类型名）表达式
★ double > int
左边是目标类型，右边是源类型
如果目标类型 > 源类型 自动转换
如果目标类型 < 源类型 强制转换
14.比较运算符：
比较运算符的运算结果是boolean型。当运算符对应的关系式成立时，运算结果为true，否则为false。
比较运算符属于二元运算符，用于程序中的变量之间、变量和自变量之间以及其他类型的信息之间的比较。
比较运算符（关系运算符）
运算符 作用 举例 操作数据 结果
比较左方是否大于右方 ‘a’>’b’ 整型、浮点型、字符型 False
< 比较左方是否小于右方 156<456 整型、浮点型、字符型 True
== 比较左方是否等于右方 ‘c’==’c’ 基本数据类型、应用型 True
= 比较左方是否大于等于右方 479>=426 整型、浮点型、字符型 True
<= 比较左方是否小于等于右方 12.45<=45.5 整型、浮点型、字符型 True
!= 比较左方是否不等于右方 ‘y’!=’t’ 基本数据类型、应用型 True
15.逻辑运算符：
返回类型为布尔型的表达式
逻辑运算符的操作元必须是boolean型数据。
&（&&）（逻辑与）
逻辑运算符 ||（逻辑或）
！（逻辑非）
逻辑运算符
运算符 含义 用法· 结合方向
&&、& 逻辑与 表达式1&&表达式2 从左到右
||、| 逻辑或 表达式1||表达式2 从左到右
！ 逻辑非 !表达式 从右到左
运算符 说明 举例
&& 两个条件同时为真，则结果为真；两个条件有一个为假，则结果为假 具有选举权的条件：
年满18周岁&&中国公民
|| 两个条件有一个为真，则结果为真；两个条件同时为假，则结果为假 从中国去美国的方式：
乘飞机||乘船
！ 条件为真时，结果为假；
条件为假时，结果为真 成为优秀软件工程师的条件：
！偷懒
使用逻辑运算符进行逻辑运算
表达式1 表达式2 表达式1&&表达式2 表达式1||表达式2 ！表达式1
Ture Ture Ture Ture false
Ture false false Ture false
false false false false Ture
false Ture false Ture Ture
逻辑运算符“&&”与“&”都表示“逻辑与”
当两个表达式都为true时，“逻辑与”的结果才会是true。使用逻辑运算符“&”会判断两个表达式；而逻辑运算符“&&”则是针对boolean类型的类进行判断，当第一个表达式为false时则不去判断第二个表达式，直接输出结果从而节省计算机判断的次数。
通常将这种在逻辑表达式中从左端的表达式可推断出整个表达式的值称为：“短路”，而那些始终执行逻辑运算符两边的表达式称为“非短路”。
“&&“属于”短路“运算符，而”&“则属于”非短路“运算符。
（&、&&）：两个条件都为true时，返回结果才为true，当有一个条件为false时，结果为false。
（|、||）：当两个条件第一个为true时，返回结果就为true。
一个&和两个&&的区别：
两个短路一个非短路
&&：当第一个条件为false时，不走第二个条件，直接返回false；
&：不论第一个结果为true还是false，都会走第二个条件。
||：当第一个条件为true时，直接返回结果true；
|：不论第一个结果是什么都会执行第二个条件。
★运算符的优先级：
*最高的优先级：小括号，即（）
*最低的优先级：赋值运算符，即=
*优先级顺序：算术运算符 > 关系运算符 > 逻辑运算符
当运算符比较多，无法确定运算符执行顺序时，可以使用小括号控制一下顺序。
16.三元运算符：
格式： 条件式？值1：值2
规则： 若条件式的值为true，则整个表达式取值1，否则取值2。
例如：boolean b = 20 < 45 ? true:false;
17.自增和自减运算符：
自增、自减运算符是单目运算符，可以放在操作元之前，也可以放在操作元之后。操作元必须是一个整型或浮点型变量。自增、自减运算符的作用是使变量的值增1或减1.放在操作元前面的增长、自减运算符，会先将变量的值加1（减1），然后再使该变量参与表达式的运算。放在操作元后面的自增、自减运算符，会先使变量参与表达式的运算，然后再将该变量加1（减1）。
++a(–a) //表示在使用变量a之前，先使a的值加（减）1
.a–(a++) //表示在使用变量a之后，使a的值加（减）1
例：++a与a++的作用都相当于a=a+1，假设a=4，则：
b=++a; //先将a的值加1，然后赋给b，此时a值为5，b值为5
同样假设a=4，则：
b=a++; //先将a的值赋给b,再将a的值变为5，此时a值为5，b值为4
小技巧：取位
法一：
//分解获得千位数字 qianwei = custNo / 1000;
//分解获得百位数字 baiwei = custNo % 1000 /10;
//分解获得十位数字 shiwei = custNo % 100 / 10;
//分解获得个位数字 gewei = custNo % 10;
法二：
//分解获得千位数字 qianwei = custNo / 1000;
//分解获得百位数字 baiwei = custNo / 100 % 10;
//分解获得十位数字 shiwei = custNo / 10 % 10;
//分解获得个位数字 gewei = custNo % 10;
第四章 流程控制
1.if条件语句
语法： if（布尔型表达式）{
语句序列
}ww
真 假
关键字if之后是作为条件的“布尔表达式”，如果该表达式返回的结果为true，则执行其后的语句；若为false，则不执行if条件之后的语句。
例如： public class Demo{
public static void main(String[] args){
//语句1；
//语句2；
if（条件）{
//语句3；
}
//语句4；
}
}
2. if…else 语句
（如果……就……；否则，就……）
假
语法：
if （条件）{ 真
//代码块1
}else{
//代码块2
}
if后面“（）”内的表达式的值必须是boolean型的。如果表达式的值为true，则执行紧跟if语句的复合语句；如果表达式的值为false，则执行else后面的复合语句。
3.产生随机数（0~9中任意整数）的方法：
int random = （int）(Math.random（）*10)；
System.out.println(random);
. random ：随机数
Math ： 数学的工具类
4.if…else if多分支语句
(如果满足某种条件，就进行某种处理，否则如果满足另一种条件则执行另一种处理)
语法： if（条件表达式1）{
语句序列1
}
. else if（条件表达式2）{
语句序列2
}
……
语句序列n
}
条件1
假
真
假
代码块1 条件2
真
代码块2 代码块3
5.嵌套if选择结构：
语法： if（条件）{ 条件1
. if（条件）{
//代码块1 代码块3
}else{
//代码块2 条件2
}
}else{ 代码块2
//代码块3
} 代码块1
注：在字符串里==是比较内存地址的
语法： str.equals(字符串)
例： if (str.equals(字符串)){ 比较字符串是否一致
6.
流程图：逐步解决指定问题的步骤和方法的一种图形化表示方法。
图新 意义
程序开始或结束
计算步骤/处理符号
输入/输出指令
判断和分支
连接符
流程线
7. switch多分支语句：
语法： switch（表达式）{
. case 常量值1
语句块1 case 块
. break；
case 常量值2
语句块2
. break；
……
. case 常量值n
. 语句块n default 块
. break;
. default:
语句块n+1;
. break;
}
关键字：switch、case、default、break
ゝswitch：表示“开关“，这个开关就是switch关键字后面小括号里表达式的值，switch语句小括号里可以是int、short、byte、char、枚举类型、String类型表达式。
ゝcase：表示“情况、情形”，case后可以是int、short、byte、char、枚举、String类型，通常是一个固定的值。Case块可以有多个，顺序可以改，但是每个case后常量的值必须各不相同。
ゝdefault：表示“默认”，即其他情况都不满足。Default后要紧跟冒号。Default块和case块的先后顺序可以变动，不会影响程序执行的结果。通常，default块放在末尾，也可以省略。
ゝbreak：表示“停止“，即跳出当前结构。
执行过程：
先计算并获得switch后面小括号里的表达式或变量的值，然后将计算结果顺序与每个case后的常量比较，当二者相等时，执行这个case块中的代码；当遇到break时，就跳出switch选择结构，执行switch选择结构之后的代码。如果没有任何一个case后的常量与switch后的小括号中的值相等，则执行switch末尾部分的default块中的代码。
8.比较switch和多重if选择结构：
相同点：都是用来处理多分支条件的结构。
不同点：switch只能处理等值条件判断的情况；if没有switch选择结构的限制，特别适合某个变量处于某个连续区间时的情况。
选择结构总结：
If选择结构：
基本if选择结构：处理单一或组合条件的情况。
If-else选择结构：处理简单的条件分支情况。
多重if选择结构：处理复杂的条件分支情况。
嵌套if选择结构：用于较为复杂的流程控制。
Switch选择结构：
多重分支并且条件判断是等值判断的情况。
If (input.hasNextInt()){ //判断用户从键盘上输入的字符是否合法
9.while循环语句
While语句也称条件判断语句，它的循环方式为利用一个条件来控制是否要继续反复执行这个语句。
特点：先判断，在执行。
语法：while（条件表达式）
{ 条件表达式 假
执行语句 真
} {语句序列}
例：int i=1； 循环条件
while ( i<=10 ) {
System.out.println(“好好学习“)；
i=i++；
} 循环操作（循环体）
10. do…while循环语句
语法： do
{ 循环操作
执行语句
}
. while（条件表达式）； 循环条件
特点：先执行，后判断。 false
11.while循环和do……while循环的区别：
◇语法不同
◇执行次序不同
◇初始情况不满足循环条件时：
＞while循环一次都不会执行
＞do……while循环不管任何情况都至少执行一次
12.for循环语句：
语法： for（表达式1：表达式2：表达式3）{
// 循环操作
表达式 形式 功能 举例
表达式1 赋值语句 循环结构的初始部分，为循环变量赋初值 int i = 0
表达式2 条件语句 循环结构的循环条件 i <= 100
表达式3 赋值语句，通常使用++或–运算符 循环结构的迭代部分，通常用来修改循环变量的值 i++
}
表达式1：参数初始化
表达式2：条件判断
表达式3：更新循环变量
流程图： 表达式1
表达式2
语句序列（循环体）
表达式3
解释：在执行for循环时，首先执行表达式1，完成某一变量的初始化工作；下一步判断表达式2的值，若表达式2的值为true，则进入循环体；在执行完循环体后紧接着计算表达式3，这部分通常是增加或减少循环控制变量的一个表达式。这样一轮循环就结束了。第二轮循环从计算表达式2开始，若表达式2返回true，则继续循环，否则跳出整个for语句。
注：这里的for就是此循环结构的关键字，for关键字后面括号中的三个表达式必须用“；“。
13.break语句
语法：
标签名：循环体{
、 break标签名；
、 }
. break：改变程序控制流
使用break语句可以跳出switch结构。在循环结构中，同样也可用break语句跳出当前循环体，从而中断当前循环。
用于do-while、while、for中时，可跳出循环而执行循环后面的语句。
14.continue语句
语法：
标签名：循环体{
. continue标签名;
}
. continue：只能用在循环里
作用：跳出循环体中剩余的语句而执行下一次循环。
15.break语句和continue语句的区别：
ゝbreak语句用于终止某个循环，程序跳转到循环体外的下一条语句。
ゝcontinue语句用于跳出本次循环，进入下一次循环的语句。
16.循环结构区别：
区别1：语法
区别2：执行顺序
◆while循环：先判断，再执行。
◆do-while循环：先执行，再判断。
◆for循环：先判断，再执行。
区别3：适用情况
◆循环次数确定的情况，通常选用for循环。
◆循环次数不确定的情况，通常选用while或do-while循环。
17.双重循环：
外层循环变量变化一次，内层循环变量要变化一遍。
第六章 数组
Array 数组 Test 练习 length 长度 sort 升序
1.数组 ：
数组是一个变量，存储相同数据类型的一组数据。
★ 数组长度固定不变，避免数组越界。
★ 数组中的所有元素必须属于相同的数据类型。
◆使用数组四步走：
1.声明数组 告诉计算机数据类型是什么
语法： 数据类型 [ ] 数组名 ； //推荐
或 数据类型 数组名 [ ]
例：int [ ] a ;
2.分配空间 告诉计算机分配几个连续的空间
语法： 数组名 = new 数据类型 [ 数组长度 ] ;
或 数据类型 [ ] 数组名 = new 数据类型 [ 数组长度 ] ；
例：a = new int [ 5 ] ;
3.赋值 向分配的格子里放数据
语法： 数组名 [ 下标值 ] ；
例：a [ 0 ] = 8;
4.处理数据
语法： 数据类型 [ ] 数据名 = { 值1，值2，值3……值n }；
例：a [ 0 ] = a [ 0 ] * 10;
数组的基本要素：
◆标识符：数组的名称，用于区分不同的数组
◆数组元素：向数组中存放的数据
◆数组下标：对数组元素进行编号，从0开始，数组中的每个元素都可以通过下标来访问
◆元素类型：数组元素的数据类型
使用java.util.Arrays类：
◆java.util包提供了许多工具类
◆Arrays类提供操作数组的方法
ゝ如：排序，查询
◆Arrays类的sort( )方法：对数组进行升序排列
多维数组：
从语法上Java支持多维数组
◆从内存分配原理的角度讲，只有一维数组。
二维数组：
语法： <数据类型> 【】【】数组名：
或者： <数据类型>数组名怕【】【】；
第七章 类和对象
对象：用来描述客观事物的一个实体，由一组属性和方法构成。
对象特征》属性：对象具有的各种特征。
每个对象的每个属性都拥有特定值。
对象特征》方法：对象执行的操作。
对象同时具有属性和方法两项特性。
对象的属性和方法通常被封装在一起，共同体现事物的特性，二者相辅相成，不能分割。
类：类是模子，定义对象将会拥有的特征（属性）和行为（方法）。
类和对象的关系：
类是抽象的概念，仅仅是模板；
对象是一个你能够看得到，摸得着的具体实体。
语法：
Public class 类名 {
//定义属性部分
属性1的类型 属性1；
属性2的类型 属性2；
……
属性n的类型 属性n；
//定义方法部分
方法1；
方法2；
……
方法n;
}
使用对象的步骤：
◆创建对象
语法：
＞类名 对象名 = new 类名（）；
例：School center = new School（）；
◆引用对象成员：使用“ . ”进行以下操作：
语法：
＞引用类的属性：对象名 . 属性
＞引用类的方法：对象名 . 方法名（）
例：center . name = “ 北京中心 ”； //给name属性赋值
Center . showCenter()； //调用showCenter方法
面向对象的优点：
1.与人类的思维习惯一致。
2.信息隐藏，提高了程序的可维护性和安全性。
3.提高了程序的可重（chong）用性。
如何定义类的方法：
类的方法定义类的某种行为（或功能）
方法的定义：
1.方法返回值的数据类型。
2.方法的名称。
3.方法的主体。
语法：
定义类的方法： public 返回值类型 方法名（）{
//方法的主体
}
步骤一：定义方法名以及返回值类型
步骤二：编写方法体
方法的返回值：
两种情况：
◆如果方法具有返回值，方法中必须使用关键字return返回该值，返回值类型为该返回值的类型。
语法： return 表达式；
作用： 跳出方法，返回结果
◆如果方法没有返回值，返回值类型为void
成员变量和局部变量的区别：
◆作用域不同
＞局部变量的作用域仅限于定义它的方法。
＞成员变量的作用域在整个类内部都是可见的。
◆初始值不同
＞Java会给成员变量一个初始值。
＞Java不会给局部变量赋予初始值。
注意：
︕ 在同个方法中，不允许有同名局部变量；
在不同的方法中，可以有同名局部变量。
︕ 在同一个类中，成员变量和局部变量同名时，
局部变量具有更高的优先级。
面向对象（oo）思想：
类的方法实现某个特定的功能，其他类不需要知道它如何实现，调用方法就可以了，不用重复写代码。
如何使用带参数的方法：
◆定义带参数的方法。
语法：
< 访问修饰符 > 返回类型 < 方法名 > ( < 形式参数列表 > ) {
该方法允许被访问调用的权限范围
//方法的主体
}
◆调用带参数发方法。 实参列表
语法：
对象名 . 方法名 （ 参数1，参数2，……，参数n ）；
构造函数（方法）：
1.构造函数的作用
1） 创建对象。任何一个对象创建时，都需要初始化才能使用，所以任何类想要创建实例对象就必须具有构造函数。
2） 对象初始化。构造函数可以对对象进行初始化，并且是给与之格式（参数列表）相符合的对象初始化，是具有一定针对性的初始化函数。
2.构造函数与普通函数的区别
1） 格式不同：
构造函数不存在返回类型，函数名与所在类的类名一致；
普通函数有返回类型，函数名可以根据需求进行命名。
2）调用时期不同
构造函数在类的对象创建时就运行；
普通函数在对象调用时才会执行。
3）执行次数不同
一个对象创建后，其构造函数只执行一次，就是创建时执行；
一个对象创建后，其普通函数可以执行多次，取决于对象的调用次数。
构造方法时一个与类同名的方法。每当类实例化一个对象时，类都会自动调用构造方法。
构造方法的特点：
1、构造方法没有返回值。
2、构造方法的名称要与本类的名称相同。
静态变量、常量和方法：
final static int NUM = 12; //静态常量
static int num1 = 24; //静态变量
static修饰与非static修饰的区别：
static、非private修饰 非static、private修饰
属性 类属性、类变量 实例属性
方法 类方法 实例方法
调用方式 类名 . 属性
类名 . 方法（）
对象 . 属性
对象 . 方法（） 对象 . 属性
对象 . 方法（）
归属 类 单个对象
封装
封装的概念:
封装：将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问。
封装的特点：
◆封装性
◆继承性
◆多态性
封装的思想：
将对象的属性和行为封装起来，其载体就是类，类通常对客户隐藏其实现细节，这就是封装的思想。
封装的好处：
1、隐藏类的实现细节。
2、方便加入控制语句。
3、方便修改实现。
4、只能通过规定方法访问数据。
封装的步骤：
1、修改属性的可见性（设为private）。
2、创建公有的getter/setter方法（用于属性的读写）。
3、在getter/setter方法中加入属性控制语句（对属性值的合法性进行判断）。
第五章 字符串
1、String类提供了length（）方法，确定字符串的长度（返回字符串中的字符数）。
2、连接多个字符串
使用“+“运算符可实现连接多个字符串的功能。
方法1:使用“+“
方法2：使用String类的concat()方法
注：concat()方法只能连接字符类型。
3、字符串查找
String类提供了两种查找字符串的方法，即indexOf()与lastIndexOf()方法。
indexOf（）方法返回的是搜索的字符或字符串首次出现的位置；
lastIndexOf（）方法返回的是搜索的字符或字符串最后一次出现的位置。
在计算机中String对象是用数组表示的。字符串的下标是0~length（）-1。
4、获取指定索引位置的字符
使用charAt（）方法可将指定索引处的字符返回。
语法：
str.charAt(int index);
ゝstr: 任意字符串。
ゝindex：整型值，用于指定要返回字符的下标。
5、获取子字符串
通过String类的substring（）方法可对字符串进行截取。这些方法的共同点就是都利用字符串的下标进行截取，且应明确字符串下标是从0开始的。
substring（）方法被两种不同的方法重载，来满足不同的需要。
（1）substring（int beginIndex）
该方法返回的是从指定的索引位置开始截取直到该字符串结尾的字串。
语法：
str.substring(int beginIndex)
其中，beginIndex指定从某一索引处开始截取字符串。
注意：在字符串中空格占用一个索引位置。
（2）substring（int beginIndex, int endIndex）
该方法返回的是从字符串某一索引位置开始截取至某一索引位置结束的子串。
语法：
substring（int beginIndex, int endIndex）
ゝbeginIndex：开始截取子字符串的索引位置。
ゝendIndex：子字符串在整个字符串中的结束位置。
6、去除空格
trim（）方法返回字符串的副本，忽略前导空格和尾部空格。
语法：
str.trim()
其中，str为任意字符串对象。
7、字符串替换
replace（）方法可实现将指定的字符或字符串替换成新的字符或字符串。
语法：
str.replace(char oldChar, char newChar)
ゝoldChar：要替换的字符或字符串。
ゝnewChar：用于替换原来字符串的内容。
replace（）方法返回的结果是一个新的字符串。如果字符串oldChar没有出现在该对象表达式中的字符串序列中，则将原字符串返回。
8、判断字符串的开始与结尾
startsWith()方法与endsWith()方法分别用于判断字符串是否以指定的内容开始或结束。这两个方法的返回值都为boolean类型。
（1）startsWith（）方法
该方法用于判断当前字符串对象的前缀是否为参数指定的字符串。
语法：
str.startsWith(String prefix)
其中，prefix是指作为前缀的字符。
（2）endsWith（）方法
该方法用于判断当前字符串是否为以给定的字符串结束。
语法：
str.endsWith(String suffix)
其中，suffix是指作为后缀的字符串。
9、判断字符串是否相等
equals（）方法比较原理：
equals（）检查组成字符串内容的字符是否完全一致。
“==”和equals（）有什么区别：
==：判断两个字符串在内存中的地址；即判断是否是同一个字符串对象。
equals（）：检查组成字符串内容的字符是否完全一致。
10、按字典顺序比较两个字符串
语法：
str.compareTo(String otherstr)
其中，str、otherstr是要比较的两个字符串对象
11、字母大小写转换
◆使用equalsIgnoreCase（）方法：忽略大小写
◆使用toLowerCase（）方法：转换小写
◆使用toUpperCase（）方法：转换大写
12、字符串分割
使用split（）方法可以使字符串按指定的分割字符或字符串对内容进行分割，并将分割后的结果存放在字符串数组中。split（）方法提供了以下两种字符串分割形式。
（1）split（String sign）
该方法可根据给定的分割符对字符串进行拆分。
语法：
str.split(String sign)
其中，sign为分割字符串的分割符，也可以使用正则表达式。
（2）split（String sign,int limit）
该方法可根据给定的分割符对字符串进行拆分，并限定拆分的次数。
语法：
str.split(String sign，int limit)
ゝsign:分割字符串的分割符，也可以使用正则表达式。
ゝlimit：限制的分割次数。
字符串常用提取方法
方法名 说明
public int indexOf(int ch)
public int indexOf(String value) 搜索第一个出现的字符ch（或字符串value），如果没有找到，返回-1
public int lastIndexOf(int ch)
public int lastIndexOf(String value) 搜索最后一个出现的字符ch（或字符串value），如果没有找到，返回-1
public String substring(int index) 提取从位置索引开始的字符串部分
public String substring(int beginindex,int endindex) 提取beginindex和endindex之间的字符串部分
Public String trim() 返回一个前后不含任何空格的调用字符串的副本
第八章 包装类
包装类
1、包装类把基本数据类型转换为对象
2、每个基本类型在java.lang包中都有一个相应的包装类
3、包装类有何作用。
（1）提供了一系列实用的方法
（2）集合不允许存放基本数据类型数据，存放数字时，要用包装类型
方法重写：
构造方法不能被继承，因此不能重写。
方法重写的规则：（必须在继承关系中）
①：方法名相同。
②：参数列表相同。
③：返回类型相同或者是其子类。
④：访问权限不能严于父类。
方法重载与方法重写的区别：
位置 方法名 参数列表 返回值 访问修饰符
方法重写 子类 相同 相同 相同或者是其子类 不能比父类更严格
方法重载 同类 相同 不相同 无关 无关
super关键字来访问父类的成员：
①：super只能出现在子类的方法和构造方法中。
②：super调用构造方法时，只能是第一句。
③：super不能访问父类的private成员。
Object类是所有类的父类。
Object类被子类经常重写的方法：
方法 说明
toString() 返回当前对象本身的有关信息，按字符串对象返回
equals() 比较两个对象是否是同一个对象，是则返回true
hashCode() 返回该对象的哈希代码值
getClass() 获取当前对象所属的类信息，返回Class对象
Object类的equals()方法：
比较两个对象是否是同一个对象，是则返回true
操作符==
（1）简单数据类型，直接比较值。如12
（2）引用类型，比较两者是否为同一个对象
注：
（1）Object类的equals()方法与没区别。
（2）当有特殊需求，如认为属性相同即为同一对象时，需要重写equals()。
（3）Java.lang.String重写了equals()方法，把equals()方法的判断变为了判断其值。
抽象类：
抽象类不能被实例化。
abstract也可用于方法——抽象方法
①：抽象方法没有方法体。
②：抽象方法必须在抽象类里。
③：抽象方法必须在子类中被实现，除非子类是抽象类。
final用法：
使用fianl修饰的类，不能被其他类继承。
使用final修饰的方法，不能被重写。
使用final修饰的属性，不能被修改。
使用final修饰引用型变量，变量不可以再指向另外的对象。
使用final修饰引用型变量，变量的值是固定不变的，而变量所指向的对象的属性值是可变的。
继承：
①：符合is—a关系。
②：使用extends关键字。
③：代码复用。
方法重写的规则：
①：方法名相同
②：参数列表相同
③：返回值类型相同或者是其子类
④：访问权限不能严于父类
Object类equals()的方法重写
super关键字来访问父类成员：
①：super只能出现在子类的方法和构造方法中
②：super调用构造方法时，只能是第一句
③：super不能访问子类的private成员
抽象类和抽象方法：
①：抽象类不能被实例化
②：抽象类可以有0~多个抽象方法
③：非抽象子类必须重写父类的所有抽象方法
final修饰符
①：修饰的类，不能再被继承
②：修饰的方法，不能被子类重写
③：修饰的变量将变成常量，只能在初始化时进行赋值。**
相关文章
- 暂无相关文章
用户点评