常用类

最新推荐文章于 2022-05-31 21:11:14 发布
最新推荐文章于 2022-05-31 21:11:14 发布
阅读量79 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42497621/article/details/115585745
版权

内部类

成员内部类，静态内部类，局部内部类，匿名内部类。
概念：再一个类中在定义一个完整的类
特点：

  • 编译之后可以生成独立的字节
  • 内部类可直接访问外部类成员，而不破坏封装
  • 可为外部类提供必要的内部功能组件
    Body$head.class Body.class
在这里插入// 身体
class Body{
  // 头部
  class Header{
    // 也会生成class文件
  }
}代码片

成员内部类

  • 在类的内部定义，与实例变量、实例方法同级别的类
  • 在外部类的一个实例部分、创建内部类对象时、必须依赖外部类对象
  • 当外部类、内部类存在重名属性时，会优先访问内部类属性
  • 成员内部类里不能定义静态成员。可以包含静态成员变量
// 外部类
public class Outer{
  //实例变量
  private String name = "张三";
  private int age = 20;
  //内部类
  class Inner{
    private String address = "北京";
    private String phone = "110";
    private String name = "李四";
    
    //方法
    public void show(){
      //打印外部类属性 此时有重名属性name
       System.out.println(Outer.this.name); // 张三
       System.out.println(age);
      //打印内部类中的属性
       System.out.println(name); // 李四
       System.out.println(address);
       System.out.println(phone);
    }
  }
}

// 测试类
public class Test{
  public static void main(String[] args){
    // 创建外部类对象
    Outer outer = new Outer();
    // 创建内部类对象
    Inner inner = outer.new Inner();
    
    //一步到位
    Inner inner = new Outer(.new Inner();
                            
    inner.show();
  }
}

静态内部类

  • 不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员
// 外部类
public class Outer{
  //实例变量
  private String name = "xxx";
  private int age = 20;
  
  // 静态内部类，和外部类相同
  static class Inner{
    private String address = "上海";
    private String phone = "111";
    // 静态成员
    private static int count = 1000;
    
    //方法
    public void show(){
      // 调用外部类的属性
      // 1. 先创建外部类对象
      Outer outer = new Outer();
      // 2. 调用外部类对象的属性
      System.out.println(outer.name);
      System.out.println(outer.age);
      // 调用静态内部类的属性和方法
      System.out.println(address);
      System.out.println(phone);
      // 调用静态内部类的静态属性
      System.out.println(Inner.count);
    }
  }
}

// 测试类
public class Test{
  public static void main(String[] args){
    // 直接创建静态内部类对象
    Outer.Inner inner = new Outer.Inner();
                     
    inner.show();
  }
}

局部内部类

  • 定义在外部类方法中，作用范围和创建对象仅限于当前方法
  • 局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的生命周期与自身相同，变量必须修饰为final
  • 限制类的使用范围
// 外部类
public class Outer{
  //实例变量
  private String name = "刘德华";
  private int age = 35;
  
  //方法
  public void show(){
    // 定义局部变量
    String address = "sz";
    
    // 局部内部类：注意不能加任何访问修饰符
    class Inner{
      private String phone = "11234";
      private String email = "ldh@qq.com";
      
      public void show2(){
        // 访问外部类的属性
        System.out.println(name); // 相当于 Outer.this.name
        System.out.println(age);
        // 访问内部类的属性
        System.out.println(this.phone);
        System.out.println(this.email);
        
        // 访问局部变量 jdk1.7要求必须常量final、jdk1.8自动添加final
        
      }
    }
    // 创建局部内部类对象
    Inner inner = new Inner();
    inner.show2();
  }
}

// 测试类
public class Test{
  public static void main(String[] args){
    // 创建外部类对象
    Outer outer = new Outer();
                     
    outer.show();
  }
}

匿名内部类

