内部类与常用类

最新推荐文章于 2024-07-20 23:59:39 发布
最新推荐文章于 2024-07-20 23:59:39 发布
阅读量73 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wly2333777/article/details/123820802
版权

内部类与常用类

内部类

内部类分类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yf3Qb0pw-1648535440981)(D:\笔记\JAVA内部类与常用类\photo\IMG_1286(20220327-085701)].PNG)

  • 内部类概念：在一个类的内部再定义一个完整的类
  • 特点：编译之后生成独立的字节码文件
  • 内部类可以直接访问外部类的私有成员，而不破坏封装
  • 可为外部类提供必要的内部功能组件

成员内部类

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

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

  • 成员内部类不能包含静态成员，但可以包含静态常量

  • package com.wly.Dome;


//外部类
public class Outer {
    //实例变量
    private String name="张三";
    private int age=21;
    //创建内部类
    class Inter{
        private String address="北京";
        private String phone="7265438";
        private String name="李四";//name被内部类覆盖
        //方法
        public void show(){//可以访问成员内部类final常量
            //打印外部类的属性
            System.out.println(Outer.this.name);//被覆盖下访问外部类属性name
            System.out.println(this.name);
            System.out.println(age);
            System.out.println(address);
            System.out.println(phone);

        }
    }
}

  • package com.wly.Dome;

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

静态内部类

  • static

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

  • package com.wly.Dome;

//外部类
public class Outer {
    //实例变量
    private String name="张三";
    private int age=21;
    //创建静态内部类和外部类级别一样
    static class  Inter{
        private String address="北京";
        private String phone="7265438";
        //静态成员
        private static int nameId=12;
        //方法
        public void show(){
            //访问外部类属性需先创建外部类对象
            Outer outer=new Outer();
            System.out.println(outer.name);
            System.out.println(outer.age);
            //内部类可以直接调用
            System.out.println(address);
            System.out.println(phone);
            //调用静态成员
            System.out.println(Inter.nameId);

        }
    }
}

  • package com.wly.Dome;
public class TestOut {
    public static void main(String[] args) {
        Outer.Inter inter=new Outer.Inter();//.包含关系
        inter.show();
    }
}

局部内部类

  • 定义在外部类方法中，作用范围和创建对象仅限于当前方法

  • 局部变量不能加任何访问修饰符

  • 局部内部类方法访问外部类方法的局部变量时，无法保证变量的生命周期与自身相同，变量必须修饰final

  • package com.wly.Dome;

//外部类
public class Outer {
    //实例变量
    private String name="张三";
    private int age=21;
    public void show(){
        String address="北京";
             //局部内部类
        class Inner{
                private String phone="7265438";
                private int nameId=23;
                public void show2(){
                    //访问外部类属性
                    System.out.println(Outer.this.name);
                    System.out.println(age);
                    //访问内部类属性
                    System.out.println(this.phone);
                    System.out.println(nameId);
                    //局部内部类方法中访问局部变量，1.7之前必须是常量final，1.8自动添加final
                    System.out.println(address);
            }
        }
        //创建局部类对象
        Inner inner=new Inner();
        inner.show2();
    }
}

  • package com.wly.Dome;

public class TestOut {
    public static void main(String[] args) {
        Outer outer=new Outer();
        //直接调用外部类方法没有结果
        //需在外部方法创建局部类对象才能调用局部内部类方法
        outer.show();
    }
}

匿名内部类

  • 没有类名的局部内部类

  • 必须继承一个父类或实现一个接口

  • 定义类、实现类、创建对像的语法合并，只能创建一个该类的对象

  • package com.wly.Dome;

public interface Usb {
    void service();
}

  • package com.wly.Dome;

public class Mouse implements Usb{
    @Override
    public void service() {
        System.out.println("========");
    }
}

  • package com.wly.Dome;

