WPCのBLOG

in heart

0%

Java 语言基础

Posted on Edited on Valine:

UML 类图

抽象类用斜体表示

+：表示 public

#：表示 protected

-：表示 private

_：表示 static

虚线：指向接口

实心菱形：组合

空心菱形：聚集

*：无限多个对象

m..n：m 到 n 个对象

java.lang.Object

+toString(): String 显示类名@十六进制数表示的内存地址

+equals(o: Object): boolean 比较两个对象是否相等

== 检测两个引用变量是否指向同一个对象

浅复制：protected native Object clone() throws CloneNotSupportedException

java.util

+Data()
+Data(elapseTime: long)
+toString(): String
+getTime(): long
+setTime(elapseTime: long): void		 用当前时间创建 Date 对象
用毫秒数创建 Date 对象
返回 Date 的字符串表示
返回毫秒数
重新设置毫秒数
+Random()
+Random(seed: long)
+nextInt(): int
+nextInt(n: int): int
+nextLong(n: long): long
+nextFloat: float
+nextDouble(): double
+nextBoolean(): Boolean		 用当前时间为种子创建 Random 对象
用 seed 为种子创建 Random 对象
返回随机 int 值
返回[0,n)中随机 int 值
返回随机 long 值
返回[0.0,1.0)中随机 float 值
返回[0.0,1.0)中随机 double 值
返回随机 boolean 值

若要更加安全，可以用 java.security.SecureRandom 类产生随机数字。

数值包装

-value: int
+MAX_VALUE: int
+MIN_VALUE: int		 -value: double
+MAX_VALUE: double
+MIN_VALUE: double
+Integer(value: int)
+Integer(s: String)
+byteValue(): byte
+shortValue(): short
+intValue(): int
+longValue(): long
+floatValue(): float
+doubleValue(): double
+compareTo(o: Integer): int
+toString(): String
+valueOf(s: String): Integer
+valueOf(s: String, radix: int): Integer
+parseInt(s: String): int
+parseInt(s: String, radix: int): int		 +Double(value: doubel)
+Double(s: String)
+byteValue(): byte
+shortValue(): short
+intValue(): int
+longValue(): long
+floatValue(): float
+doubleValue(): double
+compareTo(o: Double): int
+toString(): String
+valueOf(s: String): Double
+valueOf(s: String, radix: int): Double
+parseDouble(s: String): double
+parseDouble(s: String, radix: int): double

表示大数可以用 BigInteger 和 BigDecimal 类，BigDecimal 中有 divide(BigDecimal d, int scale, int roundingMode), add, subtract, multiple, remainder 算术运算函数，scale 指小数点后最小的整数位数，roundingMode 表示舍入方式， BigDecimal.ROUND_UP 表示向上舍入。

字符串

替换和拆分

+replace(oldChar: char, newChar: char): String
+replaceFirst(oldString: String, newString: String): String
+replaceAll(oldString: String, newString: String): String
+split(delimiter: String): String[]
+matches(s: String): boolean		 替换所有匹配字符，返回新字符串
替换第一个匹配的子字符串，返回新字符串
替换所有匹配的子字符串，返回新字符串
返回被分隔符拆分的子字符串数组
返回是否匹配，可以用正则表达式

转换为字符串

+valueOf(c: char): String
+valueOf(data: char[]): String
+valueOf(d: double): String
+valueOf(f: float): String
+valueOf(i: int): String
+valueOf(l: long): String
+valueOf(b: boolean): String
+format(format, item, item…): String

字符串构建器

