JAVA内部类与常用类

最新推荐文章于 2024-05-31 19:56:16 发布
最新推荐文章于 2024-05-31 19:56:16 发布
阅读量69 收藏
点赞数
分类专栏： Java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45736525/article/details/113854789
版权

内部类与常用类

1、内部类

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

public class Outer {
    class Inner{
        
    }
}

特点：

  • 会生成两个class文件；
  • 内部类可直接访问外部类私有成员，而不破坏封装；
  • 可为外部类提供必要的功能组件
package Inner.demo01;

public class Outer {
    private String name;
    class Inner{
        
        public void show(){
            System.out.println(name);
        }

    }
}

内部类分为：成员内部类、静态内部类、局部内部类、匿名内部类

1.1成员内部类

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

外部类的一个实例部分，创建内部类对象是，必须依赖外部类对象（创建内部类对象必须通过外部类对象）

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

当外部类、内部类存在重名属性时，会优先访问内部类属性

成员内部类不能定义静态成员

package Inner.demo01;


//外部类
public class Outer {
    //实例变量
    private String name="张三";
    private int age=20;

    //内部类
    class Inner{
        private String address="桂林";
        private String phone="110";

        //内部类与外部类属性重名时，优先访问内部类,需要访问外部类属性时Outer.this.属性
        private String name="李四";

        //不能定义静态成员
//        private static String country ="china";
        //但是可以包含常量
//        private static final String country ="china";


        //方法
        public void show(){
            //打印外部类属性
            System.out.println(name);//李四
            System.out.println(Outer.this.name);//张三
            System.out.println(Outer.this.age);//20

            //打印内部类属性
            System.out.println(this.address);//桂林
            System.out.println(this.phone);//110
        }


    }
}


package Inner.demo01;

public class Application {
    public static void main(String[] args) {

        //1.创建外部类对象
//        Outer outer = new Outer();
        //2.创建内部类对象
//        Outer.Inner inner = outer.new Inner();
//        inner.show();

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

    }
}

1.2静态内部类

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

package Inner.demo02;


//外部类
public class Outer {
    private String name="张三";
    private int age= 20;

    //静态内部类 等级和外部类一样
    static class Inner{
        private String address ="北京";
        private String phone="110";

        //静态成员
        private static  int count=1000;

        public void show(){
            //调用外部类的属性
            //1.创建外部类对象
            Outer outer = new Outer();
            //2.调用外部类对象属性
            System.out.println(outer.age);
            System.out.println(outer.name);

            //调用静态内部类属性和方法
            System.out.println(address);
            System.out.println(phone);
            //调用静态内部类的静态属性
            System.out.println(Inner.count);
        }
    }

}


package Inner.demo02;

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

1.3局部内部类

  • 定义在外部类方法中，作用范围和创建对象范围仅限于当前方法
  • 局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的生命周期与自身相同，变量必须修饰为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(){
        // 访问外部类的属性
        sout(name); // 相当于 Outer.this.name
        sout(age);
        // 访问内部类的属性
        sout(this.phone);
        sout(this.email);
        
        // 访问局部变量 jdk1.7要求必须常量final、jdk1.8自动添加final
        
      }
    }
    // 创建局部内部类对象
    Inner inner = new Inner();
    inner.show2();
  }
}

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

1.4匿名内部类

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

2、Object类

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

任何类，如果没有书写extends显示继承某个类，都默认继承Object类，否则为间接继承

Object类中所定义的方法，是任何对象都具备的方法

Object类型可以存储任何对象

  • 作为参数，可接受任何对象
  • 作为返回值，可返回任何对象

3、Object类常用方法

3.1、getClass()方法

  • public final Class<?> getClass(){}
  • 返回引用中的存储的实际对象类型；
  • 应用：通常用于判断两个引用中实际存储对象类型是否一致
 Person aaa = new Person("aaa",20);
        Person bbb = new Person("bbb", 0);
        Class<? extends Person> aClass = aaa.getClass();
        Class<? extends Person> bClass = bbb.getClass();
        if (aClass==bClass){
            System.out.println("同一个类型");
        }else {
            System.out.println("不同类型");
        }

3.2、hashCode方法

public int hashCode(){}

返回该对象的哈希码值

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

一般情况下相同对象返回相同的哈希码值

//hashCode方法
        System.out.println(aaa.hashCode());//460141958
        System.out.println(bbb.hashCode());//1163157884

