java常用类

内部类

1.成员内部类：在一个类的内部定义一个完整的类

例如：外部类public class Body{

内部类class Header{

}

}

内部类可以直接访问外部类的私有成员，而且不破坏封装

内部类可以为外部类提供必要的功能组件，

成员内部类 在类的内部定义，与实例变量，实例方法同级别的类，

在外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象

Outer outer = new outer();

Inner inner = new Inter();

一步到位： Inner inner = new Outer().new Inner();

inner.show();

当外部类、内部类存在重命名属性时、会优先访问内部类属性 例如(外部类 .this.属性)

成员内部类不能定义静态成员static、但可以定义静态常量final。

private static final String name ="li";

private static String name ="li"; 错误

打印外部类属性时 内部类属性和外部类的名字相同，要想访问外部类属性Outer.this . name

静态内部类

相当于在成员内部类的基础上 加上一个static关键字 也当相当于外部类

不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员

packageaa;//外部类

public classOuter {private String name = "ww";//静态内部类;和外部类相同

static classInner{private String address="上海";private String phone="888";//静态成员

private static String maths = "数学";public voidshow() {//调用外部类的属性//1.先创建外部类对象

Outer outer = newOuter();

System.out.print(outer.name);//调用静态内部类属性方法

System.out.print(address);//调用静态内部类的静态属性

System.out.print(Inner.maths);

}

​

}

​

}

只能直接访问外部类的静态成员(实例化成员需实例化外部类对象)

Outer.Inner inner = new Outer.Inner();

Outer.Inner.show();

public classTestOuter {public static voidmain(String[] args) {

Outer.Inner inner= newOuter. Inner();

inner.show();

}

}

3.局部内部类 (定义在方法内的)

package com.jun.li.pritact;

//外部类

public class Outer {

private String name ="刘德华";

private int age =55;

public void show() {

// 定义局部变量、局部变量是不能带修饰符的

String address = "上海";

//局部内部类 注意前面不能加任何访问修饰符

class Inner{

//局部内部类的属性

private String phone="19999999";

private String email="999999@.qq.com";

public void show2() {

//访问外部类的属性

System.out.println(Outer.this.name);

System.out.println(Outer.this.age);

System.out.println(address);

}

}

步骤(1)  //在此方法内创建内部类对象

Inner inner = new Inner();

inner.show2();

}

}

package com.jun.li.pritact;

public class OuterTest {

public static void main(String[] args) {

Outer outer = new Outer();

outer.show();

//想运行show方法中的局部内部类 需只能在其方法内创建对象 上步骤 (1)

}

}

​

​

局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的生命周期与自身相同，

变量必须修饰为final final String address = "上海";

有限的范围 当前方法内

4.匿名内部类(接口 抽象类用的多)

*没有类名的局部内部类(一切特征都与局部内部类相同)

*继承一个父类或者实现一个接口常使用

Usb usb = new Usb(){

//Usb()可以是父类，抽象类 再重写方法就行

@Override

public void service(){

System.out.println("连接成功");

}

}；

object类

超类、基类、所有类的直接或间接父类，位于继承树的顶层

任何类、没有写extends继承某个类 都默认继承Object类，否则间接继承

Object类的所定义的方法，是所继承对象都具备的

Object类可以存储任何对象 1.作为参数：接收任何对象

2.作为返回值：可以返回任何对象

object类常用方法

1.getClass()方法 返回当前类的实际对象类型

应用：通话常用于判断两个引用中实际存储对象类型是否一致

Class class1=s1.getclass();

Class class2=s2.getclass();

if(class1==class2){

System.out.print("相同类型")

}else{

System.out.print("不相同类型")

}

2.hashCode()方法 返回int类型

public int hashCode(){}

System.out.println(s1.hashCode());

System.out.println(s2.hashCode());//s1与s2地址不同所以hash值不同

Student s3=s1 //把s1地址赋给s3 所以相同

System.out.println(s3.hashCode());//相同

返回哈希码值、根据对象的地址或字符串或者数字使用hash算法计算出来的int类型的数值

3.toString()方法

eclipse中重写方法 Alt+Enter+s

public String toString(){

return name+":"+age;

}

4.equals()方法 默认实现为(this==obj)。比较两个对象地址是否相同。可覆盖 为比较两个对象的内容是否为相同、通过重写。

重写equals方法 改变equals的判断条件方法

public class Outer {

@Override

public boolean equals(Object obj) {

//1.判断两个对象是否为同一个引用 一样就不需要比ture

if(this==obj) {

return true;

}//2.判断是否为空值

if(obj==null) {

return false;}//3.判断是否为同一类型

//if(this.getClass()==obj.getClass()) {//}

if(obj instanceof Student ) {

//4.强制类型转换

Student s =(Student)obj;

//5.比较属性

if(this.name.equals(s.getName())&&this.age==s.getAge()) {

return true;

}

}

return false;

}

}

5.finalize()方法

当对象被判定为垃圾对象时 ，由JVM自动调用此方法，用于标记垃圾对象，计入回收队列

