常用类

总述

内部类
Object类
Object类常用方法
包装类
String类
BigDecimal类

内部类

成员内部类
静态内部类
局部内部类
匿名内部类

概念：在一个类的内部再定义一个完整的类

class Outer{//Outer.class文件
    class Inner{//Outer$Inner.class文件
        
    }
}

特点：

编译之后可生成独立的字节码文件
内部类可直接访问外部类的私有成员，而不破坏封装
可为外部类提供必要的内部功能组件

成员内部类

成员内部类等级和实例变量、实例方法同级别

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

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

Outer out =new Outer();
Outer.Inner in =out.new Inner();
//Outer.Inner in=new Outer().new Inner();

当外部类、内部类存在重名属性时，会优先访问内部类属性（在同名情况访问外部类属性：Outer.this.name）
成员内部类不能定义静态成员

静态内部类

静态内部类等级和外部类相同

不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员
只能直接访问外部类的静态成员（实例成员需实例化外部类对象）

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

局部内部类

定义在外部类方法中，作用范围和创建对象范围仅限于当前方法
局部内部类访问外部类当前方法中的局部变量时，因无法保证变量的生命周期于自身相同，变量必须修饰为final
限制类的使用范围

必须在该方法中创建局部类对象

匿名内部类

没有类名的局部内部类（一切特征都与局部内部类相同）
必须继承一个父类或者实现一个接口
定义类、实现类、创建对象的语法合并，只能创建一个该类的对象

Usb usb=new Usb(){
            @Override
            public void servise() {
                System.out.println("风扇开始正常工作！");
            }

        };//使用匿名内部类实例化（相当于创建了一个局部内部类）
        usb.servise();

Object类

超类、基类，所有类的直接或间接父类，位于继承树的最顶层
任何类，如没有书写extends显示继承某个类，都默认直接继承Object类，否则为间接继承
Object类中所定义的方法，是所有对象都具备的方法
Object类型可以存储任何对象
- 作为参数，可接受任何对象
- 作为返回值，可返回任何对象

clone()` 创建并返回此对象的副本
**equals(Object obj)` 指示一些其他对象是否等于此。 **
finalize() 当垃圾收集确定不再有对该对象的引用时，垃圾收集器在对象上调用该对象。
getClass() 返回此 Object的运行时类。
hashCode() 返回对象的哈希码值。（哈希码值可以理解为对象的地址（实际就是10进制地址换成了16进制地址））
notify() 唤醒正在等待对象监视器的单个线程。
notifyAll()` 唤醒正在等待对象监视器的所有线程。
toString() 返回对象的字符串表示形式。
wait()` 导致当前线程等待，直到另一个线程调用该对象的 notify（）方法或notifyAll（）方法
wait(long timeout) 导致当前线程等待，直到另一个线程调用 notify()方法或该对象的 notifyAll()方法，或者指定的时间已过
wait(long timeout, int nanos) 导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法，或者某些其他线程中断当前线程，或一定量的实时时间。

Object类常用方法

getClass（）方法

public final Class<?> getClass(){}
返回引用中存储的实际对象类型（返回的是一个类）
应用：通常用于判断两个引用中实际存储对象类型是否一致

hashCode（）方法

public int hashCode（）{}
返回该对象的哈希码值
哈希值根据对象的地址或字符串或数字使用hash算法计算出来的int类型的数值
一般情况下相同对象返回相同的哈希值

toString（）方法

public String toString（）{}
返回该对象的字符串表示（表现形式）
可以根据程序需求覆盖该方法，如：展示对象各个属性值。

（这里的覆盖指重写，从父类继承来的方法满足不了自己的需求就进行重写）

equals（）方法

public boolean equals（Object obj）{}
默认实现为（this==obj），比较两个对象地址是否相同
可进行覆盖，比较两个对象的内容是否相同

s4.equals(s5);//s4是指this，s5是指obj
//在Object 类中没有重写equals（）方法，所以比较的是地址

equals（）方法覆盖步骤

比较两个引用是否指向同一个对象
判断obj是否为null
判断两个引用指向的实际对象类型是否一致
强制类型转换
依次比较各个属性值是否相同

finalize（）方法

