JavaSE_知识点(中)（常用类）

Java——一套实用的庞大类库

集成开发工具IDEA层次划分：
工程（Project）----->模块（Module）。

8.进阶模块

（1）.final关键字：

①理解：final在英文中本意为最终的，不可变的，可便于理解为final修饰的东西无法修改；
②用法：
<1>.final修饰的类无法继承；
<2>.final修饰的方法无法被覆盖；
<3>.final修饰的变量仅能赋一次值；
final修饰的引用仅能指向一个对象，并且无法指向其他对象，但对象中的数值可被改变；final修饰的实例变量必须手动赋值；
③常量：无法被改变；
常量常常使用“static final”修饰，且全部大写，单词间使用下划线分隔。
例如：public static final double PI = 3.1415926;

（2）.包装与导包：

package关键字:

①定义：java中的“包”机制，方便程序的管理；
②语法：package+包名;
常常允许出现在java源代码的第一行；
③定义规范：公司域名倒序+项目名+模块名+功能名；
④编译与运行：
<1>编译：javac -d.(被编译的java文件名.java);
"-d"代表带包编译，“.”代表当前目录；
<2>运行：java (命名规范);

import关键字：

①定义：导包关键字；
②使用情况：
<1>A类中使用B，A与B不在一个包，使用import；
<2>A类中使用B，A与B在一个包，不使用import；
<3>在java.lang.*包下无需导包import。
③用法：
<1>import只能出现在package下面，类的声明上面；
<2>import (命名规范);

（3）.抽象类和接口:

抽象类（Abstract class）:

①概述：
<1>类和类之间存在共同特征，将共同特征提取出来，形成抽象类；
<2>抽象类属于引用数据类型；
<3>抽象类无法实例化，用于被子类继承；
<4>final和abstract对立，不可联合使用；
<5>抽象类的子类也是抽象类，存在构造方法，供子类使用；
②语法规则：
[修饰符列表] abstract class 类名{…}

抽象方法（Abstract method）：

①概述：
<1>抽象方法没有方法体，例如：public abstract void dosome();
<2>抽象类不一定有抽象方法，但抽象方法必须出现在抽象类中；
<3>非抽象类继承抽象类时，必须实现其中的抽象方法，或者将非抽象类改为抽象类。
②语法：
[修饰符列表] abstract 返回值类型 方法名();

接口（interface）：

①概述：
<1>接口是一种引用数据类型，是完全抽象的；
<2>接口支持多继承，一个接口可继承多个多个接口；
<3>接口中仅包含两部分内容：
a.常量，例如：public static final int PI;
b.抽象方法，例如：public abstract void xx();
<4>接口都是公开的（public），接口中的public abstract可以省略；
<5>接口中的常量修饰部分public static abstract可省略；
②语法：
[修饰符列表] interface 接口名{…}

接口与抽象类：

①类与类之间的继承关系在类与接口中叫作“实现(implements)”;
②继承使用extends关键字，实现使用implements关键字；
③当一个非抽象类实现接口时，必须将接口中的所有抽象方法实现；
④接口与接口之间支持多继承，一个类可实现多个接口；
⑤当implements和extends同时存在时，先写extends;
⑥抽象类和接口的区别：
<1>抽象类是半抽象的，而接口完全抽象；
<2>抽象类有构造方法，接口无构造方法；
<3>接口与接口间支持多继承，类与类中仅能继承一个类；
<4>一个类可同时实现多个接口，而只能继承一个类；

（4）.访问控制权限：

①相关关键字：public,protected,默认,private。
②控制范围比较：public>protected>默认>private。

控制权限详解：

（5）.数组：

数组概述：

①引用数据类型，其父类是Object，被存在堆内存中；
②可储存“基本数据类型”，也可储存“引用数据类型”；
③若数组中存的是Java对象，应存的其内存地址；
④数组一经创建，其长度不可变且自带Length属性；
⑤所储存的数据必须类型统一；
⑥数组在内存方面存储，其中的内存地址与第一个元素内存地址相同，且连续；
⑦下标从“0”开始，到Length-1结束；
⑧优缺点：
<1>优点：
检索效率高，通过数学表达式可计算某个下标的内存地址，从而定位元素；
<2>缺点：
a.在数组上随机增删元素时，效率较低；
b.很难在内存空间上找到一块特别大的连续的内存空间；

