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

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

文章目录

  • Java——一套实用的庞大类库
    • 8.进阶模块
      • (1).```final关键字```:
      • (2).包装与导包:
      • (3).抽象类和接口:
      • (4).访问控制权限:
      • (5).数组:
    • 9.java.lang.String
      • (1).概述:
      • (2).构造方法:
      • (3).方法:
        • <1>public char charAt(int index);
        • <2>public int compareTo(String anotherString);
        • <3>public boolean contains(CharSequence s);
        • <4>public boolean endsWith(String suffix);
        • <5>public boolean startsWith(String prefix);
        • <6>public boolean equalsIgnoreCase(String anotherString);
        • <7>public int indexOf(String str);
        • <8>public byte[] getBytes();
        • <9>public boolean isEmpty();
        • <10>public int lastIndexOf(String str);
        • <11>public String replace(String target,String replacement);
        • <12>public String substring(int beginIndex);
        • <13>public String substring(int beginIndex,int endIndex);
        • <14>public char[] toCharArray();
        • <15>.public String toLowerCase();
        • <16>public String toUpperCase();
        • <17>public static String valueOf(String str);
    • 10.java.lang.[StringBuilder]&[StringBuffer]
      • (1)简介:
      • (2)构造方法:
      • (3)拼接方法:
      • (4)性能优化与对比
    • 11.包装类(java.lang.(包装类))
      • (1).八种包装类的简介:
      • (2).装箱与拆箱:
      • (3).获取数据类型的极限值:
      • (4).IndexOutOfBoundsException:
      • (5).包装类的优点:
      • (6).int,String,Integer三者转换:
    • 12.日期类
      • (1).java.util.Date:
      • (2).java.text.SimpleDateFormat:
        • System类功能拓展:
    • 13.数字类
      • (1).java.text.DecimalFormat:
      • (2).java.math.BigDecimal:
    • 14.随机数类
    • 15.枚举
    • 16.异常
      • (1).概述:
      • (2).异常的处理:
      • (3).异常对象的相关方法:
      • (4).finally语句:
    • 17.Object类
      • (1).toString()方法:
      • (2).equals()方法:
      • (3).hashCode()方法:

集成开发工具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。

控制权限详解:
JavaSE_知识点(中)(常用类)_第1张图片

(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()方法:

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

你可能感兴趣的