JavaSE基础总结

Java语言平台:
    J2SE:JAVA基础;
    J2ME:移动端开发后被Andorid取代;
    J2EE:企业级开发;

Java语言跨平台的根本原因:Java具有不同系统版本的虚拟机(JVM);     Windows,Mac,Linux
JVM,JRE,JDK:
    JVM:JAVA虚拟机 -->保证Java程序跨平台的根本;
    JRE:JAVA运行环境  -->有JRE就可以执行Java程序;
    JDK:JAVA开发工具集 -->开发Java程序;其中的开发工具：编译工具(javac.exe)  打包工具(jar.exe)等   JDK:JRE+JAVA的开发工具。

    包含关系: JDK包含JRE 和开发工具包、JRE 包含 核心类库和JVM

Java程序的执行流程:

注释:

单行注释      格式： //注释文字

多行注释      格式： /*  注释文字  */

文档注释      格式：/** 注释文字 */

   a:解释说明程序

   b:帮助我们调试错误

 

常量:

在程序执行的过程中，其值不可以发生改变的量

• • 字符串常量 用双引号括起来的内容(“HelloWorld”)
  • 整数常量 所有整数(12,-23)
  • 小数常量 所有小数(12.34)
  • 字符常量 用单引号括起来的内容(‘a’,’A’,’0’)
  • 布尔常量 较为特有，只有true和false
  • 空常量 null(数组部分讲解)

变量：

• 变量定义的注意事项
• 变量未赋值,不能直接使用
  • 引出变量的第二种使用格式
• 变量只在它所属的范围内有效。
  • 变量在哪对大括号内，变量就属于哪对大括号（某个类中）
• 建议一行定义一个变量

 

数据类型：

1. 计算机存储单元

变量是内存中的小容器，用来存储数据。那么计算机内存是怎么存储数据的呢？无论是内存还是硬盘，计算机存储设备的最小信息单元叫“位（bit）”，我们又称之为“比特位”，通常用小写的字母b表示。而计算机最小的存储单元叫“字节（byte）”，通常用大写字母B表示，字节是由连续的8个位组成。

除了字节外还有一些常用的存储单位，大家可能比较熟悉，我们一起来看看：

• • 1B（字节） = 8bit
  • 1KB = 1024B
  • 1MB = 1024KB
  • 1GB = 1024MB
  • 1TB = 1024GB

 

1. 数据类型概述和分类

 A:为什么有数据类型

Java语言是强类型语言，对于每一种数据都定义了明确的具体数据类型，在内存中分配了不同大小的内存空间

 B:Java中数据类型的分类

 基本数据类型

 引用数据类型 

 面向对象部分讲解 ：

 注意：

整数默认是int类型，定义long类型的数据时，要在数据后面加L。

浮点数默认是double类型，定义float类型的数据时，要在数据后面加F。

 

标识符：

A 作用

• • 给包,类,方法,变量等起名字

B 组成规则

• • 由字符，下划线_，美元符$组成
    • 这里的字符采用的是unicode字符集，所以包括英文大小写字母，中文字符，数字字符等。
  • 注意事项
  • 不能以数字开头
  • 不能是Java中的关键字

 

C : 命名原则:见名知意

     包:建议域名倒过来,要求所有的字母小写 

b类或者接口

   一个单词首字母大写

    多个单词每个单词首字母大写(驼峰标识) 

c方法或者变量

 一个单词全部小写

 多个单词,从第二个单词首字母大写 

d常量

 一个单词,所有字母大写

 多个单词,所有的单词大写,用下划线区分每个单词 

 

​​​​​数据类型转换：

1. 隐式数据类型转换

取值范围小的数据类型与取值范围大的数据类型进行运算,会先将小的数据类型提升为大的,再运算

隐式转换

byte,short,char -- int -- long -- float -- double

1. 强制类型数据转换

强制转换的格式

* b = (byte)(a + b); 

强制转换的注意事项：

* 如果超出了被赋值的数据类型的取值范围得到的结果会与你期望的结果不同 

强制转换：

目标类型 变量名 = (目标类型) (被转换的数据);

不建议强制转换，因为会有精度的损失。

 

                                     JAVASE运算符

什么是运算符 : 就是对常量和变量进行操作的符号。

算数运算符：

