JavaSE学习记录06篇

类与类之间的关系

1.继承
类与类之间是单继承
接口和接口之间是多继承，用多个逗号隔开
class A{}
class B extends A{}
interface C{}
interface D{}
interface E implements C,D{}
2.实现
类和接口之间是多实现，多个用逗号隔开
class 类名 implements 接口，接口，……{}
3.依赖
依赖关系，局部变量，保存在另一个类 对象引用
方法执行完，关系就不存在了
4.关联
关联关系，成员变量保存了另一个类的对象引用
关系是长期的
5.聚合
整体和局部都有独立的生命周期
6.组合
部分和整体不可分离

内部类

当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，那么整个内部的完整结构最好使用内部类在Java中，允许一个类的定义位于另一个类的内部，前者称为内部类，后者 称为外部类。
Inner class一般用在定义它的类或语句块之内，在外部引用它时必须给出完整的名称
内部类可以访问，外部类私有化属性
成员内部类
可以看做成员变量
可以使用访问控制修饰符
在成员内部类中不能有静态声明
可以直接访问外部类的所有属性
内部类类名编译之后是外部类类名$内部类类名
创建外部类对象
外部类名 变量名=new 外部类构造
创建内部类对象
内部类类名 变量名 = 外部类对象.new 内部类构造
访问属性
对象.属性

静态内部类 可以看作静态变量
静态内部类中，可以声明成员属性也可以声明静态属性
在静态内部类中，无法直接访问外部类的成员属性，需要创建外部类对象访问才行
局部内部类
局部内部类可以看做局部变量，如果通过局部内部类访问外部方法中的局部变量的时候，该变量需要加final修饰，但是在1.8开始，final可以省略
局部内部类，不能使用权限修饰符，也不能使用static
局部内部类的类名为外部类名$1内部类名，假如内部类类名一样了，那么就是外部类类名$2内部类，以此类推
匿名内部类
在方法调用的时候，需要传入一个接口的实现类的对象的时候，可以不写类，直接写一个匿名内部类
类名为外部类名$1,外部类名$2以此类推
优点是，少定义一个类，并且还能访问外部类中的私有化属性
缺点是：无法复用

设计模式

就是在编码实践中，人们发现有很多编码经常被用到，于是就总结出来，形成固定的结构，该结构一般代表了最佳的实现方式。
让当前类只能被创建一个实例化对象
1.要控制创建对象的数量，也就意味着不能让客户直接操作构造方法，所以，需要构造方法私有化
2.对外提供一个用于获取对象的方法，没有入参，出参是当前类型的静态方法
3.创建一个静态变量，用来保存实例化之后的对象
结合对象的创建时机不同，又分为两种情况
饿汉模式：加载阶段就创建对象。
public class Singleton_01{
private static Singleton_01 s= new Singleton_01();
public static Singleton_01gentlnstance(){
return s;}}
懒汉模式：用到的时候再创建对象。
public class Singleton_02{
private static Singleton_02 s=null;
public static Singleton_02 gentlnstance(){
if(s==null){s=new Singleton_02();}return s;}}

常用API

1.String
java.lang.String:是字符串类，底层就是一个final修饰的char数组，所以String有很多特性就是数组的特性，长度一旦确定，不能更改
1字符串一旦创建，这个字符对象不能再更改
2.为了提升字符串的访问和存储效率，java虚拟机采用了一种缓存机制，把字符串都保存在了字符串常量池中。
3.在程序执行过程，假如要用到一个字符串a,String s1=“a”;先去字符串常量池中检索，是否有a，如果没有就创建一份，假如有了String s2=“a”;就直接把a返回，不再新创建了。
所以导致String s1 = “a” String s2=“a” "=="和"equals"结果是一样的
String覆写了equals
不要频繁拼接
构造方法
1字面量
String s1 =“asad”
2普通构造
String s2=new String(“xxx”)
3.字节数组
byte[] bytes={97,98,99}
String s3 = new String(bytes);
4.字节数组只截取一部分，起始（包含）+长度
String s4=new String(bytes,2,2)
5.字符数组
char[] chars={‘a’,‘b’,‘c’,‘d’}
String s5=new String(chars)
6字符数组，截取长度
String s6=new String(chars,2,2)

