JZTXT

内部类与常用类

发布时间 2023-03-29 21:30:58作者: peakyblinderss

内部类与常用类

内部类

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

  • 特点：

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

成员内部类

  • 在类的内部定义，与实例变量、实例方法同级别的类
  • 外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象
//1.创建外部类对象
Outer outer = new Outer();
//2.创建内部类对象
Inner inner = outer.new Inner();

//简化写法
Inner inner = new Outer().new Inner();
//3.调用内部类方法
inner.show();
  • 当外部类、内部类存在重名属性时，会优先访问内部类属性
//访问内部类属性
System.out.println(name);
//访问外部类属性
System.out.println(Outer.this.name);
  • 成员内部类不能定义静态成员，但是可以包含静态常量

静态内部类

  • 不依赖外部类对象，可直接创建或通过类名访问，可生命静态成员。
package OuterInner;

//外部类
public class Outer {
    private String name="朱建宇";
    private int age = 20;
    //静态内部类：和外部类相同
    static class Inner{
        private String address = "青岛";
        private String phone = "111";
        //静态成员
        private static int count = 1000;

        public void shsow(){
            //调用外部类的属性
            //1.先创建外部类对象
            Outer outer = new Outer();
            //2.调用外部类对象的属性
            System.out.println(outer.name);
            System.out.println(outer.age);
            //3.调用静态内部类的属性和方法
            System.out.println(address);
            System.out.println(phone);
            //调用静态内部类的静态属性
            System.out.println(Inner.count);
        }
    }

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

局部内部类

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

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

    public class OuterDemo02 {
    private String name = "刘德华";
    private int age = 35;
    public void show(){
        //定义局部变量
        String address = "深圳";
        //局部内部类：注意不能加任何访问修饰符
        class Inner{
            //局部内部类的属性
            private String num = "1555";
            private String email = "liudehua@qq.com";
            public void show2(){
                //访问外部类的属性
                System.out.println(OuterDemo02.this.name);
                System.out.println(OuterDemo02.this.age);
                //访问内部类的属性
                System.out.println(num);
                System.out.println(email);
                //访问局部变量
                System.out.println(address);
            }
        }
        Inner inner = new Inner();
        inner.show2();
    }

    public static void main(String[] args) {
        OuterDemo02 outer = new OuterDemo02();
        outer.show();
    }
}

匿名内部类

  • 没有类名的局部内部类（一切特征都与局部内部类相同）

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

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

  • 优点：减少代码量

  • 缺点：可读性较差

Usb usb = new Usb(){
    @Override
    public void service(){
        System.out.println("这就是匿名内部类");
    }
};
usb.service();

常用类

Object类

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

getClass()方法

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

hashCode()方法

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

toString()方法

  • public String toString(){}

  • 返回该对象的字符串表示（表现形式）

  • 可以根据程序需求覆盖该方法，如：展示对象各个属性值

eauals()方法

  • public boolean equals(Object obj){}

  • 默认实现为(this == obj)，比较两个对象地址是否相同

  • 可进行覆盖，比较两个对象的内容是否相同

    • 比较两个引用是否指向同一个对象

    • 判断obj是否为null

    • 判断两个引用指向的实际对象类型是否一致

    • 强制类型转换

    • 一次比较各个属性值是否相同

      	@Override
    public boolean equals(Object obj) {
//        1.首先判断两个对象是否是同一个引用
        if(this==obj){
            return true;
        }
//        2.判断obj是否为null
        if(obj==null){
            return false;
        }
//        3.判断是否为同一类型
//        instanceof判断对象是否是某种类型
        if(obj instanceof Student){
//            4.强制类型转换
            Student s = (Student)obj;
//            5.比较属性
            if(this.name.equals(s.getName())){
                return true;
            }
        }
        return false;
    }

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

装箱和拆箱

  • 装箱：将基本类型转成引用类型的过程

    int num1 = 18;
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;

类型转换

  • 8中包装类提供不同类型间的转换方式：

    • Number父类中提供的6个共性方法
    • parseXXX()静态方法
    • valueOf()静态方法

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

String类

  • 字符串时常量，创建以后不可改变

  • 字符串字面值存储在字符串池中，可以共享

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

  • String s = new String("hello");产生两个对象，堆、栈、池各存储一个

length()方法

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

  • 空格也算是一个字符

charAt(int index)方法

  • public char charAt(int index):根据下标获取字符
  • 超过角标范围会报错

contain(String str)方法

  • public boolean contain(String str):判断当前字符串中是否包含str

toCharArray()方法

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

indexOf(String str)方法

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

lastIndexOf(String str)方法

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

trim()方法

  • public String trim():去掉字符串前后的空格

toUpperCase()方法