• 运算符：对常量和变量进行操作的符号称为运算符
• 表达式 : 用运算符把常量或变量连接起来符合java语法的式子

不同运算符连接的式子体现的是不同类型的表达式。

1. 算数运算符取余和除法的区别

 %：取余运算符。得到的是两个相除数据的余数。

 /:除法运算符。得到是两个相除数据的商。

 使用场景： %：判断两个数据是否整除。

1. 1. 1. 字符和字符串参与加法操作

字符参与运算 :       其实是拿该字符对应的数值来操作：‘a’ 97    ‘A’ 65    ‘0’ 48

字符串参与运算 :   是字符串拼接。结果是字符串类型的。

1. 1. 1. ++和- - 的用法

参与操作的时候：

  如果++或者--在变量的后面，先拿变量参与操作，后变量做++或者--

如果++或者--在变量的前面，先变量做++或者--，后拿变量参与操作

 

1. 赋值运算符
   1. 赋值运算符分类

基本的赋值运算符：=

扩展的赋值运算符：+=,-=,*=,/=,%=

+=: a+=20;相当于a = (a的数据类型)(a + 20);

 

1. 关系运算符

       关系运算符包含以下内容:    ==,!=,>,>=,<,<=

       关系运算符的结果都是boolean型，也就是要么是true，要么是false。

 

1. 逻辑运算符 ：     &,|,^,!

         最常用: && , ||

         C:注意事项：

        a:逻辑运算符一般用于连接boolean类型的表达式或者值。

        b:表达式：就是用运算符把常量或者变量连接起来的符合java语法的式子。

     D:结论：

       &逻辑与:有false则false。

       |逻辑或:有true则true。

       ^逻辑异或:相同为false，不同为true。

       !逻辑非:非false则true，非true则false。

 

 逻辑运算符&&与&的区别：

    &&具有短路效果。左边是false，右边不执行。

||和|的区别?

||具有短路效果.左边是true,右边不执行

 

 

1. 三元运算符

       A:格式

          (关系表达式)?表达式1：表达式2；

               如果条件为true，运算后的结果是表达式1；

               如果条件为false，运算后的结果是表达式2；

      B:示例：

          获取两个数中大数。

          int x=3,y=4,z;

         z = (x>y)?x:y;//z变量存储的就是两个数的大数

 

                                                                                 JAVASE选择流程控制语句

1.顺序结构的基本使用：（程序就是这样执行的）

2.If语句的格式：

1. 格式1及执行流程

if语句第一种格式：

if(关系表达式) {

     语句体

}

执行流程:

首先判断关系表达式看其结果是true还是false

如果是true就执行语句体

如果是false就不执行语句体

1. 格式2及执行流程

if语句第二种格式：

if(关系表达式) {

     语句体1;

}else {

     语句体2;

}

执行流程

首先判断关系表达式看其结果是true还是false

如果是true就执行语句体1

如果是false就执行语句体2

1. 格式3及执行流程

if语句第三种格式：

if(关系表达式1) {

     语句体1;

}else  if (关系表达式2) {

     语句体2;

}

    …

else {

     语句体n+1;

}

执行流程

首先判断关系表达式1看其结果是true还是false

如果是true就执行语句体1

如果是false就继续判断关系表达式2看其结果是true还是false

如果是true就执行语句体2

如果是false就继续判断关系表达式…看其结果是true还是false

…

如果没有任何关系表达式为true，就执行语句体n+1

 

 

switch语句的格式及执行流程：

1. 格式解释:

switch表示这是switch语句

表达式的取值：byte,short,int,char

JDK5以后可以是枚举

JDK7以后可以是String

case后面跟的是要和表达式进行比较的值

语句体部分可以是一条或多条语句

break  表示中断，结束的意思，可以结束switch语句

default语句表示所有情况都不匹配的时候，就执行该处的内容，和if语句的else相似。

1. 执行流程

首先计算出表达式的值

其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。

最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。

 

for循环的格式及基本使用：

1. 1. 1. for循环语句格式：

for(初始化语句;判断条件语句;控制条件语句) {

         循环体语句;

    }

A:执行初始化语句

B:执行判断条件语句，看其结果是true还是false

如果是false，循环结束。

如果是true，继续执行。

C:执行循环体语句

D:执行控制条件语句

E:回到B继续

 