3.3、toSting方法

  • public String toSring(){}
  • 返回该对象的字符串表示（表现形式）
  • 可以根据程序需求覆盖该方法，如：展示对象各个属性值
  //toString方法
        System.out.println(aaa.toString());
        System.out.println(bbb.toString());

3.4、equals方法

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

Student s4 = new Strudent("小明", 17);
Student s5 = new Strudent("小明", 17);
sout(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;
}

4、包装类

  • 基本数据类型所对应的引用数据类型
  • Object 可统一所有数据，包装类的默认值是null
基本数据类型包装类型
byteByte
shortShort
intInteger
longLong
floatFloat
doubleDouble
booleanBoolean
charCharacter

4.1、类型转换与装箱、拆箱

  • 8种包装类提供不用类型间的转换方式

    Number父类中提供的6个共性方法

    parseXXX( )静态方法

    valueOf( )静态方法

  • 注意：需保证类型兼容，否则抛出NumberFormatException异常

package chapter;

public class demo01 {
    public static void main(String[] args) {
        //装箱，基本类型-->引用类型
        //基本类型
        int num1 = 10;
        //装箱有两种方法
        //1.使用Integer类创建对象
        Integer integer1 = new Integer(num1);
        //2.使用Integer.valueOf()方法
        Integer integer2 = Integer.valueOf(num1);


        //拆箱，引用类型-->基本类型
        Integer integer3 = new Integer(100);
        int num2 = integer3.intValue();


        //jdk1.5以后提供了自动装箱拆箱
        int age = 30;
        //自动装箱  底层实现 Integer integer4 = Integer.valueOf(age);
        Integer integer4 = age;


        //自动拆箱  int age2 =integer4.intValue();
        int age2 =integer4;


        //基本类型与字符串之间的转换
        //1.基本类型转成字符串
        int n1 = 15;
        //1.1使用+号
        String s1 = n1 + "";
        //1.2使用Integer的toString()方法
        String s2 = Integer.toString(n1);
        String s3 =Integer.toString(n1,16);//radix 为进制要求


        //2.字符串转换基本类型
        String str = "150";
        //使用Integer.parseInt(str)
        int n2 = Integer.parseInt(str);

        // boolean 字符串形式转成基本类型，"true" ---> true 非“true ———> false
        String str2 = "true";
        boolean b1 = Boolean.parseBoolean(str2);


    }
}

4.2、整数缓冲区

  • Java预先创建了256个常用的证书包装类型对象
  • 在实际应用当中，对已创建的对象进行复用
package chapter;

public class demo02 {
    public static void main(String[] args) {
        //面试题
        Integer integer1 = new Integer(100);
        Integer integer2 = new Integer(100);
        System.out.println(integer1==integer2);//false

        Integer integer3 = new Integer(100);// 自动装箱
        // 相当于调用 Integer.valueOf(100);
        Integer integer4 = new Integer(100);
        System.out.println(integer3==integer4); // true

        Integer integer5 = new Integer(200);// 自动装箱
        Integer integer6 = new Integer(200);
        System.out.println(integer5==integer6);; // false

        // 因为缓存区数组 [-128, 127] 在这之内地址一样
    }
}

5、String类

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

在这里插入图片描述

package chapter;

import java.util.Arrays;

public class demo03 {

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

        String content = "java是世界上最好的编程语言,java";
        System.out.println(content.length());//15
        System.out.println(content.charAt(content.length()-1));//言
        System.out.println(content.contains("java"));//true


        //4.toCharArray();返回字符串对应数组
        //5.indexOf();返回字符串首次出现的位置
        //6.lastIndexOf();返回字符串最后一次出现的位置
        System.out.println(Arrays.toString(content.toCharArray()));
        System.out.println(content.indexOf("java"));//0
        System.out.println(content.indexOf("java",4));// 从索引4开始找 返回12
        System.out.println(content.lastIndexOf("java"));//12


        // 7. trim(); //去掉字符串前后空格
        // 8. toUpperCase(); toLowerCase(); 转换大小写
        // 9. endWith(str); startWith(str);  判断是否以str 结尾、开头
        String ct = " hello world ";
        System.out.println(ct.trim());//hello world
        System.out.println(ct.toUpperCase());// HELLO WORLD
        System.out.println(ct.endsWith("java"));//false

        // 10. replace(char old, char new); 用心的字符或字符串替换旧的字符或字符串
        // 11. split(); 对字符串拆分
        System.out.println(content.replaceAll("java","php"));//php是世界上最好的编程语言,php

        String say = "java is the best language";
        String[] arr = say.split(" ");
        System.out.println(Arrays.toString(arr).length());
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

