Java基础笔记

黑马程序员基础笔记

day01
1.了解JavaSE课程内容
2.Java发展史
JDK 1.2
JDK 5.0
JDK 7.0
3.Java语言平台
JavaSE 标准版
JavaEE 企业级开发
JavaME Android取代
4.JDK、JRE、JVM
JVM java虚拟机
JRE java运行环境,包含JVM
JDK java开发工具,包含JRE

5.Java语言的跨平台性
一次编译，到处运行
注意事项：代码中不能出现相应系统命令

6.常见dos命令
打开控制台
win + R – cmd
开始–附件–命令提示符
开始–搜索–cmd
shift + 鼠标右键 （当前目录命令提示符）
常见dos命令
相应的盘符+ ： 盘符切换
cd 路径 路径的更改
cd 全路径 路径的更改
cd .. 回退一级
cd …. 回退多级
cd \ 回退根目录
md 文件夹名 新建文件夹
rd 文件夹名 删除文件夹（必须是空的）
cls 清屏
exit cmd退出

7.下载安装JDK
删除JDK
通过控制面板
软件管家

8.HelloWorld案例
public class HelloWorld {

    public static void main (String[] args) {

        System.out.println("HelloWorld")；

    }

}

Java语言编译
    命令：javac 文件名.java
Java语言运行
    命令：java 类名

9.HelloWorld案例常见问题
* 大小写
Java语言是一门严格区分大小写的计算机语言
* 标点符号
英文半角输入
* 执行语句要写在方法体中
* 文件名和类名一致
* 括号成对出现
* 文件名 — 见名知意
10.Java环境变量
配置
计算机—属性—高级系统设置—环境变量—系统变量—新建—JAVA_HOME

    JAVA_HOME ：D:\develop\Java\jdk1.7.0_80（JDK安装路径）
    path：%JAVA_HOME%\bin;(在path里最前面追加)