while循环的格式及基本使用：

一般用于死循环用得多

1. 1. 1. while循环语句格式

基本格式 

  while(判断条件语句) {

         循环体语句;

   }

扩展格式

 初始化语句;
   while(判断条件语句) {
         循环体语句;
         控制条件语句;
}

 

 

 do…while循环的格式及基本使用：

1. do…while循环语句格式

基本格式  

 do {

         循环体语句;

   }while((判断条件语句);

扩展格式   

初始化语句;

   do {

         循环体语句;

         控制条件语句;

} while((判断条件语句);

 

1. 三种循环的区别
   1. 区别概述

虽然可以完成同样的功能，但是还是有小区别：

do…while循环至少会执行一次循环体。

for循环和while循环只有在条件成立的时候才会去执行循环体

for循环语句和while循环语句的小区别：

使用区别：控制条件语句所控制的那个变量，在for循环结束后，就不能再被访问到了，而while循环结束还可以继续使用，如果你想继续使用，就用while，否则推荐使用for。原因是for循环结束，该变量就从内存中消失，能够提高内存的使用效率。

 

break:中断,结束
        注意:
            1.break不可以单独使用,只可以在循环或者switch语句中使用;
            2.break只能结束一层循环;
        作用:用于结束循环或者switch语句

 

continue:继续
        注意:
            1.continue只能在循环中使用不可以单独使用;
        作用: 用于结束本次循环继续下一次循环(从下一次循环的控制条件语句开始执行)
            
return: 返回
    作用:用于结束方法;

 

单层循环对比break，然后总结两个的区别:

break  break用于完全结束一个循环，跳出循环体执行循环后面的语句。

continue continue是跳过当次循环中剩下的语句，执行下一次循环。

 

                                                     数组

1. 数组的定义格式

数组是存储同一种数据类型多个元素的容器。

数组既可以存储基本数据类型，也可以存储引用数据类型。

1. 1. 定义格式

格式1：数据类型[] 数组名;

格式2：数据类型 数组名[];                

1. 1. 数组的初始化

Java中的数组必须先初始化,然后才能使用。

所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。

1. 1. 1. 数组的初始化方式
         1. 动态初始化:

初始化时只指定数组长度，由系统为数组分配初始值

格式：数据类型[] 数组名 = new 数据类型[数组长度];

数组长度其实就是数组中元素的个数。

举例：

int[] arr = new int[3];

解释：定义了一个int类型的数组，这个数组中可以存放3个int类型的值。

1. 1. 1. ​​​​​​​静态初始化:初始化时指定每个数组元素的初始值，由系统决定数组长度

静态初始化的格式：

 * 数据类型[] 数组名 = new 数据类型[]{元素1,元素2,...};

 *

 * 简化格式：

 * 数据类型[] 数组名 = {元素1,元素2,...};

 *

 * 举例：

 * int[] arr = new int[]{1,2,3};

 *

 * 简化后：

 * int[] arr = {1,2,3};

1. 1. 数组的内存分配
      1. JVM内存划分

Java 程序在运行时，需要在内存中的分配空间。为了提高运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

栈    存储局部变量

堆    存储new出来的东西，就是对象

方法区 

本地方法区 (和系统相关)

寄存器 (给CPU使用)

1. 1. 两个数组指向同一个地址的内存图

定义两个数组，先定义一个数组，赋值，输出。然后定义第二个数组的时候把第一个数组的地址赋值给第二个数组。然后给第二个数组赋值，再次输出两个数组的名及元素

 * 数组初始化：
 * 		A:所谓初始化，就是为数组开辟内存空间，并为数组中的每个元素赋予初始值
 * 		B:我们有两种方式对数组进行初始化
 * 			a:动态初始化	只指定长度，由系统给出初始化值
 * 			b:静态初始化	给出初始化值，由系统决定长度
 * 
 * 动态初始化：
 * 		数据类型[] 数组名 = new 数据类型[数组长度];
 */
* 两个常见小问题：
 * 		A:java.lang.ArrayIndexOutOfBoundsException
 * 			数组越界异常
 * 			产生的原因：就是你访问了不存在的索引元素。
 * 		B:java.lang.NullPointerException
 * 			空指针异常
 * 			产生的原因：数组已经不指向堆内存的数据了，你还使用数组名去访问元素。

案例：

/*
 * 需求：数组获取最值(获取数组中的最大值最小值)
 */
public class ArrayTest2 {
	public static void main(String[] args) {
		//定义数组
		int[] arr = {12,98,45,73,60};
		
		//定义参照物
		int max = arr[0];
		
		//遍历数组，获取除了0以外的所有元素，进行比较
		for(int x=1; x max) {
				max = arr[x];
			}
		}
		System.out.println("数组中的最大值是："+max);
	}
}

二维数组：

     二维数组其实就是一个元素为一维数组的数组。

定义格式
数据类型[][] 数组名;
初始化方式
数据类型[][] 变量名 = new 数据类型[m][n];
数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}};
简化版格式：数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};
/*
 * 二维数组：就是元素为一维数组的数组。
 * 
 * 定义格式：
 * 		A:数据类型[][] 数组名;
 * 
 * 如何初始化呢?
 * 		A:动态初始化
 * 			数据类型[][] 数组名 = new 数据类型[m][n];
 * 			m表示这个二维数组有多少个一维数组
 * 			n表示每一个一维数组的元素有多少个
 * 		B:静态初始化
 * 	      数据类型[][] 数组名 = new 数据类型[][]{{元素...},{元素...},{元素...},...};
 * 			简化格式：
 * 			数据类型[][] 数组名 = {{元素...},{元素...},{元素...},...};
二维数组遍历:
		for(int y=0; y

Java中的内存分配:
        栈内存:存放局部变量-->体现代码的执行流程
        堆内存:存放new出来的东西-->对象的本质(实体)
        方法区:存放.class字节码对象和常量池
        本地方法区:和系统相关的方法;
        寄存器:和CPU有关
        
        栈内存的特点:
            1.存放的是局部变量的声明,局部对象的声明;(等号左边的东西)
            2.程序执行的时候有压栈的效果;
            3.执行特点--->先进后出;
            4.栈内存中的元素在使用完毕后立即回收;
        
        堆内存的特点:
            1.堆内存中的数据都是有默认值的;(默认值根据该数据的数据类型而定)
            2.堆内存中的数据有是有地址值的;
            3.堆内存中的数据在垃圾回收机制空闲的时候回收使用完毕的垃圾;

 

                                                    方法

简单的说：方法就是完成特定功能的代码块

在很多语言里面都有函数的定义 , 函数在Java中被称为方法

不同功能的代码封装在不同的方法中，让代码更简洁和达到代码的复用

 

1. 1. 1. 方法格式

修饰符 返回值类型 方法名(参数类型 参数名1，参数类型 参数名2…) {

函数体;

return 返回值;

}

1. 1. 1. 方法格式解释

修饰符:方法的使用的范围

返回值类型 用于限定返回值的数据类型

方法名 一个名字，为了方便我们调用方法

参数类型     用于接收调用方法时传入的数据的类型

参数名        用于接收调用方法时传入的数据的变量

方法体 完成功能的代码

return 结束方法，把返回值带给调用者

1. 1. 方法的调用

 需要参数的方法最好是传参调用,方法的调用是以最大的灵活性为标准的

 

1. 1. 方法重载的概述和基本使用

在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

方法重载特点

与返回值类型无关，只看方法名和参数列表

在调用时，虚拟机通过参数列表的不同来区分同名方法

1. 1. 方法中参数传递
      1. 形式参数为基本数据类型

形式参数:
    1.当形式参数是基本数据类型的时候,形式参数的改变不影响实际参数;
    2.当形式参数是引用数据类型的时候,形式参数的改变直接影响实际参数;
        //String(字符串类型)的形式参数除外;当方法的形式参数是String类型的;
            //那么 该方法形式参数的改变不影响实际参数
        --->当String作为方法的形参时,把它当作基本数据类型来看;

 

​​​​​​​面向过程思想与面向对象思想：

A:什么是面向过程

面向过程，其实就是面向着具体的每一个步骤和过程，把每一个步骤和过程完成，然后由这些功能方法相互调用，完成需求。

B:什么是面向对象

面向对象思想就是不断的创建对象，使用对象，指挥对象做事情。（如果有对象，直接用对象，对我们直接提供服务） 用一个对象来为我们提供服务,每一个对象都要各自的功能,用时只需调用,很好的复用性和独立性,可完成更多的功能组合,并且在维护修改功能有很好的便利性,相当于模块的思想,最终需求由一个个的独立的模块组合而成

 

1. 面向过程特点与面向对象特点

A:面向过程：

强调的是过程，所有事情都需要自己完成

B:面向对象:

是一种更符合我们思想习惯的思想(懒人思想，我把事情自己不做，交给别人去做)

  可以将复杂的事情简单化（对使用者来说简单了，对象里面还是很复杂的）   模块化,简单化  更独立  组合

将我们从执行者变成了指挥者角色发生了转换

 

1. 类与对象及其使用:

b:成员方法: 就是事物的行为

E:类和对象的概念

 a:类：是一组相关的属性和行为的集合（我们班所有的同学都具备相同的属性和行为，比如：姓名，年龄，学习，这样就把所有的学生成为学生类）

 b:对象：是该类事物的具体体现（说某个同学时，他都具备自己特有的属性和行为）

 

1. 封装与私有关键字(封装性)
   1. private关键字

A:private关键字：

a:是一个权限修饰符。

b:可以修饰成员(成员变量和成员方法)

c:被private修饰的成员只在本类中才能访问。

1. 1. private最常见应用

A:把成员变量用private修饰

B:提供对应的getXxx()/setXxx()方法

1. 1. 封装的概述和好处:

A:封装概述

是面向对象三大特征之一

是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界无法直接操作和修改。就像刚才说的年龄。

B:封装原则：

将不需要对外提供的内容都隐藏起来。

把属性隐藏，提供公共方法对其访问。

成员变量private，提供对应的getXxx()/setXxx()方法

C:好处：

通过方法来控制成员变量的操作，提高了代码的安全性

把代码用方法进行封装，提高了代码的复用性

 

1. 1. 1. this关键字由来和使用:

A:this:代表所在类的对象引用

方法被哪个对象调用，this就代表那个对象

B:什么时候使用this呢

局部变量和成员变量重名

1. 1. 构造方法:

主要用来给对象的数据进行初始化

1. 1. 1. 构造方法格式:

A:构造方法格式

a:方法名与类名相同

b:没有返回值类型，连void都没有

c:没有具体的返回值

1. 1. 1. 构造方法注意事项与重载

如果你不提供构造方法，系统会给出默认构造方法

如果你提供了构造方法，系统将不再提供

构造方法也是可以重载的,重载条件和普通方法相同

1. 1. 1. 包含private,无参,有参构造的标准学生类代码:

A:类:

a:成员变量

b:构造方法

无参构造方法

带参构造方法

c:成员方法

getXxx()

setXxx()

B:给成员变量赋值的方式

a:无参构造方法+setXxx()

b:带参构造方法

 

1. 类名作为方法的形式参数
   1. 案例代码:

package com.ithe;

public class Student {
	public void study() {
		System.out.println("好好学习,天天向上");
	}
}


package com.ithe;

public class Teacher {
	public void test(Student s) {//接收传递过来的Student对象的地址值
		s.study();                  
	}
}


package com.ithe;

//需求： 调用Teacher的test方法

//类名作为形式参数：其实这里需要的是该类对象。
public class Test {
	public static void main(String[] args) {
		Teacher t = new Teacher();
		Student s = new Student();
		t.test(s);
	}
}

十五字: 
    服务员点单;
    万物皆对象;
    对象调方法;
1.面向对象的思想
    a.更符合我们的思维习惯;
    b.把复杂的问题简单化;
    c.把我们从执行者变成指挥者;
    
2.类和对象的关系:
    类:现实事物的抽象
    对象:抽象事物的具体化;

4.使用事物描述类
    1.创建对象:
        格式:  类名 对象名 = new 类名();-->调用无参的构造方法;
        格式:  类名 对象名 = new 类名(实际参数); -->调用含参的构造方法;
        
    2.对象调用方法或者属性

 

6.Java面向对象的特性
    1.封装
    2.继承
    3.多态

this 关键字
        概念: 代表的是本类对象的引用;
        可以把 this 想象成为一个虚拟的对象,这个对象并不明确的表示某一个具体的对象;
            但是当有对象调用方法或者调用属性的时候, this 就变成这个对象;
        //举例:  this ====> 镜子
                谁出现在镜子面前  镜子里的人就是谁;
        作用:
            通过 this.成员变量名 访问到成员位置上的方法;解决了局部变量隐藏成员变量的问题;
            
    变量的就近原则:
        1.若成员位置和局部位置有同名变量
        2.当使用这个变量的时候优先选择局部位置上的变量
        3.若要访问成员位置上的该变量使用 this.成员变量名

局部变量和成员变量的区别:
    1.在类中的位置不同:
        成员变量:类中方法外
        局部变量:方法内,方法的声明上,for循环的声明上,代码块内
    2.在内存中的位置不同:
        成员变量:堆内存中
        局部变量:栈内存中
    3.生命周期不同:
        成员变量:随着对象的产生而产生.随着对象的死亡而死亡;
        局部变量:随着方法的调用而产生,随着方法的执行完毕而死亡;
    4.初始化值不同:
        成员变量:根据成员变量的数据类型给与相应的初始化值;
            整型:0
            浮点型:0.0
            字符型:'\u0000'
            布尔型:false
            引用数据类型: null
        局部变量:变量未赋值不能直接使用;
    5.颜色不同:
        成员变量:细蓝色
        局部变量:栗色
        自定义常量(成员位置):粗蓝色

 

常用API

1. 1. API概念

API(Application Programming Interface) : 应用程序编程接口

编写一个机器人程序去控制机器人踢足球，程序就需要向机器人发出向前跑、向后跑、射门、抢球等各种命令，没有编过程序的人很难想象这样的程序如何编写。但是对于有经验的开发人员来说，知道机器人厂商一定会提供一些用于控制机器人的Java类，这些类中定义好了操作机器人各种动作的方法。其实，这些Java类就是机器人厂商提供给应用程序编程的接口，大家把这些类称为API。本章涉及的Java API指的就是JDK中提供的各种功能的Java类

1. 1. 快速使用API步骤:

D:看包

java.lang包下的类在使用的时候是不需要导包的

E:看类的描述

Random类是用于生成随机数的类

F:看构造方法

Random():无参构造方法

Random r = new Random();

G:看成员方法

   public int nextInt(int n):产生的是一个[0,n)范围内的随机数

调用方法：

看返回值类型：人家返回什么类型，你就用什么类型接收

看方法名：名字不要写错了

看形式参数：人家要几个参数，你就给几个，人家要什么数据类型的，你就给什么数据类型的

int number = r.nextInt(100);

 

1. 1. Scanner类
      1. Scanner类作用

  用Scanner类的方法可以完成接收键盘录入的数据

 Scanner:用于获取键盘录入的数据。(基本数据类型，字符串数据)

 * public String nextLine():获取键盘录入的字符串数据

 */