当对象被判定为垃圾对象时，由JVM自动调用此方法，用以标记垃圾对象，进入回收队列
垃圾对象：没有有效引用指向此对象时，为垃圾对象
垃圾回收：由GC销毁垃圾对象，释放数据存储空间
自动回收机制：JVM内存耗尽，一次性回收所有垃圾对象
手动回收机制：使用System.gc（）；通知JVM执行垃圾回收

包装类

包装类：基本数据类型所对应的引用数据类型

Object可统一所有数据，包装类的默认值是null

byte-Byte short-Short int-Integer long-Long

float-Float double-Double boolean-Boolean

char-Character

类型转换与装箱、拆箱

装箱：把栈里面的数据转换成堆里面的数据（基本数据类型转换为引用数据类型叫做装箱）valuOf()

int num1=18;
        //使用Integer类创建对象
        Integer integer1=new Integer(num1);
        Integer integer2=Integer.valueOf(num1);
        System.out.println("装箱");

拆箱：正好相反（引用类型转成基本类型）intValue()

 //类型转换：拆箱：引用类型转换成基本类型
        Integer integer3=new Integer(100);
        int num2 = integer3.intValue();

//JDK1.5之后，提供了自动的装箱和开箱
        int age =23;
        //自动装箱
        Integer integer4=age;
		//自动装载了Integer.valueOf(age);方法
        //编译器自动装载了Integer.intValue()方法
        //自动拆箱
        int age2=integer4;

8种包装类提供不同类型间的转换方式：
Number父类提供的6个共性方法
parseXXX（）静态方法（字符串和基本类型之间的转换）

       //1.1使用+号
       int n1=255;
       String s1=n1+"";
       //1.2使用Integer中的toString（）方法
       String                  s2=Integer.toString(n1,16);//radix:进制
       System.out.println(s1);
       System.out.println(s2);

       //2字符串转成基本类型
       //使用Integer中的parseXXX（）方法
       String str ="150";
       int s3=Integer.parseInt(str);
       System.out.println(s3);

       //boolean字符串形式转乘基本类型”true“-->true
       //非"true"-->false
       String  str1="true";
       boolean b=Boolean.parseBoolean(str1);
       System.out.println(b);

Integer缓冲区

valueOf()有个整数缓冲区-126-127，这个范围里面存在数组中
- Java预先创建了256个常用的整数包装类型对象
- 在实际应用中，对以创建的对象进行复用

String 类

字符串常量，创建之后不可改变
字符串字面值存储在字符串池（常量池）中，可以共享
String s="Hello"; 产生一个对象，字符串池中存储。
String s=new String("Hello");//产生两个对象，堆池各存储一个

方法区在JDK7.0后移到了堆中，在6.0之前是存在专门的空间叫做方法区的

String 类中的常用方法

public int length（）：返回字符串的长度
public char charAt(int index):根据下标获取字符
public boolean contains（String str）：判断当前字符串是否包含str
public cha[] toCharArray():将字符串转换成数组
public int indexOf（String str）：查找str首次出现的下标，存在，则返回该下标；不存在，则返回-1.
public int lastIndexOf（String str）：查找字符串在当前字符串中最后一次出现的下标索引
public String trim（）：去掉字符串前后的空格
public String toUpperCase（）；将小写转成大写
public boolean endWith（String str）：判断字符串是否以str结尾
public String replace(char oldChar,char newChar):将旧字符串替换成新字符串
public String[] split（String str）：根据str做拆分

package usclass.d07;

import java.util.Arrays;