常用方法

字符串.charAt(int index) :
返回该字符串中，指定位置的字符。
入参：下标
出参：char

字符串.endWith(String suffix):
判断字符串是否以指定字符串结尾
入参：String
出参：boolean

字符串.startsWith(String prefix):
判断字符串是否以指定字符串开始
入参：String
出参：boolean

字符串.equalslgnoreCase(String str):
不区分大小写比较
入参：String
出参：boolean

字符串.getByte():
把字符串转成字节数组并返回
入参：无
出参：byte[]

字符串.toCharArray():
把字符串转成字符数组并返回
入参：无
出参：char[]

字符串.indexOf(String str):
获取该字符串中指定字符串的起始位置，返回索引，找不到返回-1
入参：String
出参： int

字符串.indexOf(String str,int index)
根据给定的索引开始获取该字符串中指定字符的起始位置，返回索引，找不到返回-1
入参：String int
出参：int

字符串.indexlastIndexOf(String str)
找出和给定字符串相匹配的最后一个字符串的索引，找不到返回-1
入参：String
出参：int

字符串.length()
返回字符串长度
入参：无
出参：int

字符串.replaceAll(String regex,String replacement)
替换指定字符串，支持正则表达式
入参：String String
出参：String

字符串.replace(String str,String replacement)
替换指定字符串，支持正则表达式
入参: String String
出参：String

字符串.split(String regex)
依据分隔符分割字符串
入参：String
出参：String[]

字符串.substring(int begin)
获取字符串中以某个下标开始的字符串
入参：int
出参：String

字符串.substring(int begin,int end)
获取该字符串中，以某个下标起始（包含）到某个下标结束的子字符串（不包含）
入参：int int
出参：String

字符串.trim()
去除字符串两边的空格
入参：无
出参：无

字符串.toUpperCase()
转大写
字符串.toLowerCase()
转小写
static String valueOf(Object obj)
String.valueOf(Object obj)
调用该对象的toString方法，如果为null，则不再调用toString而是返回字符串null
打印引用类型的时候会自动调用String的valueOf所以会自动调用toString方法
字面量相加，在编译阶段就去掉了，变量相见，因为变量的值是可变的，运算之前没有办法确定变量的值，所以没有办法优化，只能转换为new的方式，重新创建并拼接字符串，如果声明为常量，则可以优化。

StringBuffer and StringBuilder

都是字符缓冲区，可以做拼接操作
String 定长，一旦创建，不仅可更改，不适合做字符串拼接操作
StringBuffeer和StringBuilder：底层是char数组，变长，预先在内存中申请一块空间，用来保存很多字符，如果预留空间不够了，会进行自动扩容
默认容量为16，容器扩大后为（当前容量*2+1）；16->34->70;
StringBuffer和StringBuilder的区别
StringBuffer线程安全，在多线程环境下，不会出现问题
StringBuilder 非线程安全，多线程环境下，可能出现问题

append：添加数据，做拼接操作
可以链式调用
sb.append().append()

toString可以把StringBuilder转换成String类型

reverse()反转

length()已有元素个数

capacity()当前容量

包装类：

想要对基本类型数据进行更多的操作，最方便的方法就是将其封装成对象，因为在对象的描述中就可以定义更多的属性和行为对该基本类型进行操作。我们不需要自己去对基本类型进行封装，Jdk已经封装好了。
概念：
装箱就是自动将基本类型转换为包装器类型
拆箱就是自动将包装器类型转化为基本数据类型
byte–>Byte
char–>Character
short–>Short
int–>Integer
long–>Long
float–>Float
double–>Double
boolean–>Boolean

使用：

基本类型
byte b1=12;
Byte b2=new Byte();
Interger

基本使用：