  • public String toUpperCase():将小写转成大写
  • toLowerCase():把大写转成小写

endWith(String str)方法

  • public boolean endWith(String str):判断字符串是否以str结尾

  • startWith(str):判断是否以str开头

replace(char oldChar,char newChar)方法

  • public String replace(char oldChar,char newChar):将旧字符串替换成新字符串

split(String str)方法

  • public String[] split(String str):根据str做拆分

练习

String str = "this is a text";
//        1.将str中的单词单独获取出来
        String[] arr = str.split(" ");
        System.out.println("-----------1.将str中的单词单独获取出来---------------");
        for (String s : arr) {
            System.out.println(s);
        }
//        2.将str中的text替换成practice
        System.out.println("------------2.将str中的text替换成practice--------------");
        String str2 = str.replace("text", "practice");
        System.out.println(str2);
//        3.在text前面插入一个easy
        System.out.println("------------3.在text前面插入一个easy--------------");
        String str3 = str.replace("text", "easy text");
        System.out.println(str3);
//        4.将每个单词首字母变成大写
        System.out.println("------------4.将每个单词首字母变成大写--------------");
        for (int i = 0; i < arr.length; i++) {
            char first = arr[i].charAt(0);
            char upperfirst = Character.toUpperCase(first);
            String news = upperfirst+arr[i].substring(1);
            System.out.println(news);
        }

可变字符串

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

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

  • 和String区别：

    • 效率比String高
    • 比String节省内存
//        StringBuffer sb = new StringBuffer();
        StringBuilder sb = new StringBuilder();
//        1.append()追加
        sb.append("java世界第一");
        System.out.println(sb.toString());
        sb.append("java真香");
        System.out.println(sb.toString());

//        2.insert()添加
        sb.insert(0,"我在最前面");
        System.out.println(sb.toString());

//        3.replace()替换
        sb.replace(0,5,"hello");
        System.out.println(sb.toString());

//        4.delete()删除
        sb.delete(0,5);
        System.out.println(sb.toString());

//        5.清空
        sb.delete(0,sb.length());
        System.out.println(sb.length());

BigDecimal

  • 许多实际应用中需要精确计算，而double时近似值存储，不在符合要求，需要借助BigDecimal

  • 位置：java.math包中

  • 作用：精确计算浮点数

  • 创建方式：BigDecimal bd = new BigDecimal("1.0")

  • 用字符串创建

方法

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

  • 减法：BigDecimal r1 = bd1.subtract(bd2);

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

  • 除法：BigDecimal r4 = bd2.divide(new BigDecimal("0.9"));

    • 除不尽的话会报错
    • 在divide方法里可以选择保留几位小数
    • 可以选择四舍五入
            BigDecimal bd1 = new BigDecimal("1.0");
        BigDecimal bd2 = new BigDecimal("0.9");
//        减法
        BigDecimal r1 = bd1.subtract(bd2);
        System.out.println(r1);

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

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

//        除法
        BigDecimal r4 = bd2.divide(new BigDecimal("0.9"));
        System.out.println(r4);
//        如果除不尽会报异常

Date类

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

  • 时间单位

    • 1秒 = 1000毫秒
    • 1毫秒 = 1000微秒
    • 1微秒 = 1000纳秒

  • Date()：分配Date对象并初始化此对象，一表示分配它的时间（精确到毫秒）

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-Calendar
    Date getTime() 返回一个Date表示此日历的时间。Calendar-Date
    void add(int field,int amount) 按照日历的规则，给指定字段添加或减少时间量
    long getTimeInMillies() 毫秒为单位返回该日历的时间值 
    //       1.创建Calendar对象
        Calendar calendar = Calendar.getInstance();
//        2.获取时间信息
//        获取年
        int year = calendar.get(Calendar.YEAR);
//        获取月
        int month = calendar.get(Calendar.MONTH);
//        获取日
        int day = 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);
        System.out.println(year+"年"+(month+1)+"月"+day+"日"+hour+":"+minute+":"+second);

SimpleDateFormat类

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

  • 进行格式化（日期->文本）、解析（文本->日期）

  • 常用的时间模式字母

    字母 日期或时间
    y 年
    M 年中月份
    d 月中天数
    H 1天中小时数
    m 分钟
    s 秒
    S 毫秒 
    //        1.创建SimpleDateFormat对象y年M月
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH-mm-ss");
//        2.创建Date
        Date date = new Date();
//        3.格式化date(把日期转成时间字符串)
        String str = sdf.format(date);
        System.out.println(str);
//        解析(把字符串转成日期)
        Date date2 = sdf.parse("1990/05/01 22-00-44");
        System.out.println(date2);

System类

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