  • 没有类名的局部内部可类（一切特征都与局部内部类相同）
  • 必须继承一个父类或者实现一个接口
  • 定义类、实现类、创建对象的语法合并。只能创建一个该类的对象
  • 优点：减少代码量
  • 缺点：可读性差
// 使用匿名内部类优化（相当于创建了一个局部内部类）
Usb usb = new Usb(){ // Usb为一个接口
  @Override
  public void service(){
    System.out.println("连接电脑成功，fan开始工作")
  }
};
usb.service();

Object类

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

getClass()方法

public final <?> getClass(){}
  • 返回引用中存储的实际对象类型
  • 应用：通常用于判断两个引用中实际存储对象类型是否一致
// 判断s1 和 s2是不是同一个类型
Class class1 = s1.getClass();
Class class2 = s2.getClass();
// getClass返回 class类型

hashCode()方法

public int hashCode(){}
  • 返回该对象的哈希码值
  • 哈希值根据对象的地址或者字符串使用hash算法计算出来的int类型的值
  • 一般情况下相同的对象返回相同的哈希码
s1.hashCode();
s2.hashCode();
// 自然不同
Student s3 = s1; // 此时s3的hashCode与s1相同

toString()方法

public String toString(){}
  • 返回该对象的字符串表示（表现形式）
  • 可以根据需求覆盖方法，如：展示对象各个属性值
System.out.println(s1.toString()); // 直接打印包+类名+哈希值
// 重写 alt + enter + s
@override
public String toString(){
  return "Student [name = " + name + ", age = " + age + "]";
}

equals()方法

public boolean equals(Object obj)
  • 默认实现为（this==obj），比较两个对象地址是否相同
  • 可以进行覆盖比较两个对象的内容是否相同
// 判断两个对象是否相等
System.out.println(s1.equals(s2)); // false

Student s4 = new Strudent("小明", 17);
Student s5 = new Strudent("小明", 17);
System.out.println(s4.equals(s5)); // false 堆中地址不同

// 重写 改变其比较内容
/*
步骤  1. 比较两个应用是否指向同一个对象
     2. 判断obj是否为null
     3. 判断两个引用只想的实际对象类型是否一致
     4. 强制类型转换
     5. 依次比较各个属性值是否相同
*/
@override
public boolean equals(Object obj){
  // 1.
  if(this == obj){
    return true;
  }
  // 2.
  if(obj == null){
    return false;
  }
  // 3.
  // if(this.getClass() == obj.getClass()){
  //
  // }
  // instanceof 判断对象是否是某种类型
  if(obj instanceof Student){
    // 4.强制类型转换
    Student s = (Student)obj;
    // 5. 比较属性
    if(this.name.equals(s.getName()) && this.age == s.getAge()){
      return true;
    }
  }
  return false;
}

finalize()方法

  • 当对象呗判定为垃圾对象时，由jvm自动调用此方法，用以标记垃圾对象，进入回收对列。
  • 垃圾对象：没有有效引用指向此对象为垃圾对象
  • 垃圾回收：由gc销毁垃圾对象，释放内存数据存储空间
  • 自动回收机制：jvm的内存耗尽，一次性回收所有垃圾对象
  • 手动回收机制：使用System.gc()通知jvm执行垃圾回收
@Override
protected void finalize() throws Throwable{
  System.out.println(this.name + "对象被回收了");
}

public static void main(String[] args){
  Student s1 = new Student("aaa", 29); // 不是垃圾
  new Student("bbb", 30); // 是辣鸡 会被回收
  //回收垃圾
  System.gc();
  System.out.println("回收垃圾"); 
  // 打印出 “回收垃圾 
  //         aaa对象被回收了”
}

包装类

  • 基本数据类型对应的引用数据类型
  • Object可统一所有数据，包装类的默认值是null
    在这里插入图片描述

类型转换与装箱和拆箱

  • 8种包装类提供不用类型间的转换方式
    1. Number父类中提供的6个共性方法
    2. parseXXX( )静态方法
    3. valueOf( )静态方法
    注意：需保证类型兼容，否则抛出NumberFormatException异常
psvm(String[] args){
  // 装箱， 基本类型 → 引用类型
  // 基本类型
  int num1 = 18;
  // 使用Integer类创建对象
  Integer integer1 = new Integer(num1);
  Integer integer2 = Integer.valueOf(num1);
  
  // 拆箱， 引用类型 → 基本类型
  Integer integer3 = new Integer(100);
  int num2 = integer3.intValue();
  
  // 上述为jdk1.5之前方法，之后提供了自动装箱拆箱
  int age = 30;
  // 自动装箱
  Integer integer4 = age;
  // 自动拆箱
  int age2 = integer4;
  
  // 基本类型和字符串之间转换
  // 1. 基本类型转成字符串
  int n1 = 100;
  // 1.1 使用+号
  String s1 = n1 + "";
  // 1.2 使用Integer中的toString()方法
  String s2 = Integer.toString(n1);
  String s2 = Integer.toString(n1, x); // x为进制要求
  
  // 2. 字符串转成基本类型
  String str = "150";
  // 使用Integer.parseXXX();
  int n2 = Integer.parseInt(str);
  
  // boolean 字符串形式转成基本类型，"true" ---> true 非“true ———> false
  String str2 = "true";
  boolean b1 = Boolean.parseBoolean(str2);
}

整数缓冲区