//最大值
Integer.MAX_VALUE
//创建对象
Integer i1=new Integer(123)
传递字符串也可以，但必须是纯数字
如果不是：
java.lang.NumberFormatException:For input string:“1231a”

相互转换

int—>Integer
Integer i1=new Integer(123);
i1=Interger.valueOf(123)
Integer–>int
int i2=i1.intValue();
String–>integer
Integer i3=new Integer(“123”)
i3=Integer.valueOf(“123”)
Integer–>String
String string=i3.toString();
int–>String
String string =123+"";
String–>int
int i4=Integer.parseInt(“123”);

常用方法：

String–>int,double
int i4=Integer.parseInt(“123”);
double d1=Integer.parseDouble(“2.4”)
把数字以二进制的字符串形式，并返回
String s1=Integer.toBinaryString(10);
八进制
s1=Integer.toOctalString(10);
十六进制
s1=integer.toHexString(10);

自动拆箱和自动装箱

八种包装类，都覆写了toString和equals()方法
Integer i3=123,编译之后就等于 Integer i3= Integer.valueOf(123)
Int i4=i3，编译之后就等于int i4=i3.intValue();

深入整型常量池

Integer.valueOf();是从整形常量池里直接拿来的 ，整形常量池的范围在-128-127之间，如果不在范围内就直接new对象
IntegerCache内部类静态私有化内部类
属性：low最小值，high最大值，cache[] 保存缓存对象的数组

总结：

常量池就是提前准备好的一些对象，当我们要保存数据的时候，发现已经创建好了，就直接拿走，不需要重新创建
当我们通过new Integer()创建对象的时候 不管值是多少，==永远是false
当我们使用Integer i1=xxx.的时候这种方式，编译之后，会转换为Integer.valueOf();这种方式会经常经过常量池，但是如果不再常量池范围内还是得new Integer()

System

System类提供的public static long currentTimeMills()用来返回当前时间与1970年1月1日0时0分0秒以毫秒为单位的时间差
此方法适于计算时间差
System 类代表系统，系统级的很多属性和控制方法都放置在该类的内部。该类位于java.lang包
由于该类的构造器是private的，所以无法创建该类的对象，也就是无法实例化该类，其内部成员变量和成员方法都是static的，所以也可以很方便的进行调用
成员变量
System类内部包含in、out、和err三个成员变量，分别代表标准输入流（键盘输入），标准输出流（显示器）和标准错误输出流(显示器)。
成员方法：
native long currentTimeMillis()：
该方法的作用是返回当前的计算机时间，时间的表达格式为当前计算机时间和GMT时间(格林威治时间)1970年1月1号0时0分0秒所差的毫秒数。
void exit(int status)：
该方法的作用是退出程序。其中status的值为0代表正常退出，非零代表异常退出。使用该方法可以在图形界面编程中实现程序的退出功能等
常用方法
Scanner scanner=new Scanner(System.in)
System.out.println()
System.err.println()
System.currentTimeMills()
System.exit()

Date

获取当前系统时间
Date d1 =new Date();
传入毫秒数，获取时间原点到指定毫秒数的时间
Date d2=new Date(1000);
常用方法：
d1.getTime()
获取指定时间的毫秒数
d1.toString()
字符串类型

格式化：

年y 月M 日d 时H 分m 秒s 毫秒S
SimpleDateFormat sdf=new SimpleDateFormat(“yyyy年MM月dd日 HH:mm:ss SSS”);
格式化，返回字符串
String string = sdf.format(d1);
时间格式的字符串 转换为Date对象
String strDate=“2022/01/14 16:21:36”
sdf=new SimpleDateFormat(“yyyy/MM/dd HH:mm:”)
Date date=sdf.parse(strDate);

Calender

获取当前日历
Calendar c=Calendar.getInstance();
获取当前是本周是第几天，周日是第一天
c.get(Calendar.Day_OF_WEEK)
年
c.get(Calendar.YEAR)
月,0是1月
c.get(Calendar.MONTH)+1
日
c.get(Calendar.Day_OF_MONTH)

Random

从0开始，生成到目标数的随机数