        // 补充两个equals/compareTo();比较大小
        String s1 = "hello";
        String s2 = "HELLO";
        System.out.println(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);
  }
}

6、BigDecimal类

  • 位置 java.math 包中
  • 作用 精确计算浮点数
  • 创建方式 BigDecimal bd = new BigDecimal("1.0");
package chapter;

import java.math.BigDecimal;

public class demo04 {
    public static void main(String[] args) {

        //运算符计算不精确
        double d1 = 1.0;
        double d2 = 0.9;
        System.out.println(d1-d2);//0.09999999999999998


        //减法
        BigDecimal bd1 = new BigDecimal("1.0");
        BigDecimal bd2 = new BigDecimal("0.9");
        BigDecimal subtract = bd1.subtract(bd2);
        System.out.println(subtract);//0.1


        //加法
        BigDecimal add = bd1.add(bd2);
        System.out.println(add);//1.9


        //乘法
        BigDecimal multiply = bd1.multiply(bd2);
        System.out.println(multiply);//0.90

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

7、Date类

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

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

package chapter;

import java.util.Date;

public class demo05 {
    public static void main(String[] args) {
        //1 创建Date对象
        Date date = new Date();
        System.out.println(date.toString());//Thu Feb 18 22:04:54 CST 2021
        System.out.println(date.toLocaleString());//2021-2-18 22:04:54 已过时 但也能用

        //创建昨天的日期
        Date date1 = new Date(date.getTime() - (60 * 60 * 24 * 1000));
        System.out.println(date1.toLocaleString());//2021-2-17 22:06:58


        //2 方法after before
        boolean after = date.after(date1);
        System.out.println(after);//true
        boolean before = date.before(date1);
        System.out.println(before);//false


        // 比较compareTo();
        int d = date.compareTo(date1);
        System.out.println(d);//1

        // 比较是否相等 equals()
        boolean equals = date.equals(date1);
        System.out.println(equals);//false
    }
}

8、Calendar类

  • Calendar提供了获取或设置各种日历字段的方法
  • 构造方法 protected Calendar(); 由于是protected 所以无法直接创建
  • 其他方法
方法名说明
static Calendar getInstance()使用默认时区和区域获取日历
void set(int year, int month, int date, 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 getTimeInMilles()毫秒为单位返回该日历的时间值
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);
}

9、SimpleDateFormat类

  • SimpleDateFormat是一个以与语言环境有关的方式来格式化和解析日期的具体类
  • 进行格式化（日期→文本）、解析（文本→日期）
  • 常用的时间模式字母
字母日期或时间示例
y年2019
M年中月份08
d月中天数10
H一天中小时（0-23）22
m分钟16
s秒59
S毫秒356
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); 
}

10、System类

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

方法名说明
static void arraycopy(…)复制数组
static long currentTimeMillis();获取当前系统时间，返回毫秒值
static void gc();建议jvm赶快启动垃圾回收期器回收垃圾
static void exit(int status);退出jvm 如果参数是0表示正常退出jvm 非0表示异常退出
主要用于获取系统的属性数据和其他操作，构造方法私有的