  • java预先创建了256个常用的整数包装类型对象
  • 在实际应用中，对已创建的对象进行复用
psvm(String[] args){
  // 面试题
  Integer integer1 = new Integer(100);
  Integer integer2 = new Integer(100);
  sout(integer1 == integer2); // false
  
  Integer integer3 = new Integer(100);// 自动装箱
  // 相当于调用 Integer.valueOf(100);
  Integer integer4 = new Integer(100);
  sout(integer3 == integer4); // true
  
  Integer integer5 = new Integer(200);// 自动装箱
  Integer integer6 = new Integer(200);
  sout(integer5 == integer6); // false
  
  // 因为缓存区数组 [-128, 127] 在这之内地址一样
}

String类

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

常用方法

// 1. length(); 返回字符串长度
// 2. charAt(int index); 返回某个位置的字符
// 3. contains(String str); 判断是否包含某个字符串

String content = "java是最好的语言, java no1";
sout(content.length()); // 10
sout(content.charAt(content.length() - 1)); // 言
sout(content.contains("java")); // true

// 4. toCharArray(); 返回字符串对应数组 
// 5. indexOf(); 返回子字符串首次出现的位置
// 6. lastIndexOf(); 返回字符串最后一次出现的位置

sout(content.toCharArray());
sout(content.indexOf"java")); // 0
sout(content.indexOf("java", 4)); // 从索引4开始找 返回12
sout(content.lastIndexOf("java")); // 12

// 7. trim(); //去掉字符串前后空格
// 8. toUpperCase(); toLowerCase(); 转换大小写
// 9. endWith(str); startWith(str);  判断是否以str 结尾、开头

String ct = " hello world ";
sout(ct.trim()); // "hello world"
sout(ct.toUpperCase()); // HELLO WORLD
sout(ct.toLowerCase()); // hello world
sout(ct.endWith("world")); // true
sout(ct.startWith("hello")) // true
  
// 10. replace(char old, char new); 用心的字符或字符串替换旧的字符或字符串
// 11. split(); 对字符串拆分

sout(content.replace("java", "php")); // php是最好的语言, php no1

String say = "java is the best language";
String[] arr = arr.say.split(" "); // "[ ,]+" 表示空格 逗号切分 +号表示切分可以多个 比如多个空格
sout(arr.length); // 5
for(String string : arr){
  sout(string);
}
// 打印出 
//java
//is
//the 
//best
//language

// 补充两个equals/compareTo();比较大小
String s1 = "hello";
String s2 = "HELLO";
sout(s1.equalsIgnoreCase(s2));// 忽略大小写比较true

// compareTo(); 两字符不同时比较字符字典序的ascii码
// 字符相同时比较长度 返回差值

案例演示

需求：

  1. 已知String str = “this is a text”;
  2. 将str中的单词单独获取
  3. 将str中的text替换成practice
  4. 在text前面插入一个easy
  5. 将每个单词的首字母改为大写
psvm(String[] args){
  String str = "this is a text";
  // 2. 
  String[] arr = str.split(" ");
  for(String s : arr){
    sout(s);
  }
  // 3.
 String str2 = str.replace("text", "practice");
  // 4. 
  String str3 = str.replace("text", "easy text");
  // 5. 
  for(int i = 0; i < arr.length; i ++){
    char first = arr[i].charAt(0);
    char upperfirst = Character.toUpperCase(first);
    String new = upperfirst + arr[i].substring(1);
  }
}

可变字符串

  • StringBuffer : 可变长字符串，运行效率慢、线程安全
  • StringBuilder : 可边长字符串、运行快、线程不安全
    效率均比String高且节省内存
psvm(String[] args){
  // StringBuffer 和 StringBuilder 用法一致
  StringBuffer sb = new StringBuffer();
  // 1. append(); 追加
  sb.append("java no1");
  // 2. insert(); 添加、插入
  sb.insert(0, "在第一个位置插入");
  // 3.replace(); 替换
  sb.replace(0, 9, str); // 左闭右开
  // 4. delete(); 删除
  sb.delete(0, 5); // 左闭右开
  // 5. 清空
  sb.delete(0, sb.length());
}

BigDecimal类

  • 位置 java.math 包中
  • 作用 精确计算浮点数
  • 创建方式 BigDecimal bd = new BigDecimal(“1.0”);
BigDecimal bd1 = new BigDecimal("1.0"); // 需用字符串
BigDecimal bd2 = new BigDecimal("0.9");
// 减法
BigDecimal r1 = bd1.subtract(bd2);
sout(r1); // 0.1