1. 1. String类
      1. String类概述

通过JDK提供的API，查看String类的说明

A:"abc"是String类的一个实例,或者成为String类的一个对象

B:字符串字面值"abc"也可以看成是一个字符串对象

C:字符串是常量，一旦被赋值，就不能被改变

D:字符串本质是一个字符数组

1. 1. 1. String类的构造方法

String(String original):把字符串数据封装成字符串对象

  String(char[] value):把字符数组的数据封装成字符串对象

  String(char[] value, int index, int count):把字符数组中的一部分数据封装成字符串对象

String:字符串类
 * 		由多个字符组成的一串数据
 * 		字符串其本质是一个字符数组
 * 
 * 构造方法：
 * 		String(String original):把字符串数据封装成字符串对象
 * 		String(char[] value):把字符数组的数据封装成字符串对象
 * 		String(char[] value, int index, int count):把字符数组中的一部分数据封装成字符串对象
 * 
 * 注意：字符串是一种比较特殊的引用数据类型，直接输出字符串对象输出的是该对象中的数据。
==:
 * 		基本数据类型：比较的是基本数据类型的值是否相同
 * 		引用数据类型：比较的是引用数据类型的地址值是否相同

1. String类的判断功能

          boolean equals(Object obj):比较字符串的内容是否相同

          boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写

          boolean startsWith(String str):判断字符串对象是否以指定的str开头

          boolean endsWith(String str):判断字符串对象是否以指定的str结尾