public class D07_1 {
    public static void main(String[] args) {
        String name ="hello";//常量存储在字符串池中
        name="zhangsan";//张三赋值给name变量，给字符串中赋值时并没有修改数据，
        // 而是重新开辟了一片空间存储张三，并将name引用指向张三
        String name2="zhangsan";

        //演示字符串中的另一种创建方法.new String（）；
        String str1 =new String("java");
        String str2=new String("java");
        System.out.println(str1==str2);
        System.out.println(str1.equals(str2));
//这里的学习分析内存是最重要的
        System.out.println("---------字符串的使用1---------");
        //字符串方法的使用
        // 1.length（）；返回字符串长度
        //2.charAt（int index）；返回某个位置的字符
        //3.contains（String str）；判断是否包含某个子字符串
        String content="java学习要努力";
        System.out.println(content.length());
        System.out.println(content.charAt(content.length() -1));
        System.out.println(content.contains("java") );
        System.out.println(content.contains("python"));
        System.out.println("-------字符串方法的使用2 -----------");
        //4.toCharArray（）；返回字符串对应的数值
        //5.indexOf（）；返回子字符串首次出现的位置
        //6.lastIndexOf（）；返回字符串最后一次出现的位置
//        System.out.println(Arrays.toString(content.toCharArray()));
        System.out.println(content.toCharArray());
        System.out.println(content.indexOf("java"));
        System.out.println(content.indexOf("java",4));
        System.out.println(content.lastIndexOf("java"));
        //7.trim();去掉字符串前后的空格
        //8.toUpperCase（）；把小写转成大写toLowerCase（）；把大写转成小写
        //9.endWith（str）；判断是否以str结尾，startWith（str）；判断是否以str开头
        //是就返回true，不是就返回false
        String content2=" hello world ";
        System.out.println(content2.trim());
        System.out.println(content2.toUpperCase());
        System.out.println(content2.toLowerCase());
        String filename="hello.java";
        System.out.println(filename.endsWith(".java"));
        System.out.println(filename.startsWith("hello"));
        System.out.println("***********************");
        //10.replace(char old,char new );用新的字符或字符串替换旧的字符或字符串
        //11.split（）；对字符串进行拆分
        System.out.println(content.replace("java","Cpp"));
        String say="java is the best programing language  ,java ,,xiang";
        //[]里面一个空格一个逗号，代表按空格和逗号分开，后面有个+代表可以按多个空格和逗号分开
        String[] arr=say.split("[ ,]+");//正则表达式
        System.out.println(arr.length);
        for (String s : arr) {
            System.out.println(s);
        }
        //两个方法equals compareTo（）；比较大小
        String s1="hello";
        String s2="HELLO";
        System.out.println(s1.equals(s2));
        System.out.println(s1.equalsIgnoreCase(s2));//忽略大小写比较
        String s3="abc";
        String s4="ayzawe";
        System.out.println(s3.compareTo(s4));
        String s5="abc";
        String s6="abc";
        System.out.println(s5.compareTo(s6));

    }
}
usclass.d07.D07_1
false
true
---------字符串的使用1---------
9
力
true
false
-------字符串方法的使用2 -----------
java学习要努力
0
-1
0
hello world
 HELLO WORLD 
 hello world 
true
true
********************************
Cpp学习要努力
8
java
is
the
best
programing
language
java
xiang
false
true
-23
0

进程已结束,退出代码0

可变字符串

StringBuffer：可变长字符串，JDK1.0提供，运行效率慢、线程安全
StringBuilder:可变长字符串，JDK5.0提供，运行效率快、线程不安全

这两个类和String的区别：

效率比String高
比String节省内存

append（）；追加
insert（）；添加（a，”***“），在a处添加 * * *
replace（）；替换（a，b，”* * * “）将从a到b替换成* * *
delete（）；删除（a，b）中间的内容

BigDecimal

位置：Java.math包中
作用：精确计算浮点数
创建方式：BigDecimal bd=new BigDecimal（“1.0”）；

（注意：一定要用字符串格式保存即“”里面重载的字符串）

方法：BigDecimal add （BigDecimal bd）加

	BigDecimal subtract（BigDecimal bd）减

BigDecimal multiply (BigDecimal bd) 乘

BigDecimal divide (BigDecimal bd ) 除

除法：divide（BigDecimal bd，int scal，Rounding Mode mode）

参数scal：指定精确到小数点后几位
参数mode：指定小数部分的取舍模式，通常采用四舍五入的模式取值为BigDecimal.ROUND_HALF_UP

Date

data:表示特定的瞬间，精确到毫秒，Date类中的大部分方法都已经被Calendar 类中的方法所取代
时间单位：1秒=1000毫秒，1毫秒=1000微秒，1微秒=1000纳秒

好多已经过时

