jdk是程序开发工具包，包含了jre（运行环境）和开发工具。jre是Java运行的环境包含了jvm和核心类库
jvm（Java虚拟机）相当于一个翻译而实现了Java语言的跨平台
public static void main(String[] args）识别入口
public class声明一个类，类名称的命名规范：所有单词的首字母大写
public class和class的区别
public class在一个java文件夹中只能有一个，而class可以有很多个
使用public class声明时，类名称必须与文件名称一致，而使用class则不必
java小程序的主类必须是public
Java程序则不必
java小程序不再需要main方法，但必须有一个父类为JApplet或Applet的类
注释
单行注释 / /注释内容
多行注释 /注释内容/
文档注释 /*注释内容/
关键字
关键字字母全部小写，并且在代码编辑器中带有不同颜色
常量
在程序运行过程中，其值不能发生改变的量
分为以下几类
字符串常量 用双引号括起来的内容例如“HelloWorld”
整数常量 整数数字例如666，-88
小数常量 带有小数点的数字，例如3.14，-2.6
字符常量 用单引号括起来的字符例如’0’,‘我’，‘A’
布尔常量 布尔值，表示真假，只有两种true和false
空常量 一个特殊的值，空值，null
注：空常量不能输出，其他常量都可以输出
数据类型
基本数据类型
整型 byte（-27~27-1）, short(-215~215-1), int(-231~231), long （整型默认为int）
浮点型 float,double （浮点型默认为double）
布尔型 boolean
字符型 char
引用数据类型
类 class
接口 interface
数组 [ ]
变量定义格式
数据类型 变量名=变量值
使用变量注意事项
因为整型默认为int，所以在使用long时要在其后加L
浮点型使用float时要在其后加F
标识符
标识符定义规则
标识符由字母，数字，下划线和美元符组成
标识符不能以数字开头0
标识符不能是关键字
标识符区分大小写
常见命名约定
小驼峰命名法 方法名，变量
单个单词首字母小写
多个单词第一个单词首字母小写，后面单词的首字母大写
大驼峰命名法 类名
单个单词的首字母大写
多个单词的每一个单词首字母都大写
类型转换
自动类型转换
byte->short
}–>int–>long–>float–>double
char
如，10为整型，若数据类型写为double则运行结果为10.0
强制类型转换
上图自动类型的顺序逆转就变成强制类型转换
强制类型转换的格式为
目标数据类型 变量名=（目标数据类型)值或变量
如int a=(int)88.88
由此可见，强制类型转换可能会导致部分数据丢失。故不建议使用强制数据转换
算术运算符
加+
减-
乘*
除/
取余%
根号k: Math.sqrt(k)
需要注意的是，在除法运算中，整数相除整数相除只能得到整数，要想得到小数必须有浮点数的参与
字符的+操作
首先做一个演示，使字符A，a，0分别与整数10相加。结果如下
由此我们就可以知道，整数和字符是能够相加的。并且字符A的值为65，a的值为97，0的值为48。总结为
A到Z的值是连续的，由65到91
a到z的值是连续的，由97到123
0到9的值是连续的，由48到58
由于演示时是用int和char类型的数据，因此相加的结果要么用int类型接收，要么用char类型接收。当我们用char类型接收时
我们会发现它是不能实现的
在算术表达式中如果存在多个基本数据类型的值的时候，整个算术表达式的类型会自动进行提升，具体提升规则如下
byte,char,short---->int---->long—>fioat---->double
因此在上述实例中，char类型被自动提升为了int类型，所以不能用char类型接收，而用int类型接收则是可以的
字符串的+操作
当“+”操作中出现字符串时，+就为连接运算符，否则就为算术运算。当连续出现+时，则从左至右依次进行“+”操作
例如
由上例就可以看出明显的顺序不同时的差别
赋值运算符
=的意思为赋值
算术中还有很多扩展的赋值运算符
+= 加后赋值
-= 减后赋值
*= 乘后赋值
/= 除后赋值
%= 除余后赋值 a%=b a除b的余数赋值给a
由上面两张图可知，i+=20和i=i+20似乎是一样的。下面换一个例子来试
此时还是正常的，但是我们换成s=s+20来试试
由上图发现，这个格式是行不通的。因为20默认是int类型，s是short类型。根据类型自动提升规则，s提升为了int类型，而在上面却已经规定了s为short类型
若要实现这个算术式，需要用强制类型转换
由此我们知道，扩展的赋值运算符其实是隐含强制类型的转换的。
自增自减运算符
变量的自增自减的运算
++ 变量值加一
– 变量值减一
当单独使用时，++放在变量前后都可
当参与操作使用时
当++在操作数前则先进行加运算再参与操作，若在操作数后则先参与操作再进行加运算
由上图输出的n和i的值可知此时当++在i后时，是先把i的值赋给n在对i进行自增
当++在i后时，则是对i进行自增后再将i的值赋给n
但是比较常用的是单独运算
关系运算符
==判断两值是否相等
！=判断两值是否不相等
=判断a是否大于等于b
<=判断a的值是否小于等于b
判断a是否大于b
<判断a是否小于b
判断结果若是则为true,否则为false.关系运算符结果为boolean型，只有true和false两种可能
逻辑运算符
& 逻辑与 a&b 存在false即为false
| 逻辑或 a|b 存在true则为true
^ 逻辑异或 a^b 相同为false，不同为true
！ 逻辑非 !a 结果与a相反
短路逻辑运算符
&& 短路与 作用与&相同，但是有短路效果，若前面为false，则后面不运行
|| 短路或 作用与|相同，但是有短路效果，若前面为true，则后面不运行
从上图来看，&和&&还有|和||，似乎逻辑运算是相同的。
而通过上面的例子发现两者输出的值是不同的。使用&时，a，b都进行了加操作
而使用&&是，a进行了加操作，而b没有进行加操作。所以&&后面的根本就没有运行。
由此我们知道，由于&&前面的结果是false，而运算规则为存在false则为false。&&为短路逻辑运算符，因此在这一步短路了，后面的操作不执行。若前面为true，则后面的操作正常执行。
同理，当||前为true，后面的操作不执行
三元运算符
格式
关系表达式？表达式1：表达式2
例如a>b?a:b
先计算关系表达式，若结果为true，则输出a，若结果为false，则输出b
数据输入
导包
import java.util.Scanner;
创建对象
Scanner sc=new Scanner(System.in);
int i=sc.nextInt();
next()和nextLine()的区别
next()在检测到用户输入的在字符串前的空格后会自动将其去掉，而在用户输入字符串后的空格将会被当作结束符或者分隔符。
*next()方法在读取内容时，会过滤掉有效字符前面的无效字符，对输入有效字符之前遇到的空格键、Tab键或Enter键等结束符，next()方法会自动将其过滤掉；只有在读取到有效字符之后，next()方法才将其后的空格键、Tab键或Enter键等视为结束符；所以next()方法不能得到带空格的字符串。
nextLine()方法字面上有扫描一整行的意思，它的结束符只能是Enter键，即nextLine()方法返回的是Enter键之前没有被读取的所有字符，它是可以得到带空格的字符串的。
nextXXX（）和hasNext()
一般输入语句后，先调用hasNext()方法来判断输入的数据数据类型是否正确，然后再调用nextXXX()方法读取数据。
分支语句
流程控制
顺序结构
按照代码的先后顺序执行
分支语句
if语句1
if(关系表达式){
语句体
}
先判断关系表达式，若结果为true则执行语句体，若结果为false则不执行语句体，接着往下执行。
if语句2
if（关系表达式）{
语句一；
}else{
语句二；
}
先判断关系表达式，若结果为true则执行语句一，若结果为false则执行语句二
if语句3
if（关系表达式）{
语句一；
}else if（关系表达式二）{
语句二；
}else if（关系表达式三）{
语句三；
}else{
语句n；
}
先判断关系表达式，若结果为true则执行语句一，若结果为false则计算关系表达式二，若结果为true则执行语句二，若结果为false则计算关系表达式三。。。。。。。。直到有一个值为true执行语句n-1或者所有都为false执行语句n
switch语句
switch（表达式）{
case 值1
语句体1
break；
case 值2
语句体2
break；
。。。。
default
语句体n
[break]（可省略）
}
！!注意case后的空格
case穿透
有时用switch语句很麻烦比如在写判断输入月份是哪个季节的时候，用switch语句要写12个case，这时可以用case穿透简化代码例如
循环结构
初始化语句
条件判断语句，一般为Boolean型
循环体语句
条件控制语句 一般为i++等
for循环
for(初始化语句；条件判断语句；条件控制语句）{
循环体语句；
}
先执行初始化语句，在进行条件判断，若结果为true则继续执行，为false则循环结束。执行循环体语句，执行条件控制语句，再返回条件判断继续。
例如
取一个三位数的个位即将这个数取除以10的余数，取这个数的百位即将这个数除100，取这个数的十位即先除十将十位挪到个位，再取除以十的余数。
例如371
个位：371%10=1
十位：371/10=37，37%10=7
百位：371/100=3
取一个数的任意一位
比如123456789则让这个5移到个位即123456789/10000，得到了12345，再取除十的余数12345%10=5
while循环
基本格式
初始语句；
while（条件判断语句）{
循环体语句；
条件控制语句；
}
do…while循环
初始语句
do{
循环体
条件执行语句
}while（条件判断语句）
三种循环的区别
for循环和while循环都是先判断再输出循环体，do…while循环则是先输出循环体再判断
for循环和while循环的区别
for循环中的变量值是归属于for循环中的，在循环结束后不能再用，而while循环中的变量值是不在循环结构中的，后面还可以再使用。
在循环中{ }内定义的变量只能在此区间内使用
死循环
循环不停止。
for（；；）{
循环体
}
（常用）while（true）{
循环体
}
do{
循环体
}while（true）
跳转控制语句
continue 用于循环中，基于条件控制，跳过某一次循环，继续执行下一次循环
break 用于循环中，基于条件控制，退出其所在的循环
Random(用于产生一个随机数)
跟Scanner使用方法类似
1.导包
import java.util.Random;
2.创建对象
Random r=new Random();
3.获取随机数
int c=r .nextInt(10); (随机数的范围是[0，10）)
如果要获取一个一到一百之间的随机数
则为
int num=r.nextInt(100)+1;
Math.random()
数组
基础定义
数组的定义格式
格式一：
数据类型[] 变量名
例如int[] a
意义是：定义了一个int类型的数组，数组名为a
格式二：
数据类型 变量名[]
例如int a[]
意义是定义了一个int类型的变量，变量名是a数组
格式一更好
数组初始化
java中的数组必须先初始化，才能使用。
什么是初始化？
初始化就是为数组中的数组元素分配储存空间并为数组中的每个元素赋值
数组初始化分为动态初始化和静态初始化
1.动态初始化
动态初始化是指在初始化时只指定数组长度，由系统为数组分配初始值
格式 数据类型[] 数组名=new 数据类型[数组长度];
2.静态初始化
静态初始化是指在初始化时指定每个数组的初始值，由系统决定数组的长度。
格式 数据类型[] 数组名= new 数据类型[] {数据一，数据二，数据三,…}
简化格式 数据类型[] 数组名={数据一，数据二，数据三，…}
数组元素访问
数组变量访问方式
格式 数组名
数组内部保存的数据访问方式
格式 数组名[索引]
什么是索引？
我们平时编号是从1开始的，但是计算机习惯的编号是从0开始的，而这个从零开始的编号，就叫索引。
索引是数组中数据的编号方式
作用：索引用于访问数组中数据类型的使用
数组名[索引]相当于变量名，是一种特殊的变量名。
java中的内存分配
内存分为两种，栈内存和堆内存
int[] arr=new int[3];
System.out.print(arr);(此时是输出内存地址假设地址为001）
数组动态初始化时，系统会分配初始化的值
整数的初始值为0
浮点数的初始值为0.0
布尔值的初始值为false
字符的初始值为空字符
引用数据类型默认值时null
数组内存图
单个数组内存图
若要修改则为
例如 arr[1] =100
多个数组内存图
数组操作中两个常见的小问题
1.索引越界
ArrayIndexOutofbounds
访问了索引中不存在的索引对应的元素
2.空指针异常
访问的数组已经不再指向堆内存的数据，从而造成了空指针异常
3.null
如果将一个引用变量赋值给null，则表示改引用变量不指向任何对象
数组常见操作
1.遍历
输出数组中的所有元素，利用for循环写出索引的数值。
如
int[] arr={1，2，3，4}；
for(int a=0;a<5;a++){
System.out.println(arr[a]);
}
但是存在如果数组内的元素过多的情况，因此数组中的元素的个数可以表示为
数组名.length
int[] arr={1，2，3，4}
for(int a=0;a<arr.length;a++){
System.out.println(arr[a]);
}
for each语句
不需要下标就可以遍历整个数组
格式
for(数据类型 a: array)
{
System.out.println(a);
}
若是二维数组则在数据类型后加[ ],三维加两个，以此类推
int[] arr={1,2,4,5};
for(int a:array){
System.out.println(a);
}
2.获取最值
获得一组数据中的最大值
例如
int[] arr={11,34,53,46};
//定义一个变量用于保存最值,并先将数组中第一个数据赋值给该变量
int max=arr[0];
//遍历数组中的数据，利用if语句将较大的的数赋值给max
for(int a=1;a<arr.length;a++){
if(max<arr[a]){
max=arr[a];
}
}
System.out.println(max);
3.二维数组
若要获得二维数组的行数，只要在数组名后加上.length即可。若要取得数组中某行元素的个数，则需在数组名后加上该行的索引，再加上.length
方法
什么是方法？
方法是将具有独立功能的代码块组织成一个整体，使其具有特殊功能的整体。
方法必须先创建才可以使用，该过程称为方法定义
方法并不是创建后自动执行的，而是需要手动使用后才会执行，这一步成为方法调用
方法的定义和调用
方法定义格式
public static void 方法名（）{
方法体
}
方法的调用
方法名（）；
带参数方法的定义和调用
1.定义和调用
带参数方法定义格式
单个参数 public static void 方法名(参数)
多个参数 public static void 方法名(数据类型 变量名1，数据类型 变量名2，…)
带参数方法的调用格式
单个参数 方法名（变量名/常量值）；
多个参数 方法名（变量名/常量值1，变量名/常量值2，…）
2.形参和实参
形参 方法定义中的参数
等同于变量 定义格式数据类型 变量名
实参 方法调用中的参数
等同于使用变量或常量，他要么是一个常量值，要么是一个变量名
带返回值方法的定义和调用
1.定义和调用格式
带返回值方法的定义格式
public static 数据类型 方法名（参数）{
return数据
}
注：此处的数据要与上面的数据类型相匹配
带返回值方法的调用格式
格式一 方法名（参数）
格式二 数据类型 变量名 =方法名（参数）
例 int a=compare(5);
注：方法的返回值通常会使用变量接收，否则该返回值将无意义
2.引用变量作为方法的返回值
引用变量作为方法的返回值时只需在方法声明的前面加上要返回的类即可。
例如一个返回值为对象的方法定义
方法的注意事项
1.方法不能嵌套定义
2.void表示无返回值，可以省略return，也可以单独的书写return，后面不加数据
方法的通用格式
public static 数据类型 方法名（参数）{
方法体；
return 数据；
}
方法调用时若是void类型的方法则直接调用即可，若不是void类型的方法则推荐使用变量接收
方法重载
1.方法重载的概述
方法的重载是实现“多态”的一种方法。有一些方法含义相同，但是带有不同的参数，这些方法使用相同的名字构成方法的重载
方法重载是指在同一个类中定义的多个方法之间的关系，满足下列条件的多个方法构成重载
多个方法在同一个类中
多个方法的方法名相同
多个方法的参数不相同（数量不同或类型不同）
Java语言中不允许多个方法的参数完全相同而只有返回值类型不同的重载
重载仅适用于方法的定义，方法的调用参考上文
方法重载的识别仅可对于方法名和参数的识别，即无法判断返回值来判断两个方法是否构成重载。
在方法调用的时候，Java虚拟机会通过参数的不同来区分同类中不同的方法
方法的参数传递
1.方法参数传递基本类型
方法调用完成之后将从栈内存中消失。对于基本数据类型的参数，形参的改变不影响实参的值
2.方法参数传递引用类型
对于引用类型的参数，形参的改变会影响实参
类和对象
什么是对象？
客观存在的事物都可以称作对象
对象是计算机世界中的数据信息，而类则是对象的数据类型
什么是类？
类是对现实生活中一类具有共同属性和行为的事物的抽象
类在现实生活中是不存在的，他只是用来描述对象信息的
类的特点
类是对象的数据类型
类是具有相同属性和行为的一组对象的集合
什么是对象的属性？
属性就是对象具有的各种特征，每个对象的每个属性都拥有特定的值
例如
什么是对象的行为
行为就是对象能够执行的操作
例如
类和对象的关系
类是现实生活中一类具有共同属性和行为的事物的抽象
对象时能看得见摸得着的实体
类是对象的抽象，对象是类的实体
类的定义
类的重要性
类是Java程序的基本组成单位
什么是类
类是现实生活中一类具有共同属性和行为的事物的抽象，用来确定对象将拥有的行为和属性
类的组成
属性和行为
属性：在类中通过成员变量来体现（类中方法以外的变量）
行为：在类中通过成员方法来实现（上述方法去掉static关键字即可）
类的定义
定义类
编写类的成员变量
编写类的成员方法
//定义类
public class 类名{
//编写成员变量
数据类型 变量一；
数据类型 变量二；
…
//编写成员方法
方法一
方法二
}
对象的使用
变量可分为基本类型变量和非基本类型变量，声明基本类型变量的格式为“数据类型 变量名”，而声名一个对象的格式为“类名 对象名”。因此可以称对象为类类型的变量。
实际上对象是一种引用类型的变量，而引用类型的变量实际上保存的是对象在内存中的首地址
创建对象
格式 类名 对象名=new 类名（）
使用对象
使用成员变量
格式 对象名.变量名
使用成员方法
格式 对象名.方法名（）
对象的赋值
在使用对象时一般先用new运算符创建对象，但有时没有使用new运算符创建新对象，仍然可以对其赋值。
匿名对象
如
Text volu=new Text();
volu.方法名（）;
改写为
new Text().方法名（）;
匿名对象使用场景：
1：当对方法只进行一次调用的时候，可以使用匿名对象。
2：当对象对成员进行多次调用时，不能使用匿名对象。必须给对象起名字。
对象内存图
成员变量和局部变量
1.什么是成员变量和局部变量
成员变量就是类中方法外的变量
局部变量是方法中的变量
2.成员变量和局部变量的区别
位置不同，成员变量是在类中方法外，而局部变量则是在方法中的变量
内存位置不同，成员变量在堆内存中，而局部变量在栈内存中
生命周期不同，成员变量是随着对象的存在而存在，而局部变量则是随着方法存在而存在
初始化值不同，成员变量有初始化值，而局部变量没有，必须先定义，赋值才能使用
封装
private关键字
是一个权限修饰符
用来修饰成员变量和成员方法
是用来保护成员不被别的类所使用，被private修饰的成员只有在本类中才能访问
针对private修饰的变量，如果需要在其它类中被使用，需提供相应的操作
通过get变量名（）的方法，用于获取成员变量的值，用public修饰
通过set变量名（参数）的方法，用于设置成员变量的值，方法用public修饰
get，set方法的变量名，首字母要大写
调用
当缺省访问控制符时表明这个成员只能被同一个包（类库）中的类所访问和调用
this关键字
this修饰的变量用于指代成员变量
方法的形参如果与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量。
在Java中当局部变量与成员变量同名时，局部变量会隐藏成员变量，如果我们要使用成员变量则需要使用this关键字
this代表所在类的对象引用，方法被哪个对象调用，this就代表哪个对象
总结
1.this代表对当前类的对象的引用
2.表示用类的成员变量
3.用于在构造方法中引用满足指定参数类型的构造器
封装
1.封装概述
是面向对象三大特征之一（继承，封装，多态）
是面向对象编程语言对客观世界的模拟。客观世界里成员变量都是隐藏在对象内部的，外界是无法直接操作的
是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
2.封装原则
将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问成员变量private，来提供对应的getxxx()和setxxx()方法
3.封装的好处
通过方法来控制成员变量的操作，提高了代码的安全性
把代码用方法进行封装提高了代码的复用性
构造方法
什么时候使用构造函数呢？
分析事物时，发现具体事物一出现，就具备了一些特征，那就将这些特征定义到构造函数内。
构造方法概述
构造方法是一种特殊的方法
作用：创建对象
构造方法的格式
public class Student{
修饰符 Student(参数){
构造方法内书写的内容
}
}
构造方法的调用
修饰符一般用public。
功能：主要完成对象数据的初始化
构造方法没有返回值，但其不能用void修饰，因为一个类的构造方法的返回值是其本身
构造方法的注意事项
构造方法的创建
如果没有定义构造方法，系统将给出一个无参的默认构造方法
如果定义了构造方法系统将不再提供默认的构造方法
构造方法的重载
如果定义了带参的构造方法还要使用无参构造方法，就必须再写一个无参构造方法
推荐的使用方式
无论是否使用，都手写一个无参构造方法
调用
构造方法也可以构成重载，其与上述方法重载相同
一个构造方法调用另一个构造方法
Java语言允许在类内从某一构造方法内调用另一个构造方法，是通过this关键字来调用的，通过this（）括号内参数的类型来区分调用的另一构造方法是哪一个。要注意this关键字必须写在构造方法内第一行的位置。
公共构造方法和私有构造方法
同样是在方法前加修饰符，用private修饰的方法只能在同一类中被调用，可借用this在public中调用方法
标准类制作
成员变量
使用private修饰
构造方法
构造一个无参方法
构造一个带参方法
成员方法
get，set方法
show方法打印结果
创建对象并为其赋值的两种方式
使用构造无参方法创建对象后用set方法赋值
使用构造有参方法直接创建有属性值的对象
静态成员
static称为静态修饰符，可以用来修饰类中的成员。被static修饰的成员称为静态成员，也称为类成员，而不用static修饰的成员称为实例成员
实例成员
如果类定义中的成员变量或成员方法没有用static修饰，则该成员就是实例成员
静态变量
用static修饰的成员变量称为静态变量，也称为类变量，它是属于类的变量。对该类任何一个具体对象而言，静态变量是一个公共储存单元，不是保存在某个对象实例的内存空间中，而是保存在类的内存空间的储存单元中。
静态变量不需要实例化就可以使用，当然也可以通过实例对象来访问静态变量。
静态变量的使用格式
类名.静态变量名;
对象名.静态变量名；
若类中含有静态变量，则静态变量必须独立于方法之外。
静态方法
一个方法声明为static有以下几重含义：
非static方法是属于某个对象的方法，在这个对象创建时，对象的方法在内存中拥有属于自己专用的代码段，而static方法是属于整个类的，它在内存中的代码段被所有对象所共用，而不被任何一个对象所专用
由于静态方法是属于整个类的，所以它不能操纵和处理属于某个对象的成员，只能处理属于整个类的成员，即static方法只能访问static成员变量或调用static成员方法
在静态方法中不能使用this或者super。因为this是代表调用该方法的对象，但现在静态方法不需要对象来调用，this自然也不应存在于静态方法内部
在调用静态方法时可以使用类名直接调用，也可以用某一个具体的对象名来调用。格式如下
类名.静态方法名();
对象名.静态方法名（）；
建议采用类名.静态方法名（）；
定义成员时，到底需不需要被静态修饰呢？
成员分两种：
1，成员变量。（数据共享时静态化）
该成员变量的数据是否是所有对象都一样：
如果是，那么该变量需要被静态修饰，因为是共享的数据。
如果不是，那么就说这是对象的特有数据，要存储到对象中。
2，成员函数。（方法中没有调用特有数据时就定义成静态）
如果判断成员函数是否需要被静态修饰呢？
只要参考，该函数内是否访问了对象中的特有数据：
如果有访问特有数据，那方法不能被静态修饰。
如果没有访问过特有数据，那么这个方法需要被静态修饰。
静态初始化器
静态初始化器是由关键字static修饰的一对大括号括起来的语句组，他的作用与构造方法相似，都是完成初始化工作的，但静态初始化器与构造方法有几点根本的不同
构造方法是对每个新创建的对象初始化，而静态初始化器是对类自身进行初始化。
构造方法是在用new运算符创建新对象时由系统自动执行，而静态初始化器一般不能由程序来调用，它是在所属的类被加载入内存时由系统调用执行的
用new运算符创建多少个新对象，构造方法就被调用多少次，但静态初始化器则在类被加载入内存时只执行一次，与创建多少个对象无关。
不同于构造方法，静态初始化器不是方法，因而没有方法名，返回值和参数
类类型的数组
数组元素可以是存放各种类型的数据，当然也可以用来存放对象。用数组来存放对象，一般要经过如下的两个步骤
声明类类型的数组变量，并用new运算符分配内存空间给数组。
用new创建新的对象，分配内存空间给它，并让数组元素指向它
以对象数组为参数进行方法调用
数组可以存放对象，因此也可将对象数组作为参数传递到方法中
public static 返回值 方法名（类名[ ] 数组名）
字符串
String类型
格式
String 变量名=new String(“字符串”)；
在对字符串赋值时，可以进行字符串的加操作
字符串的特点，字符串在创建后不可被更改
虽然String的值是不可变的但是他们可以被共享
字符串效果上相当于字符数组（char[ ]）但是底层相当于字节数组(byte[ ])
API
应用程序编程接口
String构造方法
public String()创建一个空白字符串对象，不含有任何内容
public String(char[ ] chs)根据字符数组的内容，来创建一个字符串对象
public String（byte[ ] byt)根据一个字节数组的内容，来创建一个字符串对象
String a="abc"直接赋值的方式创建字符串对象，内容就是abc
推荐使用直接赋值的方式得到字符串
String对象的特点
1.通过new创建的字符串对象，每一次new的时候都会申请一个内存空间，只不过虽然内容相同，但是地址值不同
char[] chs={‘a’,‘b’.‘c’};
String s1=new String(chs);
String s2=new String(chs);
上面的代码中，JVM会先创建一个字符数组，然后每一次new的时候都会有一个新的地址，只不过s1,s2参考的字符串内容是相同的
以直接赋值的形式创建的字符串对象，只要字符序列相同（顺序和大小写），无论在代码中出现几次，JVM都只会建立一个对象，并在字符串池中维护
String s3=“abc”;
String s4=“abc”;
在上述代码中，JVM会建立一个String对象放在字符串池中，给s3参考，而第二行代码中直接让s4参考字符串池中的String对象，也就是说他们本质上是同一个对象。
字符串的比较
使用==作比较
如果是基本类型的则比较他们的数据值是否相同
如果是引用类型的则比较他们的地址值是否相同
字符串是对象，他比较内容是否相同是通过一个方法来实现的，这个方法叫equals()
public boolean equals(Objact anObject)
将此字符串与指定对象进行比较。由于我们比较的是字符串对象，所以参数直接传一个字符串。
遍历字符串
获取字符串中的每一个字符
public char charAt(int index)
返回索引处的char值，字符索引也是从零开始的
获取字符串的长度
public int length()
字符串遍历实例
在判断字符类型时可以使用范围判断
大写字母为 a>=‘A’&&a<=‘Z’
小写字母为 a>=‘a’&&a<=‘z’
数字为 a>=‘0’&&a<=‘9’
StringBuilder
StringBuilder概述
平常进行字符串拼接操作时的内存图
由上图我们可以发现每次在进行字符串拼接操作时，每次拼接都会创造一个新的String对象。即耗时，又浪费内存空间。而这种操作还不可避免。那么有没有一种比较好的方式来解决这个问题呢？我们可以通过Java提供的StringBuilder类来解决这个问题
StringBuilder是一个可变的字符串类，我们可以把他看作是一个容器
这里的可变指的是StringBuilder的内容是可变的，而StringBuilder在做字符串拼接时是不会创建新对象的
String和StringBuilder的区别
String内容是不可变的
而StringBuilder内容是可变的
StringBuilder构造方法
public StringBuilder（）创建一个空白可变字符串对象，不含有任何内容
public StringBuilder（String str）根据字符串内容，来创建一个可变字符串对象
StringBuilder的添加和反转方法
public StringBuilder append(任何类型) 添加数据并返回对象本身
public StringBuilder reverse() 返回相反的字符序列
并且append()方法可以链式编程
（在链式编程中，s1.append(“abc”)相当于一个对象）
正常
StringBuilder和String的相互转换
StringBuilder转换为String
public String toString（）
通过toString（）可以实现StringBuilder到String的转换
String转换为StringBuilder
通过构造方法实现String转换为StringBuilder
继承，抽象类和接口
类的继承
通过继承可以提高代码的复用。
被继承的类称为父类或超类，由继承而得到的类称为子类
子类的创建
类的继承是通过extends关键字实现的，在定义类时若使用extends关键字指出新定义类的父类，就是在两个类之间建立了继承的关系。新定义的类成为子类，可以从父类那里继承所有非private成员作为自己的成员
格式
class SubClass extends SuperClass{
…
}
把SubClass声明为SuperClass的直接子类，如果SuperClass又是某个类的子类，则SubClass也是该类的间接子类。
如果没有extends关键字，则默认该类为java.lang.Object类的子类。因此Java语言的所有类都是通过直接或间接继承java.lang.Object类得到的。
子类的每个对象也是其父类的对象，这是继承性的“即是”性质，也就是说sub即是Super，反之则不然。
子类的构建方法
在Java语言的继承中，在执行子类的构造方法之前，会先调用父类中的无参构造方法，目的是帮助继承自父类的成员做初始化操作。
通过extends关键字可将父类的成员继承给子类。利用子类所产生的子类，调用从父类继承而来的方法
严格来说构造方法是不能被继承的，但不意味着子类不能调用父类的构造方法
调用父类中特定的构造方法
若要调用父类中某个特定的构造方法，可以在子类中通过super（）来调用，如果没有这个语句则父类中的无参构造方法还是会被调用
super（）语句必须写在子类构造方法的第一行
在子类中访问父类的构造方法格式为super（参数），super（）也可以重载，也就是说super（）会通过参数的个数与类型，执行父类的相应的构造方法。
如果父类中只有有参构造方法且子类中也无super（）语句，则编译时将发生错误。解决方法是在父类中加上一个不做事且没有参数的构造方法public Person(){ }
super()与this()功能相似，但是super()是从子类的构造方法来调用父类的构造方法，this()是在同一类中调用其它构造方法。当构造方法有重载时，super和this均会根据所给出的参数类型与个数，正确执行相对应的构造方法
由于super与this均必须放在构造方法的第一行，因此super与this无法同时存在于同一个构造方法之内
与this关键字一样，super指的也是对象，所以super不能在static环境中使用。
在子类中访问父类的成员
在子类中使用super不仅能访问父类的构造方法，还可以访问父类的成员，但是super不能访问在子类中添加的成员
格式
super.变量名；
super.方法名；
由于子类中不能继承父类中的private成员，但是如果将父类中的成员声明为protected的，则该成员不仅可以在父类中直接访问，也可以在子类中访问。
而其在子类中访问父类被protected修饰的成员时，可以使用super关键字调用，也可以直接调用
用protected修饰的成员可以被三种类所引用：该类自身，与它同在一个包中的其他类，以及该类的子类
覆盖
覆盖与重载相似，重载是在一个类中定义多个方法名相同，参数类型或个数不同的方法，而覆盖则是在子类中定义与父类方法名，参数个数与类型都完全相同的方法，用于实现重写父类中同名方法的功能
覆盖父类的方法
在子类中覆盖父类的方法应保持与父类方法完全相同的方法名，返回值类型与参数列表。如果子类定义的方法满足这些条件则无法构成继承，而是构成覆盖
注：子类中不能覆盖声明为final和static的方法
在子类覆盖父类的方法时，可以扩大方法的权限但不可缩小方法的权限，例如若父类中方法为protected，则子类中的覆盖方法可以写为public，但不能写为private。
通过父类的对象访问子类的成员
事实上，可以通过父类的对象来调用子类的成员
具体格式如下
需要注意的是，利用父类对象调用子类成员时，该成员方法必须是构成覆盖的方法，否则不能利用父类对象调用子类成员
创建父类类型的变量指向子类的对象，即将子类对象赋值给父类类型的变量，这种技术被称为“向上转型”
“向下转型”就是指将父类通过强制转换为子类后再赋值给子类对象。向下转型就是将抽象的类转换为较具体的类。当使用向下转型时，必须使用显式（强制）类型转换。
父类 super=new 子类;
子类 sub=(子类) super;
不可被继承的成员与最终类
在默认的情况下，父类所有的成员都可以被子类所覆盖，如果父类成员不希望被覆盖可以声明为final。如果final用来修饰成员变量说明该变量为最终变量，即常量，程序中的其他部分可以访问但不能修改。同理，final修饰成员方法则说明该方法为最终方法，不能再被覆盖。对于一些比较重要且不希望被子类重写的方法可以使用final修饰。
同理，如果一个类被final所修饰则说明这个类不能再被其他类所继承，即该类不可能有子类，这种类被称为最终类。
被private修饰的方法不能被子类所继承，也不能被覆盖，所以它自然是最终方法。
定义在类中的final成员变量和定义在方法中的final局部变量都是只读量，他们能且只能被赋值一次。
一个成员变量若被static final两个修饰符所限定时，它实际的含义就是常量，所以在程序中通常用这两个一起指定一个常量，且这样的常量只能在定义时被赋值。
在定义一个成员变量时，若只用final修饰而不用static修饰，则必须且只能赋值一次，不能缺省。赋值时可以在定义时赋值也可在构造方法中赋值。
Object类
在Java语言中有一个特殊类Object，该类是Java.lang类库中的一个类，所有的类都是直接或者间接的继承该类而得到的。所以说Object类是所有类的源。
Object类的常用方法
1.equals（）方法
字符串可以使用使用==作比较
如果是基本类型的则比较他们的数据值是否相同
如果是引用类型的则比较他们的地址值是否相同
字符串是对象，他比较内容是否相同是通过一个方法来实现的，这个方法叫equals()
public boolean equals(Objact anObject)
将此字符串与指定对象进行比较。由于我们比较的是字符串对象，所以参数直接传一个字符串。
2.toString（）方法
public String toString（）
将调用该方法的对象转换成字符串，并返回其内容。
因为默认toString()方法是以下内容，所以直接使用toString返回的是一些没有意义的字符串。
因此如果要用toString（）方法返回对象的内容，可以重新定义该方法以覆盖父类中的同名方法以满足需要。
3.getClass（）方法
返回运行时的对象所属的类。
getClass（）方法的返回值是Class类型的
4.对象运算符instanceof
利用instanceof来测试一个指定对象是否是指定类或它的子类的实例（对象），若是则返回true，否则返回false。
Class类中的getName()方法返回一个类的名称，返回值是String类型 。
通过调用 Object类中的getClass（）方法，得到当前对象所在的类，再调用Class中的getName()方法得到对象的类名字符串.获得父类名同理，为getSuperClass().
抽象类
在Java语言中可以创建一个专门的类来作为父类，这种类被称为抽象类。抽象类类似于模板，其目的是根据它的格式来创建和修改新的类。
但是并不能直接由抽象类创建对象，只能通过抽象类派生出新的子类，再由其子类创建对象。
抽象类与抽象方法
抽象类是以修饰符abstract修饰的类，定义抽象类的语法格式如下：
abstract class 类名{
}
在抽象类中的方法分为两种，一种是之前的一般的方法，另一种是“抽象方法”，它以abstract关键字开头，且没有方法体，抽象方法只需声 明而不需实现。
abstract 返回值的数据类型 方法名（参数）；
当一个方法被声明为抽象的时，则该方法必须被子类所覆盖，或者抽象类的子类也声明为抽象的。
由于抽象方法需要被覆盖，所以抽象方法中static，final，private，native和abstract不能同时使用。
接口
接口与抽象类的不同
接口的成员都是静态的且必须初始化
接口中的方法必须要全都声明为abstract的，也就是说接口中中必须全都是抽象方法
接口的定义
[public] interface 接口名称 [extends 父类接口名列表]
{
[public][static][final] 数据类型 成员变量名=常量；
[public][abstract] 返回值的参数类型 方法名（参数表）；
}
若省略数据类型前的修饰符则默认为public static final 的
若省略成员方法前的修饰符，系统仍默认为是public abstract的
接口的实现与引用
由于接口类似于抽象类，所以要利用接口的特性来创造一个新的类
接口的实现类似于继承，用关键字implements来实现接口
接口实现的语法格式为
class 类名称 implements 接口名表{
}
一个类实现接口是应注意的问题
接口的继承
接口的继承可以继承多个父接口，使用extends关键字父类接口名称使用逗号隔开
利用接口实现类的多类继承
一个类只能有一个父类，但却能实现多个接口，将接口理解为特殊的抽象类即实现了多类继承。
在实现多个接口时也是利用implements关键字，接口名用逗号隔开。
内部类与匿名内部类
内部类是在类中定义的类，内部类不能与外部类同名
内部类可以在外部类外被调用，前提是内部类被声明为public的
匿名内部类
利用内部类创建没有名称的对象，他没有名字，直接用其父类的名字或者是接口的名字。他没有修饰符，也不能定义构造方法。匿名内部类的用意是为了补充内部类中没有声明到的方法。其格式如下
（
new类名（）
{
方法名（参数)
{
方法体
}
}
）.方法名（参数）
异常
集合基础
集合概述
编程时如果要存储多个数据，使用长度固定的数组存储格式，可能满足不了我们的需求，更适应不了变化的需求这时就需要运用到集合
集合类的特点：提供一种存储空间可变的存储模型，存储的数据容量可以发生改变
集合类有很多，目前只说ArrayList
ArrayList在JAVA.util的包下所以在使用时需要导包
ArrayList:
可调整大小的数组的实现
是一种特殊的数据类型，泛型
如何使用
在出现E的地方用引用数据类型替换即可
例如ArrayList,ArrayList
ArrayList构造方法和添加方法
public ArrayList()创建一个空的集合对象
E(集合中元素的类型)
public boolean add(E,e) 将指定元素追加到集合的末尾,返回添加是否成功
public void add(int index,E element) 在指定位置插入指定元素 ，前者为索引位置，后者为要添加的元素。
ArrayList集合常用方法
public boolean remove(Object o)删除指定的元素，返回删除是否成功
public E remove(int index)删除指定索引处的元素，返回被删除的元素
public E set(int index，element E)修改指定索引处的元素并返回被修改的元素
public E get(int index)返回指定索引处的元素
public int size()返回集合中元素的个数
1253
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