11.注释
定义：解释说明
分类：
单行注释： //
特点：可以嵌套
多行注释：/注释内容/
特点：不可以嵌套
文档注释：/*注释内容/
12.关键字
定义：被Java语言赋予特定含义的单词.
特点：
1.全部小写
2.在部分高级编辑器中关键字颜色高亮显示
3.关键字不能用于类名
13.常量
常量：在程序的执行过程中，其值不可以发生改变的量

常量分类：
    A:字符串常量 "HelloWorld"
    B:整數常量      12,-23
    C:小数常量      12.23
    D:字符常量      'a','0'
    E:布尔常量      true,false
    F:空常量       null(后面讲)

14.变量
变量的定义格式：
数据类型 变量名 = 初始化值;

15.数据类型的分类
数据类型：Java是一种强类型语言，针对每一种数据都给出了明确的数据类型。

数据类型分类：
    A:基本数据类型
    B:引用数据类型(类,接口,数组)

基本数据类型：4类8种
    A:整數            占用字节数
        byte        1      -128   ---   127
        short       2
        int         4
        long        8
    B:浮点数
        float       4   
        double      8
    C:字符
        char        2
    D:布尔
        boolean     1

注意：
    A:整数默认是int类型,浮点数默认是double类型
    B:定义long类型数据的时候，要加L或者l，建议加L
      定义float类型数据的时候，要加F或者f，建议加F
变量定义的注意事项：
    A:变量未赋值,不能直接使用
    B:变量只在它所属的范围内有效
        变量属于它所在的那对大括号
    C:一行上可以定义多个变量，但是不建议

16.标识符
标识符：就是用来给包,类,方法,变量等起名字的符号

组成规则：
    A:unicode字符
        数字字符,英文大小写字母,汉字(不建议使用汉字)
    B:下划线 _
    C:美元符 $

注意事项：
    A:不能以数字开头
    B:不能是java中的关键字

常见命名规则：
    A:基本要求
        见名知意
    B:常见的命名
        a:包（其实就是文件夹，用于对类进行管理）
            全部小写,多级包.隔开
            举例：com, com.itheima
        b:类
            一个单词首字母大写
                举例：Student,Car
            多个单词每个单词的首字母大写
                举例：HelloWorld
        c:方法和变量
            一个单词首字母小写
                举例：age,show()
            多个单词组成从第二个单词开始每个单词的首字母大写
                举例：maxAge,getAge()

17.类型转换
+:这是一个运算符，用于做加法运算的。
我们在做运算的时候，一般要求参与运算的数据的类型必须一致。

类型转换：
    隐式转换
    强制转换

隐式转换：
    byte,short,char -- int -- long -- float -- double
强制转换：
    目标类型 变量名 = (目标类型) (被转换的数据);
    建议：数据做运算，结果应该是什么类型，就用什么类型接收，不要随意转换类型，否则会有精度的损失。

day02
1:eclipse基本使用
A:创建Java项目：
点击File或者在最左侧空白处，选择Java项目，在界面中写一个项目名称，然后Finish即可。
B:创建包：展开项目，在源包src下建立一个包com.itheima
C:创建类：在com.ithiema包下建立一个类HelloWorld
在界面中写一个类名：HelloWorld，然后finish即可。
D:编写代码
在HelloWorld类写main方法，在main方法中写一条输出语句：我是黑马程序员，我骄傲，我自豪。
E:编译
自动编译，在保存的那一刻帮你做好了
F:运行
选择要运行的文件或者在要运行的文件内容中
右键 – Run as - Java Application即可

2:eclipse基本配置
A:行号的显示和隐藏
显示：在代码区域的最左边的空白区域，右键 – Show Line Numbers即可。
隐藏：把上面的动作再做一次。

B:字体大小及颜色
    a:Java代码区域的字体大小和颜色：
        window -- Preferences -- General -- Appearance -- Colors And Fonts -- Java -- Java Edit Text Font
    b:控制台
        window -- Preferences -- General -- Appearance -- Colors And Fonts -- Debug -- Console font
    c:其他文件
        window -- Preferences -- General -- Appearance -- Colors And Fonts -- Basic -- Text Font

C:窗体给弄乱了，怎么办?
    window -- Perspective -- Reset Perspective

D:控制台找不到了，怎么办?
    Window--Show View—Console

3:eclipse快捷键
内容辅助键：alt+/
A:main方法
main,然后alt+/,回车
B:输出语句
syso,然后alt+/,回车

快捷键：
    A:注释
        单行  选中内容,ctrl+/,再来一次就是取消注释
        多行  选中内容,ctrl+shift+/,取消注释 ctrl+shift+\
    B:格式化
        ctrl+shift+f
        右键 -- Source  -- Format

4:eclipse删除和导入项目
A:删除项目
选中项目 – 右键 – 删除
从项目区域中删除
从硬盘上删除
B:导入项目
在项目区域右键找到import
找到General，展开，并找到
Existing Projects into Workspace
点击next,然后选择你要导入的项目
注意：这里选择的是项目名称

5.运算符
运算符：就是用于对常量和变量进行操作的符号

表达式：用运算符连接起来的符合java语法的式子。不同的运算符连接的表达式是不同类型的表达式。
    举例：a，b
          a + b

运算符分类：
    算术运算符
    赋值运算符
    关系运算符
    逻辑运算符
    三元运算符

6.算术运算符：

+，-，*，/，%，++，--

+，-，*，/的基本使用
%:用于获取两个数据相除时候的余数
/:用于获取两个数据相除时候的商

+:做加法运算
    字符参与加法运算，其实是拿字符在计算机中存储的数据值来参与运算的
    'A' 65
    'a' 97
    '0' 48
    字符串参与加法运算，其实做的不是加法运算，而是字符串的拼接
++,--:自增自减,用于对变量加1或者1
++,--既可以用在变量的后面，也可以用在变量的前面。
单独使用的时候，++或者--放在变量的前面或者后面，结果一样。
参与其它操作的时候：
    ++在后面，先拿变量做操作，然后变量在++
    ++在前面，先变量++，然后再哪变量做操作

7.赋值运算符：
基本的赋值运算符：=
扩展的赋值运算符：+=,-=,*=,/=,…
8.关系运算符：
==,!=,>,>=,<,<=
关系运算符的结果是boolean类型。
注意事项：
千万不要把==写成=
9.逻辑运算符
逻辑运算符：用于连接关系表达式
&,|,^,!
&&,||
&:有false则false
|:有true则true
^:相同则false,不同则true。举例:情侣关系。(男女)
!:true则false,false则true
&和&的结果一样
||和|的结果一样
&&和&的区别：
&&有短路效果,左边为false,右边不执行。
&左边无论是什么，右边都会执行。
||和|的区别：
||有短路效果,左边为true,右边不执行。
|左边无论是什么，右边都会执行。
10.三元运算符：
关系表达式?表达式1:表达式2

执行流程：
A:计算关系表达式的值,看是true还是false
B:如果是true,表达式1就是结果
如果是false,表达式2就是结果
11.Scanner类
为了提高程序的灵活性，我们就把数据改进为键盘录入。
如何实现键盘录入数据呢？目前我们只能使用JDK提供的类Scanner。
如何使用Scanner获取键盘录入数据呢？如下的步骤，大家目前只能记住
使用步骤：
A:导包
import java.util.Scanner;
在一个类中顺序：package > import > class
B:创建键盘录入对象
Scanner sc = new Scanner(System.in);
C:接收数据
int i = sc.nextInt();
day03
1.if语句的第一种格式
/*
* if语句有三种格式。
*
* if语句格式1：
* if(关系表达式) {
* 语句体;
* }
*
* 执行流程：
* A:首先判断关系表达式看其结果是true还是false
* B:如果是true,就执行语句体
* C:如果是false,就不执行语句体
*/
2.if语句的第二种格式
/*
* if语句格式2：
* if(关系表达式) {
* 语句体1;
* }else {
* 语句体2;
* }
*
* 执行流程：
* A:判断关系表达式的值是true还是false
* B:如果是true，就执行语句体1
* C:如果是false，就执行语句体2
*/
3.if语句的第三种格式
/*
* if语句格式3：
* if(关系表达式1) {
* 语句体1;
* }else if(关系表达式2) {
* 语句体2;
* }else if(关系表达式3) {
* 语句体3;
* }
* …
* else {
* 语句体n+1;
* }
*
* 执行流程：
* A:首先判断关系表达式1看其结果是true还是false
* B:如果是true，就执行语句体1
* 如果是false，就继续进行关系表达式2的判断看其结果是true还是false
* C:如果是true，就执行语句体2
* 如果是false，就继续进行关系表达式…的判断看其结果是true还是false
* …
* D:如果没有一个为true的，就执行语句体n+1

4.if语句三种格式的应用场景
*
* if语句的三种格式：
* 第一种格式适合做一种情况的判断
* 第二种格式适合做二种情况的判断
* 第三种格式适合做多种情况的判断
*/
5.键盘录入对象的步骤

 *      A:看到键盘录入，我们就应该想到键盘录入的三步骤
 *          导包，创建对象，接收数据
 * 导包：
 *      A:手动导包
 *          import java.util.Scanner;
 *      B:鼠标点击红色叉叉，自动生成
 *      C:快捷键(推荐)
 *          ctrl+shift+o