垃圾对象：指没有有效引用指向此对对象

垃圾回收：由GC销毁对象，释放数据存储空间

自动回收机机制：JVM的内存耗尽，一次性回收所有垃圾对象。

手动回收机制，使用System.gc(); 通知JVM执行垃圾回收。

Student s1 = new Student("aaa",20);//不会被当作垃圾回收

new Student("aaa",20);//会被当做垃圾回收

System.gc();

包装类

基本数据类型 byte、char、short、int、long、float、double、boolean，

基本数据类型都存在栈中，引用类型都在堆中

从而只能通过运算符对基本数据类型操作，

为了让基本数据类型提供更强大的功能所以创造出：基本数据类型所对应的引用数据类型

包装类 是 引用类型默认值为null

基本数据类型包装类型

byte

Byte

short

Short

int

Integer

long

Long

float

Float

double

Double

boolean

Boolean

char

Character

包装类将对应的基本数据类型包装在一个对象中(对象则变为堆中，就可以使用方法。。。)

类型转换与装箱、拆箱

装箱：把栈(基本类型)拿到堆(引用类型)中，反之拆箱。

装箱：

//基本类型

int n =18;

//使用Integer类创建对象、valueof()方法返回一个 Integer指定的 int值的 Integer实例

1.Integer integer = new Integer(n);//把传入的数字

2.Integer integer1 = Integer.valueof(n);

拆箱：

//intvalue()方法返回int值

Integer integer2 = new Integer(n);

int num2 = integer2.intvalue();

JDk1.5后自动提供装箱拆箱

//自动装箱

int a = 15;

Integer integre1=a;

//自动拆箱

int a2=integer1;

基本类型和字符串之间的转换

//基本类型转换字符串转

int n1 =100;//使用toString()方法

1.String s1 = n1+"";

2.String s2 = Integer.toString(n1);

//字符串转换成基本类型