1. String类的获取功能

* String类的获取功能：
 * int length():获取字符串的长度，其实也就是字符个数
 * char charAt(int index):获取指定索引处的字符
 * int indexOf(String str):获取str在字符串对象中第一次出现的索引
 * String substring(int start):从start开始截取字符串
 * String substring(int start,int end):从start开始，到end结束截取字符串。包括start，不包括end
 */

1. String类的转换功能
   1. 转换方法演示

       char[] toCharArray():把字符串转换为字符数组

       String toLowerCase():把字符串转换为小写字符串

       String toUpperCase():把字符串转换为大写字符串

1. String类的其它功能

 * 去除字符串两端空格	
 *		String trim()
 * 按照指定符号分割字符串	
 *		String[] split(String str)

1. StringBuilder类概述

 StringBuilder:是一个可变的字符串。字符串缓冲区类。  

    String和StringBuilder的区别：

    String的内容是固定的

    StringBuilder的内容是可变的

1. 1. ​​​​​​​+=拼接字符串耗费内存原因:

每次拼接都会产生新的字符串对象,而利用StringBuilder来拼接字符串自始至终用的都是同一个StringBuilder容器

1. 1. StringBuilder类的常用方法

  A:构造方法:

     StringBuilder()

  B:成员方法:

     public int capacity():返回当前容量 (理论值)

     public int length():返回长度(已经存储的字符个数)