一维数组：

①语法：
<1>静态初始化：
数据类型[] 变量名 = {,,,};
数据类型 变量名[] = {,,,};
<2>动态初始化：
数据类型[] 变量名 = new 数据类型[数组长度];
②数组的扩容：
新建（大容量） —> 拷贝 ----> 删除旧的数组；
③数组的拷贝：
调用System类中的arraycopy方法：
**System.arraycopy(源变量，源起点，目标变量，目标起点，长度);

二维数组：

①语法：
<1>静态初始化：
数据类型[][] 变量名 = {{…},{…},…};
<2>动态初始化：
数据类型[][] 变量名 = new 数据类型[数组长度][数组长度];
<3>元素访问：
变量名 [下标][下标];
②二维数组是特殊的一维数组，其中每个元素都是一个一维数组。

数组工具类Arrays：（java.util.Arrays）

①static sort(数据类型[] xx);
用于给数组中元素排序。
②static binarySearch(数组名 xx,数据类型 xx);
用于查找数组中的某个元素。

9.java.lang.String

(1).概述：

Ⅰ.JDK中凡是双引号括起来的字符串存储在方法区的字符串常量池中。
Ⅱ.new String(参数列表)将在堆中创建字符串对象。
Ⅲ.String类型的变量保存的是字符串常量池中的内存地址而非数据。

(2).构造方法：

//一个参数的构造方法
new String(byte[] bytes);
//三个参数的构造方法
/*
*@param bytes byte类型的数组
*@param offset 起始下标(从0开始)
*@param length 选取长度
*/
new String(byte[] bytes,int offset,int length);
/*char同理*/

(3).方法：

<1>public char charAt(int index);

使用案例：

		String string = "中国人";
        char str1 = string.charAt(1);
        System.out.println(str1);//str1 = "国"

<2>public int compareTo(String anotherString);

使用案例：

	/*
	*对比前后字符串大小。
	*@param anotherString 需要对比的字符串
	*@return result:
	*				>0  前大后小
	*				=0  两值相等
	*				<0	前小后大
	*/
		String num1 = "5";
        String num2 = "6";
        int result = num1.compareTo(num2);
        System.out.println(result);//result = -1

<3>public boolean contains(CharSequence s);

源码解析：

/*
*判断前字符串是否包含后字符串
*/
public boolean contains(CharSequence s) {
        return indexOf(s.toString()) >= 0;
    }

<4>public boolean endsWith(String suffix);

源码解析：

/*
*判断前字符串是否以suffix结尾
*/
public boolean endsWith(String suffix) {
        return startsWith(suffix, length() - suffix.length());
    }

<5>public boolean startsWith(String prefix);

/*
*判断某字符串是否以prefix开始
*/

<6>public boolean equalsIgnoreCase(String anotherString);

/*
*判断两字符串是否相等，忽略大小写
*/

<7>public int indexOf(String str);

/*
*@return 返回str在当前字符串中第一次出现的下标
*/

<8>public byte[] getBytes();

/*
*将字符串对象转换为byte[]数组
*/

<9>public boolean isEmpty();

源码解析：

/*
*判断该字符串是否为空
*/
public boolean isEmpty() {
        return value.length == 0;
    }

<10>public int lastIndexOf(String str);

/*
*@return 返回str在当前字符串中最后一次出现的下标
*/

<11>public String replace(String target,String replacement);

/*
*使用replacement替换原来的target部分
*@return 返回新的字符串
*/

<12>public String substring(int beginIndex);

/*
*截取字符串
*@param beginIndex:起始下标
*@return 截取后的字符串
*/

<13>public String substring(int beginIndex,int endIndex);

/*
*截取字符串
*@param beginIndex:起始下标 endIndex:结尾下标 范围：[begin,end)
*@return 返回截取后的字符串
*/

<14>public char[] toCharArray();

/*
*将字符串转换为char[]数组
*/

<15>.public String toLowerCase();

/*
*将字符串转为小写
*/

<16>public String toUpperCase();

/*
*将字符串转换为大写
*/

<17>public static String valueOf(String str);

/*
*将非字符串转换为字符串
*/

10.java.lang.[StringBuilder]&[StringBuffer]

(1)简介：

用于字符串的拼接

(2)构造方法：