public class TestUsb {
    public static void main(String[] args) {
//        Usb usb=new Mouse();
//        usb.service();
        //局部内部类
//        class Fan implements Usb{
//
//            @Override
//            public void service() {
//                System.out.println("+++++++++++++");
//            }
//        }
//        //使用局部内部类创建对象
//        Usb usb=new Fan();
//        usb.service();
        //匿名内部类
        Usb usb=new Usb() {
            @Override
            public void service() {
                System.out.println("+++++++++++++");
            }
        };
        usb.service();
    }
}

Object类

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

Object类常用方法

getClass方法

  • 返回引用中存储的实际对象
  • 应用：用于判断两个引用中实际存储对象类型是否一致

hashCode方法

  • 返回该对象的哈希码值
  • 哈希值根据对象的地址或字符串或数字使用hash算法计算出的int类型数值。
  • 一般情况，相同对象返回相同哈希码

toString方法

  • 返回该对象的字符串表示(表示形式)
  • 可以根据程序需求覆盖该方法，如：展示对象各个属性值

equlas方法

  • 默认实现为(this==obj){}
  • 可进行覆盖，比较两个对象内容是否相同
  • 可进行覆盖，比较两个对象的内容是否相同
  • equlas()方法覆盖步骤
    • 比较两个引用是否指向同一对象
    • 判断obj是否为null
    • 判断两个引用指向的实际类型是否一致
    • 强制类型转换
    • 依次比较个属性值是否相同

finalize方法

  • 当对象被判定为垃圾对象时，由JVM调用此方法，用以标记垃圾对象
  • 垃圾对象：没有有效引用指向此对象时，为垃圾对象
  • 垃圾回收：JVM的内存耗尽，一次性回收所有垃圾对象
  • 手动回收机制：使用System。gc();通知JVM执行垃圾回收

示例

  • package com.wly.Dome;

import java.util.Objects;

public class Student {
    private String name;
    private  int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Student() {
        super();
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {//重写toString方法
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;//强制类型转换
        return age == student.age &&
                Objects.equals(name, student.name);
    }
}

  • package com.wly.Dome;

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

        Student s1=new Student("张三",10);
        Student s2=new Student("李四",20);
        Student s3=new Student("李四",20);
        //getClass()方法
        //判断s1和s2是否是一个类型
        Class class1=s1.getClass();
        Class class2=s2.getClass();
        if (class1==class2){
            System.out.println("属于同一个类型");
        }
        //hashCode方法
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());
        Student s4=s1;
        System.out.println(s4.hashCode());
        //toString方法
        System.out.println(s1.toString());
        System.out.println(s2.toString());//包名、类、哈希值
        //equals方法，判断两个对象是否相等
        System.out.println(s1.equals(s2));
        System.out.println(s2.equals(s3));//返回false，对象不同
        //equals方法重写,
    }
}

包装类

  • 基本类型所对应的引用类型

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

  • 基本数据类型byteshortintlongfloatdoublebooleanchar
    包装类型ByteShortIntegerLongFloatDoubleBooleanCharacter

类型转换与装箱、拆箱

  • 装箱：把基本类型转为引用类

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

  • parseXXX()静态方法

  • valueOf()方法

  • package com.wly.Dome;

public class TestDome {
    public static void main(String[] args) {
        //装箱:基本类型转换为引用类型
        int num1=10;
        //使用Integer类创建对象
        Integer integer1=new Integer(num1);
        Integer integer2=Integer.valueOf(num1);
        //拆箱:引用类型转换为基本类型
        Integer integer3=new Integer(100);
        int num2=integer3.intValue();

        //1.5之后提供了自动装箱，拆箱
        int age=28;
        //自动装箱
        Integer integer4=age;
        //自动拆箱
        int age2=integer4;
        //基本类型与字符串之间的转换
        int n1=78;
        String s1=n1+"";
        //使用Integer中的toString方法
        String s2=Integer.toString(n1);//(X,Y)Y可以代表几进制
        //字符串转为基本类型
        String str="150";
        //parseInt方法
        Integer.parseInt(str);
        //boolean字符串形式转为基本类型,true----->true     非true----->false
        String str2="true";
        boolean b1=Boolean.getBoolean(str2);
    }
}

  • Integer缓冲区

  • package com.wly.Dome;

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

        Integer integer3=100;
        Integer integer4=100;
        System.out.println(integer3==integer4);
        Integer integer5=200;
        Integer integer6=200;
        System.out.println(integer5==integer6);//true    缓冲区-128——127之间对象存储
        
    }
}

