java学习笔记

第一章 Java
Java的特点
1、java语言足够简单，正因为足够简单，所有才能让人们有更多的发挥空间
2、java是一门面向对象的编程语言
3、java是为数不多的多线程编程语言
4、java提供了自动垃圾收集机制，以更好的处理垃圾空间
5、java避免复杂的指针问题，而使用了更加简单的引用来完成内存
匹配
6、java实现任意平台的移植

计算机高级编程语言类型
1、编译型
2、解释型

Java是两种语言的结合
1、编译命令：javac.exe
2、解释命令：java.exe

Java程序组成：java源文件，字节码文件，机器码指令

标识符
类名称、属性名称、方法名称都成为标识符
标识符的基本要求：标识符由字母、数字、—、$符所组成，其中不能以数字开头，，不能是java中的保留字（关键字）在编写的时候，尽量不要去使用数字，命名尽量有意义，对于$有特殊意义，不要使用
Java中的关键字
Abstract boolean break byte ease eath char
Class continue default do double else extends
False final finally float for if implements
Import instanceof int interface lonf native new
Null package private protected public return short
Static synchronized super this throw throws transient
Ture try void volatile while assert enum
Java中有两个未使用到的关键字：goto,const
Java有三个特殊含义标识：ture、false、null

第三章 Java数据类型划分
不同的数据类型可以保存不同的数据内容
Java一共分为两大数据类型：基本数据类型、引用数据类型
1、基本数据类型
1.1、数值型：
整形：byte、short、int、long 默认值：0
浮点型：float、double 默认值：0.0
1.2、字符型：char 默认值：\u000’
1.3、布尔型：boolean 默认值：false
2、引用数据类型：数组、接口 默认值：null
基本数据类型不牵扯内存分配问题，而引用数据类型需要由开发者为其分配空间，而后进行关系匹配

个人选择数据类型原则：
如果想表示整形：int
表示小数：double
描述日期、时间、数字、或表示文件内存大小：long
实现内容传递或者编码转换：byte
实现逻辑控制：boolean
如果想要使用中文：char(避免乱码)
按照保存范围：byte 1.1整形
任何一个数字常量（例如：30、100）那么都属于int类型的数据类型。即：在java之中所有设置的整数内容，默认情况下都是int型数据
所有的变量在同一块代码之中只允许声明一次

在程序的世界里面，数据类型转换有一下规律
1、数据范围小的数据与数据范围大的数据进行数学计算的时候，自动向数据范围大的数据转型后计算；
2、数据范围大的数据要变为数据范围小的数据，必须采用强制转换
3、如果是常量进行强制转换，有两种标记：常量标记（L,l）使用（数据类型）
4、数据大的数据类型也可以转换为数据小的数据类型，这样必须使用“（数据类型）”的格式
小转大：
Int变量 ±long型常量 = long型数据
大转小：
Long num=100;
Int x = (int)num;
如果long变为int时所保存的数据类型超过了int范围，那么依然会出现数据溢出
任意一个整数都属于int型，但是java编译的时候，如果发现使用的数据变量类型为：byte，并且设置的内容在byte范围内，那么就会自动帮助用户实现数据类型转换。反之超过了依然会以 int为主

提示：所有的变量在使用的时候一定不要去相信默认值，都设置具体内容
定义变量的时候直接设置默认值
使用整形就用int,90%以上都适用
1.2浮点型
浮点数就是小数，java之中只要是小数，那么就使用double型数据。double是保存范围最广的数据类型。

由于默认的小数类型是double，所以入股使用了float型，表示需要将double型变为float型，需要强制转换
例如：
Float f1 = 10.2F;
Float f2 = (float)10.2;

所有的数据类型只有double才可以保存小数

1.3字符型;char
Byte是属于字节，按照传统的概念来讲，一个字符等于两个字节，对于字符除了和字节有一些关系之外，最主要的关系在在于int变量的转换

字符可以和int互相转换
‘A’(65)~’Z’(90)
‘a’(97)~’z’(122)
‘0’(48)~’9’(57)