// 加法
BigDecimal r2 = bd1.add(bd2);

//乘法
BigDecimal r3 = bd1.multiply(bd2);

// 除法
BigDecimal r4 = new BigDecimal("1.4").subtract(new BigDecimal("0.5")).divide(new BigDecimal("0.9"), x, BigDecimal.ROUND_HALF_UP); 
//除不尽时 x填保留位数 后面为四舍五入之意

Date类

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

时间单位：1s = 1,000ms = 1,000,000 μs = 1,000,000,000 = ns

psvm(String[] args){
  // 1 创建Date对象
  Date date1 = new Date();
  sout(date1.toString()); //WED Sept 02 22:25:23 CST 2020
  sout(date1.toLocaleString()); // 已过时 但也能用 2020-9-2
  
  // 创建昨天的
  Date date2 = new Date(date1.getTime() - (60*60*24*1000));
  sout(date2.toLocaleString());
  
  // 2 方法after before
  boolean b1 = date.after(date2);
  sout(b1); //true
  boolean b2 = date1.before(date2);
  sout(b2); //false
  
  // 比较compareTo();
  int d = date1.compareTo(date1);
  sout(d); // 多的为1 少的为 -1 
  
  // 比较是否相等 equals()
  boolean b3 = date1.equals(date2);
  sout(b3); // false
}

Calendar类

  • Calendar提供了获取或者设置各种日历字段的方法
  • 构造方法 protected Calendar(); 由于是protected 所以无法直接创建
  • 其他方法
    在这里插入图片描述
psvm(String[] args){
  // 1. 创建 Calendar 对象
  Calendar calendar = Calendar.getInstance();
  sout(calendar.getTime().toLocaleString());
  // 2. 获取时间信息
  // 获取年
  int year = calendar.get(Calendar.YEAR);
  // 获取月 从 0 - 11
  int month = calendar.get(Calendar.MONTH);
  // 日
  int month = calendar.get(Calendar.DAY_OF_MONTH);
  // 小时
  int hour = calendar.get(Calendar.HOUR_OF_DAY);
  // 分钟
  int minute = calendar.get(Calendar.MINUTE);
  // 秒
  int second = calendar.get(Calendar.SECOND);
  // 3. 修改时间
  Calendar calendar2 = Calendar.getInstance();
  calendar2.set(Calendar.DAY_OF_MONTH, x);
  // 4. add修改时间
  calendar2.add(Calendar.HOUR, x); // x为正就加 负就减
  // 5. 补充方法
  int max = calendar2.getActualMaximum(Calendar.DAY_OF_MONTH);// 月数最大天数
  int min = calendar2.getActualMinimum(Calendar.DAY_OF_MONTH);
}

SimpleDateFormat

  • SimpleDateFormat是一个以与语言环境有关的方式来格式化和解析日期的具体类
  • 进行格式化（日期→文本）、解析（文本→日期）
  • 常用的时间模式字母
    在这里插入图片描述
psvm(String[] args){
  // 1. 创建对象
  SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH-mm-ss");
  // 2. 创建Date
  Date date = new Date();
  // 格式化date（日期→字符串）
  String str = sdf.format(date);
  sout(str);
  // 解析（字符串→时间）
  Date date2 = sdf.parse("1948/03/12");
  sout(date2); 
}

System类

主要用于获取系统的属性数据和其他操作，构造方法私有的
在这里插入图片描述

psvm(String[] args){
  //arraycopy 复制
  //src-原数组 srcPos-从哪个位置开始复制0 dest-目标数组 destPos-目标数组的位置 length-复制的长度
  int[] arr = {20, 18, 39, 3};
  int[] dest = new int [4];
  System.arraycopy(src, srcPos, dest, destPos, length);
  sout(arr, 4, dest, 4, 4)
    
  // Arrays.copyOf(original, newLength)
}

注意：本文是为了强化记忆自己打写
原文地址：https://www.cnblogs.com/coderzjz/p/13611161.html