String类

  • 字符串是常量，创建后不可改变(赋值时，重新开辟空间，让变量指向地址发生改变)
  • 字符串字面值存储在字符串池中，可以共享
  • 使用new对象进行赋值，字符串会存在在堆和栈中(两个对象)，变量会指向堆
  • 比较字符串时，用equals方法比较数据

常用方法

方法说明
public int length():返回字符串长度（变量.length()）
public boolean contains(String str):判断当前字符串中是否包含str（变量.contains()）
public char [] toCharArray():将字符串转换为数组( 无法正常显示，显示地址，需转换为字符串输出)
public int indexOf(String str):查找首次出现的下标，存在，则返回该下标；不存在则返回-1（可以定位角标，从第几个开始找）
public int lastIndexOf(String str):查找字符串在当前字符串中最后一次出现的下标索引
public String trim():去掉字符串前后空格
public String toUpperCase()：将小写转换为大写(toLowerCase():大写转小写)
public boolean endWith(String str)：判断字符串是否以str结尾(startWith(str):是否以str开头);
public String replace(char oldChar,char newChar);将旧字符串替换成新字符串
public String[] split(String str):根据str做拆分(两个字符拆分用中括号括起来，加号表示字符可以出现一个或多个----->变量名.split("[ ]+"))
equlas():对字符串进行比较，区分大小写（不区分大小写：equlasIgnoreCase()）
compareTo():比较编码表位置，前一个减后一个，前几位一样输出结果为减去一样部分剩余位数

可变字符串（缓冲区上操作）

StringBuffer：可变长字符串，运行效率慢，线程安全，JDK1.0提供

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

  • 效率比String高，比String节省空间
方法
方法说明
append():追加
insert():添加（可以在任何位置添加任何类型）
replace():替换（可以指定位置）
delete():删除（可以指定位置）

BigDecimal类

  • （float与double都为近似值）精确计算浮点数
  • 字符串计算精确
  • 调用该类里的subtract()方法实现减法
  • 调用该类里的add()方法实现加法
  • 调用该类里的multiply()方法实现乘法
  • 调用该类里的divide()方法实现除法（除不尽的情况下需添加保留数目与保留方法（ROUND_HALF_UP）四舍五入）
  • 对象1.方法名（对象2）

Date类

  • 表示特定的瞬间，精确到毫秒

Calendar类

  • 提供了获取或设置各种字段的方法

  • 构造方法：

    • protected Calendar():由于修饰符是protected，所以无法直接创建该对象。用getInstance()创建对象

  • 其他方法：

    方法说明
    static Calendar getlnstance()：默认时区和区域获取日历
    void set(int year,int mouth,int date,int hourofday,int minute,int second):设置日历的年龄年、月、日、时、分、秒
    int get(int field):返回给定日历字段的值。字段比如年、月、日
    void setTime(Date date)：用给定的day设置此日历的时间。Date-Calendar
    Date getTime：返回一个Date表示此日历的时间。Calendar-Date
    void add(int field,int amount):按照日历的规则，给指定字段添加(正值)或减少(负值)时间量。
    long getTimeInMillies():毫秒为单位返回该日历的时间
    getActualMaximum()和getActualMinmum():返回当前月的最大值和最小值