new StringBuffer();
new StringBuffer(int capacity);//手动设置容量

StringBuffer底层创建一个容量为16的byte[]数组，可自动扩容。

(3)拼接方法：

StringBuffer buffer = new StringBuffer(16);
buffer.append("中");
buffer.append("国");
buffer.append("人");
System.out.println(buffer);

(4)性能优化与对比

优化StringBuffer性能：

Ⅰ.在创建对象时可给定一个初始化容量；
Ⅱ.最好减少数组的扩容次数，给预估的初始化容量。

对比StringBuilder和StringBuffer：

Ⅰ.方法，构造方法均类似;
Ⅱ.本质区别是
StringBuffer是线程安全的；
StringBuilder是线程不安全的；

对比String和StringBuffer：

Ⅰ.StringBuffer对象的内容可以修改,而String对象一旦产生后就不可以被修改;
Ⅱ.StringBuffer的内部实现方式和String不同，StringBuffer在进行字符串处理时，不生成新的对象，在内存使用上要优于String类。所以在实际使用时，如果经常需要对一个字符串进行修改，例如插入、删除等操作，使用StringBuffer要更加适合一些。
Ⅲ.String:在String类中没有用来改变已有字符串中的某个字符的方法，由于不能改变一个java字符串中的某个单独字符，所以在JDK文档中称String类的对象是不可改变的。然而，不可改变的字符串具有一个很大的优点:编译器可以把字符串设为共享的(方法区中的【字符串常量池】)。

11.包装类（java.lang.(包装类)）

(1).八种包装类的简介：

    基本数据类型    父类(均在java.lang包)    包装类型
            byte           java.lang.Byte                   Byte

            short          java.lang.Short                 Short

            int              java.lang.Integer               Integer

            long           java.lang.Long                  Long

            float           java.lang.Float                  Float

            double       java.lang.Double              Double

            boolean     java.lang.Boolean            Boolean

            char           java.lang.Character         Character

(2).装箱与拆箱：

装箱：利用包装类将“基本数据类型”转为“引用数据类型”
利用Integer的构造方法：

//将int类型包装为Integer类型(已过时)
Integer i = new Integer(int value);

//将String类型包装为Integer类型(已过时)
Integer i = new Integer(String str);

//使用Integer的静态方法valueOf()(主流方法)
int inti = Integer.valueOf(int value);

拆箱：利用一些方法将“引用数据类型”转为“基本数据类型”
利用包装类自带的((数据类型)+Value())方法

Integer i = new Integer(123);
int inti = i.intValue();

(3).获取数据类型的极限值：

//获取int类型的极限值
int max_Int = Integer.MAX_VALUE;//max_Int=2^31-1
int min_Int = Integer.MIN_VALUE;//min_Int=-2^31
int min_byte = Byte.MIN_VALUE;//min_byte=-2^7
int min_short = Short.MIN_VALUE;//min_short=-2^15

(4).IndexOutOfBoundsException：

简介：
数字格式化异常。
案例：

Integer x = new Integer("中文");

(5).包装类的优点：

由于包装类是高级数据类型，合理利用包装类可有效预防NullPointerException。

(6).int,String,Integer三者转换：

int inti = 123;
Integer i = 123;
String stri = "123";

//int--->Integer(装箱)
(Integer) i = Integer.valueOf(inti);
//Integer--->int(拆箱)
(int) inti = i.intValue();
//int--->String
(String) stri = String.valueOf(inti);
(String) stri = inti+" ";
//String--->int
(int) inti = parseInt(stri);
//String--->Integer
(Integer) i = Integer.valueOf(stri);
//Integer--->String
(String) stri = String.valueOf(i);

12.日期类

(1).java.util.Date:

构造方法：

//输出当前时间
Date date = new Date();
System.out.println(date.toString);

(2).java.text.SimpleDateFormat:

作用：
专门负责日期的格式化；
构造方法：

//有参构造
/*
*@param pattern 输出日期的格式
比如：标准格式 "yyyy-MM-dd HH:mm:ss:SSS"
*/
public SimpleDateFormat(String pattern);

方法：
a.调用该类中的format(Date)方法可输出修改后格式的时间；
b.调用System类中的currentTimeMills()方法可知道从【1970-1-1 00:00:00】到现在的时间毫秒数。

