JAVA学习day07

Java常用类

day07所看的视频来源

千锋教育-新版 Java常用类最新教程

内部类

内部类的分类

1. 成员内部类
2. 静态内部类
3. 局部内部类
4. 匿名内部类

什么是内部类

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

class Outer{
    class Inner{
        
    }
}

特点：

• 编译之后可生成独立的字节码文件，文件格式是（Outer$Inner.class）
• 内部类可以直接访问还不累的私有成员，而不破坏封装

成员内部类

• 在类的内部定义，与实例变量，实例方法同级别的类
• 外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象
  • Outer out = new Outer();
  • Outer.Inner in = out.new Inner();（IDEA写法）
• 当外部类、内部类存在重名的属性时，会优先访问内部类的属性，这种情况要访问相同名字的外部类属性名字，则Outer.this.属性名来访问
• 成员内部类不能定义静态成员，但是可以包含静态常量即static final

静态内部类

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

//Outer.java
public class Outer{
    private String name = "XXX";
    private int age = 28;
    
    static class Inner{//级别和外部类一样
        private String address = "上海";
        private String phone = "111";
        //静态成员
        private static int cout = 1000;
        
        public void show(){
            //调用外部类的属性
            //1.先创建外部类对象
            Outer outer = new Outer();
            //2.再调用外部类对象的属性
            System.out.println(out.name);
            System.out.println(out.age);
            //调用静态内部的属性和方法，直接调用即可
            System.out.println(address);
            System.out.println(out.phone);
            //调用静态内部类的静态属性
            System.out.println(Inner.cout);
        }  
    }
}

//Test.java
public class TestOuter{
    public static void main(String[] args){
        //直接创建静态内部类对象而不需要先new外部类
        Outer.Inner inner = new Outer.Inner();//注意是new Outer.Inner()而不是new Outer().new.Inner()
    }
}

• 只能直接访问外部类的静态成员（实例成员需实例化外部类对象）
  • Outer.Inner inner = new Outer.Inner();
  • Outer.Inner.show();（这里是不是有点问题？存疑）

局部内部类（实际开发使用场合不多）

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

//Outer.java
public class Outer{
    private String name = "刘德华";
    private int age = 35;
    
    public void show(){
        //定义局部变量
        String address = "深圳";//jdk1.8自动是final
        
        //局部内部类，注意不能加任何访问修饰符
        class Inner{
            //局部内部类的属性
            private String phone = "15588888888";
            private String email = "[email protected]";
            
            public void show2(){
                //访问外部类的属性，可以直接访问，不可访问静态属性，因为静态属性是类的属性，不是成员的属性
                System.out.println(name);//可以写成Outer.this.name
                System.out.println(age);
                //访问内部类的属性
                System.out.println(phone);//可以写成this.phone
                System.out.println(email);
                //访问局部变量，jdk1.7要求，变量必须是常量final，jdk1.8自动添加final
                System.out.println(address);//其实已经是常量，也就是“深圳”
            }
        }
        //创建局部内部类对象然后调用才能输出结果
        Inner inner = new Inner();
        Inner.show2();
    }
}

//Test.java
public class TestOuter{
    public static void main(String[] args){
        Outer outer = new Outer();
        outer.show();//注意要在show里面创建局部内部类对象然后调用
    }
}

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

匿名内部类

• 没有类名的局部内部类（一切特征与局部内部类相同）
• 必须继承一个父类或者实现一个接口

//Usb.java
//接口
public interface USB{
    //服务
    void service();
}

//Mouse.java
public class Mouse implements Usb{
    @Override
    public void Service(){
        
        System.out.println("连接电脑成功，鼠标开始工作了...");
    }
}

//Test.java
public class TestOuter{
    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.servise();
        
        //使用匿名内部类优化（相当于创建了一个局部内部类）
        Usb usb = new Usb(){
            @Oberride
            public void service(){
                System.out.println("连接电脑成功，风扇开始工作了...");
            }
        };
        usb.service();
    }
}

• 定义类、实现类、创建对象的语法合并，只能创建一个该类的对象
• 优点：减少代码量
• 缺点：可读性较差