6.switch语句
/*
* switch语句格式：
* switch(表达式) {
* case 值1:
* 语句体1;
* break;
* case 值2:
* 语句体2;
* break;
* …
* default:
* 语句体n+1;
* break;
* }
* 格式解释：
* 表达式:byte,short,int,char
* JDK5以后可以是枚举
* JDK7以后可以是字符串
* case:就是要和表达式进行比较的值
* break:表示中断,结束的意思。
* default:表示所有的情况都不匹配的时候，就执行语句体n+1。和if语句的else相似。
* 执行流程：
* A:计算出表达式的值
* B:拿计算出来的值和case后面的值依次比较，一旦有对应的值，就执行该处的语句，在执行过程中，遇到 break，就结束。
* C:如果所有的case都不匹配，就会执行default控制的语句，然后结束。

7.for循环语句

 * for循环语句格式：
 *      for(初始化语句;判断条件语句;控制条件语句) {
 *          循环体语句;
 *      }
 * 
 *      执行流程：
 *          A:执行初始化语句
 *          B:执行判断条件语句，看结果是true还是false
 *              如果是true，就继续执行
 *              如果是false，就结束循环
 *          C:执行循环体语句
 *          D:执行控制条件语句
 *          E:回到B继续

8.while循环语句
/*
* while循环语句的基本格式：
* while(判断条件语句) {
* 循环体语句;
* }
* 扩展格式：
* 初始化语句;
* while(判断条件语句) {
* 循环体语句;
* 控制条件语句;
* }
*
* 回顾for循环的语句格式：
* for(初始化语句;判断条件语句;控制条件语句) {
* 循环体语句;
* }
*/

9.do…while循环

/*
 * do...while循环的基本格式：
 *      do {
 *          循环体语句;
 *      }while(判断条件语句);
 * 扩展格式：
 *      初始化语句;
 *      do {
 *          循环体语句;
 *          控制条件语句;
 *      }while(判断条件语句);
 * 执行流程：
 *      A:执行初始化语句;
 *      B:执行循环体语句;
 *      C:执行控制条件语句;
 *      D:执行判断条件语句，看是true还是false
 *          如果是true，回到B继续
 *          如果是false，就结束

10.三种循环的区别和应用场景

/*
 * 三种循环的区别：
 *      A:do...while至少执行一次循环体
 *      B:for,while循环先判断条件是否成立，然后决定是否执行循环体
 * 
 * for和while的小区别：
 *      for循环的初始化变量，在循环结束后，不可以被访问。而while循环的初始化变量，是可以被继续使用的。
 *      如果初始化变量，后面还要继续访问，就使用while，否则，推荐使用for。
 * 
 * 循环的使用推荐：
 *      for -- while -- do...while
 */

11.循环跳转语句 break
/*
* break:中断的意思
* 使用场景：
* A:switch语句中
* B:循环中
* 注意：
* 离开使用场景是没有意义的。
* 作用：
* 跳出循环，让循环提前结束
*/