public StringBuilder append(任意类型):添加数据，并返回自身对象

public StringBuilder reverse():反转功能

 

java集合

1. 1. 对象数组概述

 A:基本类型的数组:存储的元素为基本类型

int[] arr={1,2,3,4}

B:对象数组:存储的元素为引用类型

  Student[] stus=new Student[3];

  

 Student代表一个自定义类

Stus数组中stus[0],stus[1],stus[2]的元素数据类型为Student,

  都可以指向一个Student对象

1. 1. 集合概述

A:我们学习的是面向对象编程语言，而面向对象编程语言对事物的描述都是通过对象来体现的。

     为了方便对多个对象进行操作，我们就必须对这多个对象进行存储，而要想对多个对象进行存储， 就不能是一个基本的变量，而应该是一个容器类型的变量。

 * 集合类的特点：
 * 		长度可变。
 * 
 * ArrayList:
 * 		大小可变数组的实现
 * 
 * 		:是一种特殊的数据类型，泛型。
 * 		怎么用呢?
 * 			在出现E的地方我们使用引用数据类型替换即可
	举例：ArrayList,ArrayList
 * 
 * 构造方法：
 * 		ArrayList()
 * 
 * 添加元素：
 * 		public boolean add(E e):添加元素
 * 		public void add(int index,E element):在指定的索引处添加一个元素
 */