`String str ="100";

//使用Integer.parseXXX()

int n2 = Integer.parseInt(str);

//boolean字符串行式转换成基本类型 "true"都是true 非 true 都是false

String str2 = "false";

boolean b = Boolean.parseBoolean(str2);

Integer缓冲区

//面试题

Integer integer1 = new Integer(100);

Integer integer2 = new Integer(100);

System.out.printin(integer1==integer2);//false

//比的是地址

Integer integer3 = 100;//自动装箱 =Integer integer3 = Integer.valueof(100);

Integer integer4 = 100;//从在Cache[] 数组-128——127中找到 直接给栈内的对象 堆地址相同唯一

System.out.printin(integer3==integer4);//true

Integer integer5 = 200;

Integer integer6 = 200;

System.out.printin(integer5==integer6);//false

//Intrger.valueof(i) i 是有范围的-128——127 超出范围会 new Integer(i); 从而使地址不同

String类

字符串是常量，创建之后不可改变

字符串字面值存储在字符串池(方法区内的)中，可以共享。

实例：

String name ="Hello";//"hello"常量存储在常量池中

name ="zhangsan";    //把zhangsan赋值给name变量，给字符赋值时，并没有修改数据，而是重新开辟空间

String name2 = "zhangsan";

String s ="Hello"; 产生一个对象，字符串池中存储。

String s = new String(“Hello”)；产生两个对象，堆、常量池个存储一个。

//展示字符串的另一个创建方式

String str = new Strinf("java");//new 在堆中一个对象

String str2 = new Strinf("java");

System.out,printin(str==str2); //false 都在堆中new 所以地址不同

System.out,printin(str.equals(str2));//true 因为这是比的是数据而不是地址

字符串常用的方法

1.public int length() :返回字符串的长度

2.public char charAt(int index) :根据下标获取字符

3.public boolean contains(String str) : 判断当前字符串是否包含str

String name = "java最好";

System.out.printin(name.length()); //6

System.out.printin(name.charAt(name.length()-1));  //好

System.out.printin(name.contains("java"));//true

4.public char[ ] toCharArray( ) :将字符串转换成数组

5.public int indexOf(String str) :查找str首次出现的下标，存在，则返回该下标，不存在，则返回-1.

6.public int lastIndexOf(String str) :查找字符串在当前字符串中最后一次出现的下标索引

String name = "java最好,java真香";

System.out.printin(Arrays.toString(name.toCharArray()));// [j,a,v,a,......]

System.out.printin(name.indexOf("java"));// 0

System.out.printin(name.lastIndexOf("java"));//7

split() 方法中 拆分split(“[ ,]+”)可以表示多个空格或 , 都能拆分

equalsIgnoreCase( )忽略大小写的比较

比较大小 两个字符串依次相同位置且依次往后比较，直至没有则比较长度

案例演示

toUpperCase( )可以变为大写

截取 ：subString(int beginIndex )

subString(int beginIndex ，int endIndex)

String增强类 StringBuffer：可变长字符串，运行效率慢，线程安全

(单线程)StringBuilder： 可变长字符串，运行效率快，线程不安全

/**

* StringBuffer和StringBuilser的使用

* 比String 1.效率高

2.节省内存

*/

StringBuffer sb = new StringBuffer();

1.//append();追加

sb.append("java世界第一");

System.out.print(sb.toString());

2.//insert();添加 可以在某个位置添加

sb.insert(0,"dddddd");

3.// replace(); 可以再指定位置替换

sb.replace(0,5,"DDDDDD");

4.// delete();删除 也可指定位置

sb.delete(0,5);

BigDecimal类

位置：java.math包中

作用：精确计算浮点数。

创建方式： BigDecimal bd = new BigDecimal(“字符串”)；字符串精确

//面试题

double result =(1.4-0.5)/0.9;

//求结果 却为0.0999999999...

BigDecimal bd1 = new BigDecimal("1.0");

BigDecimal bd2 = new BigDecimal("0.9");

//减法 subtract()

BigDecimal r1 = bd1.subtract(bd2);

//加法 add()

BigDecimal r2 = bd1.add(bd2);

//乘法 multiply()

BigDecimal r3 = bd1.multiply(bd2);

//除法 divide() 面试题例题

BigDecimal r4 = new Bigdecimal("1.4")

.subtract(new Bigdecimal("0.5"))

.divide(new Bigdecimal("0.9"));

//除不尽保留几位小数 divide(Bigdecimal bd,int scal(保留几位),RoudingMode mode(取舍模式四舍五入等等))

四舍五入：Bigdecimal.ROUND_HALF_UP

Date类

Date表示特定的瞬间，精确到毫秒，Date类中的大部分方法都已经被Calender类中的方法所取代。

时间单位

1秒=1000毫秒

1毫秒=1000微秒

1微秒= 1000纳秒

toLocalString() 时间格式 xxxx - x - x

Calendar类

Calendar提供了获取或设置各种日历字段的方法

构造方法： protected Calendar() 由于修饰符是protected，所以无法直接创建该对象

1.//创建Calendar对象

Calendar calendar = Calendar.getInstance();

System.out.println(calendar.getTime().toLocalString());//现在时间2020-10-1

System.out.println(calendar.getTimeInMillis());//获取毫秒值

2.//获取时间信息

年、月、日、时、分、秒

int year = calendar.get(Calendar.YEAR);

int month = calendar.get(Calendar.MONTH); // 月是从0-11开始 所以要加1

int day = calendar.get(Calendar.DAY_OF_MONTH);

int hour = calendar.get(Calendar.HOUR_OF_DAY);// HOUR 12小时、HOUR_OF_DAY24小时

int minute = calendar.get(Calendar.MINUTE);

int second = calendar.get(Calendar.SECOND);

3.//修改时间

Calendar calendar2 = Calendar.getInstance();

calendar2.set(Calendar.DAY_OF_MONTH,5)//修改当日为5

calendar2.add(Calendar.HOUR,+/-1);//增加或减少1个小时

4.//获取最大值最小值

int max = claendar2.getActualMaximum(Calendar.DAY_OF_MONTH);

int min = claendar2.getActualMinimum(Calendar.DAY_OF_MONTH);

SimpleDateFormat类

SimpleDateFormat是一个与语言环境有关的方式来格式化和解析日期的具体类，

进行格式化(日期->文本)、解析(文本->日期) .

常用的时间模式字母

字母日期或时间示例

y

年

2019

M

年中月份

08

d

月中天数

10

H

一天中小时数

24

m

分钟

25

s

秒

60

S

毫秒

666

1.//创建SimpleDateFormat对象 y年M月s天H时m分s秒

SimpleDateFormat sdf =new SimpleDateFormat(patter);//pattern表示参数

↓

↓

SimpleDateFormat sdf =new SimpleDateFormat("yyyy年MM月dd日HH:mm:ss");

2.//创建Date

Date date = new Date();

//格式化date，把日期转成字符串

String str = sdf.format(date);

System.out.print(str);

//解析，把字符串转成日期

Date date = sdf.parse("1990/5/1")

System类

System是系统类，主要用于获取系统的属性数据和其他操作，构造方法私有的

方法名说明

static void arraycopy(......)

复制数组

static long currentTimeMillis();

获取当前系统时间，返回毫秒值

static void gc()；

建议JVM赶快启动垃圾回收器回收垃圾

static void exit (int status);

退出JVM，如果参数是0表示正常退出JVM，非0表示异常退出JVM

1.

//src :源数组

//srcPos:从哪个位置开始复制

//dest ：目标数组

//destPos：目标位置

public class Test1 {

public static void main(String[] args) {

int[] arr1 = {2,5,6,4,5};

int [] arr2 = new int[10];

//System.arraycopy(src, srcPos, dest, destPos, length);

System.arraycopy(arr1, 0, arr2, 1, 2);

for (int i = 0; i < arr2.length; i++) {

System.out.print(arr2[i]+",");

}

}

}

2.

// System.out.println(System.currentTimeMillis());

// 也可以用来计时

long start = System.currentTimeMIllis();

long end = System.currentTimeMIllis();

3.

//System.gc();垃圾回收

4.System.exit(0)

#