12.循环跳转语句 continue
/*
* continue:继续的意思
* 使用场景：
* 循环中
* 注意：
* 离开使用场景是没有意义的
* 作用：
* 结束一次循环，继续下一次的循环
* 区别：
* break:退出循环
* continue:结束一次循环，继续下一次的循环
*/
day04
1.Random产生随机数
/*
* Random:用于产生随机数
*
* 使用步骤：
* A:导包
* import java.util.Random;
* B:创建对象
* Random r = new Random();
* C:获取随机数
* int number = r.nextInt(10);
* 获取数据的范围：[0,10) 包括0,不包括10
*/

2.数组的简介&动态初始化的格式

/*
 * 数组：存储同一种数据类型的多个元素的容器。
 * 
 * 定义格式：
 *      A:数据类型[] 数组名;   (推荐的方式)
 *      B:数据类型 数组名[];
 * 
 *      举例:
 *          int[] arr; 定义了一个int类型的数组,数组名是arr
 *          int arr[]; 定义了一个int类型的变量,变量名是arr数组
 * 
 * 数组初始化：
 *      A:所谓的初始化,就是为数组开辟内存空间,并为数组中的每个元素赋予初始值
 *      B:我们有两种方式可以实现数组的初始化
 *          a:动态初始化 只给出长度,由系统给出初始化值
 *          b:静态初始化 给出初始化值,由系统决定长度
 * 
 * 动态初始化：
 *      数据类型[] 数组名 = new 数据类型[数组长度];
 */

3.数组的静态初始化
/*
* 静态初始化的格式：
* 数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3,…};
*
* 举例：
* int[] arr = new int[]{1,2,3};
*
* 简化格式：
* 数据类型[] 数组名 = {元素1,元素2,元素3,…};
* int[] arr = {1,2,3};
*/

4.两个常见异常
/*
* 两个常见小问题：
* ArrayIndexOutOfBoundsException:数组索引越界异常
* 产生的原因：我们访问了不存在的索引
*
* NullPointerException:空指针异常
* 产生的原因：数组已经不在指向堆内存的数据了，你还使用数组名去访问元素
*/

5.二维数组的格式和初始化(理解)

/*
 * 二维数组：其实就是元素为一维数组的数组。
 * 
 * 定义格式：
 *      A:数据类型[][] 数组名; (推荐的方式)
 *      B:数据类型 数组名[][];
 *      C:数据类型[] 数组名[];
 * 初始化：
 *      A:动态初始化
 *          数据类型[][] 数组名 = new 数据类型[m][n];
 *          m表示的是二维数组中一维数组的个数
 *          n表示的是一维数组中的元素个数
 *      B:静态初始化
 *          数据类型[][] 数组名 = new 数据类型[][]{{元素...},{元素...},{元素...},...};
 *          简化格式：
 *          数据类型[][] 数组名 = {{元素...},{元素...},{元素...},...};
 * 
 * 二维数组名配合索引可以获取到每一个一维数组。
 * 每一个一维数组配合索引名可以获取到数组中的元素。
 * 
 * 假如我有一个二维数组：arr。
 * 我要从中获取一维数组：arr[索引]
 * 我要从中获取二维数组的元素：arr[索引][索引]
 */

day05
1.方法的概述和定义格式

/*
 * 方法：其实就是完成特定功能的代码块
 * 
 * 定义格式：
 *      修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2...) {
 *          方法体;
 *          return 返回值;
 *      }
 * 格式解释：
 *      A:修饰符   目前记住public static
 *      B:返回值类型 用于限定返回值的数据类型
 *      C:方法名   为了方便我们调用方法的名字
 *      D:参数类型  用于限定调用方法时传入的数据的类型
 *      E:参数名   用于接收调用方法时传入的数据的变量
 *      F:方法体   完成功能的代码
 *      G:return 结束方法,并且把返回值带给调用者
 * 
 * 写一个方法有两个明确：
 *      A:返回值类型 明确功能结果的数据类型
 *      B:参数列表      明确有几个参数，以及参数的数据类型

2.方法的调用
/*
* 方法的调用：(有明确返回值的方法调用)
* A:单独调用,没有意义
* B:输出调用,有意义,但是不够好,因为我可能需要拿结果进行进一步的操作
* C:赋值调用,推荐方式
*/

 * 
 * 如果一个方法没有明确的返回值类型，也不能把返回值类型的地方空出来，应该写void表示该方法无返回值类型。
 * 
 * 方法调用：(void修饰的方法的调用)
 *      只能单独调用
 * 
 */

3.方法的重载

/*
 * 方法重载：在同一个类中，出现了方法名相同的情况。
 * 方法重载的特点：
 *      方法名相同，参数列表不同。与返回值无关。
 *      参数列表不同：
 *          参数的个数不同
 *          参数对应的数据类型不同
 * 
 * 注意：
 *      在调用方法的时候，java虚拟机会通过参数列表的不同来区分同名的方法。
 */