//以指定格式输出当前时间：
Date date = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS");
String currentTime = sdf.format(date);
System.out.println(currentTime);

System类功能拓展：

Ⅰ.System.out //输出函数包
Ⅱ.System.gc() //启动垃圾回收机制
Ⅲ.System.currentTimeMills() //获取从1970-1-1 00:00:00到当前的毫秒数
Ⅳ.System.exit(0) //退出JVM

13.数字类

数字格式的介绍：

#:任意数字
,:千分位
.:小数点
0:位数不够时补零

(1).java.text.DecimalFormat：

作用：专门负责数字的格式化。
构造方法：

/*
*param pattern:输出数字的格式
*例如：标准格式：#,###.##
*/
new DecimalFormat(String pattern);

方法：

//输出更改格式后的数字
DecimalFormat df = new DecimalFormat("#,###.##");
String format = df.format(Integer.MAX_VALUE);
System.out.println(format);

(2).java.math.BigDecimal:

简介：属于引用数据类型，称为“大数据”。
构造方法：

/*
*@param var:需要在大数据中存入的变量
*形参处存在字符，字符串，浮点型，数组等等。
*/
new BigDecimal(int var);

方法：

BigDecimal bd1 = new BigDecimal(-123);
BigDecimal bd2 = new BigDecimal(456);
//求和函数
BigDecimal addResult = bd1.add(bd2);//addResult=333
//绝对值函数
BigDecimal absResult = bd1.abs();//absResult=123
//求差函数
BigDecimal subResult = bd1.subtract(bd2);//subResult=-579

14.随机数类

作用：生成一定范围的随机数。
构造方法：

new Random();

方法：

Random r = new Random();
//生成int范围内的随机数
int numble = r.nextInt();
//生成指定范围内的随机数[0,bound)
int numble = r.nextInt(int bound);

15.枚举

作用：一种引用数据类型，结果超过两种可用一枚一枚列举出的结果。
语法规则：

//季节枚举
enum Season{
	SPRING,SUMMER,AUTUMN,WINTER
}

16.异常

(1).概述：

Ⅰ.异常时程序执行过程中的不正常情况；
Ⅱ.其作用是增强程序的健壮性；
Ⅲ.异常在java中以类的形式存在，每个异常类都可以实例化对象；
Ⅳ.编译时异常(受检异常)和运行时异常(未受检异常)都发生在运行阶段。

(2).异常的处理：

Ⅰ.方法声明位置上，使用throws关键字抛出异常（谁调用方法抛给谁）；
Ⅱ.使用try…catch语句进行异常捕捉；
Ⅲ.throw手动抛出异常；
Ⅳ.只要异常没有被捕捉，那么采用throws方法时，后续代码不会执行；
Ⅴ.try…catch捕捉后，后续代码可以执行。

(3).异常对象的相关方法：

构造方法：

//无参构造
new Exception();
//有参构造
/*
*@param message:添加打印异常描述信息
*/
new Exception(String message);

方法：

Exception exception = new Exception();
//获取异常简单描述信息
String massage = exception.getMassage();
//打印异常的堆栈信息
exception.printStackTrace();

(4).finally语句：

概述：

Ⅰ.在finally子句中的代码最后执行且一定会执行；
Ⅱ.finally子句必须和try…catch一起出现；
Ⅲ.finally子句也可和try…语句一起使用，try语块中的return最后执行；
Ⅳ.可用于关闭IO流和jdbc；

final,finally,finalize的区别：

a.final用于修饰变量，方法和类，表示不可变；
b.finalize是Object中的一个方法名；
c.finally用于处理异常。

17.Object类

(1).toString()方法：

Ⅰ.默认实现：类名+@(对象的内存地址16进制形式)；
Ⅱ.作用：将一个java对象转换为字符串形式；
Ⅲ.为了得到简介，详实的输出结果，需重写toString()方法。

(2).equals()方法：

Ⅰ.作用：使用该方法判断两个对象是否相等；
Ⅱ.“==”对于对象来说比较对象的内存地址而非对象内容；
Ⅲ.“equals()”中存在着Ⅱ中的比较方式；
Ⅳ.调用equals()方法时需重写该方法，比较内容而并非其内存地址；
Ⅴ.String类中已重写了equals和toString方法，可在String中直接使用。

(3).hashCode()方法：

作用：得到对象的哈希值。