//1.创建Date对象
        //今天
        Date date1=new Date();
        System.out.println(date1.toString());
        System.out.println(date1.toLocaleString());
        //昨天
        Date date2=new Date(date1.getTime()-(60*60*24*1000));
        System.out.println(date2.toLocaleString());
        //2.方法after befor
        System.out.println(date1.after(date2));
        System.out.println(date1.before(date2));
        //比较compareTo
        System.out.println(date2.compareTo(date1));
        //比较是否相等
        System.out.println(date1.equals(date2));

Calendar

Calendar提供了获取或设置各种日历字段的方法
构造方法
- protected Calendar():由于修饰符是protected,所以无法直接创建该对象（不能直接new）采用Calendar.getInstance（）；
static Calendar getlnstance():使用默认时区和区域获取日历
void set(int year,int month,int data,int hourofday,int minute,int second):设置日历的年、月、日、时、分、秒
int get(int field):返回给定日历字段的值。字段比如年、月。日等
void setTime（Date date）：用给定的Date 设置此日历的时间。
Date getTime（）：返回一个Date表示此日历的时间
void add（int field，int amount）：按照日历的规则，给指定字段添加或减少时间量
long getTimelnMillies（）：毫秒为单位返回该日历的时间值

        //1.创建Claendar
        Calendar time=Calendar.getInstance();
        System.out.println(time.getTime().toLocaleString() );
        System.out.println(time.getTimeInMillis() );
        //2.获取时间信息
        //获取年
        int year =time.get(Calendar.YEAR );
        //月从0-11，所以加一
        int month =time.get(Calendar.MONTH  );
        int hour =time.get(Calendar.HOUR );
        int day =time.get(Calendar.DAY_OF_MONTH  );
        int mintue =time.get(Calendar.MONTH  );
        int second =time.get(Calendar.SECOND  );
        System.out.println(year+"年"+(month+1)+"月"+day+"日"+hour+
                "时"+mintue+"分"+second+"秒");
        //设置修改时间
        Calendar time1=Calendar.getInstance();
        time1.set(Calendar.DAY_OF_MONTH ,11);
        System.out.println(time1.getTime() .toLocaleString());
        //add方法修改时间
        time1.add(Calendar.HOUR ,-1);
        System.out.println(time1.getTime().toLocaleString());
        //补充方法
        //time1.add(Calendar.MONTH ,);
        int max=time1.getActualMaximum(Calendar.DAY_OF_MONTH);
        int min=time1.getActualMinimum(Calendar.DAY_OF_MONTH);
        System.out.println(max);
        System.out.println(min);

SimpleDateFormat

SimpleDateFormat是一个以语言环境有关的方式来格式化和解析日期的具体类
进行格式化（日期->文本）、解析（文本->日期）
常用的时间模式字母
- y：年 M:月份 d:日 H:时（H24，h12）
  - m:分钟 s:秒 S:毫秒

//1.创建SimpleDateFormat 对象
        SimpleDateFormat sdf=new SimpleDateFormat("yyy/MM/dd HH-mm-ss");
        //2.创建Date
        Date date=new Date();
        //把日期转换成字符串
        String str=sdf.format(date) ;
        System.out.println(str);
        //解析（把字符串转换成日期）
        Date date1=sdf.parse("2022/02/12 11-41-00");
        System.out.println(date1 );

System

System系统类，主要用于获取系统的属性数据和其他操作，构造方法私有的（不需要创建对象就能直接使用）
static void arraycopy(...) :复制数组
static long currentTimeMillis();获取当前系统时间，返回的从1970到现在的毫秒值
static void gc();建议JVM赶快启动垃圾回收器回收垃圾
static void exit(int status);退出JVM，如果参数是0正常退出，非0表示异常退出JVM

 //arraycopy:数组的复制
        //src：原数组
        //srcPos：从那个位置开始复制
        //dest：目标数组
        //destPos：目标数组的位置
        //length：复制的长度
        int[] arr={20,18,19,32,45,2,3,6,8};
        int[] str=new int[9];
        System.arraycopy(arr,4,str,4,5);
        //System.arraycopy(arr,0,str,0,arr.length);
        for(int i=0;i<str.length;i++){
            System.out.println(str[i]);
        }

posted @ 2022-02-10 23:22 study小凝阅读(41) 评论(0) 收藏举报

刷新页面返回顶部

study小凝

常用类

常用类

总述

内部类