4.方法的形式参数和实际参数

/*
 * 方法的参数如果是基本数据类型：形式参数的改变不影响实际参数。
 * 
 * 形式参数：用于接收实际参数的变量
 * 实际参数：实际参与运算的变量
 */

/*
 * 如果参数是引用数据类型：
 *      形式参数的改变直接影响实际参数
 */

day06
方法案例练习

day07
1.面向对象思想的概述
/*
* 面向对象思想：
* 面向对象是基于面向过程的编程思想。
*
* 面向过程：强调的是每一个功能的步骤
* 面向对象：强调的是对象，然后由对象去调用功能
*
* 面向对象的思想特点：
* A:是一种更符合我们思考习惯的思想
* B:可以将复杂的事情简单化
* C:将我们从执行者变成了指挥者
*
* 举例：
* 买电脑：
* 面向过程：我要买电脑–我要明确买电脑的意义–上网查对应的参数信息–去中关村买电脑–讨价还价–买回电脑
* 面向对象：我要买电脑–班长去给我买电脑–买回电脑
* 洗衣服：
* 面向过程：把衣服脱下来–找一个盆–放点洗衣粉–加点水–浸泡10分钟–揉一揉–清洗衣服–拧干–晾起来
* 面向对象：把衣服脱下来–打开全自动洗衣机–扔衣服–按钮–晾起来
*/

2.类及其成员的解释说明

/*
 * 我们学习编程语言，其实就是为了把现实世界的事物模拟出来，实现信息化。
 * 
 * 我们是如何表示现实世界的事物的呢?
 *      A:属性    就是事物的描述信息
 *      B:行为    就是事物能够做什么
 *      举例：学生
 * 
 * Java语言最基本的单位是类，所以，我们在后面的学习过程中，是通过类来体现现实世界事物的。
 * 
 * 类：是一组相关的属性和行为的集合
 * 对象：就是该事物的具体体现
 *      举例：
 *          类       学生
 *          对象      班长
 */

3.类及其成员的定义

/*
 * 类的定义：
 *      类是用来描述现实世界的事物的
 * 
 * 事物：
 *      属性  事物的描述信息
 *      行为  事物能够做什么
 * 
 * 类是如何和事物进行对应的呢?
 *      类：
 *          成员变量
 *          成员方法

4.成员变量与成员方法

 * 成员变量：和我们前面学习过的变量的定义是一样的。
 *      位置不同：类中，方法外
 *      初始化值：不需要给初始化值
 * 成员方法：和我们前面学习过的方法的定义是一样的。
 *      去掉static关键字
 */

5.如何创建对象

/*
 * Student是一个学生事物描述类，main方法不适合放在它里面。
 * 
 * 使用一个类，其实就是使用该类的成员。(成员变量和成员方法)
 * 而我们要想使用一个类的成员，就必须首先拥有该类的对象。
 * 我们如何拥有一个类的对象呢?
 *      创建对象就可以了?
 * 我们如何创建对象呢?
 *      格式：类名 对象名 = new 类名();
 * 对象如何访问成员呢?
 *      成员变量：对象名.变量名
 *      成员方法：对象名.方法名(...)
 */

6.成员变量和局部变量的区别

/*
 * 成员变量和局部变量的区别：
 *      A:在类中的位置不同
 *          成员变量：类中，方法外
 *          局部变量：方法中或者方法声明上(形式参数)
 *      B:在内存中的位置不同
 *          成员变量：堆内存
 *          局部变量：栈内存
 *      C:生命周期不同
 *          成员变量：随着对象的创建而存在，随着对象的消失而消失
 *          局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
 *      D:初始化值的问题
 *          成员变量：有默认值
 *          局部变量：没有默认值。必须先定义，赋值，最后使用
 */

7.private关键字

/*
 * 学生类
 * 
 * 通过对象直接访问成员变量，会存在数据安全问题
 * 这个时候，我们就想能不能不让外界的对象直接访问成员变量呢?
 * 能。
 * 如何实现呢?
 *      private关键字
 * 
 * private:
 *      是一个修饰符
 *      可以修饰成员变量，也可以修饰成员方法
 *      被private修饰的成员只能在本类中被访问
 * 
 * 针对private修饰的成员变量，我们会相应的提供getXxx()和setXxx()用于获取和设置成员变量的值,方法用public修饰
 */