香蕉你个BananazZ
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java常用类
weixin_47257042的博客
05-07 2443
Java常用类： 1、 System类：System类代表当前Java程序的运行平台，程序不能创建System类的对象， System类提供了一些类变量 和类方法，允许直接通过System类来调用这些类变量和类方法。 常用方法： 2、 Runtime类：Runtime类代表Java程序的运行时环境，可以访问JVM的相关信息，每个Java程序都有一个与之对应 的Runtime实例，应用程序通过该对象与其运行时环境相连。应用程序不能创建自己的Runtime实例， 但可以通过getRuntime()方法获取与之关
JAVA常用类总结
12-22
JAVA常用类,java封装类,String类和StringBuffer类......
java中math,objects,System,Integer,bigDecimal等类的介绍
qq_40808896的博客
04-26 554
1、API基本使用 （1）Math: （2）System:不能被实例化； System类常用方法 方法名 说明 Public static void exit(int status) 终止当前运行的Java虚拟机，非零表示异常终止； Public static ling currentTimMillis() 返回当前的时间（以毫秒为单位） Arraycopy(数据
Java面试知识点：Object类、Math类、BigDecimal类、自动装箱、拆箱
岁月求索
08-18 190
问题：Java面试知识点：Object类、BigDecimal类、自动装箱、拆箱 答案： 1.Object类： 代码如下: package com.xy; /** * @ProjectName: day01 * @Package: com.xy * @ClassName: test03 * @Author: 杨路恒 * @Description: * @Date: 2021/8/13 0013 17:33 * @Version: 1.0 */ public class tes
Object(对象)转换成Bigdecimal--然后加减乘除或比较大小
热门推荐
weixin_45305706的博客
06-10 1万+
对象转换成Bigdecimal--然后加减乘除或比较大小Object(对象)转BigdecimalBigdecimal的大小比较Bigdecimal的加减乘除注意 Object(对象)转Bigdecimal 我的项目经常用 Map<String,Object> map = new HashMap<String, Object>(); 接收数据, 那么当我用map.get(“key”)的时候, 获取的 value是 一个对象, 这个对象是BigDecimal类型的, 就需要转换处理
Java常见类库（一）：Object,Math,Arrays,BigDecimal
MyTsundoku的博客
11-10 516
一、Object类 Object类是Javajava.lang包下的核心类，Object类是所有类的父类。 Object类中的方法：
java常用类之Calendar类
Walker_sis的博客
02-22 9035
java常用类之Calendar类 Calendar类提供了获取或者设置各种日历的字段的方法。 构造方法 protected Calendar():由于修饰符是prodected;所以无法直接创建该对象 其他方法 方法名 说明 static Calendar getInstance() 使用默认时区或区域获取日历 void set(int year,int month,int date,int hourofday,int minute,int second) 设置日历的时分秒
常用类-String类
XHW0901的博客
05-31 2383
常用类-String类 一、String类的理解 二、获取字符串的两种常见方式 三、字符串的常见方法 boolean equalsIgnoreCase(String str)：比较字符串内容是否相同，但是忽略大小写，通常用于验证码比较时，忽略大小写 四、String的不可变长 五、可变长的字符串
Activiti常用类简介
09-04
"Activiti常用类简介" Activiti是一款基于Apache许可的开源BPM平台，提供了一系列的常用类来帮助开发者快速构建业务流程管理系统。下面我们将对Activiti的常用类进行详细介绍。 流程引擎配置类 ...
Day20 Java常用类
03-19
Day20 Java常用类
Object转BigDecimal类型
兵哥LOVE坤
12-24 1万+
 主要讲述如何将Object类型转化成BigDecimal: /** * Object转BigDecimal类型 * * @param value 要转的object类型 * @return 转成的BigDecimal类型数据 */ public static BigDecimal getBigDecimal(Object value)...
Flash动作脚本技术(FAS程序设计项目化教程--项目七--金苑五笔打字训练系统).doc
07-23
flash
毕业设计项目之基于Opencv的车牌识别系统项目源码
最新发布
07-23
毕业设计项目之基于Opencv的车牌识别系统项目源码 版本：python3.7.3，opencv4.0.0.21，numpy1.16.2，tkinter和PIL5.4.1.
MSP4305529控制AD9833(DDS模块)
07-23
采用TI单片机MSP4305529LP来控制DDS模块产生正弦信号方波信号三角波信号或正弦扫频信号
连接器连接口装配机_包括零件图_机械3D图可修改打包下载.zip
07-23
连接器连接口装配机_包括零件图_机械3D图可修改打包下载.zip
六工位组装机_包括零件图_机械3D图可修改打包下载.zip
07-23
六工位组装机_包括零件图_机械3D图可修改打包下载
time.apk.zip
07-23
time.apk.zip
Java编程：深入理解常用类与容器类
"Java编程中的常用类和容器类是学习Java的重要组成部分，涵盖了包装类、字符串类以及不同类型的容器类的使用。" 在Java编程中，掌握常用的类和其使用方式是提高效率的关键。其中，包装类是将Java的基本数据类型转换...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值