字符与int转换
Char c = ‘A’;
Int num = c;
c = (char)num
1.4布尔型
布尔是一个数学家的名字，布尔型是一种逻辑结果，主要保存有两大数据类型：true、false，这类的数据主要用于一些逻辑判断上
例如：
Boolean flag = ture;
If(flag){
System.out.println(“hello”);

由于设计之初没有考虑到布尔型，那么久使用数字0表示false,而非0表示ture,但是这样的设计对代码开发来说比较混乱，java里面不允许使用0或1来填充布尔型变量内容。那么只能使用false,true
1.5 String型数据
只要是项目开发，100%会使用String，但是与其他基本数据类型相比，String属于引用数据类型（它属于一个类），在java里面只要是类名称，每一个单词首字母都是大写的，但是这个类的使用比较特殊

String 表示的是一个字符串，即：多个字符集，String要求使用“”声明其内容
字符串里面的“+”表示连接操作

任何数据类型加上字符串都是向字符串类型转换

在java里面也支持多种转义字符使用，例如：换行（\n）、制表（\t）、描述\（\）、
双引号（\”）、单引号（\’）
总结：
1、常用的数据类型：整数用：int、小数：double、逻辑：boolean
2、long、byte、char在处理数据的时候回用到
3、数据类型转换用远都是小的数据类型自动向大的数据类型转换，大转小需要强制转换
第四章 Java运算符
Int = 10;
此类方式称为赋值，运算符“=”是实现赋值运算使用的，进行数学计算所使用的四则运算，也属于运算符的定义范畴
在开发之中常使用的积累运算符：四则运算、逻辑运算、三目运算、位运算

简化的运算符： *=、/=、+=、-=、%=
1.1 三目运算：
Int numA=10;
Int numB=20;
Int max=numA > numB?numA:numB;
System.out.println(max);
1.2逻辑运算
与操作
当多个条件使用与进行连接的时候，那么只有多个条件都满足的时候，最终结果才是true，如果有一个条件返回false，那么最终的结果就是false;

单个“=”是赋值，“==”是判断

短路与的使用：
当多个提交件进行与（使用短路与）操作的时候，前面只要有一个条件返回false，那么后面就不在进行判断了，直接返回false;

短路或的使用：
当多个条件进行或（短路或）操作的时候，前面只要有一个条件返回了true，那么后面就不再进行判断力，直接返回true;

总结：
1、运算符写简单的操作
2、三目一定要掌握
3、使用短路与，短路或

第五章 Java程序逻辑控制
1.1程序逻辑控制
程序逻辑主要分为三种逻辑结构：顺序结构、分支结构、循环结构。其中顺序结构最好理解，所有的代码都是有前向后执行的，需要提醒的是顺序是以“{}”为界限的。

分支结构：
分支结构就是一种判断结构。对于分支结构有两类语法支持：if、switch。
If 分支语句：
if If…else If…else if…else ….
If(布尔表达式){
程序语句
} If(布尔表达式){//满足条件时执行
程序语句
}else{//不满足条件是执行
程序语句
} If(布尔表达式1){//满足条件时执行
程序语句
}
If(布尔表达式2){//满足条件时执行
程序语句
}…

Switch语法：
Switch(整数|字符|枚举|String){
Case 内容1：{
满足条件时执行；
Break;
}
Case 内容2：{
满足条件时执行；
Break;
}
Case 内容3：{
满足条件时执行；
Break;
}
Switch只能够判断内容，不能进行布尔表达式的判断
1.2循环语句
有两种循环：while循环、for循环
所有的循环语句必须要有循环初始化条件，每次循环的时候都要修改这个条件，以判断循环是否结束
Do…while循环属于先执行一次，而后在进行判断。即：不管条件是否满足都会执行一次

For循环
For(循环初始化条件；循环判断；循环条件变更){
循环语句；
}
两种语法的选择：
1、如果不知道循环次数，但是知道循环结束条件的时候使用while循环
2、如果已经明确知道了循环次数使用for循环

循环控制：
循环控制有两种语句：continue（退出本次循环）此类语句一定要与判断语句一起使用
Break：退出整个循环

总结：
While循环用于不知道次数，但是知道循环结束条件
For循环用于知道循环次数的循环
Continue和break都需要与if语句结合使用

第六章 方法
方法的基本概念
所谓的方法是指一段可以被重复调用的代码段，利用此操作可以封装执行的代码
在java之中，方法的定义格式比较复杂，所以本次给出的方法有一个要求：指的是定义在主类之中并且由主方法直接调用的方法。方法创建的语法如下：
public static 返回值类型 方法名称（参数类型 变量 、、、）{
方法体（本方法要执行的若干操作）；
return 返回值；
}
在本定义格式中，发现方法有一个返回值类型，指的是方法方法返回结果，对于此类型有两种：
1、直接设置java中的数据类型（基本数据类型 引用数据类型）
2、方法没有返回值：void
如果方法设置了返回值，那么必须使用return语句返回与之数据类型对应的数据
没有返回值：可以不使用return返回内容，但是可以使用return结束调用
定义方法名称要求：第一个单词首字母小写，而后每个单词首字母大写
在以后的编写代码的时候为了节约代码，可以直接利用方法的返回结果进行输出
如果一个方法使用了void定义为它的返回值，那么可以使用return结束一个方法的调用，但是return不会返回任何内容
只有在方法的返回值为void的前提下才可以使用return结束，使用return结束要与if判断语句一起使用

方法重载
如果说一个方法名称，有可能要执行多项操作，例如：一个add（）方法，它可能执行三个整数相加或者可能执行两个小数相加，那么这样的情况下，很明显一个方法体肯定无法满足要求，需要为add（）方法定义多个不同的功能实现，所以此类的功能就称为方法的重载，但是在进行方法重载的时候要求方法名称相同，参数类型及个数不同。

方法重载两点说明：
1、在进行方法重载的时候一定要考虑到参数类型的同一，虽然可以实现重载方法返回不同的类型的操作，但是从开发的标准来说，建议所有的重载方法使用同一种返回值类型：
2、方法重载的时候是根据参数类型及个数来区分不同的方法，而不是根据返回值的不同来确定的

方法的递归调用
递归调用是我们迈向数据结构开发的第一步
所谓的递归调用指的就是一个方法自己调用自己的情况，但是如果要想实现自己调用自己，一定需要一个结束的条件，并且每次执行的时候都需要去修改这个结束条件

总结：
1、可以将一些重复执行的代码定义在方法里
2、本次所讲解的方法有它的局限性：定义在主类，并且由主方法直接调用
3、方法的返回值一旦定义了就需要return返回相应数据
4、方法重载（overload）指的是方法名称相同，参数类型及个数不同时，尽量保证返回值类型相同
5、递归调用需要一个结束条件

第七章 面向对象
面向对象：
以一种组件化的形式进行代码的设计，这样开发出来的代码有一个最大的好处，就是重用
在面向对象的程序里面包含有如下的几个特征：
1、封装性：保护内部的定义结构安全性
2、在已有的程序结构上继承继续扩充的新功能
3、多态性：指的是在一个概念范围内的满足
面向对象就是一种组件化思想

类与对象
类与对象是整个面向对象之中最为基础的组成单元，如果需要给出划分定义的话，类就是共性的集合，而对象是一个性的产物。对象能够操作的行为都是有类来决定的，超过了类定义的范畴操作是不能够使用的
类实际上是对象的操作的模板，但是累不能够直接使用，必须通过实例化对象来使用。
类是不能够直接使用的，对象是可以直接使用的，对象是通过类产生的

类与对象的基本定义
如果要在程序中定义类可以使用“class 类名称{}”的语法结构完成，而类之中的组成主要有两点

声明实例化对象：
1、声明并实例化对象： 类名称 对象名称 = new 类名称（）；
2、声明对象：类名称 对象名称 = null；
实例化对象：对象名称 = new 类名称（）；
引用数据类型与基本数据类型最大的不同在于需要内存开辟及使用，所有关键字new的主要功能就是开辟内存空间，即：只要是引用数据类型想要使用，那么就必须使用关键字new来开辟空间

当一个对象实例化后那么就可以按照如下的方式利用对象来操作类的结构
1对象.属性：表示要操作类中属性的内容；
2、对象.方法：表示要操作类中的方法

1、堆内存：保存每一个对象的属性内容，堆内存需要使用关键字new才可以开辟；
2、栈内存：保存的时堆内存的地址，但是为了分析方便，可以简单的理解为栈内存保存的是对象名字；

任何情况下只要看见关键字new，都要表示要开辟新的堆内存空间，里面就一定会有所有类中定义的属性，当然所有的属性内柔都是对应数据类型的默认值

引用数据的初步分析
引用是整个java开发之中的核心精髓所在，即：只有掌握了这一基本概念之后，才可以项后面的课程进行深入学习。
在所有的引用分析里面，最关键的还是关键字new，一定要注意的是每一次使用关键字new都一定会开辟一块新的堆内存空间，所以如果你的代码里面声明了两个对象，并且使用了关键字new为两个对象分别实例化操作，那么一定是各自占有各自的堆内存空间，并且不会互相影响。
第八章 深入分析类与对象
封装性
在有private的时候，访问属性的时候发现，外部的对象无法在直接调用类中的属性了，所以现在等于是属性对外部而言就不可见了。

但是如果想要让程序可以正常使用，那么必须想办法让外部的程序可以操作类中的属性才可以，所以在开发之中，针对于属性有这样的以中定义：所有类中的属性都要求使用private声明，如果属性需要被外部所使用，那么按照要求定义相应的setter、getter方法
1、setter方法主要设置内容：public void setTitle(数据类型 变量)有参
2、getter方法主要是取得属性内容：public 数据类型 getTile()无参
总结：
1、封装性就是保证类内部的定义被外部不可见
2、所有的属性必须使用private封装，封装后的属性如果想要被外部访问，要定义setter、getter方法。

构造方法与匿名对象
对象产生的格式：
1、类名称 2、对象名称 = 3、new 4、类名称（）；
1、类名称规定了对象的类型即：对象可以使用那些属性于方法，都是有类定义的
2、对象名称：如果想要使用对象，需要由一个名字，这是一个唯一标记
3、new：开辟新的堆内存空间，如果没有此语句，对象无法实例化
4、类名称（）：调用一个和类名称一样的方法，这就是构造方法
通过以上简短的分析发现，所有的构造方法一直被我们调用，但是我们从来没有去定义一个这样的构造方法，之所以能够使用是因为在整个java之中，为了保证程序可以正常执行，那么即使用户没有定义任何的构造方法，也会在程序编译之后自动的为类里面增加一个没有参数、方法名称和类名称相同、没有返回值的构造方法
构造方法定义原则：方法名称与类名称相同，没有返回值

通过代码可以发现，多有的构造方法都是在对象使用关键字new实例化的时候被默认调用的

构造方法与普通方法最大区别？
构造方法是在实例化对象的时候只调用一次
普通方法是在实例化对象产生之后可以被随意调用多次
在实际的工作之中，构造方法的核心作用：在对象实例化时候设置属性的初始化内容，构造方法是为属性初始化准备的

如果一个类中明确的定义了有参构造方法的话，那么不会再默认生成构造方法，即：一个类中至少保留一个构造方法

另外构造方法也属于方法的行列，那么可以对于构造方法进行重载。所以在构造方法重载时，要求只关注参数类型及个数即可

在进行构造方法重载时候有一点代码要求：请按照参数的个数进行升序或降序排列

没有进行构造之前所有属性的值都是对应数据类型的默认值

总结：
1、构造方法定义要求：方法名称与类名称相同，无返回值声明
2、构造方法是在类对象使用关键字new实例化的时候被默认调用的，不管代码如何改变，只要有关键字new，就一定需要构造方法
3、一个类之中至少会保留一个构造方法，如果没有明确的调用构造方法，那么会自动生成一个无参的构造方法
4、构造方法的核心功能是在类对象初始化的时候为类中的属性初始化
5、构造方法重载时，只要求考虑参数类型及个数即可
6、匿名对象只能够调用一次

代码模型
这种功能的类在java开发之中称为简单java类，因为这些类里面不会包含过于复杂的程序逻辑
对于简单java类而言，那么可以给出它第一个开发要求
1、类名称必须存在有意义
2、类之中的所有属性必须封装：private封装后的属性必须提供setter,getter;
3、类之中可以提供多个构造方法，但是必须保留一个无参构造
4、类之中不允许出现任何的输出语句
5、类之中需要提供有一个取得对象完整信息的方法

第九章 数组
数组的基本概念
数组指的是一组相关变量的集合
数组的语法如下：
1、数据类型 数组名称[] = new数据类型[长度]
2、分布完成：
声明数组：数据类型 数组名称[] = null；
开辟数组：数组名称 = new数据类型[长度]；
由于数组是一种顺序的结构，并且数组的长度都是固定的，那么可以使用循环方式输出，很明显需要使用for循环，而在java里面为了方便数组输出提供有一个“数组名称.length”的属性，可以取得数组长度。

简化格式：
1、数据类型 数组名称[] = {值，值，…};
完整格式：
2、数据类型 数组名称[] = new数据类型 []{值，值…};
一维数组输出：
public static void pr(int temp[]) {
for(int x = 0;x System.out.println(temp[x]);
}
}
二维数组
在之前的数组里面只有一个“[]”,所以此类数组就是一个普通数组，或者麻烦一点可以把它称为一维数组，如果现在想要描述更多说的数据，那么可以使用二维数组，后面有两个“[][]”

二维数组的定义语法有如下两类：
1、动态初始化：数据类型 数组名称 [][] = new 数据类型[h行的个数][列的个数]
2、静态初始化：数据类型 数组名称 [][] = new 数据类型 [][]{ {值，值….},{值，值….}};
二维数组输出：
public static void print(int arr[][]) {
for(int x = 0;x for(int y = 0;y System.out.print(arr[x][y] + “、”);
}
}
}
数组排序：
public static void sort(int arr[]) {
for(int x=0; x< arr.length;x ++) {
for(int y = 0;y < arr.length - 1; y++) {
if(arr[y] > arr[y + 1]) {
int t = arr[y];
arr[y] = arr[y + 1];
arr[y + 1] = t;
}
}
}
}
也可以使用：java.util.Arrays.sort(数组名称)；
数组转至：
public static void reser(int []temp) {
int len = temp.length/2;
int head = 0;
int tail = temp.length - 1;
for(int x = 0;x < len;x ++) {
int tem = temp[head];
temp[head] = temp[tail];
temp[tail] = tem;
head ++;
tail --;

	}
}

对象数组
数组是引用类型，而类也同样是引用类型，所以如果是对象数组的话表示一个引用类型里面嵌套其他的引用类型
对象数组就是将多个对象交给数组同一管理
总结：
1、对象数组的语法定义 对象数组 = 多个对象
2、数组有一个最大的天生短板：长度固定，所以这就限制了数组在开发之中出现
3、数组排序：java.util.Arrays.sort(数组名称)

第十章 String 类的特点
String是一个字符串类型的类，使用“””定义的内容都是字符串，但是String本身毕竟是一个类，虽然这个类在使用上会有一些特殊，但是我们必须从类的角度与内存关系上来分析这个类的作用。

1、String类的两种实例化方式
String str = “hello” ;
以上就是String对象的直接赋值。代码并没有使用关键字new进行
.构造方法：public String (String str),在构造里面依然要接受一个本类对象；
String str = new String(“hello”) ;
2、字符串的比较

如果说现在有两个int型整数想要判断其是否相等，可以使用“”符号完成
String stra = “hello” ;
String strb = new String(“hello”);
String strc = stra ;
System.out.println(stra == strb);//false
System.out.println(stra == strb );//true
System.out.println(strc == strb );//false
通过以上的分析结果发现，“”现在的确是进行了比较，但是比较的并不是字符串包含的内容，而是它们所在的内存地址的数值，所以“==”是属于数值比较，比较的是内存地址。
而如果说现在要想去比较字符串的内容的话，那么可以使用String类里面定义的方法；
比较内容：public boolean equals(String str);

System.out.println(stra.equals(strb));//true
System.out.println(stra.equals(strc));//true
System.out.println(strc.equals(strb));//true
此时实现了字符串内容的比较，在以后的开发之中，只要是进行字符串相等的判断，千万不要使用“”完成。
面试题：请解释在字符串相等的判断中“”与“equals()”的区别？
1、“==”是java 提供的关系运算符，主要的功能是进行数值相等的判断，如果用在了String 对象上表示的是进行内存地址数值的比较；
2、“equals()”是由String 提供的一个方法，此方法专门进行字符串内容的比较。

3.3字符串常量就是String 的匿名对象

实际上任何的编程语言都没有提供字符串这一概念，很多的语言里面都是使用了字符数组来描述的字符串的概念。在java里面也没有字符串的概念，但是在所有的开发里面都不能离开字符串的应用，那么最终的结果就是java自己创造了字符串。但是这个字符串依然不属于基本类型数据，它是将字符串作为String类的匿名对象的形式存在的。

为了避免空指向异常的出现可以将字符串写在方法equals()的前面。
在以后的开发之中，如果要判断输入的内容是否是某一字符串，请一定要将字符串写在最前面。

第十一章 String类方法
String 类方法

方法名称	类型	功能	

1 public String(char[] value) 构造 将字符数组变为String类对象
2 public String(char[] value,
int offset,int count) 构造 将部分字符数组变为String
3 public char charAt(int index) 普通 返回指定索引对应的字符信息
4 public char[] toCharArray() 普通 将字符串以字符数组的形式返回（程序之中索引从0开始）
字节与字符串
5 public String(byte[] bytes) 构造 将全部的字节数组变为字符串
6 public String(byte[] bytes,
int offset，int length) 构造 将部分字节数组变为字符串
7 public byte[] getBytes() 普通 将字符串变为字节数组
8 public byte[] getBytes(String charsetName)throws UnsupportedEncodingException 普通 进行编码转换
字符串的比较
9 public boolean equals(Object anObject) 普通 进行相等的判断，区分大小写
10 public boolean equalsIgnoreCase(String anotherString 普通 进行相等判断，不区分大小写
11 public int compareTo(String anoth erString) 普通 判断两个字符串的大小按照字符编码比较
返回值
=0：表示比较的两个字符串内容相等

0:表示大于的结果
<0:表示小于的结果
字符串查找
12 public boolean contains(CharSequence s) 普通 判断指定的内容是佛存在
13 public int indexOf(String str) 普通 后由前向后查找字符串的位置，如果查找到了返回  （一个字母
）位置的索引，找不到返回-1
14 public int indexOf(String str,int fromIndex) 普通 由指定位置从前向后查找指定字符串位置，找不到返回-1
15 public int lastIndexOf(String str) 普通 由后向前查找字符串位置，找不到返回-1
16 public int lastIndexOf(String str,
int fromIndex) 普通 从指定位置由后向前查找指定字符串位置，找不到返回-1
17 public boolean startsWith(String prefix) 普通 判断是否以指定的字符串开头
18 public boolean startsWith(String prefix,
int toffset)
普通 从指定位置开始判断是否以指定的字符串开头
19 public boolean endsWith(String suffix) 普通 判断是否以指定的字符串结尾
字符串替换
20 public String replaceAll(String regex,
String replacement) 普通 全部替换
21 public String replaceFirst(String regex,
String replacement) 普通 替换首个满足条件的内容
字符串截取
22 public String substring(int beginIndex) 普通 从指定索引截取到结尾
23 public String substring(int beginIndex,
int endIndex) 普通 截取部分子字符串的数据
字符串拆分
24 public String[] split(String regex) 普通 按照指定字符串全部拆分
25 public String[] split(String regex,
int limit) 普通 按照指定字符串进行部分拆分

26 public String concat(String str) 普通 字符串连接
27 public String toLowerCase(Locale locale) 普通 转小写
28 public String toUpperCase(Locale locale) 普通 转大写
29 public String trim() 普通 去掉字符串左右两边的空格
30 public int length() 普通 取得字符串长度
31 public String intern() 普通 数据入池
32 public boolean isEmpty() 普通 判断是否是空字符串

字符与字节数组
String str = “hello”;
char c = str.charAt(0);
System.out.println©;
char[] data = str.toCharArray();
     for(int x =0;x          System.out.println(data[x]);
     }
String st = new String (data);
System.out.println(st);
System.out.println(new String (data,1,3));
字节与字符数组
String str = “helloworld”;
byte[] data = str.getBytes();
for(int x = 0;x < data.length;x ++) {
     data[x] -=32;        
     }
     System.out.println(new String(data));
     System.out.println(new String(data,0,5));
String sta = “HELLO”;
String stb = “hello”;
System.out.println(sta.compareTo(stb));//只有Stirng类才有大小的判断

字符串查找
String str = “helloworld”;
System.out.println(str.indexOf(“world”));
System.out.println(str.indexOf(“l”));//返回第一个
System.out.println(str.indexOf(“l”,5));
System.out.println(str.lastIndexOf(“l”));
          
if(str.contains(“world”)) {
    System.out.println(“可以查找到数据”);
}
替换
System.out.println(str.replaceAll(“l”,"-"));
 System.out.println(str.replaceFirst(“l”,"-"));
字符串截取
System.out.println(str.substring(5));
System.out.println(str.substring(0,5));
字符串拆分
String sta = “hello world nihao mldn”;
String [] result = sta.split(" “);
String [] re = sta.split(” “,2);
for(int x = 0;x < result.length;x ++) {
    System.out.println(result[x]);
 }
for(int x = 0;x < re.length;x ++) {
    System.out.println(re[x]);
 }
}
数组.length ;
String.length();
将一个字符串首字母变为大写，其余字母变为小写
public static String initcap(String tem){
return tem.substring(0,1).toUpperCase() + tem.substring(1).toLowerCase() ;
有的时候后面字母会不变，那就不要加上toLowerCase()
public class Str{
public static void main(String args[]){
//取出指定索引的字符
String str = “hello”;
char c = str.charAt(0);
System.out.println©;
//将字符串变为字符数组
char [] data = str.toCharArray();
for(int x = 0;x < data.length ;x ++){
System.out.println(data[x]);
}
//将字符串转大写
for(int x = 0;x < data.length ;x ++){
data[x] -= 32;
}
System.out.println(new String (data));
String sta = “helloworld” ;
byte arr[] = sta.getBytes();//将字符串变为字节数组
for(int x = 0;x < arr.length ;x ++){
arr[x] -= 32; //将小写变为大写
}
System.out.println(new String (arr));
System.out.println(new String (arr,5,5));
//判断字符串编码大小
String stra = “Hello” ;
String strb = “HELLO” ;
System.out.println(stra.compareTo(strb));
if(stra.compareTo(strb)>0){
System.out.println(“大于”);
}
//String sta = “helloworld” ;
//返回满足条件单词的第一个字母的索引
System.out.println(sta.indexOf(“world”));
//返回满足条件的第一个索引
System.out.println(sta.indexOf(“l”));
System.out.println(sta.indexOf(“l”,5));
//判断指定字符是否存在
System.out.println(sta.contains(“world”));
//判断是否以指定字符串开始
System.out.println(sta.startsWith(“hello”));
//判断是否以指定字符串结尾
System.out.println(sta.endsWith(“world”));
String strc = “helloworld” ;
//替换字符串中的全部
String resultA = strc.replaceAll(“l”,”");
//替换字符串中的第一个
String resultB = strc.replaceFirst(“l”,"");
System.out.println(resultA);
System.out.println(resultB);
String strd = “helloworld” ;
//字符串截取，从指定索引开始到结尾
String suba = strd.substring(5);

	//字符串截取，从指定索引开始到指定索引结束
	String subb = strd.substring(0,5) ;
	System.out.println(suba);
	System.out.println(subb);
	
	
	
	
	
	String stre = "hello world nihao mldn" ; 
	
	//将字符串按照指定条件进行拆分为字符数组
	String resu [] = stre.split(" ");
	for(int x = 0;x < resu.length ;x ++){
		System.out.println(resu[x]);
	}
	
	String st = "张三：20|李四：21|王五：22";
	String result [] = st.split("\\|");
	for(int x = 0 ;x < result.length ;x ++){
		String temp[] = result[x].split("：");
		System.out.println("姓名：" + temp[0] + "、年龄：" + temp[1]);
	}
	
	
	
	String t = "hELLO";
	System.out.println(initcap(t));
		
	
}
//将一个字符串首字母变为大写，其余字母变为小写
public static String initcap(String tem){
	return tem.substring(0,1).toUpperCase() + tem.substring(1).toLowerCase() ;
}

}

第十二章 this关键字
在java程序里面它是以“{}”为界限的。如果现在属性名称与参数出现重名的情况下，那么默认的情况下如果没有加入任何限制，指的都是最近的“{}”内容变量名称。所以在这种情况下为了可以明确找到要访问的变量属于类中的属性的时候，需要在变量前面加上this，这样就可以准确的进行属性标记
在以后的程序开发之中，只要是访问类中的属性前面必须加上“this”
调用方法
利用this可以调用普通方法或者构造方法
限制：

class Book{
private String title;
private double price ;

public Book(){
	System.out.println("一个新的Book类对象产生");
}

public Book(String title){
	this() ;
	this.title = title ;
}

public Book(String title, double price) {
	this(title) ;
	this.price = price ;
}

public void getInfo(){
	System.out.println("图书名称：" + this.title + "，价格：" + this.price );
}

}

public class Thi{
public static void main(String args[]){
Book bk = new Book(“Java开发”,89.8);

	bk.getInfo();
	
}

}

1、使用“this”调用构造方法形式只能放在代码的首行
2、进行构造方法互相调用的时候一定要留有出口
也就是说在使用this()互相调用的时候请至少保留一个构造方法没有使用this调用其他构造的情况
表示当前对象：
所谓的当前对象指的就是当前正在调用类方法的对象
总结：
1、类中的属性调用以后都要加上this
2、类中的构造方法间的相互调用，一定要留有出口
3、this表示当前对象，指的是当前正在调用方法的对象，this不是固定的
class Emp{
private int empno ;
private String ename ;
private double sal ;
private String dept ;
public Emp(){
this(0,“无名氏”,0.0,“未定”) ;
}
public Emp(int empno){
this(empno,“临时工”,800.0,“后勤部”) ;
}
public Emp(int empno,String ename){
this(empno,ename,2000.0,“技术部”);
}
public Emp(int empno,String ename,double sal,String dept){
this.empno = empno ;
this.ename= ename ;
this.sal = sal ;
this.dept = dept ;
}
public String getInfo(){
return “雇员编号：” + this.empno + “，姓名：” + this.ename + “，工资：” + this.sal + “，部门：” + this.dept ;
}
}

public class TestDemo{
public static void main(String args[]){
Emp ea = new Emp() ;
Emp eb = new Emp(7369) ;
Emp ec = new Emp(7566,“ALLEN”) ;
Emp ed = new Emp(7839,“KING”,5000.0,“财务部”) ;
System.out.println(ea.getInfo());
System.out.println(eb.getInfo());
System.out.println(ec.getInfo());
System.out.println(ed.getInfo());

}

}
3.3、表示当前对象
所谓的当前对象指的就是当前正在调用类中方法的对象

package First;
class Book{
public void print() {
//哪个对象调用print()方法，this就自动与此对象指向同一块内存地址
//this就表示当前对象
System.out.println("this = " + this);
}
}
public class TEST {

public static void main(String[] args) {
	Book booka = new Book();
	System.out.println("booka = " + booka);
	booka.print();
	System.out.println("--------------------");
	Book bookb = new Book();
	System.out.println("bookb = " + bookb);
	bookb.print();


}

}
之前 this.属性就属于当前对象中的属性，一定是堆内存保存的内容
总结：
1、类中的属性调用以后都要加上this
2、类中的构造方法间的相互调用，一定要保留出口；
3、this表示当前对象，指的是当前正在调用类中方法的对象，this不是一个固定的。

第十三章 引用传递
引用传递核心意义：同一块堆内存空间可以被不同的栈内存所指向，不同栈内存可以对同一堆内存进行内容的修改
String类对象一旦声明不可改变
package quote;

public class DemoTest {

public static void main(String[] args) {
	String msg = "hello";//String一旦声明不可改变
	fun(msg);
	System.out.println(msg);//hello
}
public static void fun(String temp) {
	temp = "world";
}

}
结论：虽然String属于类，属于引用数据类型，但是由于其内容不可改变的特点，很多的时候就直接把String当成基本数据类那样使用就完了，也就是说每一个String变量只能够保存一个数据。
第十四章 简单java类深入

第十五章 对象比较
如果说现在定义一个类，要想判断他的两个对象是否相等，那么必须要实现对象之中所有属性内容的比较
例如：
public boolean compare(Book book) {
if(book == null) {
return false;
}
if(this == book) {
return true;
}
if(this.title.equals(book.title) && this.price == book.price) {
return true;
}else {
return false;
}
}
总结：
1、对象比较是一个类自己定义的功能
2、对象比较时一定要判断是否为null，地址是否相同，属性是否相同。

第十五章 对象比较
class Book1{
private String title ;
private double price ;
public Book1(String title,double price) {
this.title = title ;
this.price = price ;
}
public boolean compare(Book1 book) {
if(book == null) {
return false ;
}
if(this == book) {
return true ;
}
if (this.title.equals(book.title) && this.price == book.price) {
return true ;
}else {
return false ;
}
}
public String getInfo() {
return "图书名称: "+ this.title + ",价格: " + this.price ;
}
}
总结：
1、对象比较一定是某一个类自己定义的功能；
2、对象比较一定时一定要判断是否为null、地址是否相同、属性是否相同
简单java类里面一定要提供对象比较的方法

第十六章static关键字
static定义属性
一旦在定义属性的时候使用了static之后，只要有一个对象修改了属性的内容，那么所有对象的static属性一起修改，也就是说此时static定义的属性是全局属性

static属性与非static属性还有一个最大的区别，所有的非static属性必须产生实例化对象之后才可以进行访问，但是static属性不受实例化对象的限制，也就是说在没有实例化对象的情况下依然可以使用static属性

在编写类的过程之中，所选的首先一定不是static属性（95%），如果需要描述共享信息的时候使用static（可以方便集体修改）可以不用重复开辟没存空间。

3.2 、static定义方法
static定义方法的时候也可以在没有实例化对象的时候直接利用类名称直接调用

static方法与非static方法访问限制
static不能够直接访问非static方法或属性，只能够调用static属性或方法
非static方法可以访问static属性或方法，不受任何限制

为什么会存在这样的限制？
所有的非static属性或方法必须在类已经明确产生了实例化对象才会分配空间，才可以使用
所有的static定义的结构不受实例化对象的限制即：可以在没有实例化对象的时候直接调用

主方法：
public：主方法是程序的开始，所以这个方法对任何的操作都是可见的，那么既然是可见的就必须是有public（公共）
static:证明此方法是由 类名称直接调用的；
void：主方法是一个程序的开始点，既然是所有的开头，那么就不能够回头，执行完毕为止
main：是一个系统规定好的名称不能够修改
String args[]:指的是一个程序运行时传递参数

总结：
1、开发之中首选的一定不是static属性或方法
2、static属性或方法可以在没有实例化对象的时候由类名称直接调用
3、static属性保存在全局数据去
内存区一共有四个：堆内存、栈内存、全局数据区、全局代码区。

第十七章 代码块
普通代码块
普通代码块的作用：防止在方法里面编写的代码变量重复
if(true) {
int num = 10;
System.out.println(“num =” + num);
}

构造块
把代码块写在一个类里面就称为构造块
构造块优先于构造方法执行且如果多次实例化会重复调用

静态块
一个代码使用了static定义就称为静态块分为两种情况
1、非主类静态块：静态块将优先于构造块执行，不管有多少实例化对象，静态块只执行一次，作用：为类中的static属性初始化
2、在主类中的静态块：静态块优先于主方法执行

第十八章 内部类
基本概念
所谓的内部类就是指在一个类的内部继续定义了其他结构类的情况
例如：
class Outer{
private String msg = “hello world”;
class Inner{
public void print() {
System.out.println(msg);
}
}
public void fun() {
Inner in = new Inner();
in.print();
}
}
内部类有一个最大的优点：可以方便访问外部类的私有操作
一旦使用了内部类，私有访问就变得非常简单了
内部类对象实例化语法：
外部类.内部类 对象 = new 外部类().new 内部类();
Outer out = new Outer();
out.fun();
Outer.Inner ine = new Outer().new Inner();
ine.print();
内部类不可能离开外部类的实例化对象，所以一定要先实例化外部类对象后才可以使用内部类对象。如果真的使用到了内部类，也基本上不会像以上的操作那样进行的。一定是通过外部类方问内部类。

static定义内部类
使用了static定义的内部类不受外部类的实例化对象控制
内部类使用了static定义，这个内部类就变为了一个外部类，并且只能访问外部类定义的static操作。相当于定义了一个外部类。
语法：
外部类.内部类 对象 = new 外部类.内部类（）;

方法中定义内部类
例如：
class Outer {
private String msg = “hello world”;
public void fun(final int num) {
final double sco = 99.9;
class Inner{
public void print() {
System.out.println(Outer.this.msg);
System.out.println(num);
System.out.println(sco);

		}
	}
	new Inner().print();
}

}

总结：
1、内部类只是阐述了基本定义的形式，但是没有讲解如何去使用
2、内部类可以与外部类之间方便的进行私有属性的访问
3、内部类可以使用private声明，声明之后，无法在外部类实例化内部类对象；
语法：
外部类.内部类 对象 = new 外部类().new 内部类();
4、使用static定义的内部类就相当于一个外部类
外部类.内部类 对象 = new 外部类.内部类（）;
5、内部类可以在方法中定义

第十九章链表
3.1链表的基本形式
链表是一种最为简单的数据结构，它的主要目的是依靠引用关系来实现多个数据的保存，那么假设现在要保存的数据是字符串
class Node{
private String data ;
private Node next ;
public Node(String data) {
this.data = data ;
}
public void setNext(Node next) {
this.next = next ;
}
public Node getNext(){
return this.next ;
}
public String getData() {
return this.data ;
}
}
public class Test1 {

public static void main(String[] args) {
	Node root = new Node("火车头");
	Node n1 = new Node("车厢A");
	Node n2 = new Node("车厢B");
	root.setNext(n1);
	n1.setNext(n2);
	print(root);


}
public static void print(Node current) {
	if(current == null) {
		return ;
	}
	System.out.println(current.getData());
	print(current.getNext()) ;
}

}
3.2、链表的基本雏形
通过分析发现：
. 用户在操作的过程之中完全没有必要去关心Node类是否存在；
. 所有的节点的引用关系不应该由用户处理，应该有一个专门的工具类来进行处理
下面需要定义一个类，来帮助客户端去隐藏所有的链表中给出的细节操作。
class Node{
private String data ;
private Node next ;
public Node(String data) {
this.data = data ;
}
public void setNext(Node next) {
this.next = next ;
}
public Node getNext(){
return this.next ;
}
public String getData() {
return this.data ;
}
//实现节点的添加
//第一次调用(Link): this = Link.root
//第二次调用（Node): this = Link.root.next
public void addNode(Node newNode) {
if(this.next == null) {//当前节点为空
this.next = newNode ;//保存新节点
} else {//当前节点之后还有节点
//当前节点的下一个节点继续保存
this.next.addNode(newNode);
}
}
//第一次调用(Link): this = Link.root
//第二次调用（Node): this = Link.root.next
public void printNode() {
System.out.println(this.data);//输出当前节点
if(this.next != null) {//现在还有下一个节点
this.next.printNode();//输出下一个
}
}
}
//需要进行Node类对象关系的处理
class Link{//负责数据的设置和输出
private Node root ;
public void add(String data) {//增加数据
//为了可以设置数据的先后关系，所以将data包装在一个Node类对象里
Node newNode = new Node(data);
//保存当前数据的时候，现在还没有根节点
if(this.root == null) {
this.root = newNode ;//将新的节点设置为根节点
}else {//根节点已经存在了
//随后后面增加的元素应该由节点来决定
//从root节点之后找到合适的位置
this.root.addNode(newNode);
}

}
public void print() {//输出数据
	if(this.root != null) {//存在根节点
		this.root.printNode() ;
	}
}

}
public class Test1 {

public static void main(String[] args) {
	Link link = new Link();
	link.add("hello");
	link.add("world");
	link.add("MLDN");
	link.add("nihao");
	link.add("世界");
	link.print();
}

}
通过以上的代码实际上就可以发现链表的基本操作特点
客户端代码不用去关注具体的Node以及引用关系的细节，只关注于提供的Link类中支持的方法；
Link类的主要功能是控制Node类的对象的产生和根节点；
Node类主要负责数据的保存以及引用关系的分配；
3.3、开发可用链表
指的是可以使用的链表实现数据的增加、修改、删除、查询操作
3.3.1、程序的基本结构
在开发具体的可用链表操作之前，首先必须明确一个道理：Node类负责所有的节点数据的保存以及节点关系的匹配，所以Node 类不可能单独去使用，而以上的实现里面Node类是可以单独使用的，外部可以绕过Link类直接操作Node类，这样明显是没有任何意义存在的，所以需要下面需要修改设计结构，让Node类只能够被Link类使用。
class Link{//链表类，外部只能够看见这一个类
//之所以定义在内部，主要是让其为Link类服务
private class Node{//定义一个节点类
private String data;
private Node next;
public Node(String data) {
this.data = data;
}
}
//上面为内部类=========================================
private Node root;

}
3.3.2、数据增加： public void add(数据类型 变量）
如果要进行新数据的增加，则应该由Link类负责节点对象的产生，并且由Link类维护根节点，所有的节点关系匹配交给Node类处理
class Link{//链表类，外部只能够看见这一个类
//之所以定义在内部，主要是让其为Link类服务
private class Node{//定义一个节点类
private String data;
private Node next;
public Node(String data) {
this.data = data;
}
public void addNode(Node newNode) {
if(this.next == null) {//当前节点为空
this.next = newNode ;
}else {//向后继续保存
this.next.addNode(newNode);
}
}
}
//上面为内部类=========================================
private Node root;
public void add(String data) {
if(data == null) {
return ;
}
Node newNode = new Node(data);//要保存的数据
if(this.root == null) {//当前根节点没有数据
this.root = newNode ;//保存根节点
}else {//根节点存在，其他节点交给Node类处理
this.root.addNode(newNode);
}
}
}
public class Test1 {

public static void main(String[] args) {
	Link all = new Link();
	all.add("hello");
	all.add("world");
}

}
此时使用了一个不许为null的判断。并不是所有的链表都不许为空
3.3.3、取得保存元素的个数： public int size()
既然每一个链表对象都只有一个root根元素，那么每一个链表就有自己的长度。可以在Link类里面设置一个count属性，随后每一次数据添加完成之后，可以进行个数的自增
class Link{//链表类，外部只能够看见这一个类
//之所以定义在内部，主要是让其为Link类服务
private class Node{//定义一个节点类
private String data;
private Node next;
public Node(String data) {
this.data = data;
}
public void addNode(Node newNode) {
if(this.next == null) {//当前节点为空
this.next = newNode ;
}else {//向后继续保存
this.next.addNode(newNode);
}
}
}
//上面为内部类=========================================
private Node root;//需要根节点
private int count = 0 ;//保存元素个数
public void add(String data) {
if(data == null) {
return ;
}
Node newNode = new Node(data);//要保存的数据
if(this.root == null) {//当前根节点没有数据
this.root = newNode ;//保存根节点
}else {//根节点存在，其他节点交给Node类处理
this.root.addNode(newNode);
}
this.count ++ ;
}
public int size() {//取得保存的数据量
return this.count ;
}
}
public class Test1 {

public static void main(String[] args) {
	Link all = new Link();
	all.add("hello");
	all.add("world");
	all.add("MLDN");
	System.out.println(all.size());
}

}
3.3.4判断是否是空链表 public boolean isEmpty()
判断链表是否为空有两种方法
第一个：判断root是否有对象（是否为null）
第二个：判断保存的数据量（count）
class Link{//链表类，外部只能够看见这一个类
//之所以定义在内部，主要是让其为Link类服务
private class Node{//定义一个节点类
private String data;
private Node next;
public Node(String data) {
this.data = data;
}
public void addNode(Node newNode) {
if(this.next == null) {//当前节点为空
this.next = newNode ;
}else {//向后继续保存
this.next.addNode(newNode);
}
}
}
//上面为内部类=========================================
private Node root;//需要根节点
private int count = 0 ;//保存元素个数
public void add(String data) {
if(data == null) {
return ;
}
Node newNode = new Node(data);//要保存的数据
if(this.root == null) {//当前根节点没有数据
this.root = newNode ;//保存根节点
}else {//根节点存在，其他节点交给Node类处理
this.root.addNode(newNode);
}
this.count ++ ;
}
public int size() {//取得保存的数据量
return this.count ;
}
public boolean isEmpty() {
return this.count == 0 ;
}
}
public class Test1 {

public static void main(String[] args) {
	Link all = new Link();
	System.out.println(all.isEmpty());
	all.add("hello");
	all.add("world");
	all.add("MLDN");
	System.out.println(all.size());
	System.out.println(all.isEmpty());
}

}
3.3.5、 数据查询 : public boolean contains(数据类型 变量)
在链表之后一定会保存多个数据，那么基本的判断数据是否存在的方式，以String为例。循环链表中的内容，并且与要查询的数据进行匹配（equals()）
class Link{//链表类，外部只能够看见这一个类
//之所以定义在内部，主要是让其为Link类服务
private class Node{//定义一个节点类
private String data;
private Node next;
public Node(String data) {
this.data = data;
}
public void addNode(Node newNode) {
if(this.next == null) {//当前节点为空
this.next = newNode ;
}else {//向后继续保存
this.next.addNode(newNode);
}
}
public boolean containsNode(String data) {
if(data.equals(this.data)) {
return true;
} else {
if(this.next != null) {
return this.next.containsNode(data);
} else {
return false ;
}
}
}
}
//上面为内部类=========================================
private Node root;//需要根节点
private int count = 0 ;//保存元素个数
public void add(String data) {
if(data == null) {
return ;
}
Node newNode = new Node(data);//要保存的数据
if(this.root == null) {//当前根节点没有数据
this.root = newNode ;//保存根节点
}else {//根节点存在，其他节点交给Node类处理
this.root.addNode(newNode);
}
this.count ++ ;
}
public int size() {//取得保存的数据量
return this.count ;
}
public boolean isEmpty() {
return this.count == 0 ;
}
public boolean contains(String data) {
if (data == null || this.root == null) {
return false ;
}
return this.root.containsNode(data) ;
}
}
public class Test1 {

public static void main(String[] args) {
	Link all = new Link();	
	all.add("hello");
	all.add("world");
	all.add("MLDN");
	System.out.println(all.contains("hello"));
}

}
3.3.6、根据索引取得数据 ： public 数据类型 get（int index）
通过以上的代码测试发现，链表里面保存了多个String类的对象，在程序里面只有数组里面可以保存多个对象，现在使用的链表与数组相比较的话，优势就是没有长度限制，所以严格意义上来讲就是一个动态的对象数组，那么既然链表属于动态对象数组，那么也应该具备像数组那样可以根据索引取得元素功能
由于是动态对象数组，所以数组中的每一个元素索引的内容都一定是动态生成

class Link{//链表类，外部只能够看见这一个类
//之所以定义在内部，主要是让其为Link类服务
private class Node{//定义一个节点类
private String data;
private Node next;
public Node(String data) {
this.data = data;
}
public void addNode(Node