8.this关键字
/*
* 学生类
*
* 起名字我们要求做到见名知意。
* 而我们现在的代码中的n和a就没有做到见名知意，所以我要改进。
*
* 如果有局部变量名和成员变量名相同，在局部使用的时候，采用的是就近的原则。
*
* 我们有没有办法把局部变量的name赋值给成员变量的name呢?
* 有。
*
* 什么办法呢?
* 用this关键字就可以解决这个问题
*
* this:代表所在类的对象引用
* 方法被哪个对象调用，this就代表那个对象
*
* 使用场景：
* 局部变量隐藏成员变量
*/

9.构造方法的格式和注意事项

/*
 * 构造方法：
 *      给对象的数据进行初始化
 * 
 * 格式：
 *      方法名和类名相同
 *      没有返回值类型，连void都不能写
 *      没有具体的返回值
 * 
 * 构造方法的注意事项：
 *      A:如果我们没有给出构造方法，系统将会提供一个默认的无参构造方法供我们使用。
 *      B:如果我们给出了构造方法，系统将不在提供默认的无参构造方法供我们使用。
 *        这个时候，如果我们想使用无参构造方法，就必须自己提供。
 *        推荐：自己给无参构造方法
 *      C:构造方法也是可以重载的
 * 
 */

10.构造方法的使用
//如何调用构造方法呢?
//通过new关键字调用
//格式：类名 对象名 = new 构造方法(…);

11.类名作为形式参数：其实这里需要的是该类对象。
12.如果方法的返回值是类名：其实返回的是该类的对象
day08
常用API的练习过程中体会以下三句话:
* 1.通过new构造方法来创建对象,然后就可以用对象调用成员方法

• 2.方法调用时,要什么数据类型的参数,就给什么数据类型的值

• 3.方法调用时,方法的返回值是什么,就用什么类型的变量来接收

常用API的掌握要求:
* 1.查询api,首先得知道类名,再看该类中有哪些构造方法,用构造方法就可以创建对象,用对象就可以调用成员方法

• 2.记住方法名,理解记忆该方法的功能

• 3.常用api熟悉到在开发中信手拈来

• String:字符串类
  由多个字符组成的一串数据
  字符串其本质是一个字符数组

• 构造方法：
  String(String original)
  public String(String original):把字符串数据封装成字符串对象
  public String(char[] value):把字符数组的数据封装成字符串对象
  public String(char[] value, int index, int count):把字符数组中的一部分数据封装成字符串对象

Object:是类层次结构中的根类，所有的类都直接或者间接的继承自该类。

如果一个方法的形式参数是Object，那么这里我们就可以传递它的任意的子类对象。
* String类的判断功能：
public boolean equals(Object obj):比较字符串的内容是否相同
public boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
public boolean startsWith(String str):判断字符串对象是否以指定的str开头
public boolean endsWith(String str):判断字符串对象是否以指定的str结尾
* String类的获取功能：
public int length():获取字符串的长度，其实也就是字符个数
public char charAt(int index):获取指定索引处的字符
public int indexOf(String str):获取str在字符串对象中第一次出现的索引
public String substring(int start):从start开始截取字符串
public String substring(int start,int end):从start开始，到end结束截取字符串。包括start，不包括end
*案例:

遍历字符串(获取字符串中的每一个字符)
统计一个字符串中大写字母字符，小写字母字符，数字字符出现的次数。(不考虑其他字符)
* String类的转换功能：
public char[] toCharArray():把字符串转换为字符数组
public String toLowerCase():把字符串转换为小写字符串
public String toUpperCase():把字符串转换为大写字符串
字符串的遍历：
A:length()加上charAt()
B:把字符串转换为字符数组，然后遍历数组
*案例:

键盘录入一个字符串，把该字符串的首字母转成大写，其余为小写。(只考虑英文大小写字母字符)
* 去除字符串两端空格
public String trim()
* 按照指定符号分割字符串
public String[] split(String str)
*案例:

把数组中的数据按照指定个格式拼接成一个字符串
举例：int[] arr = {1,2,3};
输出结果：[1, 2, 3]
字符串反转
举例：键盘录入”abc”
输出结果：”cba”
day09
* StringBuilder:是一个可变的字符串。字符串缓冲区类。
String和StringBuilder的区别：
String的内容是固定的。
StringBuilder的内容是可变的。
* 构造方法：
public StringBuilder()
* 成员方法：
public int capacity():返回当前容量
public int length():返回长度（字符数）
容量：理论值
长度：实际值
* 添加功能
public StringBuilder append(任意类型):添加数据，并返回自身对象
* 反转功能
public StringBuilder reverse()
* StringBuilder和String的相互转换
StringBuilder – String
public String toString():通过toString()就可以实现把StringBuilder转成String
String – StringBuilder
StringBuilder(String str):通过构造方法就可以实现把String转成StringBuilder
案例:

• 把数组拼接成一个字符串
• 把字符串反转
  判断一个字符串是否是对称字符串
  例如”abc”不是对称字符串，”aba”、”abba”、”aaa”、”mnanm”是对称字符串
  快速生成javabean类