SimpleDateFormat类

  • 以与语言环境有关的方式来格式化和解析日期的具体类

  • 进行格式化（日期—>文本）（文本------>日期）

    模式字母yMdHmsS
    日期或时间年年中月份月中天数一天中小时数分钟秒毫秒

  • 实例化时设置带参

  • package com.wly.Dome;

import javax.xml.crypto.Data;
import java.text.SimpleDateFormat;
import java.util.Date;

public class TestDome {
    public static void main(String[] args) throws Exception{
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy/MM/dd");
        //创建Date
        Date date=new Date();
        //格式化date
        String str=sdf.format(date);
        System.out.println(str);
        //解析
        Date date2=sdf.parse("2001/03/03");
        System.out.println(date2);
    }
}

System类

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

方法

方法名说明
static viod arraycopy(…）复制数组 arraycopy(原数组，位置起点，目标数组，目标位置，复制个数)
static long currentTimeMillis()获取当前系统时间，返回的是毫秒值
static void gc()建议JVM赶快启动垃圾回收器回收垃圾
static void exit(int status)退出jvm，如果参数为0表示正常退出jvm,非0表示异常退出jvm

System类

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

方法

方法名说明
static viod arraycopy(…）复制数组 arraycopy(原数组，位置起点，目标数组，目标位置，复制个数)
static long currentTimeMillis()获取当前系统时间，返回的是毫秒值
static void gc()建议JVM赶快启动垃圾回收器回收垃圾
static void exit(int status)退出jvm，如果参数为0表示正常退出jvm,非0表示异常退出jvm
n . x
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【十】Java内部类与常用类
奈何的人生
02-27 2044
目录 一、内部类 二、Object类 三、Object类常用方法 四、包装类 五、String类 六、BigDecemal类 思维导图参考：【十】Java内部类与常用类思维导图 【经典StringBuilder案例与详解】 1、jdk中StringBuilder字符串调优和intern();方法 2、四种内部类详解和区别实例 3、equals与==的区别以及equals方法的重写 4、St...
内部类使用
weixin_42472690的博客
05-03 296
文章目录内部类成员内部类：静态内部类局部内部类匿名内部类 内部类 概念： 在一个类的内部再定义一个完整的类 特点： 编译后可生成独立的字节码文件内部类可以直接访问外部类的私有成员，而不破坏封装可为外部类提供必要的内部功能组件 成员内部类： 在类的内部定义，与实例变量、实例方法同级别的类 外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象。 当外部类、内部类存在重名属性时，会优先访问内部类属性 成员内部类不能定义静态属性（可包含静态常量） package innerclass;
四种内部类详解
LCW0102的博客
11-22 2406
内部类就是嵌套在其他类内部的类，共分为四种，分别是：成员内部类、静态内部类、方法内部类、匿名内部类。 1. 成员内部类： //外部类Outter public class Outter { //外部类的私有属性 private int age = 20; private String name = "xiaoli"; //内部类 class Inner{ //内部类的私有属性和方法 private String msg = "
Java内部类以及使用场景
ylx1066863710的博客
12-15 4492
所谓内部类，即定义在另一个类中的类。那么，为什么会有内部类这个概念，他的使用场景又是什么呢？首先，来看一下内部类的特点： 1. 它体现了一种代码的隐藏机制和访问控制机制，内部类与所在外部类有一定的关系，往往只有该外部类调用此内部类，所以没有必要专门用一个Java文件存放这个类。 public class Outer { 　　private int num; 　　private class Inner { 　　　　private int num; 　　} } 一般的类是不允许用private修饰符
内部类和异常
Hello_zbs的博客
03-29 254
内部类 内部类，即类内部的类。类中类。形式如下： public class Outter{ // 外部类 class Inner{ // 内部类 } } 内部类的作用 内部类可以很好的实现隐藏 一般的非内部类，是不允许有 private 与protected权限的，但内部类可以 内部类拥有外围类的所有元素的访问权限 可以实现多重继承 匿名内部类优化接口 隐藏细节 平时我们对类的访问权限，都是...
JAVA常用类与内部类
12-22
什么是内部类？ 在类中定义的类，称之为内部类。 Java中有几种内部类？ 1、成员内部类：定义在类中的类，属于类的成员，创建成员内部类对象必须依赖外部类对象。 2、静态内部类：定义在类中的类，class 关键字前...
Java的接口、内部类、常用类
12-22
JAVA接口、内部类、常用类 一、JAVA接口 1.1 什么是接口？: 接口相当于特殊的抽象类，定义方式、组成部分于抽象类类似。 微观概念:接口是一种能力和约定 接口的定义:代表了某种能力 方法的定义:能力的具体要求 经验:...
java匿名内部类实例简析
09-05
- **简洁的回调机制**：在事件监听中，如Java AWT/Swing，匿名内部类常用来创建事件处理器。 - **轻量级封装**：有时为了封装一些特定的功能，创建一个单独的类过于繁琐，此时可以使用匿名内部类。 3. **访问权限...
java常用类总结.docx
06-08
在Java中，内部类（包括静态内部类）可以访问外部类的所有成员，而静态成员和方法可以在类加载时被直接调用，无需创建类的实例。 枚举类型是Java中的常量集合，每个枚举成员都是`Enum`类的实例。枚举成员默认是`...
浅谈FileItem类的常用方法
09-01
如果FileItem内部使用了临时文件，完成写入后，临时文件可能会被自动删除。 5. `getString()`: 此方法将FileItem的内容转化为字符串，有两个重载版本，一个默认使用系统默认编码，另一个接受指定的字符集编码。在...
在eclipse中导入本地的jar包配置Junit环境步骤（包含Junit中的方法一直标红的解决方法）
最新发布
weixin_70987470的博客
07-20 216
从本地导入Junit
Java内存模型
weixin_44267758的博客
07-19 546
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 469
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 740
JVM-垃圾回收与内存分配
java算法day19
TOMOT77的博客
07-20 120
我第一时间想到的方法是遍历二叉树+哈希。哈希用来统计数字出现的次数。之后遍历map收集结果。利用了BST的性质，即BST的中序序列是有序序列。
【Java算法】前缀和 下
2302_79806056的博客
07-18 1025
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
Java实验2
qq_64727229的博客
07-16 530
类的封装、继承、多态和接口（1）有理数四则运算（2）最终得分
对androidTestDebug 产物进行重新签名
shuizhizhiyin的专栏
07-19 384
在运行 gradle assembleAndroidTestDebug 任务后，自定义的 reSignAndroidTestDebug 任务将会被执行，并对子模块的 androidTestDebug 产物进行重新签名。your_keystore_path.jks、your_keystore_password、your_key_alias 和 your_key_password 需要替换为你的实际路径和密码。如果需要对其他子模块的产物进行重新签名，可以根据需要创建不同的自定义任务。// 设置密钥库密码。
每 日练 习
m0_67187271的博客
07-19 790
正确答案：C 解析：是正确的，这是最基本的类定义形式，没有继承任何类，也没有实现任何接口。也是正确的，这里定义了一个名为x的类，它继承了名为y的类。同样是正确的，这里定义了一个公共类x，它继承了Applet类，这在Java中是合法的，尤其是在创建GUI应用程序时常见。是不正确的，因为在Java中，我们不能使用static关键字来修饰一个类的定义。static关键字只能用于类的方法、变量或者是内部类（即嵌套类），但不能用于顶级类（非嵌套类）。所以，这个选项是错误的。因此，正确答案是C。
Java基础：Object类详解与常用方法
哈希码通常是根据对象内部的某些属性计算得出的整数值，确保每个对象有一个唯一的标识符。 2. **toString()** 方法：这个方法返回一个字符串表示当前对象，通常包含对象的类型名、可能的唯一标识（如哈希码）或其他...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值