Object类

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

getClass()方法

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

//Test.java
public class Test{
    public static void main(String[] args){
        Student s1 = new Student("aaa", 20);
        Student s2 = new Student("bbb",22);
        //判断s1和s2是不是同一类型
        Class class1 = s1.getclass();
        Class class2 = s2.getclass();
        if(class1 == class2){
            System.out.println("s1和s2属于同一类型");
        }
    }
}

hashCode()方法

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

//Test.java
public class Test{
    public static void main(String[] args){
        Student s1 = new Student("aaa", 20);
        Student s2 = new Student("bbb",22);
        //判断s1和s2是不是同一类型
        Class class1 = s1.getclass();
        Class class2 = s2.getclass();
        if(class1 == class2){
            System.out.println("s1和s2属于同一类型");
        }
        
        //hashCode方法
        System.out.println(s1.hashCode());//s1和s2的hashCode不一样
        System.out.println(s2.hashCode());
        Student s3 = s1;
        System.out.println(s3.hashCode());//和s1一样
    }
}

toString()方法

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

//toString方法
//Test.java
public class Test{
    public static void main(String[] args){
        Student s1 = new Student("aaa", 20);
        Student s2 = new Student("bbb",22);
        
        System.out.println(s1.toString());
        System.out.println(s2.toString());
        //打印结果是com.(包名).Student@(哈希值)
    }
}

equals()方法

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

//Test.java
public class Test{
    public static void main(String[] args){
        Student s1 = new Student("aaa", 20);
        Student s2 = new Student("bbb",22);
        
        System.out.println(s1.equals(s2));//打印flase
        
        Student s4 = new Student("小明",17);
        Student s5 = new Student("小明",17);
         System.out.println(s4.equals(s5));//打印flase，因为地址不同
    }
}

//重写equals
//Student.java
public class Student extends Object{
    private String name;
    private int age;
    
    @Override
    public boolean equals(object obj){
        //1.判断两个对象是否是同一个引用
        if(this == obj){
            return true;
        }
        //2.判断obj是否为null
        if(obj == null){
            return false;
        }
        //3.判断是否同一类型
        if(obj instanceof Student){
            //4.强制类型转换，因为instanceof判断的是是否是子类或同类，是就返回true，所有需要类型转换
            Student s = (Student)obj;
            //5.比较属性
            if(this.name.equals(s.getName()) && this.age==s.getAge()){
                return true;
            }
        }
    }
}

finalize()方法

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

包装类

• 基本数据类型对应的引用数据类型
• Object可统一所有数据，包装类的默认值是null

包装类

类型转换与装箱、拆箱

装箱：把基本类型转换为引用类型（把栈里的基本数据类型放在堆里）

拆箱：把引用类型转换为基本类型

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

  • Number父类中提供的6各共性方法
  • valueOf()静态方阿飞

  package com.changyonglei.demo03;
  
  public class Demo01 {
      public static void main(String[] args) {
          //类型转换：装箱，把基本类型转为引用类型的过程
          //基本类型
          int num1 = 18;
          //使用Interger类创建对象
          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;
      }
  }
  
  

• parseXXX()静态方法

package com.changyonglei.demo03;