• 自动生成构造方法：

代码区域右键 – Source – Generate Constructors from Superclass… 无参构造方法
代码区域右键 – Source – Generate Constructor using Fields… 带参构造方法
* 自动生成getXxx()/setXxx():

代码区域右键 – Source – Generate Getters and Setters…
*案例:

1. 创建一个学生数组，存储三个学生对象并遍历
   
   • 为什么会出现集合类：
     我们学习的是面向对象编程语言，而面向对象编程语言对事物的描述都是通过对象来体现的。
     为了方便对多个对象进行操作，我们就必须对这多个对象进行存储，而要想对多个对象进行存储，
     就不能是一个基本的变量，而应该是一个容器类型的变量。
     到目前为止，我们学习过了哪些容器类型的数据呢？StringBuilder,数组。
     StringBuilder的结果只能是一个字符串类型，不一定满足我们的需求。
     所以，我们目前只能选择数组了，也就是我们前面学习过的对象数组。
     但是，数组的长度是固定的，适应不了变化的需求，那么，我们该如何选择呢?
     这个时候，java就提供了集合类供我们使用。
   • 集合类的特点：

长度可变。
* ArrayList:
大小可变数组的实现

:是一种特殊的数据类型，泛型。

怎么用呢?

在出现E的地方我们使用引用数据类型替换即可
举例：ArrayList,ArrayList
* 构造方法：
public ArrayList()
* 添加元素：
public boolean add(E e):添加元素
public void add(int index,E element):在指定的索引处添加一个元素
* 获取元素
public E get(int index):返回指定索引处的元素
* 集合长度
public int size():返回集合中的元素的个数
* 删除元素
public boolean remove(Object o):删除指定的元素，返回删除是否成功
public E remove(int index):删除指定索引处的元素，返回被删除的元素
* 修改元素
public E set(int index,E element):修改指定索引处的元素，返回被修改的元素
* ArrayList集合的遍历
通过size()和get()配合实现的
*案例:

1. 存储字符串并遍历
2. 给定一个字符串数组：{“张三丰”,“宋远桥”,“张无忌”,“殷梨亭”,“张翠山”,“莫声谷”}，
   将数组中的元素添加到集合中，并把所有姓张的人员打印到控制台上。
3. 存储自定义对象并遍历
4. 创建一个集合，存储学生对象，学生对象的数据来自于键盘录入，最后，遍历集合
   
   • 集合版的学生管理系统的代码实现
     *步骤如下：

A. 定义学生类
B. 学生管理系统的主界面的代码编写
C. 学生管理系统的查看所有学生的代码编写
D. 学生管理系统的添加学生的代码编写
E. 学生管理系统的删除学生的代码编写
F. 学生管理系统的修改学生的代码编写
day10
* io流概述
可以把数据存储到文件,也可以从文件中读取数据
常见应用:
文件的复制(U盘拷贝)
上次图片(微信图片,QQ空间图片)
下载文件(迅雷)
* io流分类
* 输出流(将内存中的数据写出到文件中)
写数据–输出流–FileWriter
* FileWriter 的构造方法:

public FileWriter(String fileName):传递一个文件名称
* 输出流写数据的步骤：

A:创建输出流对象
B:调用输出流对象的写数据方法，并刷新缓冲区
C:释放资源
public class FileWriterDemo {
public static void main(String[] args) throws IOException {
//A:创建输出流对象
FileWriter fw = new FileWriter(“d:\a.txt”);

    // B:调用输出流对象的写数据方法，并刷新缓冲区
    //写一个字符串数据
    fw.write("IO流你好");

    //数据没有直接写到文件，其实是写到了内存缓冲区
    fw.flush();

    //C:释放资源: 通知系统释放和该文件相关的资源
    fw.close();

}

}
相对路径：相对当前项目而言的，在项目的根目录下(a.txt)
绝对路径：以盘符开始的路径(d:\a.txt)
* close()和flush()方法的区别：

• flush():刷新缓冲区。流对象还可以继续使用。
• close():先刷新缓冲区，然后通知系统释放资源。流对象不可以再被使用了。
• FileWriter 的成员方法(write()的五个重载方法 ):

public void write(String str):写一个字符串数据
public void write(String str,int index,int len):写一个字符串中的一部分数据
public void write(int ch):写一个字符数据,这里写int类型的好处是既可以写char类型的数据，也可以写char对应的int类型的值。’a’,97
public void write(char[] chs):写一个字符数组数据
public void write(char[] chs,int index,int len):写一个字符数组的一部分数据
* 实现数据的追加的方法:

public FileWriter(String fileName, boolean append):
方法说明: 根据给定的文件名(fileName)创建FileWriter对象，通过append来指示数据写入位置.如果为 true，则将数据写入文件末尾处,如果为false,则数据从文件起始位置写起
* 输入流(将文件中的数据读入到内存中)
读数据–输入流–FileReader
* FileReader 的构造方法:

public FileReader(String fileName):传递文件名称
* java.io.FileNotFoundException: fr.txt (系统找不到指定的文件。)

• 输入流读数据的步骤：

A:创建输入流对象
B:调用输入流对象的读数据方法
C:释放资源
public class FileReaderDemo {
public static void main(String[] args) throws IOException {
//A:创建输入流对象
FileReader fr = new FileReader(“FileWriterDemo.java”);

    //B:调用输入流对象的读数据方法
    //int read():一次读取一个字符

    /*
    //第一次读数据
    int ch = fr.read();
    System.out.println(ch);
    System.out.println((char)ch);

    //第二次读数据
    ch = fr.read();
    System.out.println(ch);
    System.out.println((char)ch);

    //第三次读数据
    ch = fr.read();
    System.out.println(ch);
    System.out.println((char)ch);

    //这是时候，我们发现代码的重复度很高，想用循环改进，但是不知道循环的结束条件是什么
    ch = fr.read();
    System.out.println(ch);

    ch = fr.read();
    System.out.println(ch);
    //通过测试，我们知道，如果读取数据的返回值是-1的时候，就说明没有数据了，这也是我们循环的结束条件
    */

    //故代码最终改造为循环格式:
    int ch;
    //1:fr.read()
    //2:ch=fr.read()
    //3:ch != -1
    while((ch=fr.read())!=-1) {
        //System.out.println(ch);
        //System.out.println((char)ch);
        System.out.print((char)ch);
    }

    //C:释放资源
    fr.close();
}

}
* 缓冲流
BufferedWriter:将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。
BufferedReader:从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
* 缓冲流的特殊功能：

BufferedWriter:
public void newLine():写一个换行符，这个换行符由系统决定
BufferedReader:
public String readLine():一次读取一行数据，但是不读取换行符
* 核心案例代码一:

/*
* 需求：把项目路径下的FileWriterDemo.java中的内容复制到项目路径下的Copy.java中
* 数据源：FileWriterDemo.java -读数据 -FileReader
* 目的地：Copy.java -写数据 -FileWriter
*/

public class CopyFileDemo2 {
public static void main(String[] args) throws IOException {
//创建输入流对象
FileReader fr = new FileReader(“FileWriterDemo.java”);
//创建输出流对象
FileWriter fw = new FileWriter(“Copy.java”);

    //读写数据
    char[] chs = new char[1024];
    int len;
    while((len=fr.read(chs))!=-1) {
        fw.write(chs, 0, len);
    }

    //释放资源
    fw.close();
    fr.close();
}

}
* 核心案例代码二:

/*
* 需求：把项目路径下的FileWriterDemo.java中的内容复制到项目路径下的Copy.java中
* 数据源：FileWriterDemo.java – 读数据 – FileReader – 高效的读数据 – BufferedReader
* 目的地：Copy.java – 写数据 – FileWriter – 高效的写数据 – BufferedWriter
*/

public class CopyFileDemo {
public static void main(String[] args) throws IOException {
//创建输入缓冲流对象
BufferedReader br = new BufferedReader(new FileReader(“FileWriterDemo.java”));
//创建输出缓冲流对象
BufferedWriter bw = new BufferedWriter(new FileWriter(“Copy.java”));

    //读写数据
    String line;
    while((line=br.readLine())!=null) {
        bw.write(line);
        bw.newLine();
        bw.flush();
    }

    //释放资源
    bw.close();
    br.close();
}

}
* 核心案例代码三:

/*
* 从文本文件中读取数据到ArrayList集合中，并遍历集合
* 每一行数据作为一个字符串元素
*
* 分析：
* A:创建输入缓冲流对象
* B:创建集合对象
* C:读取数据，每次读取一行数据，把该行数据作为一个元素存储到集合中
* D:释放资源
* E:遍历集合
*/

public class FileToArrayListTest {
public static void main(String[] args) throws IOException {
//创建输入缓冲流对象
BufferedReader br = new BufferedReader(new FileReader(“array.txt”));

    //创建集合对象
    ArrayList<String> array = new ArrayList<String>();

    //读取数据，每次读取一行数据，把该行数据作为一个元素存储到集合中
    String line;
    while((line=br.readLine())!=null) {
        array.add(line);
    }

    //释放资源
    br.close();

    //遍历集合
    for(int x=0; x<array.size(); x++) {
        String s = array.get(x);
        System.out.println(s);
    }
}

}

原文地址：http://bbs.itheima.com/thread-370429-1-1.html