+StringBuilder()
+StringBuilder(capacity: int)
+StringBuilder(s: String)
+append(data: char[]): StringBuilder
+append(data: char[], offset: int, len: int): StringBuilder
+append(v: aPrimitiveType): StringBuilder
+append(s: String): StringBuilder
+delete(startIndex: int, endIndex: int): StringBuilder
+deleteCharAt(index: int): StringBuilder
+insert(index: int, data: char[], offset: int, len: int): StringBuilder
+insert(offset: int, data: char[]): StringBuilder
+insert(offset: int, b: aPrimitiveType: StringBuilder
+insert(offset: int, s: String): StringBuilder
+replace(startIndex: int, endIndex: int, s: String): StringBuilder
+reverse(): StringBuilder
+setChatAt(index: int, ch: char): void		 构建容量为16的空字符串构建器
构建指定容量的字符串构建器
构建指定字符串的字符串构建器
追加一个字符数组到对象
追加 data 的子数组到对象
追加一个基本类型值到对象
追加字符串到对象
删除从 startIndex 到 endIndex-1 的字符
删除给定下标的字符
在给定下标插入 data 的子数组
在给定下标插入data 数组
在给定下标插入基本类型值
在给定下标插入字符串
替换从 startIndex 到 endIndex-1 的字符
倒置构建器的字符
将指定下标的字符替换

StringBuffer 类与 StringBuilder 相似，不过多了一个缓存区，便于多任务并发访问。

+toString(): String
+capacity(): int
+charAt(index: int): char
+length(): int
+setLength(newLength: int): void
+substring(startIndex: int): String
+substring(startIndex: int, endIndex: int): Stromg
+trimToSize(): void		 返回字符串
返回构建器容量
返回指定下标的字符
返回构建器中字符数
设置构建器新长度，如果太小则减小到刚好
返回从 startIndex 开始的子字符串
返回从 startIndex 到 endIndex-1 的子字符串
减少用于字符串构建器的存储大小
+ArrayList()
+add(e: E): void
+add(index: int, e: E): void
+clear(): void
+contains(o: Object): boolean
+get(index: int): E
+indexOf(o: Object): int
+lastIndex(o: Object): int
+isEmpty(): boolean
+remove(o: Object): boolean
+remove(index: int): E
+size(): int
+set(index: int, e: E): E
+toArray(data: char[]): void		 创建空列表
添加 e 到列表结尾
添加 e 到指定位置
删除列表所有元素
如果列表包含 o，则返回 true
返回列表指定下标的元素
返回列表中第一个匹配元素的下标
返回列表中最后一个匹配元素下标
如果列表是空的，返回 true
去除列表第一个元素
去除列表指定下标元素
返回列表元素个数
设置指定下标的元素
从数组列表创建对象数组

列表方法

java.util.Collections.sort

java.util.Collections.shuffle

Arrays.asList

继承

Java 不允许多重继承类，但可多重继承接口

instanceof 可以查看是否是某一对象的实例

子类不能削弱父类方法的访问权限

构造方法

调用父类构造方法唯一方式是在子类构造方法的第一行用 super 函数，如果不被显式调用就自动调用 super()

方法重写

@Override

重写之后必须有一样的签名，相同的或者兼容的返回值

静态方法可以继承，但是不能重写，如果重新定义就会隐藏父类方法

多态决定使用父类对象的地方都能用子类，父类引用能引用子类

动态绑定决定使用方法是时以实际类型为准

final 可以防止继承和重写

类型转换

转换对象不创建新对象

. 操作符优先于转换符

异常

  • 声明异常

    throws Exception1, Exception2

  • 抛出异常

    throw Exception;

  • 捕获异常

    1
    2
    3
    4
    try{
    }
    catch(Exception1|Exception2){
    }

  • 免检异常

    Erroer 和 RuntimeException

  • finally 子句

    任何情况下，finally{} 语句都会执行，即使前面有 return 语句

+Exception()
+Exception(message: String)
+Exception(message: String, cause: Exception)		 构建一个没有信息的异常类
构建一个给定信息的异常类
构建一个给定信息和子句的异常，形成链式异常
+getMessage(): String
+toString(): String
+printStackTrace(): void
+getStackTrace(): StackTraceElement[]		 返回异常类信息
返回类全名+“+ ”+getMessage
打印对象和它的调用栈的跟踪信息
返回栈跟踪元素的数组

抽象类

  • 用 abstract 声明

  • 抽象方法只有定义没有实现，抽象方法不能是静态的。

  • 抽象类不能用 new 创建实例，但抽象类可以用作数据类型。

  • 有抽象方法的类必须声明为抽象类，但可以定义不含抽象方法的抽象类。

+byteValue(): byte
+shortValue(): short
+intValue(): int
+longValue(): long
+floatValue(): float
+doubleValue(): double
YEAR
MONTH
DATE
HOUR
HOUR_OF_DAY
MINUTE
SECOND
DAY_OF_WEEK
DAY_OF_MONTH
DAY_OF_YEAR
WEEK_OF_MONTH
WEEK_OF_YEAR
AM_PM		 年
月
日
小时（12）
小时（24）
分钟
秒
一周天数，1是星期天
和 DATE 一样
当前年的天数
当前月的星期数
当前年的星期数
表明上午还是下午（0代表上午，1代表下午）
#Calendar()
+get(field: int): int
+set(field: int, value: int): void
+set(year: int, month: int, dayOfMonth: int): void
+getActualMaximum(field: int): int
+add(field: int, amount: int): void
+getTime(): java.util.Date
+setTime(date: java.util.Date): void		 创建一个默认日历
返回日历域的值
将给定的日历设为指定值
使用指定年月日设定日历，月份从0开始
返回日历域最大值
对给定日历域增加或减少指定数量时间
返回代表该日历的 Date 对象
使用给定 Date 对象初始化日历
+GregorianCalendar()
+GregorianCalendar(year: int, month: int, dayOfMonth: int)
+GregorianCalendar(year: int, month: int, dayOfMonth: int, hour: int, minute: int, second: int)

接口

  • @FunctionalInterface 表明这是个函数接口

  • 用 interface 声明

  • 其中数据域都是 public static final，定义时可省略

  • 其中方法都是 public abstract，定义时可省略

  • 方法体空的接口叫标记接口

  • ```java public interface Comparable{ public int compareTo(E 0); } 

    1
    2
    3
    4

    - ```java
      public interface Cloneable{
      }

    -numerator: long
    -denominator: long    		 该有理数的分子
    该有理数的分母
    +Rational()
    +Rational(numerator: long, denominator: long)
    +getNumerator(): long
    +getDenominator(): long
    +add(secondRational: Rational): Rational
    +subtract(secondRational: Rational): Rational
    +multiply(secondRational: Rational): Rational
    +divide(secondRational: Rational): Rational
    +toString(): String
    -gcd(n: long, d: long): long    		 分子0，分母1创建对象
    使用给定分子，分母创建对象
    返回分子
    返回分母
    返回和
    返回差
    返回乘积
    返回商
    返回“分子/分母”，如果分母为1，则返回“分子”
    返回 n 和 d 的最大公约数

文件类

+File(pathname: String)
+File(parent: String, child: String)
+File(parent: File, child: String)
+exists(): boolean
+canRead(): boolean
+canWrite(): boolean
+isDirectory(): boolean
+isFile(): boolean
+isAbsolute(): boolean
+isHidden(): boolean
+getAbsolutePath(): String
+getCanonlicalPath(): String
+getName(): String
+getPath(): String
+getParent(): String
+lastModified(): long
+length(): long
+listFile(): File[]
+delete(): boolean
+renameTo(dest: File): boolean
+mkdir(): boolean
+mkdirs(): boolean		 以一个指定路径创建对象
在 parent 下创建一个子路径的对象
在 parent 下创建一个子路径的对象
检测文件或者目录是否存在
检测文件是否存在且可读
检测文件是否存在且可写
判断对象是否是一个目录
判断对象是否是一个文件
判断对象是否是通过绝对路径创建的
判断文件是否是隐藏的
返回对象代表的绝对路径名
和 getAbsolutePath() 返回相同，不过简化了
返回对象路径名的最后名字
返回完整的路径
返回当前目录或者文件的父目录
返回文件最后修改时间
返回文件的大小，如果是目录或者不存在返回0
返回对象下的所有文件
删除对象代表的文件或目录，成功则返回 true
将对象代表文件或目录改名为 dest 中指定的名字，成功就返回 true
创建对象代表的目录，如果成功返回 true
和 mkdir() 相同，除了会一同创建父目录

文本I/O

try-with-resources 自动关闭资源

1
try(声明和创建资源){使用资源}
+Scanner(source: File)
+Scanner(source: String)
+close()
+hasNext(): boolean
+next(): String
+nextLine(): String
+nextByte(): byte
+nextShort(): short
+nextInt(): int
+nextLong(): long
+nextFloat(): float
+nextDouble(): double
+useDelimiter(pattern: String): Scanner		 以指定文件对象创建 Scanner
以指定文件名创建 Scanner
关闭对象
如果对象中还有数据，则返回 true
从对象中读取下一个标记作为字符串返回
从对象读取一行，以换行结束
从对象中读取下一个标记作为 byte 值返回
从对象中读取下一个标记作为 short 值返回
从对象中读取下一个标记作为 int 值返回
从对象中读取下一个标记作为 long 值返回
从对象中读取下一个标记作为 float 值返回
从对象中读取下一个标记作为 double 值返回
设置对象的分隔符，并返回对象
+PrintWriter(file: File)
+PrintWriter(filename: String)
+Print(s: String): void
+Print(c: char): void
+Print(cArray: char[]): void
+Print(i: int): void
+Print(l: long): void
+Print(f: float): void
+Print(d: double): void
+Print(b: boolean): void
println 方法
printf 方法		 以指定文件对象创建 PrintWriter
以指定文件名创建 PrintWriter
将字符串写入文件
将字符写入文件
将字符数组写入文件
将 int 写入文件
将 long 写入文件
将 float 写入文件
将 double 写入文件
将 boolean 写入文件
和 print 相似，不过多打一个换行符
windows 下是 ，Unix 下是

二进制I/O

二进制 I/O 中的所有方法都声明抛出 java.io.IOException 或其子类

+read(): int
+read(b: byte[]): int
+read(b: byte[], off: int, len: int): int
+close(): void
+skip(n: long): long		 从输入流中读取下一个字节数据，读到最后则返回-1
从输入流中读取 b.length 个字节到数组 b，返回实际读取字节数
从输入流中读取字节并将他们保存在 b 的子数组中
关闭输入流
从输入流中跳过并丢弃 n 字节数据，返回实际跳过的字节数
+write(): int
+write(b: byte[]): int
+write(b: byte[], off: int, len: int): int
+close(): void
+flush(): void		 +FileOutputStream(file: File)
+FileOutputStream(filename: String)
+FileOutputStream(file: File, append: boolean)
+FileOutputStream(filename: String, append: boolean)
若 append 为 true 则数据追加到文件
+readBoolean(): boolean
+readByte(): byte
+readChar(): char
+readShort(): short
+readInt(): int
+readLong(): long
+readFloat(): float
+readDouble(): double
+readLine(): string
+readUTF(): string		 +writeBoolean(b: boolean): void
+writeByte(v: int): void
+writeBytes(s: string): void
+writeChar(c: char): void
+writeChars(s: string): void
+writeShort(v: short): void
+writeInt(): int
+writeLong(v: long): void
+writeFloat(v: float): void
+writeDouble(v: double): void
+writeUTF(s: string): void

writeByees 适用于由 ASCII 码构成的字符串

+RadomAccessFile(file: File, mode: String)
+RadomAccessFile(file: String, mode: String)
+close(): void
+getFilePointer(): long
+length(): long
+read(): int
+read(b: byte[]): int
+read(b: byte[], off: int, len: int): int
+seek(pos: long): void
+setLength(newLongeh: long): void
+skipBytes(n: int): int
+write(b: byte[]): void
+write(b: byte[], off: int, len: int): void		 使用指定的 File 对象和模式创建对象
mode 可以取 r, rw, w
关闭对象
返回从起始位置计算的偏移量，字节为单位
返回文件长度
读取一个字节
读取 b.length 个字节到数组
读取 len 个字节到数组
设置偏移量
为文件设置一个新的长度
跳过 n 个字节
从指定字节数组写 b.length 个字节到文件
向数组写入 len 个字节

内部类

  • 一个内部类只能被其外部类使用

  • 一个内部类被编译为“外部类名$内部类名.class”

  • 内部类可以引用外部类中的数据和方法

  • static 内部类不能访问外部类的非静态成员

  • 在其他类中创建内部类：

    1
    2
    3
    OuterClass.InnerClass innerObjec t = outerObject.new InnerClass()
    如果是静态内部类
    OuterClass.InnerClass innerObjec t = new OuterObject.InnerClass()

匿名内部类

  • 匿名内部类总是从一个父类或实现一个接口
  • 匿名内部类不能有显式 extends 或 implements
  • 匿名内部类必须实现父类或接口所有抽象方法
  • 匿名内部类总是用父类无参构造方法创建实例，接口则是 Object()
  • 匿名内部类被编译成 OuterClassName$n.class

lambda 表达式

(type1 param1, type2 pararm2...) -> expression

(type1 param1, type2 pararm2...) -> {statements;}

param -> expression

param -> {statements;}

SAM 接口是只有一个抽象方法的接口

lambda 表达式创建的对象继承 SAM 接口

您的打赏将会成为我前进的动力！！