方法名	说明
static void arraycopy(...)	复制数组
static long currentTimeMillis();	获取当前系统时间，返回毫秒值
static void gc();	建议jvm赶快启动垃圾回收期器回收垃圾
static void exit(int status);	退出jvm 如果参数是0表示正常退出jvm 非0表示异常退出
Guido_PSG
关注
专栏目录
java.time中日期时间的创建、增减、修改、查询、格式化、解析
樱_花_庄
08-15 1164
Java用线程安全的java.time代替了原来线程不安全的Date和Calendar。 通过查阅资料，学习了新增的time的一些基本使用方法。 打开任意分割线内的代码块注释，都可以直接运行。
Java 内部类
我的博客
02-20 1443
当静态内部类对象存在时，并不存在一个被它寄生的外部类对象，静态内部类对象只持有外部类的类引用，没有持有外部类对象的引用。在非静态内部类里可以直接访问外部类的私有成员，是因为在非静态内部类的对象里保存了一个它所寄生外部类对象的引用。当调用非静态内部类的实例方法时，必须有一个非静态内部类的实例，非静态内部类实例必须寄生在外部类实例里。如果把一个内部类放在方法里定义，那这个内部类就是一个局部内部类，局部内部类仅在方法里有效。把 A 类定义在 B 类的内部，A——内部类（嵌套类），B——外部类（宿主类）。
java日期方法
weixin_63204261的博客
08-02 1679
java日期处理
【Java】Java日期时间类
zgsdlr的博客
12-19 1390
Java中获取当前日期可以通过Date或Calendar类的对象实现，本文整理了两个类的常用方法及其功能的实现。 Date类 1.获取当前日期时间——创建Date类对象 Date currentDate = new Date(); 2.日期先后比较 currentDate.before(newDate); //判断currentDate是否在newDate之前，返回布尔值 currentDate.after(newDate); ////判断currentDate是否在newDate之前，返回布尔值
java基础-Date日期
m0_73910811的博客
11-27 129
时间原点的概念：Java中Date日期从1970年1月1日8点0分0秒开始计算。
Java中如何得到文件的创建时间&最后修改时间
StarLOVELeaf的博客
02-21 7857
java中只能用java.io.File获得文件的最后修改时间，如下： 比如我在D盘有个文件夹a，现在要获取其创建时间： File file = new File("D:\\a"); long time = file.lastModified();//返回文件最后修改时间，是以个long型毫秒数 String ctime = new SimpleDateFormat("yyyy-MM-
JAVA常用类与内部类
12-22
Java中有几种内部类？ 1、成员内部类：定义在类中的类，属于类的成员，创建成员内部类对象必须依赖外部类对象。 2、静态内部类：定义在类中的类，class 关键字前加入 static 修饰符，创建静态内部类对象不需要外部...
Java的接口、内部类、常用类
12-22
JAVA接口、内部类、常用类 一、JAVA接口 1.1 什么是接口？: 接口相当于特殊的抽象类，定义方式、组成部分于抽象类类似。 微观概念:接口是一种能力和约定 接口的定义:代表了某种能力 方法的定义:能力的具体要求 经验:...
java常用类总结.docx
06-08
自动装箱和拆箱是Java 5引入的特性，允许基本类型与对应的包装类之间自动转换。例如，当一个`int`变量传递给接受`Object`参数的方法时，`int`会被自动转换为`Integer`对象。 在Java中，内部类（包括静态内部类）...
Java静态内部类实现单例过程
08-25
Java中的单例模式是一种常用的软件设计模式，它保证一个类只有一个实例，并提供一个全局访问点。在Java中，有多种实现单例的方式，包括饿汉式、懒汉式、双重检查锁定(DCL)、静态内部类和枚举。这里我们将重点讨论...
Java获得文件创建时间
03-05
VC++工程 博文链接：https://pet.iteye.com/blog/188313
java获取文件创建时间
05-11
用java代码 获取文件创建时间，有一点小问题就是，当文件名有空格时，将会出错、有心人可解决、
java实现创建时间、修改时间自动生成
qq_60614034的博客
09-06 888
每次新增，识别到实体类具有对应的属性就会触发方法填充日期。
【Java基础】java中常用的几个时间类
最新发布
weixin_61898502的博客
05-31 426
Java时间类用法
java 创建 时间_java创建Date日期时间笔记
weixin_42367472的博客
02-12 1万+
(1)public Date()创建的日期类对象的日期时间被设置成创建时刻相对应的日期时间。例:Java代码1.Date today=new Date(); //today被设置成创建时刻相对应的日期时间。(2)public Date (long date)long 型的参数date可以通过调用Date类中的static方法parse(String s)来获得。例:Java代码1.long l=...
java创建指定日期_如何创建指定的日期和时间
热门推荐
weixin_32862641的博客
02-12 1万+
importjava.text.DateFormat;importjava.text.ParseException;importjava.text.SimpleDateFormat;importjava.util.Date;new一个java.util.SimpleDateFormat类的实例，构造方法可以指定日期格式，例如yyyy-MM-dd，其中yyyy表示四位年份，MM表示两位月份，...
时间java_Java 日期时间
weixin_39781363的博客
02-12 307
Java 日期时间java.util 包提供了 Date 类来封装当前的日期和时间。Date 类提供两个构造函数来实例化 Date 对象。第一个构造函数使用当前日期和时间来初始化对象。Date()第二个构造函数接收一个参数，该参数是从1970年1月1日起的毫秒数。Date(longmillisec)Date对象创建以后，可以调用下面的方法。序号方法和描述1boolean after(Date da...
Java内部类与常用类(Object和String)解析
"Java编程中的内部类以及常用类和Object、String类的概览" 在Java编程中，内部类是一个非常重要的概念，它允许我们在一个类的内部定义另一个类。内部类提供了更高级别的封装，并且可以访问外部类的所有成员，包括...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值