public class Demo01 {
    public static void main(String[] args) {
        //把基本数据类型转换为字符串
        int n1 = 15;
        //1.使用+号
        String s1 = n1+"";
        //2.使用Integer中的toString()方法
        String s2 = Integer.toString(n1,16);//输出f，十六进制

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

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

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

整数缓冲区

• Java预先创建了256个常用的整数包装类型对象

先看代码

package com.changyonglei.demo03;

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

        Integer integer3 = 100;//自动装箱
        Integer integer4 = 100;
        System.out.println(integer3 == integer4);//true

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

• 在实际应用中，堆已创建的对象进行复用

堆里有一个Cache数组，从-128到127的对象都创建好了，所以100是true，200不在这个范围内，他就new了Integer

String类

String

• 字符串是常量，创建之后不可改变
• 字符串字面值存储在字符串池（字符串池在方法区中）中，可以共享

package com.changyonglei.demo04;

public class Demo01 {
    public static void main(String[] args) {
        String name = "hello";//"hello"常量存储在字符串池中
        name = "zhangsan";//”张三“赋值给name，是在字符串池重新开辟一个空间，让name指向它
        String name2 = "zhangsan";//找一下字符串池有没有zhangsan，有就name2指向它，和name指向同一个对象
        
    }
}

• String s = "Hello";产生一个对象，字符串池中存储
• String s = new String("Hello");产生两个对象，堆、池各存储一个

String常用方法

• public in length()：返回字符串的长度
• public char charAt(int index)：根据下标获取字符
• public boolean contains(String str)：判断当前字符串是否包含str

  //整体代码的一部分      
        String content = "Java是世界上最好的编程语言";
        System.out.println(content.length());//15,空格也算一个字符
        System.out.println(content.charAt(content.length()-1));//言
        System.out.println(content.contains("Java"));//true
        System.out.println(content.contains("php"));//false

• public char[] toCharArray()：将字符串转换成数组
• public int indexOf(String str)：查找str首次出现的下标，存在，则返回该下标；不存在，则返回-1
• public int lastIndexOf(String str)：查找字符串在当前字符串中最后一次出现的下标索引

  //代码的一部分      
        String content = "Java是世界上最好的编程语言";
        System.out.println(Arrays.toString(content.toCharArray()));//[J, a, v, a, 是, 世, 界, 上, 最, 好, 的, 编, 程, 语, 言]
        System.out.println(content.indexOf("Java"));//0
        System.out.println(content.indexOf("Java",5));//从第5个下表开始找，实际上没有输出-1
        System.out.println(content.lastIndexOf("Java"));//0

• public String trim()：去掉字符串前后的空格
• public String toUpperCase()：将小写转成大写。toLowerCase()：把大写转成小写
• public boolean endWith(String str)：判断字符串是否以str结尾

//代码的一部分
        String content2 = "      hello world      ";
        System.out.println(content2.trim());//hello world
        System.out.println(content2.toUpperCase(Locale.ROOT));//      HELLO WORLD      
        System.out.println(content2.toLowerCase(Locale.ROOT));//      hello world      
        String filename = "hello.java";
        System.out.println(filename.endsWith(".java"));//true
        System.out.println(filename.startsWith("hello"));//true
    }

• public String replace(char oldChar,char newChar)：将旧字符串替换成新字符串
• public String[] split(String str)：根据str做拆分

//代码的一部分
        String content = "Java是世界上最好的编程语言";
        System.out.println(content.replace("Java","php"));//php是世界上最好的编程语言
        String say = "java is the best programing language,java xiang";
        String[] arr = say.split("[ ,]");//用空格或者逗号拆分，写成[ ,]+，则空格或者逗号可以出现多个
        System.out.println(arr.length);//8
        for(String string : arr){
            System.out.println(string);//一个个输出

• equals和compare

//代码的一部分
        //补充两个方法equals,comnpare();比较大小
        String s1 = "hello";
        String s2 = "HELLO";
        System.out.println(s1.equalsIgnoreCase(s2));//忽略大小写的比较，true

        String s3 = "abc";//97
        String s4 = "xyz";//120
        System.out.println(s3.compareTo(s4));//比较首个不同字母的数值，-23

        String s5 = "abc";
        String s6 = "abcxyz";
        System.out.println(s5.compareTo(s6));//这种情况比较长度，输出-3

可变字符串

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

//四个常用方法
package com.changyonglei.demo04;
/*
- StringBuffer：可变长字符串，JDK1.0提供，运行效率慢、线程安全
- StringBuilder：可变长字符串，JDK5.0提供，运行效率快、线程不安全
 */
public class Demo05 {
    public static void main(String[] args) {
        //StringBuffer sb = new StringBuffer();//两种写法都可以
        StringBuilder sb = new StringBuilder();
        //1.append();追加
        sb.append("java世界第一");
        System.out.println(sb.toString());//java世界第一
        sb.append("java真香");
        System.out.println(sb.toString());//java世界第一java真香
        sb.append("java不错");
        System.out.println(sb.toString());//java世界第一java真香java不错
        //2.insert();添加
        sb.insert(0,"我在最前面");
        System.out.println(sb.toString());//我在最前面java世界第一java真香java不错
        //3.replace();替换
        sb.replace(0,5,"hello");//含头不含尾巴
        System.out.println(sb.toString());//hellojava世界第一java真香java不错
        //4.delete();删除
        sb.delete(0,5);
        System.out.println(sb.toString());//java世界第一java真香java不错
        //清空
        sb.delete(0,sb.length());
        System.out.println(sb.length());//0
    }
}

BigDecimal

• 位置：java.math包中
• 作用：精确计算浮点数
• 创建方法：BigDecimal bd=new BigDecimal("1.0");
• 方法：加减乘除如下代码

package com.changyonglei.demo04;

import com.oop.demo05.B;

import java.math.BigDecimal;

public class Demo07 {
    public static void main(String[] args) {
        //BigDecimal，大的浮点数精确计算
        BigDecimal bd1 = new BigDecimal("1.0");
        BigDecimal bd2 = new BigDecimal("0.9");

        //减法
        BigDecimal r1 = bd1.subtract(bd2);
        System.out.println(r1);//0.1

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

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

        //除法
        BigDecimal r4 = new BigDecimal("1.4")
                .subtract(new BigDecimal("0.5"))
                .divide(new BigDecimal("0.9"));
        System.out.println(r4);//1

        BigDecimal r5 = new BigDecimal("10").divide(new BigDecimal("3"),2,BigDecimal.ROUND_HALF_UP);//ROUND_HALF_UP四舍五入的意思，可以选择模式，2是保留小数的位数
        System.out.println(r5);//3.33
    }
}

Date类

• Date表示特定的瞬间，精确到毫秒。Date类中大部分方法都已经被Calendar类中的方法所去掉
• 时间单位
  • 1秒=1000毫秒
  • 1毫秒=1000微妙
  • 1微妙=1000纳秒

package com.changyonglei.demo05;

import java.util.Date;

public class Demo01 {
    public static void main(String[] args) {
        //1.创建Date对象
        Date date1 = new Date();
        System.out.println(date1.toString());//Fri Feb 11 22:55:38 CST 2022
        System.out.println(date1.toLocaleString());//2022-2-11 22:55:38
        Date date2 = new Date(date1.getTime()-60*60*24*1000);
        System.out.println(date2.toLocaleString());//2022-2-10 22:55:38
        
        //2.方法after before8
        boolean b1 = date1.after(date2);
        System.out.println(b1);//true
        boolean b2 = date1.before(date2);
        System.out.println(b2);//false

        //比较compareTo(),输出0或者1
        int d = date1.compareTo(date2);
        System.out.println(d);//1

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

Calendar

• Calendar提供了获取或设置各种日历字段的方法
• 构造方法
  • protected Calendar()：由于修饰符是protected，所以无法直接创建对象

SimpleDateFormate

• SimpleDateFormat是一个以语言环境有关的方式来格式化和解析日期的具体类
• 进行格式化（日期->文本）、解析（文本->日期）
• 常用的时间模式字母

常用的时间模式字母

package com.changyonglei.demo05;

import java.text.SimpleDateFormat;
import java.util.Date;

public class Demo03 {
    public static void main(String[] args) throws Exception{
        //1.创建一个SimpleDateFormat
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
        //2.创建Date
        Date date = new Date();
        //格式化date（把日期转成字符串）
        String str = sdf.format(date);
        System.out.println(str);
        //解析（把字符串转成日期）
        Date date2 = sdf.parse("1990/05/01");
        System.out.println(date2);
    }
}

System类

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

package com.changyonglei.demo05;

public class Demo04 {
    public static void main(String[] args) {
        //1.System.arraycopy();复制数组
        //arraycopy，数组的复制
        //src：源数组
        //srcPos：从哪个位置开始复制
        //dest：目标数组
        //destPos：目标数组的位置
        //length：复制的长度
        int[] arr = {20,18,15,8,35,26,45,90};
        int[] dest = new int[8];
        System.arraycopy(arr, 0, dest, 0, arr.length);
        for(int i=0; i