1. 1. 1. ArrayList删改查方法

A:获取元素

    public E get(int index):返回指定索引处的元素

B:集合长度

     public int size():返回集合中的元素的个数

C:删除元素

    public boolean remove(Object o):删除指定的元素，返回删除是否成功

    public E remove(int index):删除指定索引处的元素，返回被删除的元素

D:修改元素

public E set(int index,E element):修改指定索引处的元素，返回被修改的元素

 

IO流概述及FileWriter类使用

1. 1. IO流概述及分类

 IO流用来处理设备之间的数据传输

   Java对数据的操作是通过流的方式

   Java用于操作流的类都在IO包中

  流按流向分为两种：输入流，输出流

1. 1. 1. FileWriter向文件中写数据

A:FileWriter向文件中写数据操作步骤:

      a:使用FileWriter流关联文件

      b:利用FileWriter的写方法写数据

      c:利用FileWriter的刷新方法将数据从内存刷到硬盘上

      d:利用FileWriter的关流方法将释放占用的系统底层资源

   B:FileWriter方法:

构造方法

FileWriter(String fileName) 传入一个文件的路径

成员方法

void write(String str) 向文件中写str

void flush()  将内存中的数据刷新到文件中

void close()  关流释放系统底层资源

1. 1. 1. FileWriter其它写方法

void write(String str):写一个字符串数据

void write(String str,int index,int len):写一个字符串中的一部分数据

void write(int ch):写一个字符数据,这里写int类型的好处是既可以写char类型的数据，也可以写char对应的int类型的值。'a',97

void write(char[] chs):写一个字符数组数据

void write(char[] chs,int index,int len):写一个字符数组的一部分数据